Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Einfaches Menü für Xbox360/PC Spiel

Werbeanzeige

Big_Santa

Treue Seele

  • »Big_Santa« ist der Autor dieses Themas

Beiträge: 180

  • Private Nachricht senden

21

13.12.2012, 18:13

Ich habe mir das Kapitel zur Vererbung angesehen. Jedoch habe ich noch immer Probleme mit Exit() und kann deshalb das Interface nicht richtig testen.Ich versuche gerade ein Interface(so wie du es beschrieben hast) einzubauen. Ich bekomme Exit() ins Intro eingebaut, wenn ich es aber nicht im Intro, sondern im Menü haben möchte, dann funktioniert das Programm nicht richtig.
Das Intro erscheint zwar wenn ich das Programm ausführe, wenn ich jedoch dann auf die Space Taste drücke geschieht nichts. Ich komme also nicht ins Menü. Die Hauptspiel-Klasse(in der das eigentliche Spiel abläuft) habe ich jetzt mal bewusst weggelassen damit der Code nicht zu unübersichtlich wird.
Game1-Klasse:

C#-Quelltext

 
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

public class Game1 : Microsoft.Xna.Framework.Game     { 
        GraphicsDeviceManager graphics; 
        SpriteBatch spriteBatch; 
        private IState currentState; 

      
        public Game1() 
        { 
            graphics = new GraphicsDeviceManager(this); 
            Content.RootDirectory = "Content"; 
        } 
        
        protected override void Initialize() 
        { 
            currentState = new Intro(this); 
            base.Initialize(); 
        } 

        protected override void LoadContent() 
        {        
            spriteBatch = new SpriteBatch(GraphicsDevice); 
            currentState.Load(Content); 
        }
      
        protected override void Update(GameTime gameTime) 
        { 
            currentState.Update(gameTime);      
            KeyboardState kbState = Keyboard.GetState(); 
            base.Update(gameTime); 
        } 

        protected override void Draw(GameTime gameTime) 
        { 
            GraphicsDevice.Clear(Color.CornflowerBlue); 
            spriteBatch.Begin(); 
            currentState.Render(spriteBatch); 
            spriteBatch.End(); 
            
            base.Draw(gameTime); 
        } 
    }

Interface:

C#-Quelltext

 
1
2
3
4
5

public interface IState         { 
            void Load(ContentManager content); 
            void Update(GameTime gametime); 
            void Render(SpriteBatch batch); 
        }


Intro-Klasse:

C#-Quelltext

 
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

public class Intro : IState     { 
        private IState currentState; 
        Texture2D Titelbildschirm; 
        private Game1 exit; 
          

        public Intro(Game1 game) 
        { 
            exit = game; 
        } 


        public void Load(ContentManager content) 
        { 
           Titelbildschirm = content.Load<Texture2D>("gruft"); 
        } 

        public void Update(GameTime gametime) 
        { 
            KeyboardState kbState = Keyboard.GetState(); 
            if (kbState.IsKeyDown(Keys.Space)) 
              currentState = new Menu(exit); 
        } 

        public void Render(SpriteBatch batch) 
        { 
            batch.Draw(Titelbildschirm, new Rectangle(0, 0, 1280, 720), Color.White); 
        } 
    }


Menu-Klasse:

C#-Quelltext

 
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

public class Menu:IState   { 
    private IState currentState; 
    Texture2D Auswahlbildschirm; 

    private Game1 exit; 

        public Menu(Game1 game) 
        { 
            exit = game; 
        } 

    public void Load(ContentManager content) 
    { 
        Auswahlbildschirm = content.Load<Texture2D>("menubild"); 
    } 

    public void Update(GameTime gametime) 
    { 
        KeyboardState kbState = Keyboard.GetState(); 
        if (kbState.IsKeyDown(Keys.Enter)) 
            currentState = new Hauptspiel(); 
        if (kbState.IsKeyDown(Keys.Escape)) 
            exit.Exit(); 
    } 

    public void Render(SpriteBatch batch) 
    { 
        batch.Draw(Auswahlbildschirm, new Rectangle(0, 0, 1280, 720), Color.White); 
    } 
  }

Schorsch

Supermoderator

Beiträge: 5 145

