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

Revision 2799, 14.3 KB checked in by ramipasa, 9 years ago (diff)

plaah,....

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        private 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(int animTypeId, Vector2 location)
44        {
45            //StaticAnimInstance animInstance = new StaticAnimInstance(animTypeId, 0,
46            //    new Vector2(((ALTKConstants.WindowWidth / 2.0f) + location.X) - (StaticAnimTypes[animTypeId].Texture.Width / 2.0f),
47            //        ((ALTKConstants.WindowHeight / 2.0f) + location.Y) - (StaticAnimTypes[animTypeId].Texture.Height / 2.0f)));
48
49            //StaticAnimInstance animInstance = new StaticAnimInstance(animTypeId, 0,
50            //   new Vector2(location.X, location.Y));
51
52            StaticAnimInstance animInstance = new StaticAnimInstance(animTypeId, 0,
53               new Vector2((ALTKConstants.WindowWidth / 2.0f) - (StaticAnimTypes[animTypeId].Texture.Width / 2.0f) + location.X,
54                   (ALTKConstants.WindowHeight / 2.0f) - (StaticAnimTypes[animTypeId].Texture.Height / 2.0f) + (location.Y * -1)));
55
56            AnimInstances.Add(animInstance);
57        }
58
59        /// <summary>
60        /// Allows the game component to perform any initialization it needs to before starting
61        /// to run.  This is where it can query for any required services and load content.
62        /// </summary>
63        public override void Initialize()
64        {
65            // TODO: Add your initialization code here
66
67            base.Initialize();
68
69            spriteBatch = new SpriteBatch(GraphicsDevice);
70            InitStaticAnims();
71        }
72
73        private void InitStaticAnims()
74        {
75            StaticAnimationType genExplosion = new StaticAnimationType("GEN_EXPLOSION");
76            genExplosion.DisappearingRate = 2.5;
77            genExplosion.InitialVisibilityRate = 25.0;
78            genExplosion.TimeEntirelyVisible = 5;
79            genExplosion.Texture = ALTKHandler.Loader.loadTexture("gen_explosion");
80
81            StaticAnimationType stars1 = new StaticAnimationType("STARS_1");
82            stars1.DisappearingRate = 0.5;
83            stars1.InitialVisibilityRate = 0.75;
84            stars1.TimeEntirelyVisible = 0;
85            stars1.TimeWithMinOpacity = 5;
86            stars1.MinimumOpacity = 0.2;
87            stars1.Texture = ALTKHandler.Loader.loadTexture("backgroundStars1");
88
89            StaticAnimationType stars2 = new StaticAnimationType("STARS_2");
90            stars2.DisappearingRate = 0.35;
91            stars2.InitialVisibilityRate = 0.55;
92            stars2.TimeEntirelyVisible = 0;
93            stars2.TimeWithMinOpacity = 5;
94            stars2.MinimumOpacity = 0.4;
95            stars2.Texture = ALTKHandler.Loader.loadTexture("backgroundStars2");
96
97            StaticAnimationType starSmoke = new StaticAnimationType("STARSMOKE");
98            starSmoke.DisappearingRate = 0.40;
99            starSmoke.InitialVisibilityRate = 0.25;
100            starSmoke.TimeEntirelyVisible = 0;
101            starSmoke.TimeWithMinOpacity = 5;
102            starSmoke.MinimumOpacity = 0.25;
103            starSmoke.Texture = ALTKHandler.Loader.loadTexture("background_starsmoke");
104
105            StaticAnimationType galaxy = new StaticAnimationType("GALAXY");
106            galaxy.DisappearingRate = 0.80;
107            galaxy.InitialVisibilityRate = 0.15;
108            galaxy.TimeEntirelyVisible = 0;
109            galaxy.TimeWithMinOpacity = 5;
110            galaxy.MinimumOpacity = 0.25;
111            galaxy.Texture = ALTKHandler.Loader.loadTexture("background_galaxy");
112
113            StaticAnimTypes.Add(genExplosion);
114            StaticAnimTypes.Add(stars1);
115            StaticAnimTypes.Add(stars2);
116            StaticAnimTypes.Add(starSmoke);
117            StaticAnimTypes.Add(galaxy);
118        }
119
120        /// <summary>
121        /// Allows the game component to update itself.
122        /// </summary>
123        /// <param name="gameTime">Provides a snapshot of timing values.</param>
124        public override void Update(GameTime gameTime)
125        {
126           
127
128            // TODO: Add your update code here
129            for (int sAnimId = 0; sAnimId < AnimInstances.Count; sAnimId++)
130            {
131                int uniqueId = AnimInstances[sAnimId].UniqueId;
132
133                // Pysyvät animaatiot
134                if (AnimInstances[sAnimId].getAnimClass().TimeEntirelyVisible == 0)
135                {
136
137                    // Animaatio maksimiläpinäkyvyydessään
138                    if (AnimInstances[sAnimId].Stage == 0)
139                    {
140                        AnimInstances[sAnimId].CurrentVisibility = AnimInstances[sAnimId].getAnimClass().MinimumOpacity;
141
142                        AnimInstances[sAnimId].CurrentTimeVisible++;
143
144                        if (AnimInstances[sAnimId].CurrentTimeVisible > AnimInstances[sAnimId].getAnimClass().TimeWithMinOpacity)
145                        {
146                            AnimInstances[sAnimId].CurrentTimeVisible = 0;
147                            AnimInstances[sAnimId].Stage = 1;
148                        }
149                    }
150                    // Tulossa näkyviin
151                    else if (AnimInstances[sAnimId].Stage == 1)
152                    {
153                        AnimInstances[sAnimId].CurrentVisibility = AnimInstances[sAnimId].CurrentVisibility +
154                            AnimInstances[sAnimId].getAnimClass().InitialVisibilityRate;
155
156                        if (AnimInstances[sAnimId].CurrentVisibility > 255.0)
157                        {
158                            AnimInstances[sAnimId].CurrentVisibility = 255;
159                            AnimInstances[sAnimId].Stage = 2;
160                        }
161                    }
162                    // Täysin näkyvissä
163                    else if (AnimInstances[sAnimId].Stage == 2)
164                    {
165                        AnimInstances[sAnimId].CurrentTimeVisible++;
166
167                        if (AnimInstances[sAnimId].CurrentTimeVisible > AnimInstances[sAnimId].getAnimClass().TimeEntirelyVisible)
168                        {
169                            AnimInstances[sAnimId].CurrentTimeVisible = 0;
170                            AnimInstances[sAnimId].Stage = 3;
171                        }
172                    }
173                    // Poistumassa näkyvistä
174                    else if (AnimInstances[sAnimId].Stage == 3)
175                    {
176                        AnimInstances[sAnimId].CurrentVisibility = AnimInstances[sAnimId].CurrentVisibility -
177                            AnimInstances[sAnimId].getAnimClass().DisappearingRate;
178
179                        if (AnimInstances[sAnimId].CurrentVisibility < AnimInstances[sAnimId].getAnimClass().MinimumOpacity)
180                        {
181                            AnimInstances[sAnimId].Stage = 0;
182                        }
183                    }
184                }
185                // Katoavat animaatiot
186                else
187                {
188                    // Animaatio on vasta tulossa näkyviin
189                    if (AnimInstances[sAnimId].Stage == 0)
190                    {
191                        AnimInstances[sAnimId].CurrentVisibility = AnimInstances[sAnimId].CurrentVisibility +
192                            AnimInstances[sAnimId].getAnimClass().InitialVisibilityRate;
193
194                        if (AnimInstances[sAnimId].CurrentVisibility > 255.0)
195                        {
196                            AnimInstances[sAnimId].CurrentVisibility = 255;
197                            AnimInstances[sAnimId].Stage = 1;
198                        }
199                    }
200                    // Animaatio on täysin näkyvissä
201                    else if (AnimInstances[sAnimId].Stage == 1)
202                    {
203                        AnimInstances[sAnimId].CurrentTimeVisible++;
204
205                        if (AnimInstances[sAnimId].CurrentTimeVisible == AnimInstances[sAnimId].getAnimClass().TimeEntirelyVisible)
206                        {
207                            AnimInstances[sAnimId].Stage = 2;
208                        }
209                    }
210                    // Animaatio on poistumassa näkyvistä
211                    else if (AnimInstances[sAnimId].Stage == 2)
212                    {
213                        AnimInstances[sAnimId].CurrentVisibility = AnimInstances[sAnimId].CurrentVisibility - AnimInstances[sAnimId].getAnimClass().DisappearingRate;
214
215                        if (AnimInstances[sAnimId].CurrentVisibility < 0.0)
216                        {
217
218                            AnimInstances.RemoveAt(sAnimId);
219
220                            continue;
221                        }
222                    }
223                }
224            }
225
226            base.Update(gameTime);
227        }
228
229        public override void Draw(GameTime gameTime)
230        {
231            GraphicsDevice device = spriteBatch.GraphicsDevice;
232            spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.NonPremultiplied);
233
234            for (int sAnimId = 0; sAnimId < AnimInstances.Count; sAnimId++)
235            {
236                StaticAnimInstance animInstance = AnimInstances[sAnimId];
237                Texture2D animTexture = StaticAnimTypes[animInstance.StaticAnimTypeId].Texture;
238
239                spriteBatch.Draw(
240                    animTexture, 
241                    new Rectangle(C.ToInt32(animInstance.Location.X),
242                        C.ToInt32(animInstance.Location.Y),
243                        animTexture.Width,
244                        animTexture.Height),
245                        new Color(255, 255, 255, Convert.ToInt32(animInstance.CurrentVisibility)));
246            }
247
248            spriteBatch.End();
249
250            base.Draw(gameTime);
251        }
252    }
253
254    public class StaticAnimationType
255    {
256        public StaticAnimationType() { }
257
258        public StaticAnimationType(string className)
259        {
260            ClassName = className;
261        }
262
263        Texture2D aTexture;
264        string aAssetPath;
265        string aClassName;
266        double aVisibilityRate;
267        double aDisappearingRate;
268        int aTimeEntirelyVisible;
269        double aMinOpacity = 128.0;
270        int aTimeMinOpacity;
271
272        public Texture2D Texture
273        {
274            get { return aTexture; }
275            set { aTexture = value; }
276        }
277
278        public string ClassName
279        {
280            get { return aClassName; }
281            set { aClassName = value; }
282        }
283
284        public string TexturePath
285        {
286            get { return aAssetPath; }
287            set { aAssetPath = value; }
288        }
289
290        public double InitialVisibilityRate
291        {
292            get { return aVisibilityRate; }
293            set { aVisibilityRate = value; }
294        }
295
296        public double DisappearingRate
297        {
298            get { return aDisappearingRate; }
299            set { aDisappearingRate = value; }
300        }
301
302        /// <summary>
303        /// The time the static animation stays entirely visible (zero transparency). 100 = 1 second.
304        /// </summary>
305        public int TimeEntirelyVisible
306        {
307            get { return aTimeEntirelyVisible; }
308            set { aTimeEntirelyVisible = value; }
309        }
310
311        public double MinimumOpacity
312        {
313            get { return aMinOpacity; }
314            set { aMinOpacity = value; }
315        }
316
317        public int TimeWithMinOpacity
318        {
319            get { return aTimeMinOpacity; }
320            set { aTimeMinOpacity = value; }
321        }
322    }
323
324    public class StaticAnimInstance
325    {
326        public StaticAnimInstance() { }
327
328        public StaticAnimInstance(int animTypeId, int uniqueId, Vector2 location)
329        {
330            StaticAnimTypeId = animTypeId;
331            UniqueId = uniqueId;
332            Location = location;
333        }
334
335        int aStage;
336        double aCurrentVisibility;
337        int aCurrentTimeVisible;
338        int aAnimTypeId;
339        int aUniqueId;
340        Vector2 aLocation;
341
342        /// <summary>
343        /// The current stage of the animation. 0 = appearing, 1 = entirely visible, 2 = disappearing
344        /// </summary>
345        public int Stage
346        {
347            get { return aStage; }
348            set { aStage = value; }
349        }
350
351        public double CurrentVisibility
352        {
353            get { return aCurrentVisibility; }
354            set { aCurrentVisibility = value; }
355        }
356
357        /// <summary>
358        /// The amount of time the static animation has been fully visible. After this is larger than the
359        /// AnimType's TimeEntirelyVisible, the anim will start disappearing.
360        /// </summary>
361        public int CurrentTimeVisible
362        {
363            get { return aCurrentTimeVisible; }
364            set { aCurrentTimeVisible = value; }
365        }
366
367        public int StaticAnimTypeId
368        {
369            get { return aAnimTypeId; }
370            set { aAnimTypeId = value; }
371        }
372
373        public int UniqueId
374        {
375            get { return aUniqueId; }
376            set { aUniqueId = value; }
377        }
378
379        public Vector2 Location
380        {
381            get { return aLocation; }
382            set { aLocation = value; }
383        }
384
385        public StaticAnimationType getAnimClass()
386        {
387            return StaticAnimHandler.StaticAnimTypes[StaticAnimTypeId];
388        }
389    }
390}
Note: See TracBrowser for help on using the repository browser.