source: 2012/23/RamiP/YAG2DSSBase/YAG2DSS/YAG2DSS/ALTKEngine/StaticAnimHandler.cs @ 2809

Revision 2809, 17.3 KB checked in by ramipasa, 9 years ago (diff)

Aseet, taustat

Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using Microsoft.Xna.Framework;
5using Microsoft.Xna.Framework.Audio;
6using Microsoft.Xna.Framework.Content;
7using Microsoft.Xna.Framework.GamerServices;
8using Microsoft.Xna.Framework.Graphics;
9using Microsoft.Xna.Framework.Input;
10using Microsoft.Xna.Framework.Media;
11using C = System.Convert;
12
13namespace ALTK
14{
15    /// <summary>
16    /// This is a game component that implements IUpdateable.
17    /// </summary>
18    public class StaticAnimHandler : Microsoft.Xna.Framework.DrawableGameComponent
19    {
20        public static List<StaticAnimationType> StaticAnimTypes = new List<StaticAnimationType>();
21        private List<StaticAnimInstance> AnimInstances = new List<StaticAnimInstance>();
22
23        SpriteBatch spriteBatch;
24
25        public StaticAnimHandler(Game game)
26            : base(game)
27        {
28           
29            // TODO: Construct any child components here
30        }
31
32        public int GetStaticAnimIdFromClassName(string className)
33        {
34            for (int animTypeId = 0; animTypeId < StaticAnimTypes.Count; animTypeId++)
35            {
36                if (className == StaticAnimTypes[animTypeId].ClassName)
37                    return animTypeId;
38            }
39
40            return -1;
41        }
42
43        public void AddStaticAnim(string ClassName, Vector2 location)
44        {
45            int animId = GetStaticAnimIdFromClassName(ClassName);
46            AddStaticAnim(animId, location);
47        }
48
49        public void AddStaticAnim(int animTypeId, Vector2 location)
50        {
51            //StaticAnimInstance animInstance = new StaticAnimInstance(animTypeId, 0,
52            //    new Vector2(((ALTKConstants.WindowWidth / 2.0f) + location.X) - (StaticAnimTypes[animTypeId].Texture.Width / 2.0f),
53            //        ((ALTKConstants.WindowHeight / 2.0f) + location.Y) - (StaticAnimTypes[animTypeId].Texture.Height / 2.0f)));
54
55            //StaticAnimInstance animInstance = new StaticAnimInstance(animTypeId, 0,
56            //   new Vector2(location.X, location.Y));
57
58            StaticAnimInstance animInstance = new StaticAnimInstance(animTypeId, 0,
59               new Vector2((ALTKConstants.WindowWidth / 2.0f) - (StaticAnimTypes[animTypeId].Texture.Width / 2.0f) + location.X,
60                   (ALTKConstants.WindowHeight / 2.0f) - (StaticAnimTypes[animTypeId].Texture.Height / 2.0f) + (location.Y * -1)));
61
62            AnimInstances.Add(animInstance);
63        }
64
65        /// <summary>
66        /// Allows the game component to perform any initialization it needs to before starting
67        /// to run.  This is where it can query for any required services and load content.
68        /// </summary>
69        public override void Initialize()
70        {
71            // TODO: Add your initialization code here
72
73            base.Initialize();
74
75            spriteBatch = new SpriteBatch(GraphicsDevice);
76            InitStaticAnims();
77        }
78
79        private void InitStaticAnims()
80        {
81            StaticAnimationType genExplosion = new StaticAnimationType("GEN_EXPLOSION");
82            genExplosion.DisappearingRate = 2.5;
83            genExplosion.InitialVisibilityRate = 25.0;
84            genExplosion.TimeEntirelyVisible = 5;
85            genExplosion.Texture = ALTKHandler.Loader.loadTexture("gen_explosion");
86
87            StaticAnimationType stars1 = new StaticAnimationType("STARS_1");
88            stars1.DisappearingRate = 0.5;
89            stars1.InitialVisibilityRate = 0.75;
90            stars1.TimeEntirelyVisible = 0;
91            stars1.TimeWithMinOpacity = 5;
92            stars1.MinimumOpacity = 0.2;
93            stars1.Texture = ALTKHandler.Loader.loadTexture("backgroundStars1");
94
95            StaticAnimationType stars2 = new StaticAnimationType("STARS_2");
96            stars2.DisappearingRate = 0.35;
97            stars2.InitialVisibilityRate = 0.55;
98            stars2.TimeEntirelyVisible = 0;
99            stars2.TimeWithMinOpacity = 5;
100            stars2.MinimumOpacity = 0.4;
101            stars2.Texture = ALTKHandler.Loader.loadTexture("backgroundStars2");
102
103            StaticAnimationType starSmoke = new StaticAnimationType("STARSMOKE");
104            starSmoke.DisappearingRate = 0.40;
105            starSmoke.InitialVisibilityRate = 0.25;
106            starSmoke.TimeEntirelyVisible = 0;
107            starSmoke.TimeWithMinOpacity = 5;
108            starSmoke.MinimumOpacity = 0.25;
109            starSmoke.Texture = ALTKHandler.Loader.loadTexture("background_starsmoke");
110
111            StaticAnimationType starsmoke_blue = new StaticAnimationType("STARSMOKE_BLUE");
112            starsmoke_blue.DisappearingRate = 0.37;
113            starsmoke_blue.InitialVisibilityRate = 0.21;
114            starsmoke_blue.TimeEntirelyVisible = 0;
115            starsmoke_blue.TimeWithMinOpacity = 11;
116            starsmoke_blue.MinimumOpacity = 0.31;
117            starsmoke_blue.Texture = ALTKHandler.Loader.loadTexture("background_starsmoke_blue");
118
119            StaticAnimationType starsmoke_red = new StaticAnimationType("STARSMOKE_RED");
120            starsmoke_red.DisappearingRate = 0.57;
121            starsmoke_red.InitialVisibilityRate = 0.37;
122            starsmoke_red.TimeEntirelyVisible = 0;
123            starsmoke_red.TimeWithMinOpacity = 3;
124            starsmoke_red.MinimumOpacity = 0.17;
125            starsmoke_red.Texture = ALTKHandler.Loader.loadTexture("background_starsmoke_red");
126
127            StaticAnimationType starsmoke_white = new StaticAnimationType("STARSMOKE_WHITE");
128            starsmoke_white.DisappearingRate = 0.2;
129            starsmoke_white.InitialVisibilityRate = 0.125;
130            starsmoke_white.TimeEntirelyVisible = 0;
131            starsmoke_white.TimeWithMinOpacity = 15;
132            starsmoke_white.MinimumOpacity = 0.35;
133            starsmoke_white.Texture = ALTKHandler.Loader.loadTexture("background_starsmoke_white");
134
135            StaticAnimationType galaxy = new StaticAnimationType("GALAXY");
136            galaxy.DisappearingRate = 0.80;
137            galaxy.InitialVisibilityRate = 0.15;
138            galaxy.TimeEntirelyVisible = 0;
139            galaxy.TimeWithMinOpacity = 5;
140            galaxy.MinimumOpacity = 0.25;
141            galaxy.Texture = ALTKHandler.Loader.loadTexture("background_galaxy");
142
143            StaticAnimationType galaxy_blue = new StaticAnimationType("GALAXY_BLUE");
144            galaxy_blue.DisappearingRate = 0.725;
145            galaxy_blue.InitialVisibilityRate = 0.25;
146            galaxy_blue.TimeWithMinOpacity = 13;
147            galaxy_blue.MinimumOpacity = 0.3;
148            galaxy_blue.Texture = ALTKHandler.Loader.loadTexture("background_galaxy_blue");
149
150            StaticAnimationType galaxy_red = new StaticAnimationType("GALAXY_RED");
151            galaxy_red.DisappearingRate = 0.91;
152            galaxy_red.InitialVisibilityRate = 0.31;
153            galaxy_red.TimeWithMinOpacity = 9;
154            galaxy_red.MinimumOpacity = 0.10;
155            galaxy_red.Texture = ALTKHandler.Loader.loadTexture("background_galaxy_red");
156
157            StaticAnimationType galaxy_white = new StaticAnimationType("GALAXY_WHITE");
158            galaxy_white.DisappearingRate = 0.65;
159            galaxy_white.InitialVisibilityRate = 0.165;
160            galaxy_white.TimeWithMinOpacity = 7;
161            galaxy_white.MinimumOpacity = 0.15;
162            galaxy_white.Texture = ALTKHandler.Loader.loadTexture("background_galaxy_white");
163
164            StaticAnimTypes.Add(genExplosion);
165            StaticAnimTypes.Add(stars1);
166            StaticAnimTypes.Add(stars2);
167            StaticAnimTypes.Add(starSmoke);
168            StaticAnimTypes.Add(starsmoke_blue);
169            StaticAnimTypes.Add(starsmoke_red);
170            StaticAnimTypes.Add(starsmoke_white);
171            StaticAnimTypes.Add(galaxy);
172            StaticAnimTypes.Add(galaxy_blue);
173            StaticAnimTypes.Add(galaxy_red);
174            StaticAnimTypes.Add(galaxy_white);
175        }
176
177        /// <summary>
178        /// Allows the game component to update itself.
179        /// </summary>
180        /// <param name="gameTime">Provides a snapshot of timing values.</param>
181        public override void Update(GameTime gameTime)
182        {
183           
184
185            // TODO: Add your update code here
186            for (int sAnimId = 0; sAnimId < AnimInstances.Count; sAnimId++)
187            {
188                int uniqueId = AnimInstances[sAnimId].UniqueId;
189
190                // Pysyvät animaatiot
191                if (AnimInstances[sAnimId].getAnimClass().TimeEntirelyVisible == 0)
192                {
193
194                    // Animaatio maksimiläpinäkyvyydessään
195                    if (AnimInstances[sAnimId].Stage == 0)
196                    {
197                        AnimInstances[sAnimId].CurrentVisibility = AnimInstances[sAnimId].getAnimClass().MinimumOpacity;
198
199                        AnimInstances[sAnimId].CurrentTimeVisible++;
200
201                        if (AnimInstances[sAnimId].CurrentTimeVisible > AnimInstances[sAnimId].getAnimClass().TimeWithMinOpacity)
202                        {
203                            AnimInstances[sAnimId].CurrentTimeVisible = 0;
204                            AnimInstances[sAnimId].Stage = 1;
205                        }
206                    }
207                    // Tulossa näkyviin
208                    else if (AnimInstances[sAnimId].Stage == 1)
209                    {
210                        AnimInstances[sAnimId].CurrentVisibility = AnimInstances[sAnimId].CurrentVisibility +
211                            AnimInstances[sAnimId].getAnimClass().InitialVisibilityRate;
212
213                        if (AnimInstances[sAnimId].CurrentVisibility > 255.0)
214                        {
215                            AnimInstances[sAnimId].CurrentVisibility = 255;
216                            AnimInstances[sAnimId].Stage = 2;
217                        }
218                    }
219                    // Täysin näkyvissä
220                    else if (AnimInstances[sAnimId].Stage == 2)
221                    {
222                        AnimInstances[sAnimId].CurrentTimeVisible++;
223
224                        if (AnimInstances[sAnimId].CurrentTimeVisible > AnimInstances[sAnimId].getAnimClass().TimeEntirelyVisible)
225                        {
226                            AnimInstances[sAnimId].CurrentTimeVisible = 0;
227                            AnimInstances[sAnimId].Stage = 3;
228                        }
229                    }
230                    // Poistumassa näkyvistä
231                    else if (AnimInstances[sAnimId].Stage == 3)
232                    {
233                        AnimInstances[sAnimId].CurrentVisibility = AnimInstances[sAnimId].CurrentVisibility -
234                            AnimInstances[sAnimId].getAnimClass().DisappearingRate;
235
236                        if (AnimInstances[sAnimId].CurrentVisibility < AnimInstances[sAnimId].getAnimClass().MinimumOpacity)
237                        {
238                            AnimInstances[sAnimId].Stage = 0;
239                        }
240                    }
241                }
242                // Katoavat animaatiot
243                else
244                {
245                    // Animaatio on vasta tulossa näkyviin
246                    if (AnimInstances[sAnimId].Stage == 0)
247                    {
248                        AnimInstances[sAnimId].CurrentVisibility = AnimInstances[sAnimId].CurrentVisibility +
249                            AnimInstances[sAnimId].getAnimClass().InitialVisibilityRate;
250
251                        if (AnimInstances[sAnimId].CurrentVisibility > 255.0)
252                        {
253                            AnimInstances[sAnimId].CurrentVisibility = 255;
254                            AnimInstances[sAnimId].Stage = 1;
255                        }
256                    }
257                    // Animaatio on täysin näkyvissä
258                    else if (AnimInstances[sAnimId].Stage == 1)
259                    {
260                        AnimInstances[sAnimId].CurrentTimeVisible++;
261
262                        if (AnimInstances[sAnimId].CurrentTimeVisible == AnimInstances[sAnimId].getAnimClass().TimeEntirelyVisible)
263                        {
264                            AnimInstances[sAnimId].Stage = 2;
265                        }
266                    }
267                    // Animaatio on poistumassa näkyvistä
268                    else if (AnimInstances[sAnimId].Stage == 2)
269                    {
270                        AnimInstances[sAnimId].CurrentVisibility = AnimInstances[sAnimId].CurrentVisibility - AnimInstances[sAnimId].getAnimClass().DisappearingRate;
271
272                        if (AnimInstances[sAnimId].CurrentVisibility < 0.0)
273                        {
274
275                            AnimInstances.RemoveAt(sAnimId);
276
277                            continue;
278                        }
279                    }
280                }
281            }
282
283            base.Update(gameTime);
284        }
285
286        public override void Draw(GameTime gameTime)
287        {
288            GraphicsDevice device = spriteBatch.GraphicsDevice;
289            spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.NonPremultiplied);
290
291            for (int sAnimId = 0; sAnimId < AnimInstances.Count; sAnimId++)
292            {
293                StaticAnimInstance animInstance = AnimInstances[sAnimId];
294                Texture2D animTexture = StaticAnimTypes[animInstance.StaticAnimTypeId].Texture;
295
296                spriteBatch.Draw(
297                    animTexture, 
298                    new Rectangle(C.ToInt32(animInstance.Location.X),
299                        C.ToInt32(animInstance.Location.Y),
300                        animTexture.Width,
301                        animTexture.Height),
302                        new Color(255, 255, 255, Convert.ToInt32(animInstance.CurrentVisibility)));
303            }
304
305            spriteBatch.End();
306
307            base.Draw(gameTime);
308        }
309    }
310
311    public class StaticAnimationType
312    {
313        public StaticAnimationType() { }
314
315        public StaticAnimationType(string className)
316        {
317            ClassName = className;
318        }
319
320        Texture2D aTexture;
321        string aAssetPath;
322        string aClassName;
323        double aVisibilityRate;
324        double aDisappearingRate;
325        int aTimeEntirelyVisible;
326        double aMinOpacity = 128.0;
327        int aTimeMinOpacity;
328
329        public Texture2D Texture
330        {
331            get { return aTexture; }
332            set { aTexture = value; }
333        }
334
335        public string ClassName
336        {
337            get { return aClassName; }
338            set { aClassName = value; }
339        }
340
341        public string TexturePath
342        {
343            get { return aAssetPath; }
344            set { aAssetPath = value; }
345        }
346
347        public double InitialVisibilityRate
348        {
349            get { return aVisibilityRate; }
350            set { aVisibilityRate = value; }
351        }
352
353        public double DisappearingRate
354        {
355            get { return aDisappearingRate; }
356            set { aDisappearingRate = value; }
357        }
358
359        /// <summary>
360        /// The time the static animation stays entirely visible (zero transparency). 100 = 1 second.
361        /// </summary>
362        public int TimeEntirelyVisible
363        {
364            get { return aTimeEntirelyVisible; }
365            set { aTimeEntirelyVisible = value; }
366        }
367
368        public double MinimumOpacity
369        {
370            get { return aMinOpacity; }
371            set { aMinOpacity = value; }
372        }
373
374        public int TimeWithMinOpacity
375        {
376            get { return aTimeMinOpacity; }
377            set { aTimeMinOpacity = value; }
378        }
379    }
380
381    public class StaticAnimInstance
382    {
383        public StaticAnimInstance() { }
384
385        public StaticAnimInstance(int animTypeId, int uniqueId, Vector2 location)
386        {
387            StaticAnimTypeId = animTypeId;
388            UniqueId = uniqueId;
389            Location = location;
390        }
391
392        int aStage;
393        double aCurrentVisibility;
394        int aCurrentTimeVisible;
395        int aAnimTypeId;
396        int aUniqueId;
397        Vector2 aLocation;
398
399        /// <summary>
400        /// The current stage of the animation. 0 = appearing, 1 = entirely visible, 2 = disappearing
401        /// </summary>
402        public int Stage
403        {
404            get { return aStage; }
405            set { aStage = value; }
406        }
407
408        public double CurrentVisibility
409        {
410            get { return aCurrentVisibility; }
411            set { aCurrentVisibility = value; }
412        }
413
414        /// <summary>
415        /// The amount of time the static animation has been fully visible. After this is larger than the
416        /// AnimType's TimeEntirelyVisible, the anim will start disappearing.
417        /// </summary>
418        public int CurrentTimeVisible
419        {
420            get { return aCurrentTimeVisible; }
421            set { aCurrentTimeVisible = value; }
422        }
423
424        public int StaticAnimTypeId
425        {
426            get { return aAnimTypeId; }
427            set { aAnimTypeId = value; }
428        }
429
430        public int UniqueId
431        {
432            get { return aUniqueId; }
433            set { aUniqueId = value; }
434        }
435
436        public Vector2 Location
437        {
438            get { return aLocation; }
439            set { aLocation = value; }
440        }
441
442        public StaticAnimationType getAnimClass()
443        {
444            return StaticAnimHandler.StaticAnimTypes[StaticAnimTypeId];
445        }
446    }
447}
Note: See TracBrowser for help on using the repository browser.