Wohnort: Wickede

Beruf: Softwareentwickler

  • Private Nachricht senden

22

14.12.2012, 09:13

Du hast in der Klasse Intro eine Variable Namens currentState und setzt diese auf Menu wenn du die Leertaste drückst. Du willst aber dass currentState in der Klasse Game1 auf ein neues Menu gesetzt wird. Du könntest Game1 eine public Methode geben um den GameState zu setzen. Möglich wäre eine Methode StartMenu, oder SetGameState, welcher du dann ein Enum oder etwas anderes übergeben könntest. Da gibt es jetzt ne Menge Möglichkeiten wie du das umsetzen kannst. Der Rest sieht doch schon gut aus.
„Es ist doch so. Zwei und zwei macht irgendwas, und vier und vier macht irgendwas. Leider nicht dasselbe, dann wär's leicht.
Das ist aber auch schon höhere Mathematik.“

Big_Santa

Treue Seele

  • »Big_Santa« ist der Autor dieses Themas

Beiträge: 180

  • Private Nachricht senden

23

14.12.2012, 11:37

Ich habe jetzt mal das enum GameStates in Game1 eingebaut . Jedoch weiß ich nicht so recht wie die Intro-Klasse der Game1-Klasse den neuen Zustand(Menu) übergeben soll. Wenn die Space-Taste gedrückt wird soll ja das Menü aufgerufen werde. Ich habe in der Vergangenheit zwar schon mit enum gearbeitet, jedoch bis jetzt nur in der Game1-Klasse. Ich weiß nicht wie ich das machen soll wenn ich von mehreren Klassen aus auf enum GameStates zugreifen soll und das ganze auch noch richtig in Game1 benutzen soll.
Ich habe nur ein paar kleine Änderungen in den beiden Klassen Game1 und Intro vorgenommen. Außerdem bekomme ich jetzt in der Intro-Klasse folgende Fehlermeldungen:
The name 'IntroState' does not exist in the current context
'GameStates': cannot reference a type through an expression; try 'menuinterface.Game1.GameStates' instead
Game1-Klasse:

C#-Quelltext

 
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

public class Game1 : Microsoft.Xna.Framework.Game     { 
        GraphicsDeviceManager graphics; 
        SpriteBatch spriteBatch; 
        private IState currentState; 

        public enum GameStates 
        { 
            IntroState, 
            MenuState, 
            HauptspielState, 
        } 

        private GameStates currentGameState = GameStates.IntroState; 

      
        public Game1() 
        { 
            graphics = new GraphicsDeviceManager(this); 
            Content.RootDirectory = "Content"; 
        } 
        
        protected override void Initialize() 
        { 
            currentState = new Intro(this); 
            base.Initialize(); 
        } 

        protected override void LoadContent() 
        {        
            spriteBatch = new SpriteBatch(GraphicsDevice); 
            currentState.Load(Content); 
        } 

        protected override void Update(GameTime gameTime) 
        { 
            currentState.Update(gameTime);      
            KeyboardState kbState = Keyboard.GetState(); 
            base.Update(gameTime); 
        } 

        protected override void Draw(GameTime gameTime) 
        { 
            GraphicsDevice.Clear(Color.CornflowerBlue); 
            spriteBatch.Begin(); 
            currentState.Render(spriteBatch); 
            spriteBatch.End(); 
            
            base.Draw(gameTime); 
        } 
    }


Intro-Klasse:

C#-Quelltext

 
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

public class Intro : IState     { 
        private IState currentState; 
        Texture2D Titelbildschirm; 
        private Game1 game1;        

        public Intro(Game1 game) 
        { 
            game1 = game; 
        } 

        public void Load(ContentManager content) 
        { 
           Titelbildschirm = content.Load<Texture2D>("gruft"); 
        } 

        public void Update(GameTime gametime) 
        { 
            KeyboardState kbState = Keyboard.GetState(); 
            if (kbState.IsKeyDown(Keys.Space)) 
                game1.GameStates = IntroState; 
              currentState = new Menu(game1); 
        } 

        public void Render(SpriteBatch batch) 
        { 
            batch.Draw(Titelbildschirm, new Rectangle(0, 0, 1280, 720), Color.White); 
        } 
    }

