Problem bei SpriteAnimation

  • VB.NET

    Problem bei SpriteAnimation

    Ich bin momentan dabei eine kleine Sidescroller Engine aufzubauen. Diese funktioniert mit Direct2D und soll dem Programmierer eine Vielzahl an vorgegebenen Funktionen bieten, welche ihm die Programmierarbeit erleichtern soll.

    Ich habe eine Struktur namens Stage, welche alle Objekte beinhaltet und diese dann zeichnet. Dann habe ich noch eine Klasse namens Sprite, welche ein Objekt mit Bild und eigener Physik darstellen soll, welches man der Stage hinzufügen kann. Außerdem gibt es noch die Klasse Animation, welche einen Array von Bitmaps beinhaltet. Wenn man eine neue Animation instanziiert, dann kann man das Play-Event dieser Animation in einem Sprite aufrufen, sodass dieser Sprite dann in einem angegebenen Abstand sein Image wechselt, wodurch eine Animation entsteht.

    Allerdings funktioniert das Play-Event nicht wie gewollt, da (wie ich per Debugger festgestellt habe) die Variablen immer wieder neu initialisiert werden, und somit nie das nächste Bild angezeigt wird. Ich suche jetzt schon seit ein paar Tagen (keine Scherz!!!) nach irgendeinem dummen Denkfehler, welcher das New-Event der Animation-Struktur immer wieder erneut aufruft.

    Es ist wahrscheinlich einer dieser Fehler, nach denen man tagelang sucht und irgendwann fällt einem auf, dass man eine Anweisung um eine Zeile verschieben muss. Doch mittlerweile bin ich das suchen Leid und hab mich daher entschieden euch mal danach suchen zu lassen.

    Also, viel Spass mit folgendem Code:

    Hauptform:

    Quellcode

    1. Stage Stage1;
    2. Sprite star;
    3. System.Drawing.Bitmap[] Frames = { _2DSidescrollerEngine.Properties.Resources.star_1, _2DSidescrollerEngine.Properties.Resources.star_2, _2DSidescrollerEngine.Properties.Resources.star_3, _2DSidescrollerEngine.Properties.Resources.star_4};
    4. Animation anim;
    6. private void Form1_Shown(object sender, EventArgs e)
    7. {
    8. //Instantiate Stage:
    9. Stage1 = new Stage(null, System.Drawing.Color.CornflowerBlue, new Size(2500, this.Height), 60, this);
    11. //Initialize Stage:
    12. star = new Sprite(new Rectangle2(new Vector2(100, 100), new Size2(9, 9)), _2DSidescrollerEngine.Properties.Resources.star_1, Stage1.RenderTarget);
    13. anim = new Animation("StarBlinking", 4, Frames, 0.5F, Stage1.RenderTarget);
    14. star.AddAnimation(anim);
    15. Stage1.AddSprite(star);
    17. //Run Stage
    18. Stage1.Run();
    19. }


    Stage-Klasse:

    Quellcode

    1. public class Stage
    2. {
    3. private SharpDX.Direct2D1.Bitmap backImgV;
    4. private Size SizeV;
    5. private Rectangle2 cameraBounds;
    6. public int BackgroundImageStretchMode;
    7. private System.Threading.Thread renderThread;
    8. private Stopwatch FPSSW;
    9. private float targetFPSV;
    10. private float FPSV;
    11. private float maxFPSV;
    12. private bool stopGame;
    13. private Color4 backgroundColorV;
    14. private bool showFPSV = true;
    15. private RenderTarget Target;
    16. private SharpDX.DirectWrite.Factory textFactory;
    17. private List<Sprite> spriteList;
    19. /// <summary>
    20. /// Instantiates a new Stage to play on.
    21. /// </summary>
    22. /// <param name="backgroundImage">The Image drawn at the back of the scene. "null" to have nothing as background.</param>
    23. /// <param name="backgroundColor">The Color the Stage gets cleared with from frame to frame.</param>
    24. /// <param name="stageSize">The Size of the Stage in Pixels.</param>
    25. /// <param name="targetFPS">The maximum FPS to run the game with.</param>
    26. /// <param name="targetForm">The Form the stage will be drawn on.</param>
    27. public Stage(Image backgroundImage, System.Drawing.Color backgroundColor, Size stageSize, int targetFPS, Form targetForm)
    28. {
    29. //Get the Size of the Stage:
    30. SizeV = stageSize;
    32. //Set the Camera Bounds:
    33. cameraBounds = new Rectangle2(new Vector2(0, 0), new Size2(targetForm.Width, targetForm.Height));
    35. //Get the targetFPS:
    36. targetFPSV = targetFPS;
    38. //Start Stopwatch:
    39. FPSSW = new Stopwatch();
    41. //Initialize Direct2D:
    42. HwndRenderTargetProperties props;
    43. SharpDX.Direct2D1.Factory d2dFactory;
    45. d2dFactory = new SharpDX.Direct2D1.Factory(SharpDX.Direct2D1.FactoryType.MultiThreaded);
    46. props = new HwndRenderTargetProperties();
    47. props.Hwnd = targetForm.Handle;
    48. props.PixelSize = new SharpDX.Size2(targetForm.ClientSize.Width, targetForm.ClientSize.Height);
    49. props.PresentOptions = PresentOptions.RetainContents;
    50. Target = new WindowRenderTarget(d2dFactory, new RenderTargetProperties(), props);
    51. Target.DotsPerInch = new Size2F(96, 96);
    52. textFactory = new SharpDX.DirectWrite.Factory();
    54. //Convert the Background-Image as Drawing.Image to a SharpDX.Bitmap
    55. if (backImgV != null)
    56. {
    57. backImgV = Graphics2D.ConvertBitmap(Target, new System.Drawing.Bitmap(backgroundImage));
    58. }
    60. //Instantiate a new List of Sprites:
    61. spriteList = new List<Sprite>();
    62. }
    64. /// <summary>
    65. /// The Background-Color the stage is getting cleared with.
    66. /// </summary>
    67. public System.Drawing.Color BackColor {
    68. get { return Graphics2D.AsDrawingColor(backgroundColorV); }
    69. set { backgroundColorV = Graphics2D.AsColor4(value); }
    70. }
    72. /// <summary>
    73. /// The Size of the Stage.
    74. /// </summary>
    75. public Size Size {
    76. get { return SizeV; }
    77. set { SizeV = value; }
    78. }
    80. /// <summary>
    81. /// The time in seconds, that is past from the Run()-Call till now.
    82. /// </summary>
    83. public double GameTime {
    84. get { return FPSSW.ElapsedMilliseconds / 1000; }
    85. }
    87. /// <summary>
    88. /// The user-defined limit of FPS that can be reached.
    89. /// </summary>
    90. public float TargetFPS {
    91. get { return targetFPSV; }
    92. set { targetFPSV = value; }
    93. }
    95. /// <summary>
    96. /// The Maximum FPS that can be reached without any FPS-limitation.
    97. /// </summary>
    98. public float MaxFPS {
    99. get { return maxFPSV; }
    100. }
    102. /// <summary>
    103. /// Shows if the Stage is actually running or not.
    104. /// </summary>
    105. public bool IsRunning {
    106. get { return !stopGame; }
    107. }
    109. /// <summary>
    110. /// Shows whether the FPS should be shown or not.
    111. /// </summary>
    112. public bool FPSVisible {
    113. get { return showFPSV; }
    114. set { showFPSV = value; }
    115. }
    117. public RenderTarget RenderTarget {
    118. get { return Target; }
    119. }
    121. /// <summary>
    122. /// A List of the Sprites that are drawn in the Stage.
    123. /// </summary>
    124. public List<Sprite> Sprites {
    125. get { return spriteList; }
    126. }
    128. /// <summary>
    129. /// Adds a new Sprite to draw in the stage.
    130. /// </summary>
    131. /// <param name="sprite">The Sprite that needs to be added.</param>
    132. public void AddSprite(Sprite sprite) {
    133. spriteList.Add(sprite);
    134. }
    136. /// <summary>
    137. /// Starts running the internal gameloop of the Stage with its drawing and gamelogic.
    138. /// </summary>
    139. public void Run()
    140. {
    141. //New Thread for maximum Performance:
    142. renderThread = new System.Threading.Thread(GameLoop);
    143. //Start the GameLoop:
    144. renderThread.Start();
    145. //Start the GameTime-Counter:
    146. FPSSW.Start();
    147. }
    149. private void GameLoop()
    150. {
    151. while (!stopGame)
    152. {
    153. long Duration = FPSSW.ElapsedMilliseconds;
    154. if (renderThread.TrySetApartmentState(System.Threading.ApartmentState.MTA) == false)
    155. {
    156. //Singlethreaded:
    157. Application.DoEvents();
    158. }
    159. //Calculation:
    160. GameLogic();
    161. //Rendering:
    162. Draw();
    163. while (FPSSW.ElapsedMilliseconds - Duration < 1) { /*Wait for interval to get bigger than one*/};
    164. maxFPSV = Convert.ToSingle(1000 / (FPSSW.ElapsedMilliseconds - Duration));
    165. while (FPSSW.ElapsedMilliseconds - Duration < 1000 / targetFPSV)
    166. {
    167. //Wait for next Frame
    168. }
    169. FPSV = Convert.ToSingle(1000 / (FPSSW.ElapsedMilliseconds - Duration));
    170. //It is normal to have the FPSV a bit lower than the targetFPS
    171. }
    172. }
    174. private void GameLogic()
    175. {
    176. spriteList[0].PlayAnimation("StarBlinking", GameTime);
    177. }
    179. private void Draw()
    180. {
    181. var T = Target;
    182. T.BeginDraw();
    183. //Clear the surface:
    184. T.Clear(backgroundColorV);
    186. //Paint the Background:
    187. if (backImgV != null)
    188. {
    189. if (BackgroundImageStretchMode == 0)//Don't stretch or tile the Background-Image
    190. {
    191. T.DrawBitmap(backImgV, 1F, BitmapInterpolationMode.Linear);
    192. }
    193. else if (BackgroundImageStretchMode == 1)//Stretch the Background-Image to the Size of the Stage
    194. {
    195. T.DrawBitmap(backImgV, new SharpDX.RectangleF(0, 0, SizeV.Width, SizeV.Height), 1F, BitmapInterpolationMode.Linear);
    196. }
    197. else if (BackgroundImageStretchMode == 2)//Tile the Background-Image on the X- and Y-Axes
    198. {
    199. for (int i = 0; i <= SizeV.Width / backImgV.PixelSize.Width; i++)
    200. {
    201. for (int j = 0; j <= SizeV.Height / backImgV.PixelSize.Height; j++)
    202. {
    203. T.DrawBitmap(backImgV, new SharpDX.RectangleF(i * backImgV.PixelSize.Width, j * backImgV.PixelSize.Height, backImgV.PixelSize.Width, backImgV.PixelSize.Height), 1F, BitmapInterpolationMode.Linear);
    204. }
    205. }
    206. }
    207. else if (BackgroundImageStretchMode == 3)//Tile the Background-Image on the X-Axis
    208. {
    209. for (int i = 0; i <= SizeV.Width / backImgV.PixelSize.Width; i++)
    210. {
    211. T.DrawBitmap(backImgV, new SharpDX.RectangleF(i * backImgV.PixelSize.Width, 0, backImgV.PixelSize.Width, backImgV.PixelSize.Height), 1F, BitmapInterpolationMode.Linear);
    212. }
    213. }
    214. else if (BackgroundImageStretchMode == 4)//Tile the Background-Image on the Y-Axis
    215. {
    216. for (int j = 0; j <= SizeV.Height / backImgV.PixelSize.Height; j++)
    217. {
    218. T.DrawBitmap(backImgV, new SharpDX.RectangleF(0, j * backImgV.PixelSize.Height, backImgV.PixelSize.Width, backImgV.PixelSize.Height), 1F, BitmapInterpolationMode.Linear);
    219. }
    220. }
    221. }
    223. //Draw here:
    224. for (int i = 0; i < spriteList.Count; i++) {
    225. T.DrawBitmap(spriteList[i].Image, new SharpDX.RectangleF(spriteList[i].Position.ToPointF(cameraBounds).X, spriteList[i].Position.ToPointF(cameraBounds).Y, spriteList[i].Width, spriteList[i].Height), 1F, BitmapInterpolationMode.Linear);
    226. }
    228. //Drawing the FPS:
    229. if (showFPSV)
    230. {
    231. T.DrawText(FPSV.ToString() + " FPS", new SharpDX.DirectWrite.TextFormat(textFactory, "Arial", 16), new SharpDX.RectangleF(5, 5, 100, 100), new SharpDX.Direct2D1.SolidColorBrush(Target, new Color4(1F, 0F, 0F, 1F)));
    232. }
    233. T.EndDraw();
    234. }
    236. /// <summary>
    237. /// Stops running the Stage and drawing it onto the Form.
    238. /// </summary>
    239. public void Close()
    240. {
    241. //Close the Thread:
    242. stopGame = true;
    243. renderThread.Abort();
    244. }
    245. }


    Sprite-Struktur:

    Quellcode

    1. public struct Sprite
    2. {
    3. private SharpDX.Direct2D1.Bitmap imgV;
    5. private Rectangle2 boundsV;
    7. private List<Animation> anims;
    9. public Sprite(Rectangle2 Bounds, Image stdImg, RenderTarget Target)
    10. {
    11. boundsV = Bounds;
    12. imgV = Graphics2D.ConvertBitmap(Target, new System.Drawing.Bitmap(stdImg));
    13. anims = new List<Animation>();
    14. }
    16. public Vector2 Position
    17. {
    18. get { return boundsV.Position; }
    19. set { boundsV.Position = value; }
    20. }
    22. public Size2 Size
    23. {
    24. get { return boundsV.Size; }
    25. set { boundsV.Size = value; }
    26. }
    28. public float X
    29. {
    30. get { return boundsV.X; }
    31. set { boundsV.X = value; }
    32. }
    34. public float Y
    35. {
    36. get { return boundsV.Y; }
    37. set { boundsV.Y = value; }
    38. }
    40. public float Width
    41. {
    42. get { return boundsV.Width; }
    43. set { boundsV.Width = value; }
    44. }
    46. public float Height
    47. {
    48. get { return boundsV.Height; }
    49. set { boundsV.Height = value; }
    50. }
    52. public SharpDX.Direct2D1.Bitmap Image
    53. {
    54. get { return imgV; }
    55. set { imgV = value; }
    56. }
    58. public void AddAnimation(Animation anim){
    59. anims.Add(anim);
    60. }
    62. public void PlayAnimation(string animationName, double gameTime) {
    63. for (int i = 0; i < anims.Count; i++)
    64. {
    65. if (anims[i].Name == animationName)
    66. {
    67. anims[i].Play(gameTime, ref imgV);
    68. break;
    69. }
    70. }
    71. }
    72. }


    Animation-Struktur:

    Quellcode

    1. public struct Animation {
    2. private SharpDX.Direct2D1.Bitmap[] framesV;
    3. private int frameCountV;
    4. private float frameIntervalV;
    5. private string nameV;
    7. private Stopwatch AnimSW;
    8. private bool isPlayingV;
    9. private double startTime;
    10. private int index;
    12. public Animation(string name, int frameCount, System.Drawing.Bitmap[] frames, float frameInterval, RenderTarget Target) {
    13. nameV = name;
    14. frameCountV = frameCount;
    15. framesV = new SharpDX.Direct2D1.Bitmap[frames.Length];
    16. for (int i = 0; i < frames.Length; i++) {
    17. framesV[i] = Graphics2D.ConvertBitmap(Target, frames[i]);
    18. }
    19. frameIntervalV = frameInterval;
    20. AnimSW = new Stopwatch();
    21. framesV = new SharpDX.Direct2D1.Bitmap[frameCount];
    22. isPlayingV = false;
    23. startTime = 0;
    24. index = 0;
    25. }
    27. public string Name {
    28. get { return nameV; }
    29. set { nameV = value; }
    30. }
    32. public float FrameInterval {
    33. get { return frameIntervalV; }
    34. set { frameIntervalV = value; }
    35. }
    37. public int FrameCount {
    38. get { return frameCountV; }
    39. set { frameCountV = value; }
    40. }
    42. public SharpDX.Direct2D1.Bitmap[] Frames {
    43. get { return framesV; }
    44. set { framesV = value; }
    45. }
    47. public bool IsPlaying {
    48. get { return isPlayingV; }
    49. }
    51. public void Play(double gameTime, ref SharpDX.Direct2D1.Bitmap img) {
    52. if (startTime + frameIntervalV <= gameTime)
    53. {
    54. img = framesV[index];
    55. index++;
    56. if (index >= framesV.Length) {
    57. index = 0;
    58. }
    59. startTime = gameTime;
    60. }
    61. }
    62. }


    Sorry wenn das ein bisschen viel Code ist, aber ich weiß echt nicht mehr, wo der Fehler liegen könnte, also wollte ich mal auf Nummer sicher gehen. ^^
    Dateien
    Auch Dunkelheit kann Erleuchtung bringen...

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Karabonga“ ()

Facebook
Telefonspende