← Back to branch summary

~crempp/psg/devel

« back to all changes in this revision

Viewing changes to src/GSEng/GameStateMgr.py

  • Committer: Administrator
  • Date: 2009-12-14 04:46:06 UTC
  • Revision ID: administrator@gauss-20091214044606-deet4mtmsh0rwz52
Broken!

* Organized code into modules but did not fix it to work. In order to do this I had to remove the gui directory so I can add the GUI directory in the next commit.
* Began work on skybox extension.

Chad

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/GSEng/GameStateMgr.py
 
1
''' GameStateMgr.py
 
2
        Author:                 Chad Rempp
 
3
        Date:                   2009/05/27
 
4
        Purpose:                
 
5
        Usage:                  None
 
6
        References:             None
 
7
        Restrictions:   None
 
8
        License:                TBD
 
9
        Notes:                  
 
10
'''
 
11
 
 
12
# Python imports
 
13
import sys, random, cPickle
 
14
 
 
15
# Panda imports
 
16
from pandac.PandaModules import CollisionHandlerQueue
 
17
from pandac.PandaModules import CollisionNode
 
18
from pandac.PandaModules import CollisionRay
 
19
from pandac.PandaModules import CollisionTraverser
 
20
from pandac.PandaModules import GeomNode
 
21
from pandac.PandaModules import Plane
 
22
from pandac.PandaModules import Point3
 
23
from pandac.PandaModules import Vec3
 
24
 
 
25
# PSG imports
 
26
import Controller
 
27
import GeomObjects
 
28
import Event
 
29
import Entity
 
30
import Player
 
31
import Map
 
32
from Util import Singleton
 
33
from Game import ClientGame
 
34
 
 
35
# GameState---------------------------------------------------------------------
 
36
class GameStateManager:
 
37
        """A class that keeps track of the game state."""
 
38
        __metaclass__=Singleton
 
39
        
 
40
        gameId     = 0
 
41
        gameName   = ''
 
42
        players    = []
 
43
        turnNumber = 0
 
44
        map        = None
 
45
        startTime  = 0
 
46
        
 
47
        # States
 
48
        s_WaitingForSelection = True
 
49
        s_MoveCursor   = False
 
50
        s_AttackCursor = False
 
51
        selected = None
 
52
        currentPlayer = None
 
53
        
 
54
        def __init__(self,  gameToLoad=None):
 
55
                self.entitymanager = Entity.EntityManager()
 
56
                Event.Dispatcher().register(self, 'E_Key_Move', self.onMoveKey)
 
57
                Event.Dispatcher().register(self, 'E_Key_Exit', self.onExitKey)
 
58
                Event.Dispatcher().register(self, 'E_EntitySelect', self.onEntitySelect)
 
59
                #Event.Dispatcher().register(self, 'E_EntityUnSelect', self.onEntityUnSelect)
 
60
                Event.Dispatcher().register(self, 'E_Mouse_1', self.onMouse1)
 
61
                self.selector = Controller.Selector()
 
62
                
 
63
        
 
64
        def onMoveKey(self, event):
 
65
                if isinstance(self.selected, ShipEntity):
 
66
                                self.s_DoingMoveSelection  = True
 
67
                                self.movehandler = MovementSelectionHandler(self, self.selected)
 
68
                                self.game.mousecontroller.attach(self.movehandler)
 
69
        
 
70
        def onExitKey(self, event):
 
71
                # TODO - Handle this better.
 
72
                if self.s_MoveCursor:
 
73
                        # Exit moving state
 
74
                        self.selected.representation.unselectMove()
 
75
                        self.selected = None
 
76
                        self.s_MoveCursor = False
 
77
                        self.s_WaitingForSelection = True
 
78
                        self.selector.unpause()
 
79
                if self.s_AttackCursor:
 
80
                        # Exit attacking state (do not execute)
 
81
                        self.selected.representation.unselectAttack()
 
82
                else:
 
83
                        Event.Dispatcher().broadcast(Event.Event('E_ExitProgram', src=self))
 
84
                        
 
85
        def onMouse1(self, event):
 
86
                if self.s_MoveCursor:
 
87
                        # Exit moving state (execute move)
 
88
                        moveTo = self.selected.representation._movecursor.getPosition()
 
89
                        self.selected.representation.unselectMove()
 
90
                        self.selected.move(moveTo)
 
91
                        # TODO - calc fuel usage
 
92
                        self.selected.moved = True
 
93
                        self.s_MoveCursor = False
 
94
                        # Enter attacking state
 
95
                        self.selector.unpause()
 
96
                        self.selected.representation.selectAttack()
 
97
                        self.s_AttackCursor = True
 