Schorsch

Supermoderator

Beiträge: 5 145

Wohnort: Wickede

Beruf: Softwareentwickler

  • Private Nachricht senden

24

14.12.2012, 11:53

Du versuchst da ganz merkwürdige Dinge.
Game1 hat den aktuellen Zustand. Du willst außerhalb von Game1 den Zustand in Game1 ändern. Du hast die Referenz auf Game1 schon. Wie kannst du Game1 nun mitteilen, dass etwas geändert werden soll?
„Es ist doch so. Zwei und zwei macht irgendwas, und vier und vier macht irgendwas. Leider nicht dasselbe, dann wär's leicht.
Das ist aber auch schon höhere Mathematik.“

Big_Santa

Treue Seele

  • »Big_Santa« ist der Autor dieses Themas

Beiträge: 180

  • Private Nachricht senden

25

14.12.2012, 15:50

Ich habe noch immer Probleme damit den Aufbau zu verstehen.
"currentState.Update(gameTime);" aus Game1 ruft ja "void Update(GameTime gametime);" aus Interface 60x pro Sekunde auf. Dadurch übergibt die Game1-Klasse Informationen an das Interface, und das Interface vererbt die Informationen dann an die Klasse/Zustand, der gerade aktiv ist. Ist das richtig so?
Ich weiß nur nicht richtig wie ich dem Interface sagen soll, welcher Zustand gerade aktiv ist. Ich weiß nicht wie das in Code aussehen soll. Ich habe zwar jetzt den enum Block erstellt. Jedoch weiß ich nicht wie ich die Variable currentGameState in Zusammenhang mit dem Interface nutzen soll.
Im Moment kommt keine Fehlermeldung. Das Intro wird geladen, wenn ich dann aber auf die Space Taste klicke passiert nicht. Ich gehe davon aus dass es daran hängt dass ich nicht richtig weiß wie ich die Zustände am besten wechseln soll.

C#-Quelltext

 
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

public class Game1 : Microsoft.Xna.Framework.Game     { 
        GraphicsDeviceManager graphics; 
        SpriteBatch spriteBatch; 
        IState currentState; 

        public enum GameStates 
        { 
            IntroState = 0, 
            MenuState = 1, 
            HauptspielState = 2, 
        } 

        public GameStates CurrentState 
        { 
            get { return currentGameState; } 
            set { currentGameState = value; } 
        } 

        private GameStates currentGameState = GameStates.IntroState; 

      
        public Game1() 
        { 
            graphics = new GraphicsDeviceManager(this); 
            Content.RootDirectory = "Content"; 
        } 
        
        protected override void Initialize() 
        { 
            currentState = new Intro(this); 
            base.Initialize(); 
        } 

        protected override void LoadContent() 
        {        
            spriteBatch = new SpriteBatch(GraphicsDevice); 
            currentState.Load(Content); 
        } 
        
      
        protected override void Update(GameTime gameTime) 
        { 
            currentState.Update(gameTime);      
            KeyboardState kbState = Keyboard.GetState(); 
            base.Update(gameTime); 
        } 

        protected override void Draw(GameTime gameTime) 
        { 
            GraphicsDevice.Clear(Color.CornflowerBlue); 
            spriteBatch.Begin(); 
            currentState.Render(spriteBatch); 
            spriteBatch.End(); 
            
            base.Draw(gameTime); 
        } 
    }


C#-Quelltext

 
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

public class Intro : IState     { 
        private IState currentState; 
        Texture2D Titelbildschirm; 
        private Game1 game1;        

        public Intro(Game1 game) 
        { 
            game1 = game; 
        } 

        public void Load(ContentManager content) 
        { 
           Titelbildschirm = content.Load<Texture2D>("gruft"); 
        } 

        public void Update(GameTime gametime) 
        { 
            KeyboardState kbState = Keyboard.GetState(); 
            if (kbState.IsKeyDown(Keys.Space)) 
                game1.CurrentState = Game1.GameStates.MenuState; 
              currentState = new Menu(game1); 
        } 

        public void Render(SpriteBatch batch) 
        { 
            batch.Draw(Titelbildschirm, new Rectangle(0, 0, 1280, 720), Color.White); 
        } 
    }

Schorsch

