Flashhilfe.de - Flash Community

Blinkende Sterne [Flash MX 2004]

 


AntwortenRegistrieren Seite1  

moerti#1
Benutzerbild von moerti
Beiträge: 59
Registriert: Nov 2006

03.04.2007, 16:43

Hallo

Ich habe mir hier einige Einträge zum Thema blinkende Sterne angesehen. Ich habe auch viel hilfreiches gefunden. Allerdings keine Lösung für mein Problem. Auch bei Flashkit nicht.

Ich möchte einen Sternenhimmel erstellen, indem Sterne platziert werden. Nun sollen diese Stern allerdings mit einem alpha von beispielweise 50 dargestellt werden. Das ist soweit kein Problem...

Nun sollen dies Sterne aber im ersten Schritt folgendes machen:

1. Die BEREITS PLATZIERTE Sterne sollen aufleuchten
2. Das Aufleuchten soll sanft mittels eines tweens geschehen und nicht einfach nur an/aus.
3. Die Sterne sollen in unterschiedlicher Stärke aufleuchten

Ich verwende momentan dieses Script:

ActionScript:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function copyStern(anzahl, xdist, ydist) {
    for (i=0; i<anzahl; i++) {
        duplicateMovieClip(stern, "stern"+i, i);
        eval("stern"+i)._x = random(xdist);
        eval("stern"+i)._y = random(ydist);
    }
}
copyStern(30, 800, 600);

function moveStar() {
    stern._alpha = random(100);
    stern._x = random(50);
    stern._y = random(50);
    stern._xscale = random(100);
    stern._yscale = random(100);
    stern._rotation = random(390);
}
setInterval(moveStar, 300);


Hat jemand Interesse mir ein paar Tips zu geben? Danke schon mal
Geändert von moerti am 03.04.07 um 16:45 Uhr
Werbung
Beiträge: 0
Registriert: Feb 2016


burnZ#2
Benutzerbild von burnZ
Beiträge: 2827
Wohnort: Bayern
Registriert: Aug 2005

03.04.2007, 19:04

So, diesmal hab ich sogar beachtet das es sich um FlashMX handelt *g*
Hab also eine Flash MX *.fla erstellt und Kompilierung auf Flash7/AS2.0
eingestellt.

