def game_setting_menu(interface, input_board, squareside):
fenetre = None
if interface != 1:
if (input_board == []):
print("\033[90m")
squareside = input('\033[92mChoose size for Npuzzle: \n\033[91m')
#####################
#Ce check est obligatoire sinon tu peux balance une string ....
if squareside.isdigit() == False or int(squareside) < 2:
print("\033[91mBad value select int > 1\033[0m")
exit()
elif int(squareside) > 100:
print("\033[91mDo you really wanna wait forever ??\033[0m")
exit()
#####################
squareside = int(squareside)
print("\033[90m")
heuristic, algo = terminal_menu(squareside)
gamemode = 'ia'
# Comment this else if you don't want to go in the menu
#
else:
fenetre = pygame.display.set_mode((1000, 800), 0, 32)
menu_items = ('IA', 'Solo', 'Quit')
pygame.display.set_caption('Game Menu')
gm = GameMenu(fenetre, menu_items, input_board)
# return the choice enter in the menu
heuristic, algo, squareside, gamemode = gm.run()
return heuristic, algo, squareside, gamemode, fenetre
def __init__(self):
self.farm = Farm()
self.dices = [
Dice(6 * [AnimalType.RABBIT] + 3 * [AnimalType.SHEEP] + [AnimalType.PIG, AnimalType.COW, AnimalType.WOLF]),
Dice(6 * [AnimalType.RABBIT] + 2 * [AnimalType.SHEEP, AnimalType.PIG] + [AnimalType.HORSE, AnimalType.FOX])]
self.menu = GameMenu(self)
self.turns = []
def __init__(self, game):
self.allSprites = pygame.sprite.Group()
self.entities = pygame.sprite.Group()
self.layer1 = pygame.sprite.Group() # layer 1
self.layer2 = pygame.sprite.Group() # layer 2
self.layer3 = pygame.sprite.Group() # layer 3
self.layer4 = pygame.sprite.Group() # layer 4 is all layers combined
self.game = game
self.currentLayer = 4
self.level = ""
# Hud for when the game is running
self.hud = GameHud(self.game)
self.menu = GameMenu(self.game)
self.messageSystem = MessageHud(self.game)
self.personClickManager = PersonClickManager(self.game)
self.transportClickManager = TransportClickManager(self.game)
self.personHolderClickManager = PersonHolderClickManager(self.game)
self.rendering = False
# Game timer to keep track of how long has been played
self.timer = 0
# Make this dependant on the level and make it decrease
# as the number of people who reach their destinations increase
self.timeStep = 25
self.lives = DEFAULTLIVES
self.score, self.bestScore = 0, 0
self.dt = 1 # Control the speed of whats on screen
self.startDt = self.dt
self.fixedScale = 1 # Control the size of whats on the screen
self.startingFixedScale = 0
self.paused = False # Individual pause for the levels
self.setDefaultMap()
self.totalPeople, self.completed, self.totalToComplete = 0, 0, 0
self.totalPeopleNone = False
self.slowDownMeterAmount = 75
self.debug = False
self.darkMode = False
# The connection types availabe on the map (always has layer 4)
self.connectionTypes = ["layer 4"]
class Game:
def __init__(self):
self.farm = Farm()
self.dices = [
Dice(6 * [AnimalType.RABBIT] + 3 * [AnimalType.SHEEP] + [AnimalType.PIG, AnimalType.COW, AnimalType.WOLF]),
Dice(6 * [AnimalType.RABBIT] + 2 * [AnimalType.SHEEP, AnimalType.PIG] + [AnimalType.HORSE, AnimalType.FOX])]
self.menu = GameMenu(self)
self.turns = []
def resolve_turn(self):
self.menu.print_options()
picked_option = InputListener.get_int_input()
option = self.menu.get_option(picked_option)
turn = Turn(option)
turn.resolve_turn()
self.turns.append(turn)
def main_loop(self):
while True:
self.resolve_turn()
def __init__(self):
self.is_running = False
self.is_alive = False
self.is_train = False
self.is_human = True
self.__hero = Hero()
self.__score = 0
self.__action_queue = []
self.__width = WIDTH
self.__height = HEIGHT
self.__clock = None
self.__environment = None
self.screen = pg.display.set_mode((self.__width, self.__height))
pg.init()
self.__graphics = Graphics(self.screen)
self.menu = GameMenu(self, self.screen)
def handle_key(self, key):
if self.flow_path:
return
if self.menu is not None:
self.menu.handle_key(key)
return
if key == pygame.K_ESCAPE and not self.menu:
self.menu = GameMenu(game=self,
main=self.main,
screen=self.screen,
settings=self.settings)
return
if self.reset_on_next_click:
self.reset_fullness()
self.reset_on_next_click = False
if key == pygame.K_RETURN:
self.start_flow()
#add bounds to game world
gameWorld.addObject(objects.BoundingBox(gameWorld, 20, 20))
gameWorld.addObject(objects.Field())
#add players to game world
player = HumanPlayer(gameWorld, (-5.0, 1.1, 5.0))
player.camera = gameWorld.camera
gameWorld.addObject(player)
gameWorld.addObject(AiPlayer(gameWorld, ball.body, (-5.0, 1.1, -5.0)))
gameWorld.addObject(AiPlayer(gameWorld, ball.body, (5.0, 1.1, -5.0)))
gameWorld.addObject(AiPlayer(gameWorld, ball.body, (5.0, 1.1, 5.0)))
glClearColor(0.5, 0.7, 0.9, 1.0)
#create game menu object
gameMenu = GameMenu()
#add the background objects to menu
gameMenu.addObject(objects.Field())
gameMenu.addObject(objects.BoundingBox(gameMenu, 10.0, 10))
crazyCubes = [objects.Cube(gameMenu, (-5.0, 1.001, -5.0), 200, (2.0, 2.0, 2.0), (1,1,0)),
objects.Cube(gameMenu, (-5.0, 3.002, -5.0), 200, (2.0, 2.0, 2.0), (0,0,1)),
objects.Cube(gameMenu, (-5.0, 5.003, -5.0), 200, (2.0, 2.0, 2.0), (1,0,0)),
objects.Cube(gameMenu, (-5.0, 7.004, -5.0), 200, (2.0, 2.0, 2.0), (0,1,0))]
for cube in crazyCubes: gameMenu.addObject(cube)
crazyBall = objects.Sphere(gameMenu, (-4,4,4), 200, 2.0, (0,0,1))
crazyBall.body.addForce((5515, 3515, -454451))
gameMenu.addObject(crazyBall)
gameMenu.camera.setTarget(crazyBall)
layer.sprite.position = new.center
scroller.set_focus(*new.center)
# Schedule Updates
layer.schedule(update)
# Add map to scroller
scroller.add(tilemap)
#Create Scene
scene = Scene()
# Create and add background
background = Background()
scene.add(background)
#Add main layer to scroller
scroller.add(layer)
scroller.add(ShowCollision())
# Add scroller to scene
scene.add(scroller)
# Game menu configuration
menu = GameMenu(scene)
menuScene = Scene()
menuScene.add(menu)
director.run(menuScene)
def main():
game_menu = GameMenu()
game_menu.showing()
#add bounds to game world
gameWorld.addObject(objects.BoundingBox(gameWorld, 20, 20))
gameWorld.addObject(objects.Field())
#add players to game world
player = HumanPlayer(gameWorld, (-5.0, 1.1, 5.0))
player.camera = gameWorld.camera
gameWorld.addObject(player)
gameWorld.addObject(AiPlayer(gameWorld, ball.body, (-5.0, 1.1, -5.0)))
gameWorld.addObject(AiPlayer(gameWorld, ball.body, (5.0, 1.1, -5.0)))
gameWorld.addObject(AiPlayer(gameWorld, ball.body, (5.0, 1.1, 5.0)))
glClearColor(0.5, 0.7, 0.9, 1.0)
#create game menu object
gameMenu = GameMenu()
#add the background objects to menu
gameMenu.addObject(objects.Field())
gameMenu.addObject(objects.BoundingBox(gameMenu, 10.0, 10))
crazyCubes = [
objects.Cube(gameMenu, (-5.0, 1.001, -5.0), 200, (2.0, 2.0, 2.0),
(1, 1, 0)),
objects.Cube(gameMenu, (-5.0, 3.002, -5.0), 200, (2.0, 2.0, 2.0),
(0, 0, 1)),
objects.Cube(gameMenu, (-5.0, 5.003, -5.0), 200, (2.0, 2.0, 2.0),
(1, 0, 0)),
objects.Cube(gameMenu, (-5.0, 7.004, -5.0), 200, (2.0, 2.0, 2.0),
(0, 1, 0))
]
class GameEngine:
def __init__(self):
self.is_running = False
self.is_alive = False
self.is_train = False
self.is_human = True
self.__hero = Hero()
self.__score = 0
self.__action_queue = []
self.__width = WIDTH
self.__height = HEIGHT
self.__clock = None
self.__environment = None
self.screen = pg.display.set_mode((self.__width, self.__height))
pg.init()
self.__graphics = Graphics(self.screen)
self.menu = GameMenu(self, self.screen)
@staticmethod
def off_screen():
pg.display.iconify()
def setup(self):
self.is_running = True
self.is_alive = True
self.__action_queue = []
self.__score = 0
self.__hero = Hero()
self.__environment = Environment()
self.__environment.create_level()
self.__clock = pg.time.Clock()
def __key_checker(self, event):
if not self.is_train:
if event.type == pg.KEYDOWN:
if event.key == pg.K_ESCAPE:
self.menu.pause_menu()
elif event.key == pg.K_SPACE:
if not self.is_alive:
self.menu.start_menu()
elif 'jump' not in self.__action_queue:
self.__action_queue.append('jump')
elif event.key == pg.K_LCTRL:
if 'sit' not in self.__action_queue:
self.__action_queue.append('sit')
elif event.type == pg.KEYUP:
if event.key == pg.K_SPACE:
if 'jump' in self.__action_queue:
self.__action_queue.remove('jump')
elif event.key == pg.K_LCTRL:
if 'sit' in self.__action_queue:
self.__action_queue.remove('sit')
def get_action_from_key_check(self):
if len(self.__action_queue) == 0:
return 'nothing'
else:
return self.__action_queue[0]
def __collision_check(self):
collision_logic = CollisionLogic()
current_prop = self.__environment.prop_list[0]
if collision_logic.check_collision(self.__hero, current_prop):
self.is_alive = False
def get_state(self):
cur_prop = self.__environment.prop_list[0]
hero_y = self.__hero.coord[1]
hero_x_size, hero_y_size = self.__hero.size
hero_r_u_x = hero_x_size
hero_r_u_y = hero_y + hero_y_size
hero_vel_y = self.__hero.vel[1]
hero_acc_y = self.__hero.acc[1]
prop_x, prop_y = cur_prop.coord
prop_x_size, prop_y_size = cur_prop.size
prop_r_u_x = prop_x + prop_x_size
prop_r_u_y = prop_y + prop_y_size
prop_vel_x = cur_prop.vel[0]
hero_y /= self.__height
hero_r_u_x /= self.__width
hero_r_u_y /= self.__height
hero_vel_y /= MAX_VEL
hero_acc_y /= MAX_ACC
prop_x /= self.__width
prop_y /= self.__height
prop_r_u_x /= self.__width
prop_r_u_y /= self.__height
prop_vel_x /= MAX_VEL
result = [
hero_y, hero_r_u_x, hero_r_u_y, hero_vel_y, hero_acc_y, prop_x,
prop_y, prop_r_u_x, prop_r_u_y, prop_vel_x
]
return result
def get_all_info(self):
next_state = self.get_state()
reward = 1
done = not self.is_alive
return next_state, reward, done
def render(self):
self.__clock.tick(FPS)
for event in pg.event.get():
if event.type == pg.QUIT:
exit(0)
else:
self.__key_checker(event)
if not self.is_alive:
finished = self.__graphics.draw_wasted_screen()
if finished:
self.menu.start_menu()
else:
visible_obj = self.__environment.prop_list
self.__graphics.draw(self.__hero, visible_obj, self.__score,
STANDARD_MODE)
pg.display.update()
def step(self, action):
self.__score += 1
self.__collision_check()
self.__hero.change_state(action)
self.__hero.update()
self.__environment.update()
def main():
director.init(**window)
menu = GameMenu()
menu.start_game()
from constants import *
from display import Display
from fever import Fever
from game import Game
from menu import GameMenu
from settings import Settings
# Set up
myDisplay = Display()
mySettings = Settings()
myMenu = GameMenu(myDisplay, mySettings)
# myPowerup = PowerUp(myDisplay.surface)
myFever = Fever(myDisplay.surface, myDisplay, mySettings)
# myPowerup.set_track(myFever.track)
myGame = Game(myMenu, myDisplay, myFever, mySettings)
running = True
# Game loop
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
myGame.run()
# Quit the game
pygame.quit()
quit()
class SpriteRenderer():
# Loads all the sprites into groups and stuff
def __init__(self, game):
self.allSprites = pygame.sprite.Group()
self.entities = pygame.sprite.Group()
self.layer1 = pygame.sprite.Group() # layer 1
self.layer2 = pygame.sprite.Group() # layer 2
self.layer3 = pygame.sprite.Group() # layer 3
self.layer4 = pygame.sprite.Group() # layer 4 is all layers combined
self.game = game
self.currentLayer = 4
self.level = ""
# Hud for when the game is running
self.hud = GameHud(self.game)
self.menu = GameMenu(self.game)
self.messageSystem = MessageHud(self.game)
self.personClickManager = PersonClickManager(self.game)
self.transportClickManager = TransportClickManager(self.game)
self.personHolderClickManager = PersonHolderClickManager(self.game)
self.rendering = False
# Game timer to keep track of how long has been played
self.timer = 0
# Make this dependant on the level and make it decrease
# as the number of people who reach their destinations increase
self.timeStep = 25
self.lives = DEFAULTLIVES
self.score, self.bestScore = 0, 0
self.dt = 1 # Control the speed of whats on screen
self.startDt = self.dt
self.fixedScale = 1 # Control the size of whats on the screen
self.startingFixedScale = 0
self.paused = False # Individual pause for the levels
self.setDefaultMap()
self.totalPeople, self.completed, self.totalToComplete = 0, 0, 0
self.totalPeopleNone = False
self.slowDownMeterAmount = 75
self.debug = False
self.darkMode = False
# The connection types availabe on the map (always has layer 4)
self.connectionTypes = ["layer 4"]
def setDefaultMap(self):
self.levelData = {
"mapName": "",
"locked": {
"isLocked": False,
"unlock": 0
}, # Amount to unlock
# Map can / cannot be deleted; maps that cant be
# deleted cant be opened in the editor
"deletable": True,
"saved": False, # Has the map been saved before
"width": 18,
"height": 10,
"difficulty": 1, # Out of 4
"total": 8, # Total to complete the level
"score": 0,
"completion": {
"total": 10,
"completed": False,
"time": 0
},
"backgrounds": {
"layer 1": CREAM, # Default color: CREAM :)
"layer 2": CREAM,
"layer 3": CREAM,
"layer 4": CREAM
},
"connections": {},
"transport": {},
"stops": {},
"destinations": {}
} # Level data to be stored, for export to JSON
# Save function, for when the level has already
# been created before (and is being edited)
def saveLevel(self):
self.game.mapLoader.saveMap(self.levelData["mapName"], self.levelData)
def setRendering(self, rendering, transition=False):
self.rendering = rendering
self.hud.main(transition) if self.rendering else self.hud.close()
if self.rendering:
self.messageSystem.main()
else:
self.messageSystem.close()
# Create the paused surface when first rendering
self.createPausedSurface()
def runStartScreen(self):
if self.rendering and not self.debug:
self.menu.startScreen()
def runEndScreen(self, completed=False):
if self.rendering and not self.debug:
if completed:
self.menu.endScreenComplete(True) # Run with transition
else:
self.menu.endScreenGameOver(True) # Run with transition
def setCompleted(self, completed):
self.completed = completed
self.hud.setCompletedText()
# When the player completed the level, set it to complete
# in the level data and save the data
def setLevelComplete(self):
if not hasattr(self, 'levelData'):
return
# If the level is not already set to completed, complete it
if not self.levelData["completion"]["completed"]:
self.levelData["completion"]["completed"] = True
self.saveLevel()
# Use the number of lives left to work out the players score TODO:
# Make this use other factors in the future
# Return the previous keys and difference so
# this can be used in the menu animation
def setLevelScore(self):
if not hasattr(self, 'levelData'):
return
self.score = self.lives
previousScore = 0
if "score" in self.levelData:
previousScore = self.levelData["score"]
self.bestScore = previousScore
if self.score > previousScore:
self.levelData["score"] = self.score
self.saveLevel()
if self.score - previousScore > 0:
scoreDifference = self.score - previousScore
else:
scoreDifference = 0
# Use this in the menu animation
previousKeys = config["player"]["keys"]
config["player"]["keys"] += scoreDifference
dump(config)
return previousKeys, scoreDifference, previousScore
def setTotalToComplete(self, totalToComplete):
self.totalToComplete = totalToComplete
def setSlowDownMeterAmount(self, slowDownMeterAmount):
self.slowDownMeterAmount = slowDownMeterAmount
def setDt(self, dt):
self.dt = dt
def setFixedScale(self, fixedScale):
self.fixedScale = fixedScale
def setStartingFixedScale(self, startingFixedScale):
self.startingFixedScale = startingFixedScale
def setDebug(self, debug):
self.debug = debug
def setDarkMode(self):
if ("backgrounds" in self.levelData
and "darkMode" in self.levelData["backgrounds"]
and self.levelData["backgrounds"]["darkMode"]):
self.darkMode = True
else:
self.darkMode = False
def setTotalPeople(self, totalPeople):
self.totalPeople = totalPeople
def setLives(self, lives):
self.lives = lives
def togglePaused(self):
self.dt = 0
self.paused = not self.paused
# self.game.paused = not self.game.paused
# self.createPausedSurface()
def getStartDt(self):
return self.startDt
def getDt(self):
return self.dt
def getFixedScale(self):
return self.fixedScale
def getStartingFixedScale(self):
return self.startingFixedScale
def getHud(self):
return self.hud
def getMenu(self):
return self.menu
def getMessageSystem(self):
return self.messageSystem
def getLevel(self):
return self.level
def getLevelData(self):
return self.levelData
def getPersonClickManager(self):
return self.personClickManager
def getTransportClickManager(self):
return self.transportClickManager
def getLayer(self):
return self.currentLayer
def getCompleted(self):
return self.completed
def getTotalToComplete(self):
return self.totalToComplete
def getSlowDownMeterAmount(self):
return self.slowDownMeterAmount
def getDebug(self):
return self.debug
def getConnectionTypes(self):
return self.connectionTypes
def getDarkMode(self):
return self.darkMode
def getTotalPeople(self):
return self.totalPeople
def getLives(self):
return self.lives
def getAllDestination(self):
if hasattr(self, 'allDestinations'):
return self.allDestinations
def getScore(self):
return self.score
def getBestScore(self):
return self.bestScore
def getPaused(self):
return self.paused
def getCurrentLayer(self):
return self.currentLayer
def getPersonHolderClickManager(self):
return self.personHolderClickManager
def removeLife(self):
self.lives -= 1
# remove a heart from the hud here or something
self.hud.setLifeAmount()
if self.lives <= 0:
# Although we pause the game in the timer, we want to
# stop anything else from reducing the life count here whilst the
# timer is decreasing (so no one can die whilst it is decreasing)
pass
def addToCompleted(self):
self.completed += 1
# self.timeStep -= 0.5
self.hud.setCompletedAmount()
self.meter.addToAmountToAdd(20)
# Reset the level back to its default state
def clearLevel(self):
self.paused = False # Not to confuse the option menu
self.startingFixedScale = 0 # reset the scale back to default
self.timer = 0
self.lives = DEFAULTLIVES
self.totalPeople = 0
self.totalPeopleNone = False
self.entities.empty()
self.allSprites.empty()
self.layer1.empty()
self.layer2.empty()
self.layer3.empty()
self.layer4.empty()
# Reset the layers to show the top layer
self.currentLayer = 4
self.connectionTypes = []
self.setDefaultMap()
def createLevel(self, level, debug=False):
self.clearLevel()
# Currently this calls the wrong hud as its done before the hud is set
self.setCompleted(0)
self.debug = debug
self.gridLayer4 = Layer4(self, (self.allSprites, self.layer4), level)
# Set the name of the level
self.level = self.gridLayer4.getGrid().getLevelName()
# Set the level data
self.levelData = self.gridLayer4.getGrid().getMap()
# for running the game in test mode (when testing a level)
if self.debug:
# Push the level down since we have hud at the top
spacing = (1.5, 1.5)
self.hud = PreviewHud(self.game, spacing)
else:
# self.startingFixedScale = -0.05
# spacings = {
# (16, 9): (1.5, 1),
# (18, 10): (2, 1.5),
# (20, 11): (1.5, 1),
# (22, 12): (1.5, 1)}
# size = (self.levelData["width"], self.levelData["height"])
# spacing = spacings[size]
spacing = (1.5, 1)
self.hud = GameHud(self.game, spacing)
# we want to get which connectionTypes are available in the map
for connectionType in self.levelData['connections']:
self.connectionTypes.append(connectionType)
self.gridLayer3 = Layer3(self,
(self.allSprites, self.layer3, self.layer4),
level, spacing)
self.gridLayer1 = Layer1(self,
(self.allSprites, self.layer1, self.layer4),
level, spacing)
# Walking layer at the bottom so nodes are drawn above metro stations
self.gridLayer2 = Layer2(self,
(self.allSprites, self.layer2, self.layer4),
level, spacing)
self.gridLayer4.addLayerLines(self.gridLayer1, self.gridLayer2,
self.gridLayer3)
self.gridLayer1.grid.loadTransport("layer 1")
self.gridLayer2.grid.loadTransport("layer 2")
self.gridLayer3.grid.loadTransport("layer 3")
self.removeDuplicates()
# Set all the destinations to be the destinations from all layers
layer1Destinations = self.gridLayer1.getGrid().getDestinations()
layer2Destinations = self.gridLayer2.getGrid().getDestinations()
layer3Destinations = self.gridLayer3.getGrid().getDestinations()
self.allDestinations = (layer1Destinations + layer2Destinations +
layer3Destinations)
# Set number of people to complete level
if "total" not in self.levelData:
self.totalToComplete = random.randint(8, 12)
else:
self.totalToComplete = self.levelData["total"]
# self.totalToComplete = 1
self.meter = MeterController(self, self.allSprites,
self.slowDownMeterAmount)
self.setDarkMode()
# If there is more than one layer we want to be able
# to see 'all' layers at once (layer 4)
# otherwise we only need to see the single layer
if len(self.connectionTypes) > 1 or self.debug:
self.connectionTypes.append("layer 4")
else:
self.showLayer(
self.getGridLayer(self.connectionTypes[0]).getNumber())
# Draw the level to a surface and return this surface for blitting
# (i.e on the level selection screen)
def createLevelSurface(self, level):
self.clearLevel()
self.startingFixedScale = -0.2
spacings = {
(16, 9): (3.5, 2),
(18, 10): (4, 2.5),
(20, 11): (4.5, 2.8),
(22, 12): (5, 3)
}
gridLayer4 = MenuLayer4(self, (), level)
levelData = gridLayer4.getGrid().getMap()
size = (levelData["width"], levelData["height"])
spacing = spacings[size]
gridLayer3 = Layer3(self, (), level, spacing)
gridLayer1 = Layer1(self, (), level, spacing)
gridLayer2 = Layer2(self, (), level, spacing)
gridLayer4.addLayerLines(gridLayer1, gridLayer2, gridLayer3)
return gridLayer4.getLineSurface()
# Create a new surface when the game is paused with all the sprites
# currently in the game, so these don't have to be drawn every frame
# (as they are not moving)
def createPausedSurface(self):
if self.rendering and self.game.paused:
self.pausedSurface = pygame.Surface(
(int(config["graphics"]["displayWidth"] *
self.game.renderer.getScale()),
int(config["graphics"]["displayHeight"] *
self.game.renderer.getScale()))).convert()
lineSurface = (
self.getGridLayer("layer " +
str(self.currentLayer)).getLineSurface())
self.pausedSurface.blit(lineSurface, (0, 0))
for entity in self.entities:
entity.drawPaused(self.pausedSurface)
self.renderPausedLayer(1, self.layer1)
self.renderPausedLayer(2, self.layer2)
self.renderPausedLayer(3, self.layer3)
self.renderPausedLayer(4, self.layer4)
# for component in (
# self.hud.getComponents()
# + self.messageSystem.getComponents()):
# # draw hud and message system
# component.drawPaused(self.pausedSurface)
return self.pausedSurface
def getSpriteLayer(self, connectionType):
if connectionType == "layer 1":
return self.layer1
elif connectionType == "layer 2":
return self.layer2
elif connectionType == "layer 3":
return self.layer3
elif connectionType == "layer 4":
return self.layer4
def getGridLayer(self, connectionType):
if connectionType == "layer 1":
return self.gridLayer1
elif connectionType == "layer 2":
return self.gridLayer2
elif connectionType == "layer 3":
return self.gridLayer3
elif connectionType == "layer 4":
return self.gridLayer4
# Get all the nodes from all layers in the spriterenderer
def getAllNodes(self, sortNodes=False):
layer1Nodes = self.gridLayer1.getGrid().getNodes()
layer2Nodes = self.gridLayer2.getGrid().getNodes()
layer3Nodes = self.gridLayer3.getGrid().getNodes()
allNodes = layer1Nodes + layer2Nodes + layer3Nodes
# Sort the node so that the stops are at the top
if sortNodes:
allNodes = sorted(allNodes, key=lambda x: isinstance(x, Stop))
allNodes = sorted(allNodes,
key=lambda x: isinstance(x, Destination))
# Reverse the list so they're at the front
allNodes = allNodes[::-1]
return allNodes
# Remove duplicate nodes on layer 4 for layering
def removeDuplicates(self, allNodes=None, removeLayer=None):
seen = {}
dupes = []
removeLayer = self.layer4 if removeLayer is None else removeLayer
if allNodes is None:
allNodes = self.getAllNodes()
# Make sure stops are at the front of the list, so they are not removed
allNodes = sorted(allNodes, key=lambda x: isinstance(x, Stop))
allNodes = sorted(allNodes, key=lambda x: isinstance(x, Destination))
allNodes = allNodes[::-1] # Reverse the list so they're at the front
for node in allNodes:
if node.getNumber() not in seen:
seen[node.getNumber()] = 1
else:
if seen[node.getNumber()] == 1:
dupes.append(node)
for node in dupes:
removeLayer.remove(node)
# if there is a node above the given node,
# return the highest node, else return node
def getTopNode(self, bottomNode):
allNodes = self.getAllNodes(True)
for node in allNodes:
if node.getNumber() == bottomNode.getNumber():
return node
return bottomNode
def update(self):
if not self.rendering:
return
self.allSprites.update()
if self.paused:
return
self.events()
self.timer += self.game.dt * self.dt
# Always spawn a person if there is no people
# left on the map, to stop player having to wait
if self.timer > self.timeStep:
self.timer = 0
self.gridLayer2.createPerson(self.allDestinations)
if self.totalPeople <= 0:
if not self.totalPeopleNone:
self.timer = 0
self.totalPeopleNone = True
# wait 2 seconds before spawing the next
# person when there is no people left
if self.timer > 2 and self.totalPeopleNone:
self.timer = 0
self.gridLayer2.createPerson(self.allDestinations)
self.totalPeopleNone = False
def events(self):
if pygame.key.get_pressed()[pygame.K_SPACE]:
self.game.clickManager.setSpaceBar(True)
if (self.dt != self.startDt - self.meter.getSlowDownAmount()
and not self.meter.getEmpty()):
self.game.audioLoader.playSound("slowIn", 1)
else:
if self.dt != self.startDt:
self.game.audioLoader.playSound("slowOut", 1)
self.game.clickManager.setSpaceBar(False)
# Make people on the current layer clickable, and the rest non-clickable
def resetPeopleClicks(self):
totalPeople = (self.gridLayer1.getPeople() +
self.gridLayer2.getPeople() +
self.gridLayer3.getPeople())
currentLayerPeople = self.getGridLayer(
"layer " + str(self.currentLayer)).getPeople()
for person in totalPeople:
if person in currentLayerPeople or self.currentLayer == 4:
# Always went every person to be clickable on the top layer
person.setCanClick(True)
else:
person.setCanClick(False)
def resetPersonHolderClicks(self):
totalNodes = self.getAllNodes()
for node in totalNodes:
if (node.getConnectionType() == "layer " + str(self.currentLayer)
or self.currentLayer == 4):
# Always want every person holder to be clickable
# on the top layer
node.getPersonHolder().setCanClick(True)
else:
node.getPersonHolder().setCanClick(False)
def showLayer(self, layer):
if not self.rendering:
return
# Only switch to a layer that is in the map
if "layer " + str(layer) in self.connectionTypes:
self.currentLayer = layer
# Redraw the nodes so that the mouse cant collide with them
self.resize()
self.hud.updateLayerText()
self.resetPeopleClicks()
self.resetPersonHolderClicks()
def resize(self):
# If a layer has any images, they must be resized here
if self.rendering:
self.gridLayer1.resize()
self.gridLayer2.resize()
self.gridLayer3.resize()
# Only need to do this if it has components
self.gridLayer4.resize()
# We want to reset the layer 4 lines with the
# new ones (resized) from the other layers
self.gridLayer4.addLayerLines(self.gridLayer1, self.gridLayer2,
self.gridLayer3)
# resize huds and menus
self.hud.resize()
self.menu.resize()
self.messageSystem.resize()
for sprite in self.allSprites:
sprite.dirty = True
self.createPausedSurface()
# Draw all the sprites in a layer, based on what layer the player
# is currently on
def renderLayer(self, layerInt, gridLayer, group):
if self.currentLayer == layerInt:
gridLayer.draw()
for sprite in group:
sprite.draw()
# Draw all sprites to the paused surface, based on what layer the player
# is currently on
def renderPausedLayer(self, layerInt, group):
if self.currentLayer == layerInt:
for sprite in group:
sprite.drawPaused(self.pausedSurface)
def render(self):
if self.rendering:
if not self.game.paused:
# Entities drawn below the other sprites
for entity in self.entities:
entity.draw()
self.renderLayer(1, self.gridLayer1, self.layer1)
self.renderLayer(2, self.gridLayer2, self.layer2)
self.renderLayer(3, self.gridLayer3, self.layer3)
self.renderLayer(4, self.gridLayer4, self.layer4)
else:
if hasattr(self, 'pausedSurface'):
self.game.renderer.addSurface(
self.pausedSurface, (self.pausedSurface.get_rect()))
self.hud.display()
self.messageSystem.display()
self.menu.display()