Supermoderator

Beiträge: 5 145

Wohnort: Wickede

Beruf: Softwareentwickler

  • Private Nachricht senden

26

14.12.2012, 17:33

Nimm die Variable currentState aus der Klasse Menu. Dein Menü ist ein IState und soll keinen besitzen. Guck dir dafür noch mal den Unterschied zwischen "ist ein" und "hat ein" als Beziehung an. Es ist sehr wichtig die beiden auseinander halten zu können und auch zu verstehen wann man was davon verwendet.
Dein Problem ist ja eigentlich, dass Game1 den aktuellen Zustand besitzt. Wann der Zustand geändert wird, dass weiß nur die Klasse Menu. Menu muss Game1 also irgendwie mitteilen, dass der Zustand sich ändern soll.
Das hast du mit dem Property ja schon versucht. Das Problem ist, Game1 kann damit einen Enum Wert setzen. Dadurch bekommt currentState aber keinen neuen Wert. Wenn du möchtest, dass currentState in Game1 geändert wird, dann musst du auch eben dies machen. Die Enumeration soll da eigentlich nur als Hilfe dienen. Du kannst eine Methode schreiben die so einen Enum Wert als Parameter bekommt und festzulegen welcher Zustand gestartet werden soll.
Im Prinzip sowas:

C#-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public void ChangeGameState(GameStates newState)
{
    switch(newState)
    {
        case IntroState:
            currentState = new Intro();
            break;
        case MenuState:
            currentState = new Menu();
            break;
        case GameState:
            currentState = new Game();
            break;
    }
    currentState.Load();
}


Diese Methode bekommt die Klasse Game1. Parameter musst du natürlich anpassen. Die Methode selbst bekommt einen Wert deiner Enumeration als Parameter. Wenn du jetzt in deiner Menu Klasse game1.SetGameState(GameStates.GameState); aufrufst, dann wechselt die Klasse Game1 den Zustand zum Spiel. Eben weil der aktuelle Zustand auf den Spielzustand gewechselt wird. Wenn du das verstanden hast und umsetzen konntest, dann nimm dir erst mal ein paar einfache Dinge vor. Du wirfst viele Sachen noch durcheinander. Du hast mehr davon, wenn du zuerst die Grundlagen festigst. Dann fällt dir sowas viel viel leichter.
„Es ist doch so. Zwei und zwei macht irgendwas, und vier und vier macht irgendwas. Leider nicht dasselbe, dann wär's leicht.
Das ist aber auch schon höhere Mathematik.“

Big_Santa

Treue Seele

  • »Big_Santa« ist der Autor dieses Themas

Beiträge: 180

  • Private Nachricht senden

27

15.12.2012, 11:12

Es funktioniert jetzt alles. Jedoch habe ich noch ein paar Fragen zum Code.
Warum steht die Zeile „currentState.Load(Content);“ im switch Block?
Wird dadurch von jedem ausgewählten State(Klasse) die Load-Methode aufgerufen? Beim IntroState wäre das ja dann die Load-Methode der Intro-Klasse. Dann bräuchte ich ja folgende Zeile aus Game1 LoadContent() nicht mehr, oder?

C#-Quelltext

 
1

currentState.Load(Content);

Ich verstehe nicht was das „this“ in den Klammern des switch Blocks bedeutet. Warum braucht man das?

C#-Quelltext

 
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

public class Game1 : Microsoft.Xna.Framework.Game     { 
        GraphicsDeviceManager graphics; 
        SpriteBatch spriteBatch; 
        IState currentState; 

        public enum GameStates 
        { 
            IntroState = 0, 
            MenuState = 1, 
            MaingameState = 2, 
            QuitgameState = 3 
        } 


        public void ChangeGameState(GameStates newState) 
        { 
            switch (newState) 
            { 
                case GameStates.IntroState: 
                    currentState = new Intro(this); 
                    break; 
                case GameStates.MenuState: 
                    currentState = new Menu(this); 
                    break; 
                case GameStates.MaingameState: 
                    currentState = new Maingame(this); 
                    break; 
                case GameStates.QuitgameState: 
                    currentState = new Quit(this); 
                    break; 
            } 
            currentState.Load(Content); 
        } 