Hier die Stern-Klasse (Stars.as, über #include zu holen):
ActionScript:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
/**
* Kleine Klasse zum erzeugen von Sternen
* anhand einer Vorlage in der Bibliothek.
*
* Eine FlashMX Lösung infolge von:
* http://flashhilfe.de/forum/flash/blinkende-sterne-204858-204858.html
*
* @author Jean-Pascal Hövel <burnz@flashhilfe.de>
*
* @param   template Id der Sternvorlage aus der Bibliothek
* @param   target    Ziel Clip indem die Sterne erzeugt werden.
* @param   count    Menge an Sternen
*/

function Stars(template:String, target:MovieClip, count:Number, width:Number, height:Number){
   // private variablen
   var template:String    = template;
   var target:MovieClip  = target;
   var count:Number      = count;
   var interval:Number    = -1;
   var isRunning:Boolean  = false;
   var isRendered:Boolean = false;
   var stars:Array        = new Array();
   var width:Number      = width;
   var height:Number      = height;
   
   // bestimmt maximales alpha von sternen
   this.maxAlpha = 60;
   
   // bestimmt minimales alpha von sternen
   this.minAlpha = 10;
   
   // bestimmt minimales scale von sternen
   this.minScale = 10;
   
   // bestimmt maximales scale von sternen
   this.maxScale = 100;
   
   // bestimmt minimale geschwindikeit (relativ zu fps)
   this.minSpeed = 1;
   
   // bestimmt maximales geschwindikeit (relativ zu fps)
   this.maxSpeed = 10;
   
   // bestimmt minimale zeit die ein stern nichts tut (in frames)
   this.minIdle = 10;
   
   // bestimmt maximales zeit die ein stern nichts tut (in frames)
   this.maxIdle = 90;
      
   // [private] updatet die optionen der sterne
   var updateCheck = function(option:String, a:Number, b:Number){
      // sterne durchlaufen
      for(var i:Number = 0; i < stars.length; i++){   
         // wenn keine scale option
         if(option.indexOf('Scale') === -1){
            // option updaten
            stars[i][option] = b;
         }
         else {
            // neuen wert ermitteln
            var scale:Number = rand((option === 'minScale' ? b : this.minScale),
                              (option === 'maxScale' ? b : this.maxScale));
                        
            // übernehmen
            stars[i]._xscale = scale;
            stars[i]._yscale = scale;
         }
      }
      
      return b;
   }
   
   // [private] watcher registieren
   this.watch("minAlpha", updateCheck);
   this.watch("maxAlpha", updateCheck);
   this.watch("minScale", updateCheck);
   this.watch("maxScale", updateCheck);
   this.watch("minSpeed", updateCheck);
   this.watch("maxSpeed", updateCheck);
   this.watch("minIdle" , updateCheck);
   this.watch("maxIdle" , updateCheck);
   
   // [private] gibt eine zufällige zahl zwischen min und max wieder
   var rand = function(min:Number, max:Number){
      return Math.floor(Math.random() * (max - min + 1)) + min;
   }
   
   // [private] onEnterFrame methode für sterne
   var animate = function(){
      // wenn nicht am warten...
      if(this.idleFrames == undefined){
         // wenn kein ziel alpha definiert...
         if(this.targetAlpha == undefined){
            // alpha ermitteln
            this.targetAlpha = this.rand(this.minAlpha, this.maxAlpha);
            
            // geschwinkigkeit ermitteln
            this.animationSpeed = this.rand(this.maxSpeed, this.minSpeed);
         }
         else {
            // wenn ziel alpha größer als momentanes
            if(this.targetAlpha > this._alpha){
               // alpha erhöhen
               this._alpha = this._alpha + this.animationSpeed;

               // wenn ziel überschritten
               if(this.targetAlpha <= this._alpha){
                  // ziel werte löschen
                  delete this.targetAlpha;
                  delete this.animationSpeed;
                  
                  // idle wert bestimen
                  this.idleFrames = this.rand(this.minIdle, this.maxIdle);
               }
            }   
            // wenn ziel alpha niedriger als momentanes
            else if(this.targetAlpha < this._alpha){
               // alpha verringern
               this._alpha = this._alpha - this.animationSpeed;   
               
               // wenn ziel unterschritten
               if(this.targetAlpha >= this._alpha){
                  // ziel werte löschen
                  delete this.targetAlpha;
                  delete this.animationSpeed;
                  
                  // idle wert bestimen
                  this.idleFrames = this.rand(this.minIdle, this.maxIdle);
               }
            }
         }
      }
      else {
         // frames runterzählen
         this.idleFrames--;

         // wenn 0 ereicht
         if(this.idleFrames <= 0){
            // idleFrames löschen
            delete this.idleFrames;
         }
      }
   }
   
   // [public] erzeugt die sterne und animiert sie anhand der einstellungen
   this.render = function(){
      // wenn noch nicht gerendert...
      if(!isRendered){
         // sterne erzeugen
         for(var i:Number = 1; i < count + 1; i++){
            // stern attachen
            stars.push(target.attachMovie(template, '__STAR_' + i, target.getNextHighestDepth()));
            
            // referenz holen
            var current:MovieClip = stars[stars.length - 1];
            
            // zufällige position
            current._x = rand(0, width);
            current._y = rand(0, height);
            
            // zufälliges alpha
            current._alpha = rand(this.minAlpha, this.maxAlpha);
            
            // zufälligens scale
            var scale:Number = rand(this.minScale, this.maxScale);
            
            // scale anwenden
            current._xscale = scale;
            current._yscale = scale;
            
            // alpha werte übergeben
            current.minAlpha = this.minAlpha;
            current.maxAlpha = this.maxAlpha;
            
            // speed werte übergeben
            current.minSpeed = this.minSpeed;
            current.maxSpeed = this.maxSpeed;
            
            // warte werte übergeben
            current.minIdle = this.minIdle;
            current.maxIdle = this.maxIdle;
            
            // funktionen referenzieren
            current.rand = rand;
         }
      }
      
      // isRendered auf true
      isRendered = true;
   }
   
   // [public] startet die alpha animation der sterne
   this.animate = function(){
      // wenn nicht am animieren..
      if(!isRunning){
         // wenn sterne gerendert...
         if(isRendered){
            // sterne durchlaufen
            for(var i:Number = 0; i < stars.length; i++){      
               // onEnterFrame setzen
               stars[i].onEnterFrame = animate;
            }
            
            // isRunning auf true
            isRunning = true;
         }
         else {
            // informativer trace
            trace('Stars.animate(): Die Sterne müssen erst durch render() erzeugt werden um sie animieren zu können');
         }
      }
      else {
         // informativer trace
         trace('Stars.animate(): Sterne werden bereits animiert. Siehe Stars.stop()');
      }
   }
   
   // [public] stoppt die alpha animation
   this.stop = function(){
      // wenn am animieren..
      if(isRunning){      
         // sterne durchlaufen
         for(var i:Number = 0; i < stars.length; i++){      
            // onEnterFrame löschen
            delete stars[i].onEnterFrame;
         }   
         
         // isRunning auf false
         isRunning = false;
      }
      else {
         // informativer trace
         trace('Stars.stop(): Es läuft keine Animation. Siehe Stars.animate()');
      }
   }
   
   // [public] zerstört die sterne
   this.remove = function(){
      // wenn erzeugt..
      if(isRendered){
         // sterne löschen
         while(stars.length !== 0){
            // stern poppen und unloaden
            stars.pop().removeMovieClip();
         }
         
         // array komplett resetten
         stars = new Array();
         
         // isRendered auf false
         isRendered = false;
      }
      else {
         // informativer trace
         trace('Stars.remove(): Es wurden noch keine Sterne erzeugt. Siehe Stars.render()');
      }
   }
}


Und hier ein Beispiel Skript, platziert auf _root und mit einem durch "star" verknüpften MovieClip in der Bibliothek der bei mir einen kleinen weissen Kreis beinhaltet. Die *.fla hat eine FPS Einstellung von 31:
ActionScript:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// include
#include "Stars.as"

// objekt erzeugen
// id der vorlage in der bibi, ziel clip, anzahl, breite, höhe
var myStars = new Stars('star', _root, 250, 550, 400);

// legt minimales & maximales alpha der sterne fest
myStars.minAlpha = 0;
myStars.maxAlpha = 80;

// legt minimales & maximales scale der sterne fest
myStars.minScale = 10;
myStars.maxScale = 45;

// legt minimalen & maximalen speed fest (beachte fps einstellung vom film)
myStars.minSpeed = 1;
myStars.maxSpeed = 5;

// legt minimale & maximale wartezeit zwischen animationen fest
// angabe in fps (z.B film hat 30fps dann für 2 sekunden 60 eintragen)
myStars.minIdle = 20; // weniger als eine sekunde
myStars.maxIdle = 90; // ca. 3 sekunden

// sterne rendern
myStars.render();

// sterne animieren
myStars.animate();

// werte die nach animate() oder render() geändert werden,
// werden automatisch auf alle sterne angewendet
myStars.maxSpeed = 10;

// diese zeile würde alle animationen stoppen
//myStars.stop();

// diese zeile würde alle erzeugten sterne löschen
//myStars.remove();


Ich weiss es ist eine onEnterFrame Lösung, aber wenn man nicht zu krass mit Sternen und Höhe\Breite abgeht ist es nicht all zu aufwendig denke ich (auf meinem core²duo läufts absolut flüssig mit dem Beispielskript)

Im Anhang nochmal Stars.as & Stars.fla Beispiel als ZIP.

----------------------------------------------------------------------
Dies ist die Signatur von burnZ. Alle Rechte vorbehalten!

Angehängte Dateien:
Komprimierte Datei stars.zip7.26 KB
Geändert von burnZ am 03.04.07 um 19:52 Uhr
moerti#3
Benutzerbild von moerti
Beiträge: 59
Registriert: Nov 2006

Themenautor/in

03.04.2007, 20:29

BOOAAAA.....Erst einmal vielen Dank!

Ich habs nach deiner Anleitung kurz nachgebaut, da sich das fla nicht öffnen konnte.
Hat aber super geklappt.
Geändert von moerti am 03.04.07 um 20:40 Uhr
Maslyn#4
Benutzerbild von Maslyn
Beiträge: 3
Registriert: Nov 2007

09.02.2011, 18:02

Hallo,

wie blendet man das Script denn aus ?
Mit Alpha auf O funktioniert es nicht.

Liebe Grüße
Maslyn
Werbung
Beiträge: 0
Registriert: Feb 2016


Yoshio#5
Benutzerbild von Yoshio
Beiträge: 5
Registriert: Feb 2009

15.02.2011, 07:12

Guten Morgen!

Die sterne sind super :)