98
                                        
 
99
        def onEntitySelect(self, event):
 
100
                if self.s_WaitingForSelection:
 
101
                        self.selected = self.entitymanager.getFromTag(event.data)
 
102
                        if self.selected.moved is not True:
 
103
                                # Enter moving state
 
104
                                Event.Dispatcher().broadcast(Event.Event('E_UpdateGUI', src=self, data=self.selected))
 
105
                                self.s_WaitingForSelection = False
 
106
                                self.selected.representation.selectMove()
 
107
                                self.s_MoveCursor = True
 
108
                                self.selector.pause()
 
109
                if self.s_AttackCursor:
 
110
                        if self.selected.attacked is not True:
 
111
                                # Exit attacking state (execute attack)
 
112
                                shipToAttack = self.entitymanager.getFromTag(event.data)
 
113
                                self.selected.representation.fireRockets(shipToAttack.pos)
 
114
                                self.selected.representation.unselectAttack()
 
115
                                # TODO - damage calc
 
116
                                self.selected.attacked = True
 
117
                                self.s_AttackCursor = False
 
118
                                self.selected = None
 
119
                                # Enter waitingforselection state
 
120
                                self.s_WaitingForSelection = True
 
121
                        
 
122
        def newGame(self, game):
 
123
                ''' Create game objects from the game object.
 
124
                        game (ClientGame).'''
 
125
                print("NEWGAME-->")
 
126
                self.gameId     = game.id
 
127
                self.gameName   = game.name
 
128
                self.turnNumber = game.turnNumber
 
129
                self.mapFileName= game.mapFileName
 
130
                self.startTime  = game.startTime
 
131
                self.mapName    = game.mapName
 
132
                
 
133
                print(self.mapFileName)
 
134
                
 
135
                # Load map
 
136
                fh = open(Map.MAP_PATH+self.mapFileName,'rb')
 
137
                serializedMap = cPickle.load(fh)
 
138
                players = serializedMap.getPlayers()
 
139
                planets = serializedMap.getPlanets()
 
140
                ships   = serializedMap.getShips()
 
141
                #print('SM - %s'%str(serializedMap._planets))
 
142
                print("num planets = %d"%len(planets))
 
143
                print("num ships = %d"%len(ships))
 
144
                
 
145
                print(planets)
 
146
                # Players
 
147
                for p in players:
 
148
                        self.players.append(Player(name=p['name'], faction=p['faction'], type=p['type'],ai=p['ai']))
 
149
                        
 
150
                # Planets
 
151
                for e in planets:
 
152
                        print(e)
 
153
                        self.entitymanager.addEntity(e)
 
154
                
 
155
                # Ships
 
156
                for e in ships:
 
157
                        print(e)
 
158
                        self.entitymanager.addEntity(e)
 
159
                        
 
160
                '''
 
161
                # Create players (for testing just 1 human, 1 computer)
 
162
                self.players.append(Player.Player("Player1"))
 
163
                self.players.append(Player.Player("Computer"))
 
164
                
 
165
                # Create planets
 
166
                for i in range(10):
 
167
                        pos = Vec3(random.uniform(-200, 200), 
 
168
                                                                random.uniform(-200, 200), 
 
169
                                                                random.uniform(-30, 30))
 
170
                        p = Entity.EntityPlanet(tag="Planet-"+str(i), pos=pos)
 
171
                        self.entitymanager.addEntity(p)
 
172
                        #p.addEntity(e)
 
173
                for i in range(3):
 
174
                        pos = Vec3(i*20, 0, 0)
 
175
                        e = Entity.EntityLightCapture(tag="Ship-"+self.players[0].name+"-"+str(i), pos=pos)
 
176
                        e.owner = self.players[0].name
 
177
                        self.entitymanager.addEntity(e)
 
178
                for i in range(3):
 
179
                        pos = Vec3(i*20, 50, 0)
 
180
                        e = Entity.EntityLightCapture(tag="Ship-"+self.players[1].name+"-"+str(i), pos=pos)
 
181
                        e.owner = self.players[1].name
 
182
                        self.entitymanager.addEntity(e)
 
183
                self.currentPlayer = self.players[0]
 
184
                '''
 
185
                
 
186
        def loadGame(self, gameToLoad):
 
187
                print("loadGame not implemented yet")
 
188
                
 
189
        def startGame(self):
 
190
                pass
 
191
 
 
192
class TurnMgr:
 
193
        _usedEntities = []
 
194
        def __init__(self):
 
195
                print("TurnMgr")
 
196
                
 
197
        def doTurnTask(self, Task, player):
 
198
                
 
199
                return Task.cont
 
200
                
 
201
        def endTurn(self):
 
202
                pass