        public GameStates CurrentState 
        { 
            get { return currentGameState; } 
            set { currentGameState = value; } 
        } 

        private GameStates currentGameState = GameStates.IntroState; 

      
        public Game1() 
        { 
            graphics = new GraphicsDeviceManager(this); 
            Content.RootDirectory = "Content"; 
        } 
        
        protected override void Initialize() 
        { 
            ChangeGameState(GameStates.IntroState); 
            base.Initialize(); 
        } 

        protected override void LoadContent() 
        {        
            spriteBatch = new SpriteBatch(GraphicsDevice); 
            currentState.Load(Content); 
        } 

        protected override void Update(GameTime gameTime) 
        { 
            currentState.Update(gameTime);      
            KeyboardState kbState = Keyboard.GetState(); 
            base.Update(gameTime); 
        } 

        protected override void Draw(GameTime gameTime) 
        { 
            GraphicsDevice.Clear(Color.CornflowerBlue); 
            spriteBatch.Begin(); 
            currentState.Render(spriteBatch); 
            spriteBatch.End(); 
            
            base.Draw(gameTime); 
        } 
    }

Ich arbeite im Moment an einem Quit-Auswahlbildschirm. Wenn der Spieler während des Spiels die ESC-Taste drückt soll ein kleiner Bildschirm kommen der fragt ob der Spieler das Hauptspiel verlassen(und ins Menü zurück gehen) oder weiterspielen möchte.
Dabei habe ich das Problem dass das Hauptspiel überschrieben(neu gestartet) wird wenn der Spieler im Quit-Auswahlbildschirm "weiterspielen" wählt.
Ist es kompliziert sowas ähnliches wie in diesem Bild zu machen? Das Spiel darf ja nicht(wie im Moment bei mir) neu gestartet werden wenn man in dem kleinen Menü weiterspielen wählt.
aba6ff793bf251e3a50e0fae87593626.gif

Schorsch

Supermoderator

Beiträge: 5 145

Wohnort: Wickede

Beruf: Softwareentwickler

  • Private Nachricht senden

28

15.12.2012, 13:39

Du meinst wohl, warum die Load Methode nicht im Switch Block steht sondern dahinter. Das Interface IState legt doch fest, dass eine Klasse die von IState erbt, unter anderem die Methode Load(ContentManager); bereitstellen muss. In currentState ist ein Objekt vom Typ IState. Du könntest jetzt jedes mal im case-Block die Load Methode mit aufrufen, das wäre aber recht anstrengend. Du müsstest für jeden Zustand Load(Content) aufrufen. Du weißt jedoch, dass currentState nach dem Switch-Block erzeugt ist und kannst deswegen einfach an dieser Stelle Load aufrufen. Du kannst für dich überlegen, ob du eine Load Methode überhaupt brauchst. Hier gab es vor kurzem eine Diskussion darüber ob Init-Methoden Sinn machen, oder ob man immer nur den Konstruktor benutzen soll. Die Load Methode kann man hier mit so einer Init Methode vergleichen. Im Prinzip macht eine Load Methode dann Sinn, wenn du dein Objekt möglicherweise neu laden willst ohne es zu zerstören.
Zum Thema this. This gibt dir die aktuelle Klasse zurück. Der Konstruktor von Intro legt doch zum Beispiel fest, dass er als Parameter ein Objekt vom Typ Game1 bekommen möchte. In Game1 erzeugst du nun ein Objekt vom Typ Intro. Du musst diesem Objekt nun irgendwie ein Game1 mit geben. Game1 möchte sich selbst als Parameter übergeben. Unt genau das macht man mit this. This ist einfach eine Referenz auf das Objekt indem es aufgerufen wird.
Zu deinem Menü Problem. Da gibt es mehrere Möglichkeiten. Einerseits könnte man das über die Methode lösen, welche im Wiki beschrieben wird. Dort benutzt man einen StateManager, der die Zustände auf einem Stack ablegt. Du hast das Spiel auf dem Stack abgelegt, wenn nun das Ingamemenü aufgerufen wird, dann wird das Spiel "nicht" von Stack entfernt, das Ingamemenü aber einfach oben drauf geschoben. Wenn du jetzt von Ingamemenü wieder ins Spiel willst, wird das Ingamemenü einfach entfernt und das Spiel ist wieder oben. Andererseits könntest du auch einfach immer den Letzten Zustand speichern. Du hast dann also nicht nur currentState sondern auch lastState vom Typ IState. Wenn der Zustand gewechselt wird, dann muss natürlich vorher der alte Zustand neu gesetzt werden. Jetzt könntest du eine Funktion schreiben, die den Zustand auf den letzten Zustand zurück setzt. Die Version mit dem Stack ist natürlich noch etwas flexibler.
So und nun tu mir bitte einen gefallen:) Entweder kaufst du dir ein Buch über C#, oder guckst dir das Openbook von Galileo mal allgemein an und arbeitest es durch. Bis auf die Fragen zur Lösung von GameStates waren das im Prinzip alles Fragen, die man automatisch geklärt kriegt wenn man ein Buch darüber gelesen hat;) Tu dir also selbst den gefallen und lern die Grundlagen vernünftig. So hast du dann auch selbst mehr davon.
„Es ist doch so. Zwei und zwei macht irgendwas, und vier und vier macht irgendwas. Leider nicht dasselbe, dann wär's leicht.
Das ist aber auch schon höhere Mathematik.“