ich habe das alles so gemacht wie beschrieben
nun aber habe ich ein bilderrahmen gebaut in diesen rahmen ein bild mit ein himmel gesetzt
nun aber habe ich dass problem das die sterne genau auf diesen rahmen mit drauf sind
wie bekomme ich es hin das ich die position der sterne bestimmen kann?
man kann zwar größe etc angeben aber leider nicht die position :/

wäre nett wenn ihr mir weiter helfen könntet.

besten dank in vorraus.
vindel#6
Benutzerbild von vindelFlashhilfe.de Moderator
Beiträge: 3000
Wohnort: Köln
Registriert: Oct 2007

15.02.2011, 10:12

@Maslyn:
Im Script steht:
ActionScript:
1
2
3
4
5
// diese zeile würde alle animationen stoppen
myStars.stop();

// diese zeile würde alle erzeugten sterne löschen
myStars.remove();

Wenn du jetzt allerdings erst ein ausblenden ohne plötzliches verschwinden haben möchtest, dann musst du die Variablen für die neune Sterne anpassen.
ActionScript:
1
2
myStars.minAlpha = 0;
myStars.maxAlpha = 80;
Damit kannst du "live" die Alpha-spanne bestimmen und so auch ein Ausblenden realisieren!

@Yoshio:
Die sterne werden in dem erstellen MC immer zwischen 0 und der angegebenen Breite / Höhe positioniert.
Um jetzt nciht immer links oben vom Rand die sterne zu haben, lädst du die Sterne nciht in deine Hauptebene (_root) sondern erstellst dir einen MC, den du so positionierst wie du möchtest und ihm unter "Eigenschaften" einen Instanznamen gibst. Diesen instanznamen gibst du dann im Konstruktor vom Objekt an:
ActionScript:
1var myStars = new Stars('star', deinInstanznamen, 250, 550, 400);
public Weltformel(Problem){
      if (Problem gelöst) return Lösung;
      else Weltformel(kleiners Problem);
}
Yoshio#7
Benutzerbild von Yoshio
Beiträge: 5
Registriert: Feb 2009

15.02.2011, 21:35

Hallo vindel

Danke das hat mir sehr geholfen.

Gruß Yoshio

AntwortenRegistrieren Seite1  

Schnellantwort

Du musst registriert sein, um diese Funktion nutzen zu können.

 
Ähnliche Beiträge zum Thema
Partner Webseiten: art-and-law.de  Mediengestalter.info   php-resource.de   phpforum.de   phpwelt.de   Pixelio.de   Scubacube.de  
Haftungsausschluss   Datenschutzerklärung   Hier Werben   Impressum
© 1999-2019 Sebastian Wichmann - Flashhilfe.de