class GameController(object):
def __init__(self):
pygame.init()
self.clock = pygame.time.Clock()
self.screen = pygame.display.set_mode(SCREENSIZE, 0, 32)
self.background = pygame.surface.Surface(SCREENSIZE).convert()
self.background.fill(BLACK)
self.mousePosition = None
self.bsp = None
self.testvertexlist = []
self.segments = [
] #make global for testing so we can see them dynamically
self.events = EventManager(self)
self.player = None
self.WR3D = None
self.mode3D = False
print("SCREEN WIDTH = " + str(SCREENWIDTH))
def update(self):
'''Main game loop'''
#dt = self.clock.tick(30) / 1000.0
x, y = pygame.mouse.get_pos()
self.mouseposition = Vector2(x, y)
self.events.update(self.mouseposition)
self.render()
def getTestSector(self):
'''From the testsectors file. Press button 5'''
L = testsectors.sector5()
print(L)
self.segments = []
for pair in L:
v1 = Vector2(pair[0])
v2 = Vector2(pair[1])
self.segments.append(Segment(v1, v2, name=pair[2]))
self.bsp = BSP(self.segments)
self.bsp.createTree()
def stepThroughTree(self):
'''This just helps me step through the tree one iteration at a time to see what it is doing for debugging.'''
self.bsp.traverseTree()
def createPlayer(self):
'''Create a player in the middle of the screen'''
#self.getSegmentDrawingOrder(self.mouseposition)
if self.player is None and self.bsp is not None:
self.player = Player(SCREENWIDTH / 2, SCREENHEIGHT / 2)
self.WR3D = WallRender3D(self.bsp.tree, self.player)
def render(self):
self.screen.blit(self.background, (0, 0))
if not self.mode3D:
if len(self.segments) > 0:
for seg in self.segments:
seg.render(self.screen)
if self.player is not None:
if self.mode3D:
self.WR3D.render(self.screen)
else:
self.player.render(self.screen)
pygame.display.update()
class Game(object):
"""Manages other game modules."""
def __init__(self, min_cycle_time=10):
self.min_cycle_time = min_cycle_time
self._run = False
self._last_update = 0
self._last_mouse_pos = None
self._selecting = False
self._select_start_pos = None
self._selection_rect = None
self._mouse_right_down = False
pygame.init()
screen_width, screen_height = screen_size = (1024, 768)
self._screen = pygame.display.set_mode(screen_size, pygame.DOUBLEBUF)
self._map = Map('default')
self._camera = Camera(screen_size)
self._renderer = Renderer(self._screen, self._camera)
self._objects = ObjectManager(self._map.size)
self._event_mgr = EventManager()
self._event_mgr.subscribe(pygame.QUIT, self._handle_quit)
self._event_mgr.subscribe(self._camera.move_event, self._camera_moved)
self._input = InputManager(self._event_mgr)
self._input.set_keybind(pygame.K_ESCAPE, self.stop)
self._input.set_keybind(pygame.K_q, self.stop)
self._input.set_hotarea((0, 0, screen_width, 2),
self._camera.set_move, {'y': -1})
self._input.set_hotarea((0, screen_height - 2, screen_width, 2),
self._camera.set_move, {'y': 1})
self._input.set_hotarea((0, 0, 2, screen_height - 2),
self._camera.set_move, {'x': -1})
self._input.set_hotarea((screen_width - 2, 0, 2, screen_height),
self._camera.set_move, {'x': 1})
self._input.set_hotarea((2, 2, screen_width - 4, screen_height - 4),
self._camera.stop_moving)
self._event_mgr.subscribe(self._input.mouse_drag_start,
self._select_start)
self._event_mgr.subscribe(self._input.mouse_drag_update,
self._select_update)
self._event_mgr.subscribe(self._input.mouse_drag_end,
self._select_end)
self._event_mgr.subscribe(self._input.lclick, self._leftclick)
self._event_mgr.subscribe(self._input.rclick, self._rightclick)
self._event_mgr.subscribe(self._input.rsclick,
self._right_shiftclick)
def run(self):
"""Run the main game loop."""
self._load()
self._last_update = pygame.time.get_ticks()
self._run = True
while self._run:
gametime = pygame.time.get_ticks()
time_passed = gametime - self._last_update
if time_passed < self.min_cycle_time:
pygame.time.wait(1) # give other threads some cpu time
continue
self._update(gametime, time_passed)
self._draw()
self._shutdown()
def _load(self):
unit_tex = self._renderer.load_texture('cross.png')
for x in range(0, 48, 16):
unit_pos = (x, 16)
unit_rect = Rect(unit_pos, self._renderer.texture_size(unit_tex))
unit_id = self._objects.create(Unit, unit_rect)
self._renderer.assign_texture(unit_id, unit_tex)
def _shutdown(self):
pass
def _update(self, gametime, time_passed):
self._event_mgr.update()
self._objects.update(gametime)
self._camera.update(time_passed)
self._last_update = gametime
#noinspection PyUnusedLocal
def _camera_moved(self, event):
if self._selecting:
self._update_selection_rectangle(self._last_mouse_pos)
def _select_start(self, event):
self._selecting = True
self._select_start_pos = self._camera.point_to_map(event.pos)
self._update_selection_rectangle(event.pos)
#noinspection PyUnusedLocal
def _select_end(self, event):
self._selecting = False
self._objects.select_area(self._selection_rect)
def _select_update(self, event):
self._last_mouse_pos = event.pos
self._update_selection_rectangle(event.pos)
def _update_selection_rectangle(self, pos):
map_pos = self._camera.point_to_map(pos)
self._selection_rect = Rect(min(self._select_start_pos[0], map_pos[0]),
min(self._select_start_pos[1], map_pos[1]),
abs(map_pos[0] - self._select_start_pos[0]),
abs(map_pos[1] - self._select_start_pos[1]))
def _leftclick(self, event):
self._objects.select_at(self._camera.point_to_map(event.pos))
def _rightclick(self, event):
self._objects.send_selected(self._camera.point_to_map(event.pos))
def _right_shiftclick(self, event):
self._objects.send_selected(self._camera.point_to_map(event.pos), True)
def _draw(self):
self._renderer.frame_start()
self._renderer.draw_map(self._map)
objs = self._objects.query(self._camera.view_rect)
self._renderer.draw_objects(objs)
if self._selecting:
self._renderer.draw_rectangle(self._selection_rect, (255, 0, 0))
self._renderer.frame_end()
def _draw_objects(self, surface, area):
pass
#noinspection PyUnusedLocal
def _handle_quit(self, event):
self.stop()
def stop(self):
self._run = False
class GameApp(App):
def build(self):
self.state_mgr = StateManager()
self.window = Window()
Clock.schedule_interval(self.update, 1.0 / 60.0)
self.game_state = GameState('lvl/levels')
self.state_mgr.push_state(self.game_state)
self.state_mgr.push_state(GameCreatorState(self))
self.event_manager = EventManager()
self.window.event_manager = self.event_manager
return self.window
def start_new_game(self):
next_lvl = self.game_state.advance_level()
# if we finished all the levels
restart_game = False
if not next_lvl:
self.game_state.reset()
next_lvl = self.game_state.advance_level()
restart_game = True
# create new game
game_logic = GameLogic()
game_logic.game_state = self.game_state
game_logic.event_manager = self.event_manager
self.add_graphic_state(game_logic)
game_logic.build_level(next_lvl)
self.game_logic = game_logic
# Display message at the begining of each level
msg = 'Level %d' % self.game_state.current_level
self.add_graphic_state(TemporaryMessage(msg))
if restart_game:
self.add_graphic_state(StartMenu())
msg = 'Credit goes here'
self.add_graphic_state(TemporaryMessage(msg))
else:
self.add_graphic_state(EndLevel(True))
# # take screenshot
# def take_screenshot(_, key):
# if key == 's':
# self.window.take_screenshot('screenshot.png')
# self.window.event_manager.register_action('key down', take_screenshot)
def update(self, dt):
self.state_mgr.update(dt=dt)
self.event_manager.update(dt)
if self.game_logic.game_ended:
# if this is the first time after the game has ended
if not self.game_logic.stop_when_unpaused:
display_msg = TemporaryMessage('GOOAAALL!!', duration=2)
self.add_graphic_state(display_msg)
self.game_logic.stop_when_unpaused = True
def add_graphic_state(self, state):
state_gfx = state.build_widget()
self.window.add_widget(state_gfx)
self.state_mgr.push_state(state)
def on_quit():
self.window.remove_widget(state_gfx)
state.on_quit = on_quit
class GameController(object):
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode(SCREENSIZE, 0, 32)
self.background = None
self.background_edit = None
self.background_connection = None
self.background_check = None
self.setBackground()
self.grid = [] #list of lines that define the grid
self.setup()
self.events = EventManager(self)
def setup(self):
self.vertices = {}
self.vertexShadow = None
self.showVertices = True
self.editMode = False #move vertices around
self.connectionMode = False #connect vertices together
self.checkMode = False #For checking the vertices properties by clicking on them
self.probeMode = False #For testing. Create a probe point (vertex)
self.drawGraphQuickMode = False
self.hoverVertex = None #vertex the mouse is hovering over at any point in time
self.vertex0 = None #vertex that connection line is coming from
self.followMouse = False #If true then the hoverVertex will follow the mouse if it is not None
self.drawConnectionLine = False
self.connectionLine = None #The line that shows when you are drawing a line from one vertex to the next
self.showGrid = False
self.vertex_key_ctr = 0
self.bsp = None
self.testvertexlist = []
self.clock = pygame.time.Clock()
def setBackground(self):
self.background = pygame.surface.Surface(SCREENSIZE).convert()
self.background.fill(DARKGRAY)
self.background_edit = pygame.surface.Surface(SCREENSIZE).convert()
self.background_edit.fill(BACKGROUNDEDIT)
self.background_connection = pygame.surface.Surface(
SCREENSIZE).convert()
self.background_connection.fill(CONNECTIONMODECOLOR)
self.background_check = pygame.surface.Surface(SCREENSIZE).convert()
self.background_check.fill(CHECKMODECOLOR)
self.background_probe = pygame.surface.Surface(SCREENSIZE).convert()
self.background_probe.fill(PROBEMODECOLOR)
self.segments = [
] #make global for testing so we can see them dynamically
def defineGrid(self):
'''Defines vertical and horizontal lines'''
#Define vertical lines
for i in range(NCOLS):
self.grid.append(
Line(Vector2(i * TILEWIDTH, 0),
Vector2(i * TILEWIDTH, SCREENHEIGHT), GRAY))
#Define horizontal lines
for i in range(NROWS):
self.grid.append(
Line(Vector2(0, i * TILEHEIGHT),
Vector2(SCREENWIDTH, i * TILEHEIGHT), GRAY))
def update(self):
'''Main game loop'''
x, y = pygame.mouse.get_pos()
mouseposition = Vector2(x, y)
self.hoverVertex = None
for vertex in self.vertices.values():
if vertex.inbounds(mouseposition):
self.hoverVertex = vertex
if self.editMode:
if self.hoverVertex is not None:
if self.followMouse:
self.hoverVertex.position = mouseposition
if self.probeMode:
if self.probe is not None:
if self.followMouse:
self.probe.position = mouseposition
if self.vertexShadow is not None:
self.vertexShadow.update(mouseposition)
if self.connectionLine is not None:
self.connectionLine.vector1 = mouseposition
self.events.update(mouseposition)
self.render()
def getVertex(self, position):
'''Return the key to the vertex that matches the position. Return None if no matches.'''
for key in self.vertices.keys():
if self.vertices[key].position == position:
return key
return None
def getTestSector(self):
'''From the testsectors file. '''
L = testsectors.sector1()
print("Test sector set")
def getAllSegments(self):
'''Just returns a list of all of the segments. [(1,2), (2,3), (4,5), ...].
as SegmentDirected objects.'''
segments = []
for key in self.vertices.keys():
for i in range(len(self.vertices[key].neighbors)):
segments.append(
Segment(self.vertices[key],
self.vertices[key].neighbors[i]))
return segments
def createBinaryTree(self):
'''Performs the steps necessary to split the segments into a space partitioned binary tree. PRESS B'''
self.segments = self.getAllSegments()
self.bsp = BSP(self.segments)
self.bsp.createTree(
) #just for testing. Normally doesn't return anything
self.segments = self.bsp.segmentList
def stepThroughTree(self):
'''This just helps me step through the tree one iteration at a time to see what it is doing for debugging.'''
self.bsp.traverseTree()
self.segments = self.bsp.segmentList
def createVertex(self, position):
'''Create a new vertex and add it to the dictionary'''
vertex = Vertex(position, key=self.vertex_key_ctr)
self.vertices[self.vertex_key_ctr] = vertex
self.vertex_key_ctr += 1
self.vertexShadow = None
def createVertexShadow(self, position):
self.vertexShadow = VertexShadow(position)
def createConnectionLine(self):
'''The line that is shown when connecting two nodes together. vertex0 is where the line is anchored'''
self.vertex0 = self.hoverVertex
position = self.hoverVertex.position
self.connectionLine = Line(position, position, RED)
def connectVerticesDirected(self):
'''Only vertex 1 knows about vertex 2'''
self.vertex0.addNeighbor(self.hoverVertex)
#def connectVerticesUndirected(self):
# '''Connect two vertices together such that they are neighbors of each other'''
# print("Undirected")
# #print(str(self.vertex0.key) + " <==> " + str(self.hoverVertex.key))
# self.vertex0.addNeighbor(self.hoverVertex)
# self.hoverVertex.addNeighbor(self.vertex0)
def removeNeighbors(self):
'''Remove all the neighbors from the vertices'''
for vertex in self.vertices.values():
vertex.neighbors = []
def render(self):
if self.editMode:
self.screen.blit(self.background_edit, (0, 0))
elif self.connectionMode:
self.screen.blit(self.background_connection, (0, 0))
elif self.checkMode:
self.screen.blit(self.background_check, (0, 0))
elif self.probeMode:
self.screen.blit(self.background_probe, (0, 0))
else:
self.screen.blit(self.background, (0, 0))
if self.showGrid:
for line in self.grid:
line.render(self.screen)
if self.connectionLine is not None:
self.connectionLine.render(self.screen)
for vertex in self.vertices.values():
vertex.renderConnections(self.screen)
if self.showVertices:
for vertex in self.vertices.values():
vertex.render(self.screen)
if self.vertexShadow is not None:
self.vertexShadow.render(self.screen)
#This is just to show where the line splits will be made when doing bsp
if len(self.testvertexlist) > 0:
#self.testvertexlist.render(self.screen)
for b in self.testvertexlist:
b.render(self.screen)
if len(self.segments) > 0:
for seg in self.segments:
seg.render(self.screen)
pygame.display.update()