Big_Santa

Treue Seele

  • »Big_Santa« ist der Autor dieses Themas

Beiträge: 180

  • Private Nachricht senden

29

15.12.2012, 23:38

Zitat von »Schorsch«

Zu deinem Menü Problem. Da gibt es mehrere Möglichkeiten. Einerseits könnte man das über die Methode lösen, welche im Wiki beschrieben wird. Dort benutzt man einen StateManager, der die Zustände auf einem Stack ablegt. Du hast das Spiel auf dem Stack abgelegt, wenn nun das Ingamemenü aufgerufen wird, dann wird das Spiel "nicht" von Stack entfernt, das Ingamemenü aber einfach oben drauf geschoben. Wenn du jetzt von Ingamemenü wieder ins Spiel willst, wird das Ingamemenü einfach entfernt und das Spiel ist wieder oben. Andererseits könntest du auch einfach immer den Letzten Zustand speichern. Du hast dann also nicht nur currentState sondern auch lastState vom Typ IState. Wenn der Zustand gewechselt wird, dann muss natürlich vorher der alte Zustand neu gesetzt werden. Jetzt könntest du eine Funktion schreiben, die den Zustand auf den letzten Zustand zurück setzt. Die Version mit dem Stack ist natürlich noch etwas flexibler.
Wenn das Ingame-Menü im Vordergrund und das pausierte Hauptspiel im Hintergrund sein soll, dann brauche ich doch immer einen currentState und einen lastState oder nicht?
Der currentState wäre das Ingame-Menü das gerade oben auf dem Stack ist. Das Hauptspiel wäre der lastState der sich im Stack unter dem currentState befindet.
Wenn man dann im Ingame-Menü auf "Resume" klickt wird das Hauptspiel wieder der currentState.
Ich verstehe nicht richtig wie das nachher als Code aussehen soll. Es wird doch immer nur der currentState gezeichnet. Wenn man im Ingame-Menü ist, muss dann der lastState(pausiertes Hauptspiel) zuerst gezeichnet werden, und danach der currentState(aktives Ingame-Menü). Oder wie geht man da vor?

Welches Buch für 2D Programmierung würdest du empfehlen?

Schorsch

Supermoderator

Beiträge: 5 145

Wohnort: Wickede

Beruf: Softwareentwickler

  • Private Nachricht senden

30

16.12.2012, 21:14

Das wäre doch schon eine Möglichkeit. Dazu habe ich wenig Ahnung. Ich habe C# erst recht spät gelernt und konnte da schon programmieren. Hier gab es mal ein paar Threads zum Thema Bücher. Da waren auch welche zu C# und XNA dabei. Wirago hatte da glaube ich welche vorgeschlagen. Musst du mal mit der Suchfunktion gucken.
„Es ist doch so. Zwei und zwei macht irgendwas, und vier und vier macht irgendwas. Leider nicht dasselbe, dann wär's leicht.
Das ist aber auch schon höhere Mathematik.“

Werbeanzeige

Ähnliche Themen