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

Revision 2768, 12.5 KB checked in by ramipasa, 9 years ago (diff)

Muutettu ALTK-logiikoita toimimaan Jypelin kanssa.

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