source: gamelib/engine.py @ 320:9bf0e701a36e

Last change on this file since 320:9bf0e701a36e was 320:9bf0e701a36e, checked in by Neil Muller <drnlmuller@…>, 11 years ago

Switch between 'Finished Day' and 'Fast Forward' modes

File size: 8.8 KB
Line 
1"""Game engine and states."""
2from pgu.engine import Game, State, Quit
3import pygame
4from pygame.locals import USEREVENT, QUIT, KEYDOWN, K_ESCAPE, K_n, K_d, K_s, K_i
5
6import gameboard
7import gameover
8import sound
9import constants
10import mainmenu
11import helpscreen
12
13class Engine(Game):
14    def __init__(self, main_app):
15        self.main_app = main_app
16        self.clock = pygame.time.Clock()
17        self.main_menu = mainmenu.make_main_menu()
18        self._open_window = None
19        self.scoreboard = gameover.ScoreTable()
20        self.gameboard = None
21
22    def tick(self):
23        """Tic toc."""
24        pygame.time.wait(10)
25
26    def open_window(self, window):
27        """Open a widget as the main window."""
28        if self._open_window is not None:
29            self.main_app.close(self._open_window)
30        self.main_app.open(window)
31        self._open_window = window
32
33    def create_game_board(self):
34        """Create and open a gameboard window."""
35        self.gameboard = gameboard.GameBoard(self.main_app)
36        self.open_window(self.gameboard.get_top_widget())
37
38    def set_main_menu(self):
39        """Open the main menu"""
40        self.open_window(self.main_menu)
41
42    def set_help_screen(self):
43        """Open the main menu"""
44        help_screen = helpscreen.make_help_screen()
45        self.open_window(help_screen)
46
47    def create_game_over(self):
48        """Create and open the Game Over window"""
49        for mode, days in constants.TURN_LIMITS.iteritems():
50            if days == constants.TURN_LIMIT:
51                game_over = gameover.create_game_over(self.gameboard,
52                        self.scoreboard[mode], mode)
53        self.gameboard = None
54        self.open_window(game_over)
55
56    def event(self, e):
57        if not Game.event(self, e):
58            if self.gameboard:
59                return self.gameboard.event(e)
60            return False
61        return True
62       
63
64class MainMenuState(State):
65    def init(self):
66        sound.stop_background_music()
67        self.game.set_main_menu()
68
69    def event(self, e):
70        if events_equal(e, START_DAY):
71            self.game.create_game_board()
72            return DayState(self.game)
73        elif events_equal(e, GO_HELP_SCREEN):
74            return HelpScreenState(self.game)
75        elif e.type is KEYDOWN:
76            if e.key == K_ESCAPE:
77                return Quit(self.game)
78            elif e.key == K_s:
79                self.game.create_game_board()
80                return DayState(self.game)
81            elif e.key == K_i:
82                return HelpScreenState(self.game)
83        elif e.type is not QUIT:
84            self.game.main_app.event(e)
85
86    def paint(self, screen):
87        screen.fill((0,0,0))
88        self.game.main_app.paint(screen)
89        pygame.display.flip()
90
91    def update(self, screen):
92        update = self.game.main_app.update(screen)
93        pygame.display.update(update)
94
95class HelpScreenState(State):
96    def init(self):
97        sound.stop_background_music()
98        self.game.set_help_screen()
99
100    def event(self, e):
101        if e.type is KEYDOWN and e.key == K_ESCAPE:
102            return MainMenuState(self.game)
103        elif events_equal(e, GO_MAIN_MENU):
104            return MainMenuState(self.game)
105        elif e.type is not QUIT:
106            self.game.main_app.event(e)
107
108    def paint(self, screen):
109        screen.fill((0,0,0))
110        self.game.main_app.paint(screen)
111        pygame.display.flip()
112
113    def update(self, screen):
114        update = self.game.main_app.update(screen)
115        pygame.display.update(update)
116
117class DayState(State):
118    def init(self):
119        """Add some chickens to the farm"""
120        sound.stop_background_music()
121        self.game.gameboard.start_day()
122
123        sound.play_sound("daybreak.ogg")
124        # disable timer
125        pygame.time.set_timer(MOVE_FOX_ID, 0)
126        pygame.time.set_timer(ANIM_ID, SLOW_ANIM_SPEED)
127        self.game.gameboard.advance_day()
128        self.game.gameboard.clear_foxes()
129        sound.background_music("daytime.ogg")
130        self.game.gameboard.hatch_eggs()
131
132    def event(self, e):
133        if events_equal(e, START_NIGHT):
134            self.game.gameboard.reset_states()
135            return NightState(self.game)
136        elif e.type is KEYDOWN and e.key == K_ESCAPE:
137            self.game.gameboard.reset_states()
138            return GameOver(self.game)
139        elif e.type is ANIM_ID:
140            self.game.gameboard.run_animations()
141        elif e.type is KEYDOWN and e.key == K_n:
142            return pygame.event.post(START_NIGHT)
143        elif events_equal(e, GO_MAIN_MENU):
144            return MainMenuState(self.game)
145        elif e.type is not QUIT:
146            self.game.main_app.event(e)
147
148    def paint(self, screen):
149        self.game.main_app.paint(screen)
150        pygame.display.flip()
151
152    def update(self, screen):
153        self.game.gameboard.update()
154        update = self.game.main_app.update(screen)
155        pygame.display.update(update)
156
157    def loop(self):
158        self.game.gameboard.loop()
159
160class NightState(State):
161    def init(self):
162        """Add some foxes to the farm"""
163        sound.stop_background_music()
164        self.game.gameboard.start_night()
165
166        sound.play_sound("nightfall.ogg")
167        # Add a timer to the event queue
168        self.cycle_count = 0
169        self.cycle_time = SLOW_ANIM_SPEED
170        pygame.time.set_timer(MOVE_FOX_ID, 4*self.cycle_time)
171        pygame.time.set_timer(ANIM_ID, self.cycle_time)
172        self.game.gameboard.spawn_foxes()
173        sound.background_music("nighttime.ogg")
174
175        self.game.gameboard.lay_eggs()
176
177    def event(self, e):
178        if events_equal(e, START_DAY):
179            if self.game.gameboard.is_game_over():
180                return GameOver(self.game)
181            return DayState(self.game)
182        elif (e.type is KEYDOWN and e.key == K_d) or \
183                events_equal(e, FAST_FORWARD):
184            if self.cycle_time > FAST_ANIM_SPEED:
185                self.cycle_time = FAST_ANIM_SPEED
186            else:
187                self.cycle_time = SLOW_ANIM_SPEED
188            pygame.time.set_timer(ANIM_ID, self.cycle_time)
189            pygame.time.set_timer(MOVE_FOX_ID, 4*self.cycle_time)
190        elif e.type is KEYDOWN and e.key == K_ESCAPE:
191            self.game.gameboard.set_cursor()
192            return GameOver(self.game)
193        elif e.type is ANIM_ID:
194            self.game.gameboard.run_animations()
195        elif e.type is MOVE_FOX_ID:
196            # Timer aren't nessecairly ordered, so we make sure
197            # we don't get a ANIM event until at least cycle after this
198            pygame.time.set_timer(ANIM_ID, self.cycle_time)
199            # Ensure any outstanding animitions get cleaned up
200            self.game.gameboard.run_animations()
201            self.cycle_count += 1
202            if self.cycle_count > constants.NIGHT_LENGTH:
203                return pygame.event.post(START_DAY)
204            if self.game.gameboard.move_foxes():
205                # All foxes are gone/safe, so dawn happens
206                return pygame.event.post(START_DAY)
207        elif e.type is not QUIT:
208            self.game.main_app.event(e)
209
210    def loop(self):
211        self.game.gameboard.loop()
212
213    def paint(self, screen):
214        self.game.main_app.paint(screen)
215        pygame.display.flip()
216
217    def update(self, screen):
218        self.game.gameboard.update()
219        update = self.game.main_app.update(screen)
220        pygame.display.update(update)
221
222class GameOver(State):
223    def init(self):
224        """Setup everything"""
225        sound.stop_background_music()
226        self.game.create_game_over()
227        pygame.time.set_timer(MOVE_FOX_ID, 0)
228        pygame.time.set_timer(ANIM_ID, 0)
229
230    def event(self, e):
231        if e.type is KEYDOWN:
232            if e.key == K_ESCAPE:
233                return MainMenuState(self.game)
234        elif events_equal(e, GO_MAIN_MENU):
235            return MainMenuState(self.game)
236        elif e.type is not QUIT:
237            self.game.main_app.event(e)
238
239    def paint(self, screen):
240        screen.fill((0,0,0))
241        self.game.main_app.paint(screen)
242        pygame.display.flip()
243
244    def update(self, screen):
245        update = self.game.main_app.update(screen)
246        pygame.display.update(update)
247
248# pygame events
249
250def events_equal(e1, e2):
251    """Compare two user events."""
252    return (e1.type is e2.type and e1.name == e2.name)
253
254START_DAY = pygame.event.Event(USEREVENT, name="START_DAY")
255START_NIGHT = pygame.event.Event(USEREVENT, name="START_NIGHT")
256GO_MAIN_MENU = pygame.event.Event(USEREVENT, name="GO_MAIN_MENU")
257GO_HELP_SCREEN = pygame.event.Event(USEREVENT, name="GO_HELP_SCREEN")
258FAST_FORWARD = pygame.event.Event(USEREVENT, name="FAST_FORWARD")
259MOVE_FOX_ID = USEREVENT + 1
260ANIM_ID = USEREVENT + 6
261MOVE_FOXES = pygame.event.Event(MOVE_FOX_ID, name="MOVE_FOXES")
262QUIT = pygame.event.Event(QUIT)
263
264# Due to the way pgu's loop timing works, these will only get proceesed
265# at intervals of 10ms, so there's no point in them not being multiples of 10
266FAST_ANIM_SPEED=20
267SLOW_ANIM_SPEED=50
Note: See TracBrowser for help on using the repository browser.