def __init__(self,
dir_sprites,
dir_sounds,
dir_fonts,
lifes=constants['MAX_PLAYER_LIFES'],
hjump=constants['INITIAL_PLAYER_HJUMP'],
gravity=constants['INITIAL_PLAYER_GRAVITY'],
position=list(constants['START_POSITION_PLAYER'])):
self.hud = Hud(dir_sprites, dir_fonts, lifes=lifes)
self.sprites = {
'wait':
pygame.image.load(dir_sprites['player_wait']).convert_alpha(),
'run':
pygame.image.load(dir_sprites['player_run']).convert_alpha(),
'hurt':
pygame.image.load(dir_sprites['player_hurt']).convert_alpha()
}
#the following attribute will be modified in method _run...
self.sprite_base = self.sprites['wait']
self.sounds = {
'score_plus':
pygame.mixer.Sound(dir_sounds['sound_player_score_plus'])
}
self.attributes = {
'hjump': hjump,
'gravity': gravity,
'position': position
}
def __init__(self, virtual_width, virtual_height, map_height, map_width):
self.v_rect = pygame.Rect(0, 0, virtual_width, virtual_height-config.hud_size)
self.map_rect = pygame.Rect(0, 0, map_width, map_height)
self.hud_rect = pygame.Rect(0, virtual_height-config.hud_size, virtual_width, config.hud_size)
self.map_layer = []
self.map_layer_surf= pygame.Surface((self.map_rect.w, self.map_rect.h))
self.item_layer = []
self.item_layer_surf= pygame.Surface((self.map_rect.w, self.map_rect.h), flags=pygame.SRCALPHA)
self.unit_layer = []
self.unit_layer_surf= pygame.Surface((self.map_rect.w, self.map_rect.h), flags=pygame.SRCALPHA)
self.unit_action_surf = pygame.Surface((self.map_rect.w, self.map_rect.h), flags=pygame.SRCALPHA)
self.hud = Hud(0, virtual_height-config.hud_size, virtual_width, config.hud_size, self)
self.hud_surf = pygame.Surface((self.hud_rect.w, self.hud_rect.h))
self.hud_surf.fill(pygame.Color("#737373"))
self.hud_font = pygame.font.Font("assets/bitwise/bitwise.ttf", 25)
self.dirty = 1
self.font = pygame.font.Font(None, 20)
self.mouse_events = []
def postInit(self):
#
# initialize game content
#
base.cTrav = CollisionTraverser("base collision traverser")
base.pusher = CollisionHandlerPusher()
self.menu = Menu()
self.credits = Credits()
self.charSelection = CharacterSelection()
self.levelSelection = LevelSelection()
self.koScreen = KoScreen()
self.hud = Hud()
self.menuMusic = loader.loadMusic("assets/audio/menuMusic.ogg")
self.menuMusic.setLoop(True)
self.fightMusic = loader.loadMusic("assets/audio/fightMusic.ogg")
self.fightMusic.setLoop(True)
base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
#
# Event handling
#
self.accept("escape", self.__escape)
#
# Start with the menu
#
self.request("Menu")
def start_loop(self):
"""Loop for start screen"""
selected = False
background = Background(START_BG, [0, 0])
top_score = Hud(10, 350, 200, 40, "TOP SCORE")
def launch_game():
nonlocal selected
selected = True
self.game_loop()
while not selected:
for event in pygame.event.get():
if event.type == pygame.QUIT:
selected = True
top_score.prop = self.scores.top_score
self.clock.tick(20)
pygame.mouse.set_visible(True)
self.screen.blit(background.image, background.rect)
large_text = pygame.font.Font('freesansbold.ttf', 80)
text_surf, text_rect = text_objects("OMEGA!", large_text,
(210, 208, 224))
text_rect.center = ((self.screen_width / 2),
(self.screen_height / 2.75))
self.screen.blit(text_surf, text_rect)
top_score.update(dest=self.screen)
button('PLAY', ((self.screen_width / 2) - 50), 240, 100, 40,
((37, 31, 71), (108, 100, 153), (210, 208, 224)),
self.screen, launch_game)
def __init__(self, _parent=None):
self.parent = _parent
# Containers
self.game_objects = {}
self.game_doors = {}
self.game_objects_np = render.attachNewNode("Game_Objects")
self.game_doors_np = render.attachNewNode("Player_Doors")
self.game_doors_np.setPos(0, 0, 0)
self.game_counter_node = None
self.game_collector_nodes = []
self.redDudesCount = 0
self.blueDudesCount = 0
# Physics world
self.physics_world = None
self.builder = Builder(self)
# level lights
self.directLight = None
# Dude class
self.dude = None
self.spawnPoints = self.builder.spawnPoints
# HUD
self.hud = Hud()
# Lightshow
self.elapsed = 0.0
def start_game(self):
self.logger.info("STARTGAME")
self.tank = tanks[self.cl_id]
self.hud = Hud()
self.camera = Camera()
self.camera.init_gl(Game.WIDTH, Game.HEIGHT)
self.on_resize = self.camera.on_resize
self.bg_player.play()
self.running = True
self.gui.remove(self.stack)
def initAttr(self):
self.turn = True
self.hudWidth = HUD["HUD_WIDTH"]
self.edgeWidth = GAME["EDGE_WIDTH"]
# 先获取 board 部分的大小，再自适应自己的大小
self.board = Board((self.hudWidth, self.edgeWidth))
Div.__init__(self, (self.board.width + self.hudWidth,
self.board.height + self.edgeWidth * 2))
# 根据窗口高度设置 HUD 高度
self.hud = Hud((0, self.height), (0, 0))
self.hud.setMark(self.turn)
self.board.setTurn(self.turn)
self.gameID = 0
self.order = None
def __init__(self) -> None:
self.game_objects = {
"check": [],
"switch": [],
"robot": [],
"platform": [],
"laser": [],
"shot": [],
"gate": [],
"plr": [self.plr],
"hud": [Hud(self)]
}
self.game_data = {}
pyxel.init(SCREEN_WIDTH, SCREEN_HEIGHT, caption="Jumpstick robo")
pyxel.load(
os.path.join(os.path.dirname(__file__), 'assets',
'jumpy_robot.pyxres'), )
self.load_objects()
first_check = self.game_objects["check"][0]
first_check.activate()
self.plr.current_checkpoint = first_check
self.plr.kill(True)
self.plr.current_checkpoint.restore()
self.game_data = json.loads(game_data)
self.update_gate_status()
self.draw_state = self.draw_title
self.update_state = self.update_title
pyxel.run(self.update, self.draw)
def run_game():
pygame.init()
m_settings = Settings()
stats = Estadisticas(m_settings)
fj.cargar_puntuacion(stats)
screen = pygame.display.set_mode((m_settings.screen_width, m_settings.screen_height)) #dibujar pantalla
nave = Nave(screen, m_settings) #Dibujar nave
balas = Group() #Un grupo es una lista con funciones añadidas
marcianitos = Group()
fj.crear_flota(m_settings, screen, nave, marcianitos)
icon = pygame.image.load("images/alien.bmp")
pygame.display.set_icon(icon)
pygame.display.set_caption("Marcianitos")
boton = Boton(m_settings, screen, "Jugar")
hud = Hud(m_settings, screen, stats)
m.musica_fondo()
while True:
fj.comprobar_eventos(m_settings, screen, nave, balas, stats, marcianitos, boton)
if stats.jugando:
nave.actualizar_posicion(m_settings)
fj.actualizar_balas(m_settings, screen, nave, marcianitos, balas, stats, hud)
fj.actualizar_flota(m_settings, stats, screen, balas, marcianitos, nave, hud)
fj.actualizar_pantalla(m_settings, screen, nave, marcianitos, balas, boton, stats, hud)
def postInit(self):
#
# initialize game content
#
base.cTrav = CollisionTraverser("base collision traverser")
base.pusher = CollisionHandlerPusher()
self.menu = Menu()
self.credits = Credits()
self.charSelection = CharacterSelection()
self.levelSelection = LevelSelection()
self.koScreen = KoScreen()
self.hud = Hud()
self.menuMusic = loader.loadMusic("assets/audio/menuMusic.ogg")
self.menuMusic.setLoop(True)
self.fightMusic = loader.loadMusic("assets/audio/fightMusic.ogg")
self.fightMusic.setLoop(True)
base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
#
# Event handling
#
self.accept("escape", self.__escape)
#
# Start with the menu
#
self.request("Menu")
def __init__(self, window, input_handler):
super(GameScreen, self).__init__()
self.window = window
self.input_handler = input_handler
self.camera = Camera(window)
self.render = Render(self.camera, self.window)
sc_batch = self.render.scene_batch
st_batch = self.render.static_batch
self.player = player.Player(renderhook=self.render.playerhook)
self.proj_viewer = ProjectileViewer(
self.send_center, batch=sc_batch, scale=self.render.scale,
rndhook=self.render.attack)
self.controls = {}
self.controls_old = {}
self.map = Map('blank')
#self.player.spawn(100, 100)
self.time = 0
self.moves = moves(1024)
self.index = [0]
self.head = [0]
#other players
self.players = {}
self.specs = {}
#crosshair
self.cross = CrossHair(batch=st_batch)
self.isSpec = 0.5
self.hud = Hud(batch=st_batch, window=self.window)
self.gs_view = GameStateViewer(self.players, self.hud.update_prop,
self.hud.set_score)
self.frozen = False
self.rest_time = 0
def init_game():
""" Инициализирует игру и создает объект экрана"""
pygame.init()
global screen
screen = pygame.display.set_mode(
(game_settings.screen_width, game_settings.screen_height))
pygame.display.set_caption("Aliens")
# Создание кнопки Play
global play_button
play_button = Button(game_settings, screen, "Play")
global hud
hud = Hud(game_settings, screen, stats)
# Создание корабля
global ship
ship = Ship(game_settings, screen)
# Создание группы для хранения пуль
global bullets
bullets = pygame.sprite.Group()
# Создание пришельцев
global aliens
aliens = pygame.sprite.Group()
# Создание флота пришельцев
create_fleet()
def __init__(self):
ShowBase.__init__(self)
pman.shim.init(self)
#props = WindowProperties()
#props.setCursorHidden(True)
#props.setMouseMode(WindowProperties.M_relative)
#base.win.requestProperties(props)
base.disableMouse()
self.mouse = [0, 0]
self.setFrameRateMeter(True)
self.win.setClearColor((0, 0, 0, 1))
self.cTrav = CollisionTraverser()
self.cTrav.setRespectPrevTransform(True)
self.delay = [0, 5]
base.win.display_regions[1].dimensions = (0, 1, 0.25, 1)
render.setShaderAuto()
self.music = None
self.shuffleSong()
self.mode = "edit"
self.defineKeys()
self.hud = Hud(self)
self.road = RoadMan(self)
self.road.enableEditing()
self.spawn()
self.taskMgr.add(self.update)
def __init__(self):
self.display = Display()
self.player = Charactor(self)
self.level = Level(self)
self.hud = Hud()
self.prepare_stage()
def initialize(self):
self.player = Tabby(0, 0)
self.hud = Hud()
self.pause = Pause()
self.title = TitleScreen()
self.camera = Camera(self.player.sprite)
self.cameratarget = self.player
self.entities.append(self.player) #player should always be the first in the list
def __init__(self):
pygame.mixer.pre_init(48000,-16,2, 1024) #Sound Settings
pygame.init()
#sets the screen resolution for the game and sets a rect for the game screen
self.screen = pygame.display.set_mode((1024,768))
self.screen_rect = self.screen.get_rect()
#initializes a clock for the game
self.clock = pygame.time.Clock()
#initializes a menu object and HUD object and Score object
self.menu = Menu()
self.hud = Hud()
self.score = Score()
#sets a boolean for whether you are still in the menu or not
self.inMenu = True
#sets a camera for the world
self.camBorder = 32
self.cam = Camera(pygame.Rect(100, 100, 1024, 768), pygame.Rect(self.camBorder, self.camBorder, 2048 - self.camBorder, 1536 - self.camBorder))
self.camShakeFactor = 0 #Magnitude of shake
self.camShakeDecayFactor = 0.08 #Lerp Amount
#Timing
self.timer = pygame.time.get_ticks()
self.elapsed = 0
#Sound Controller
self.soundCon = SoundCon()
#Game Values
self.backgroundImg = pygame.image.load("Images/Arena/Arena2.png").convert_alpha()
self.backgroundImgRect = self.backgroundImg.get_rect()
self.player = Player( self.hud )
#Effects
self.effectInstances = []
self.spawnSound = pygame.mixer.Sound("Sounds/ShipRev.wav")
self.deathSound = pygame.mixer.Sound("Sounds/shipExplo.wav")
self.enemyExplo = pygame.mixer.Sound("Sounds/enemyExplo.wav")
self.clashSound = pygame.mixer.Sound("Sounds/clash.wav")
self.boostSound = pygame.mixer.Sound("Sounds/boostLow.wav")
#Game over fade out
self.fadeImage = pygame.image.load("Images/HUD/CrackedGlass.png").convert_alpha()
self.fadeRect = self.fadeImage.get_rect()
self.fadeSurface = pygame.Surface((1024, 768), pygame.SRCALPHA)
self.fadeSurfaceAlpha = 0
self.fadeSurfaceRate = 1
self.doFade = False
self.restartGame = False
#Enemies
self.enemyList = []
self.baseNumEnemies = 2
self.spawnTime = 10
self.currentSpawnTime = 30
def __init__(self):
GameBase.__init__(self, debug=False)
FSM.__init__(self, "GUI FSM")
base.disableMouse()
self.menu = Menu()
self.missionScreen = MissionScreen()
self.debrief = Debrief()
self.hud = Hud()
self.missionSelect = MissionSelect()
base.camLens.setFov(90)
self.setMusic("audio/music.mp3", volume=0.5)
self.setMusic("audio/engine1.wav", volume=0.3)
self.request("Menu")
base.taskMgr.add(self.missionOverTask, "is mission over")
def get_new_game():
scene = Scene()
game = Game()
hud = Hud()
end_game = EndGame()
game_ctrl = GameCtrl(game, hud, end_game)
scene.add(game, z=0, name="game layer")
scene.add(game_ctrl, z=1, name="game control layer")
scene.add(hud, z=2, name="hud layer")
scene.add(end_game, z=3, name="end game layer")
return scene
def brushing(self):
self.weapons = []
self.spiders = []
self.effects = []
self.dead_spiders = []
self.hud = Hud()
self.player = Player()
self.bonus_time = 0
self.bonus_timmer = 30
self.double_bonus = False
self.tripple_bonus = False
self.level = 0
def restart(self, game_data):
"""Start a new game with the current game_data"""
self.game_data = game_data
self.state = MonorailGame.STATE_INTRO
self.scenario = self.game_data.get_quest().create_scenario(
self.game_data.skill_level.value)
self.playfield = self.scenario.playfield
self.controller = ctrl.GroundControl(self.playfield)
self.init_goldcars()
self.hud = Hud(self.scenario, self.controller, self.game_data)
self.hud.start_intro_screen()
self.begin_timeout = 25 * 3
self.ingame_menu = None
self.gui_state = GuiState()
self.mouse_timeout = MonorailGame.MOUSE_TIMEOUT
self.is_paused = False
def __init__(self, _main):
self.main = _main
self.name = ""
self.points = 0
self.health = 100.0
self.runSpeed = 1.8
self.keyMap = {
"left":False,
"right":False,
"up":False,
"down":False
}
base.camera.setPos(0,0,0)
self.model = loader.loadModel("Player")
self.model.find('**/+SequenceNode').node().stop()
self.model.find('**/+SequenceNode').node().pose(0)
base.camera.setP(-90)
self.playerHud = Hud()
self.playerHud.hide()
self.model.hide()
# Weapons: size=2, 0=main, 1=offhand
self.mountSlot = []
self.activeWeapon = None
self.isAutoActive = False
self.trigger = False
self.lastShot = 0.0
self.fireRate = 0.0
self.playerTraverser = CollisionTraverser()
self.playerEH = CollisionHandlerEvent()
## INTO PATTERNS
self.playerEH.addInPattern('intoPlayer-%in')
#self.playerEH.addInPattern('colIn-%fn')
self.playerEH.addInPattern('intoHeal-%in')
self.playerEH.addInPattern('intoWeapon-%in')
## OUT PATTERNS
self.playerEH.addOutPattern('outOfPlayer-%in')
playerCNode = CollisionNode('playerSphere')
playerCNode.setFromCollideMask(BitMask32.bit(1))
playerCNode.setIntoCollideMask(BitMask32.bit(1))
self.playerSphere = CollisionSphere(0, 0, 0, 0.6)
playerCNode.addSolid(self.playerSphere)
self.playerNP = self.model.attachNewNode(playerCNode)
self.playerTraverser.addCollider(self.playerNP, self.playerEH)
#self.playerNP.show()
self.playerPusher = CollisionHandlerPusher()
self.playerPusher.addCollider(self.playerNP, self.model)
self.playerPushTraverser = CollisionTraverser()
self.playerPushTraverser.addCollider(self.playerNP, self.playerPusher)
def initAttr(self):
self.turn = True
self.hudWidth = HUD["HUD_WIDTH"]
self.edgeWidth = GAME["EDGE_WIDTH"]
# 先获取 board 部分的大小，再自适应自己的大小
self.board = Board((self.hudWidth, self.edgeWidth))
Div.__init__(self, (self.board.width + self.hudWidth, self.board.height + self.edgeWidth * 2))
# 根据窗口高度设置 HUD 高度
self.hud = Hud((0, self.height), (0, 0))
self.hud.setMark(self.turn)
self.board.setTurn(self.turn)
self.gameID = 0
self.order = None
def __init__(self, ventana):
super(Lienzo, self).__init__()
#Cambiar el color de fondo de la ventana
self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(0,0,0))
# Pedir el tamano de la ventana
self.set_size_request(WINDOW_SIZE,WINDOW_SIZE)
#Asignar la ventana que recibe de paramentro a la ventana que se
#utilizara en el lienzo
self.ventana=ventana
#expose-event es una propiedad de DrawingArea que le dice como
#dibujares, aqui le decimos que utilize nuestra funcion paint
#para ese evento en vez del que trae por defaul.
self.connect("expose-event", self.paint)
#reconocer cuando oprimes y sueltas el mouse
self.connect("button_press_event",self.button_press)
self.connect("button_release_event",self.button_release)
self.connect("motion_notify_event",self.actualizar_dragged)
self.set_events(gtk.gdk.BUTTON_PRESS_MASK|gtk.gdk.BUTTON_RELEASE_MASK|gtk.gdk.POINTER_MOTION_MASK)
self.hud=Hud()
self.minTimeToNextCell=100
self.maxTimeToNextCell=300
self.ticksToNextCell=random.randint(self.minTimeToNextCell,self.maxTimeToNextCell)
self.trainingZoneLimit=WINDOW_SIZE-100
#cells
self.virus=[]
self.cells=[]
self.trainingSet=[]
self.draggingObject = None
self.objetoSeleccionado=[]
self.currentState="Running"
self.classificationList=["Target","Enemy","Food"]
self.divisionPoints=[]
self.currentCell = 0
self.apareciendo = []
self.numCells = 0
self.read_file()
self.r_table = Table()
self.qagent = QAgent(self.r_table,'A')
self.init_simulation()
self.init_training_set()
def __init__(self):
self.framerate = 0
self.number_meanies = 32
self.bricks_in_level = 0
self.display = Display()
self.hud = Hud()
pygame.key.set_repeat(100,5)
self.meanies = pygame.sprite.Group()
self.player = Charactor(self)
self.player.speed = 2
self.level = Level(self)
self.level.load_level(0)
self.start_game()
def main():
hud = Hud()
# ser = serial.Serial(port = '/dev/ttyUSB0',
# baudrate = 9600,
# parity = serial.PARITY_NONE,
# stopbits = serial.STOPBITS_ONE,
# bytesize = serial.EIGHTBITS,
# timeout = 1)
logger = 0
kv = {}
stringKV = {}
firstPass = True
while True:
# wrapping this all in a try-catch should handle file-opening/-closing timeline nicely
# i.e. catch TclError(possibly tclError): close file
#
# var parsing and file writing will need to be wrapped in classes
sleep(0.5)
#kv = RT.randomKV()
#print kv
try:
#inLine = ser.readline()
inLine = RT.randomKVLine()
if inLine[0] == '@':
newKV = parseLineToKV(inLine)
newStringKV = parseLineToStringKV(inLine)
if firstPass:
keys = sorted(newStringKV.keys())
logger = Logger(keys)
firstPass = False
if newKV != kv:
kv = newKV
stringKV = newStringKV
hud.updateHud(kv)
hud.update_idletasks()
hud.update()
logger.logKV(stringKV)
print strfkv(stringKV)
except TclError: #possibly tclError
print "HUD was closed"
logger.close()
break
except err:
print err
break
def __init__(self, ventana):
""""""
super(Lienzo, self).__init__()
#Cambiar el color de fondo de la ventana
self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(0,0,0))
# Pedir el tamano de la ventana
self.set_size_request(WINDOW_SIZE,WINDOW_SIZE)
#Asignar la ventana que recibe de paramentro a la ventana que se
#utilizara en el lienzo
self.ventana=ventana
#expose-event es una propiedad de DrawingArea que le dice como
#dibujares, aqui le decimos que utilize nuestra funcion paint
#para ese evento en vez del que trae por defaul.
self.connect("expose-event", self.paint)
#reconocer cuando oprimes y sueltas el mouse
self.connect("button_press_event",self.button_press)
self.connect("button_release_event",self.button_release)
self.connect("motion_notify_event",self.actualizar_dragged)
self.set_events(gtk.gdk.BUTTON_PRESS_MASK|gtk.gdk.BUTTON_RELEASE_MASK|gtk.gdk.POINTER_MOTION_MASK)
#Inicializar todos los valores
self.init_simulation(None)
self.hud=Hud()
#celulas
self.annealedCells=cellList+stationList
self.virus=vir
self.annealingCompleted=False
self.initialized=False
self.allVisited=False
self.visitedCells=0
self.nextCell=None
self.draggingObject = None
self.corriendo = True
self.bestEnergy=0
self.currentEnergy=0
self.currentTemp=0
self.objetoSeleccionado=[]
def __init__(self, ventana):
super(Lienzo, self).__init__()
#Cambiar el color de fondo de la ventana
self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(0,0,0))
# Pedir el tamano de la ventana
self.set_size_request(WINDOW_SIZE,WINDOW_SIZE)
#Asignar la ventana que recibe de paramentro a la ventana que se
#utilizara en el lienzo
self.ventana=ventana
#expose-event es una propiedad de DrawingArea que le dice como
#dibujares, aqui le decimos que utilize nuestra funcion paint
#para ese evento en vez del que trae por defaul.
self.connect("expose-event", self.paint)
#reconocer cuando oprimes y sueltas el mouse
self.connect("button_press_event",self.button_press)
self.connect("button_release_event",self.button_release)
self.connect("motion_notify_event",self.actualizar_dragged)
self.set_events(gtk.gdk.BUTTON_PRESS_MASK|gtk.gdk.BUTTON_RELEASE_MASK|gtk.gdk.POINTER_MOTION_MASK)
self.hud=Hud()
self.minTimeToNextCell=200
self.maxTimeToNextCell=200
self.ticksToNextCell=random.randint(self.minTimeToNextCell,self.maxTimeToNextCell)
#cells
self.virus=[Virus(
random.randint(0,100-VIRUS_WIDTH),
random.randint(0,WINDOW_SIZE-CELL_HEIGHT),
) for i in xrange(TOTAL_VIRUS)]
self.virus[0].policy="Fuzzy"
self.virus[1].policy="Random"
self.cells=[]
self.draggingObject = None
self.objetoSeleccionado=[]
self.currentState="Running"
self.classificationList=["Target","Enemy","Food"]
self.trainingZoneLimit=WINDOW_SIZE-100
self.fnn = None
self.init_simulation()
self.run_simulation()
def load(self):
super().load()
blockWidth = blocks.Block.width
blockHeight = blocks.Block.height
self.gameArea = Rect(Game.curGame.width - blockWidth,
Game.curGame.height - Hud.height, 0, 0)
if (self.len() == 0):
self.generateMap()
playerStartX = blockWidth
playerStartY = blockHeight
self.player = characters.EditCursor(playerStartX, playerStartY)
# Add player
self.addGameObject(self.player, 1)
self.addGameObject(Hud(blockWidth, self.gameArea.height + blockHeight))
def __init__(self):
super(World, self).__init__()
self.frames = 1
# this is normal difficulty by default
# easy would prolly be .7ish and hard.. 1.3 or so?
self.difficulty = 0.7
self.spawnFreq = 10
self.scrollPosition = 0
self.scrollSpeed = 3
self.endPosition = FRAMES_UNTIL_BOSS * self.scrollSpeed
self.startScreen = True
self.helpScreen = False
self.difficultyScreen = False
self.bossMode = False
self.gameOver = False
self.winScreen = False
self.score = 0
self.call_popcorn = 0
self.boss_music=False
self.holdingLeftMouseButton = False
#for keeping track of for the win screen!
self.numEnemiesAppeared = 0
self.numEnemiesDestroyed = 0
self.numViruses = 0
self.numWorms = 0
self.numPopUps = 0
self.playerGroup = pygame.sprite.GroupSingle()
self.enemies = pygame.sprite.Group()
self.pickups = pygame.sprite.Group()
self.bullets = pygame.sprite.Group()
self.mines = pygame.sprite.Group()
self.backgrounds = pygame.sprite.Group()
self.spawnBkg()
# sprite groups listed in draw order (lowest sprite get drawn first)
self.spriteGroups = [self.backgrounds, self.mines, self.pickups, self.bullets, self.enemies, self.playerGroup]
self.hud = Hud()
def __init__(self, player, character_name, position=Vec2D(0, 0)):
"""Initialize all member variables of character.
damage -- numeric value, the amount of harm dealt through normal_attack
lock -- bool varible, says if the character is currently casting an
ability or motion
action -- string, the action currently being excecuted by the character
"""
pygame.sprite.Sprite.__init__(self)
self.name = character_name
self.damage = 100
self.attribute = self.attributes[self.name]
self.lock = True
self.action = "introduction"
self.enemy_position = pygame.Rect(0, 0, 0, 0)
if not isinstance(position, Vec2D):
self.position = Vec2D(position)
else:
self.position = position
if player == 1:
self.controls = P1_CONTROLS
self.direction = "Right"
elif player == 2:
self.controls = P2_CONTROLS
self.direction = "Left"
else:
raise SystemExit("player argument should be either 1 or 2")
self.movements = {}
for action in get_all_movements(self.name):
self.movements[action] = Movement(self.name, action)
self.skills = SkillManager()
self.hud = Hud(player, self.name)
self.sound_effects = SoundManager(self.name)
self.update({})
def restart( self, game_data ):
"""Start a new game with the current game_data"""
self.game_data = game_data
self.state = MonorailGame.STATE_INTRO
self.scenario = self.game_data.get_quest().create_scenario(self.game_data.skill_level.value)
self.playfield = self.scenario.playfield
self.controller = ctrl.GroundControl( self.playfield )
self.init_goldcars()
self.hud = Hud( self.scenario, self.controller, self.game_data )
self.hud.start_intro_screen()
self.begin_timeout = 25 * 3
self.ingame_menu = None
self.gui_state = GuiState()
self.mouse_timeout = MonorailGame.MOUSE_TIMEOUT
self.is_paused = False
def __init__(self):
self.framerate = 0
self.number_meanies = 16
self.display = Display()
self.hud = Hud()
self.meanie_list = []
pygame.key.set_repeat(100,5)
self.meanies = pygame.sprite.Group()
self.player = Charactor("held.png", self.display)
self.player.speed = 2
self.init_floors()
self.init_ladders()
self.barrels = pygame.sprite.Group()
self.init_barrels()
self.testgroup = pygame.sprite.Group()
self.init_meanies(0)
def __init__(self):
self.framerate = 0
self.number_meanies = 32
self.bricks_in_level = 0
self.display = Display()
self.hud = Hud()
pygame.key.set_repeat(100,5)
self.meanies = pygame.sprite.Group()
self.player = Charactor(self)
self.player.speed = 2
self.init_floors()
self.bricks_in_level = len(self.steine)
self.init_ladders()
self.barrels = pygame.sprite.Group()
self.init_barrels()
self.testgroup = pygame.sprite.Group()
self.init_meanies(0)
def __init__(self, window):
super(GameScreen, self).__init__()
self.window = window
self.camera = Camera(window)
self.player = player.Player()
self.proj_viewer = ProjectileViewer(self.send_center)
self.controls = {}
self.controls_old = {}
self.map = Map('blank')
#self.player.spawn(100, 100)
self.time = 0
self.moves = moves(1024)
self.index = [0]
self.head = [0]
#other players
self.players = {}
self.specs = {}
#crosshair
self.cross = CrossHair()
self.isSpec = True
self.hud = Hud()
self.gs_view = GameStateViewer(self.players, self.hud.update_prop,
self.hud.set_score)
def load(self):
super().load()
blockWidth = blocks.Block.width
blockHeight = blocks.Block.height
self.gameArea = Rect(Game.curGame.width - blockWidth,
Game.curGame.height - Hud.height, 0, 0)
playerStartX = blockWidth
playerStartY = blockHeight
# If there are playerSpawn blocks
if (self.hasAny(blocks.PlayerSpawn)):
# Get the location of the block
playerSpawn = self.getGameObjectsByType(blocks.PlayerSpawn)
# Create a player if there is not one already
if not (self.player):
self.player = characters.Player(playerStartX, playerStartY)
# Spawn the player on the block
self.player.x = playerSpawn[0].x
self.player.y = playerSpawn[0].y
self.removeGameObjectsByType(blocks.PlayerSpawn)
self.addGameObject(self.player)
# If there are not Player Objects create one
elif (not self.hasAny(characters.Player)):
if not (self.player):
self.player = characters.Player(0, 0)
self.player.x = playerStartX
self.player.y = playerStartY
self.addGameObject(self.player)
# If there are Player Objects
elif (self.hasAny(characters.Player)):
self.player = self.getGameObjectsByType(characters.Player)[0]
self.addGameObject(Hud(blockWidth, self.gameArea.height + blockHeight))
self.originalGos = self.gameObjects
class Main(ShowBase, FSM):
"""Main function of the application
initialise the engine (ShowBase)"""
def __init__(self):
"""initialise the engine"""
ShowBase.__init__(self)
base.notify.info("Version {}".format(versionstring))
FSM.__init__(self, "FSM-Game")
#
# BASIC APPLICATION CONFIGURATIONS
#
# disable pandas default camera driver
self.disableMouse()
# set antialias for the complete sceen to automatic
self.render.setAntialias(AntialiasAttrib.MAuto)
# shader generator
render.setShaderAuto()
# Enhance font readability
DGG.getDefaultFont().setPixelsPerUnit(100)
# get the displays width and height for later usage
self.dispWidth = self.pipe.getDisplayWidth()
self.dispHeight = self.pipe.getDisplayHeight()
#
# CONFIGURATION LOADING
#
# load given variables or set defaults
# check if particles should be enabled
# NOTE: If you use the internal physics engine, this always has
# to be enabled!
particles = ConfigVariableBool("particles-enabled", True).getValue()
if particles:
self.enableParticles()
def setFullscreen():
"""Helper function to set the window fullscreen
with width and height set to the screens size"""
# set window properties
# clear all properties not previously set
base.win.clearRejectedProperties()
# setup new window properties
props = WindowProperties()
# Fullscreen
props.setFullscreen(True)
# set the window size to the screen resolution
props.setSize(self.dispWidth, self.dispHeight)
# request the new properties
base.win.requestProperties(props)
# Set the config variables so we correctly store the
# new size and fullscreen setting later
winSize = ConfigVariableString("win-size")
winSize.setValue("{} {}".format(self.dispWidth, self.dispHeight))
fullscreen = ConfigVariableBool("fullscreen")
fullscreen.setValue(True)
# Render a frame to make sure the fullscreen is applied
# before we do anything else
self.taskMgr.step()
# make sure to propagate the new aspect ratio properly so
# the GUI and other things will be scaled appropriately
aspectRatio = self.dispWidth / self.dispHeight
self.adjustWindowAspectRatio(aspectRatio)
# check if the config file hasn't been created
if not os.path.exists(prcFile):
setFullscreen()
# automatically safe configuration at application exit
#base.exitFunc = self.__writeConfig
#
# INITIALIZE GAME CONTENT
#
base.cTrav = CollisionTraverser("base collision traverser")
base.pusher = CollisionHandlerPusher()
self.menu = Menu()
self.credits = Credits()
self.charSelection = CharacterSelection()
self.levelSelection = LevelSelection()
self.koScreen = KoScreen()
self.hud = Hud()
self.menuMusic = loader.loadMusic("assets/audio/menuMusic.ogg")
self.menuMusic.setLoop(True)
self.fightMusic = loader.loadMusic("assets/audio/fightMusic.ogg")
self.fightMusic.setLoop(True)
base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
#
# EVENT HANDLING
#
# By default we accept the escape key
self.accept("escape", self.__escape)
#
# ENTER GAMES INITIAL FSM STATE
#
self.request("Menu")
#
# FSM PART
#
def enterMenu(self):
show_cursor()
self.accept("Menu-Start", self.request, ["CharSelection"])
self.accept("Menu-Credits", self.request, ["Credits"])
self.accept("Menu-Quit", self.userExit)
self.ignore("KoScreen-Back")
self.koScreen.hide()
self.menu.show()
if self.menuMusic.status() != AudioSound.PLAYING:
self.menuMusic.play()
if self.fightMusic.status() == AudioSound.PLAYING:
self.fightMusic.stop()
def exitMenu(self):
self.ignore("Menu-Start")
self.ignore("Menu-Credits")
self.ignore("Menu-Quit")
self.menu.hide()
def enterCredits(self):
self.accept("Credits-Back", self.request, ["Menu"])
self.koScreen.hide()
self.credits.show()
def exitCredits(self):
self.ignore("Credits-Back")
self.credits.hide()
def enterCharSelection(self):
self.accept("CharSelection-Back", self.request, ["Menu"])
self.accept("CharSelection-Start", self.request, ["LevelSelection"])
self.charSelection.show()
def exitCharSelection(self):
self.ignore("CharSelection-Start")
self.ignore("CharSelection-Back")
self.charSelection.hide()
self.selectedChar1 = self.charSelection.selectedCharacter1
self.selectedChar2 = self.charSelection.selectedCharacter2
def enterLevelSelection(self):
self.accept("LevelSelection-Back", self.request, ["CharSelection"])
self.accept("LevelSelection-Start", self.request, ["Game"])
self.levelSelection.show()
def exitLevelSelection(self):
self.ignore("LevelSelection-Start")
self.ignore("LevelSelection-Back")
self.levelSelection.hide()
def enterGame(self):
# main game code should be called here
self.arena = Arena(self.levelSelection.selectedLevel)
self.arena.start()
self.camera.setPos(0, -5, 1.25)
self.player = Player(0, self.selectedChar1, "p1")
self.player2 = Player(1, self.selectedChar2, "p2")
self.player.setEnemy(self.player2.collisionNodeName)
self.player2.setEnemy(self.player.collisionNodeName)
self.player.start(self.arena.getStartPos(1))
self.player2.start(self.arena.getStartPos(2))
self.taskMgr.add(self.updateWorldCam, "world camera update task")
self.accept("gameOver", self.gameOver)
self.hud.show()
def lifeChanged(charId, health):
base.messenger.send("hud_setLifeBarValue", [charId, health])
self.accept("lifeChanged", lifeChanged)
hide_cursor()
if self.fightMusic.status() != AudioSound.PLAYING:
self.fightMusic.play()
if self.menuMusic.status() == AudioSound.PLAYING:
self.menuMusic.stop()
def exitGame(self):
# cleanup for game code
self.taskMgr.remove("world camera update task")
self.player.stop()
self.player2.stop()
del self.player
del self.player2
self.arena.stop()
self.ignore("gameOver")
self.ignore("lifeChanged")
self.hud.hide()
#
# FSM PART END
#
#
# BASIC FUNCTIONS
#
def gameOver(self, LoosingCharId):
show_cursor()
winningChar = 1
if LoosingCharId == 0:
winningChar = 2
self.accept("KoScreen-Back", self.request, ["Credits"])
self.koScreen.show(winningChar)
def updateWorldCam(self, task):
playerVec = self.player.getPos() - self.player2.getPos()
playerDist = playerVec.length()
x = self.player.getX() + playerDist / 2.0
self.camera.setX(x)
zoomout = False
if not self.cam.node().isInView(self.player.getPos(self.cam)):
camPosUpdate = -2 * globalClock.getDt()
self.camera.setY(self.camera, camPosUpdate)
zoomout = True
if not self.cam.node().isInView(self.player2.getPos(self.cam)):
camPosUpdate = -2 * globalClock.getDt()
self.camera.setY(self.camera, camPosUpdate)
zoomout = True
if not zoomout:
if self.camera.getY() < -5:
camPosUpdate = 2 * globalClock.getDt()
self.camera.setY(self.camera, camPosUpdate)
return task.cont
def __escape(self):
"""Handle user escape key klicks"""
if self.state == "Menu":
# In this state, we will stop the application
self.userExit()
elif self.state == "LevelSelection":
self.request("CharSelection")
else:
# In every other state, we switch back to the Menu state
self.request("Menu")
def __writeConfig(self):
"""Save current config in the prc file or if no prc file exists
create one. The prc file is set in the prcFile variable"""
page = None
#
#TODO: add any configuration variable names that you have added
# to the dictionaries in the next lines. Set the current
# configurations value as value in this dictionary and it's
# name as key.
configVariables = {
# set the window size in the config file
"win-size":
ConfigVariableString(
"win-size", "{} {}".format(self.dispWidth,
self.dispHeight)).getValue(),
# set the default to fullscreen in the config file
"fullscreen":
"#t"
if ConfigVariableBool("fullscreen", True).getValue() else "#f",
# particles
"particles-enabled":
"#t" if self.particleMgrEnabled else "#f",
# audio
"audio-volume":
str(round(self.musicManager.getVolume(), 2)),
"audio-music-active":
"#t"
if ConfigVariableBool("audio-music-active").getValue() else "#f",
"audio-sfx-active":
"#t"
if ConfigVariableBool("audio-sfx-active").getValue() else "#f",
# logging
"notify-output":
os.path.join(basedir, "game.log"),
# window
"framebuffer-multisample":
"#t" if ConfigVariableBool("framebuffer-multisample").getValue()
else "#f",
"multisamples":
str(ConfigVariableInt("multisamples", 8).getValue()),
"texture-anisotropic-degree":
str(ConfigVariableInt("texture-anisotropic-degree").getValue()),
"textures-auto-power-2":
"#t" if ConfigVariableBool("textures-auto-power-2",
True).getValue() else "#f",
}
page = None
# Check if we have an existing configuration file
if os.path.exists(prcFile):
# open the config file and change values according to current
# application settings
page = loadPrcFile(Filename.fromOsSpecific(prcFile))
removeDecls = []
for dec in range(page.getNumDeclarations()):
# Check if our variables are given.
# NOTE: This check has to be done to not loose our base or other
# manual config changes by the user
if page.getVariableName(dec) in configVariables.keys():
removeDecls.append(page.modifyDeclaration(dec))
for dec in removeDecls:
page.deleteDeclaration(dec)
else:
# Create a config file and set default values
cpMgr = ConfigPageManager.getGlobalPtr()
page = cpMgr.makeExplicitPage("Application Config")
# always write custom configurations
for key, value in configVariables.items():
page.makeDeclaration(key, value)
# create a stream to the specified config file
configfile = OFileStream(prcFile)
# and now write it out
page.write(configfile)
# close the stream
configfile.close()
def main():
""" Main Program """
pygame.init()
# Set the height and width of the screen
size = [SCREEN_WIDTH, SCREEN_HEIGHT]
screen = pygame.display.set_mode(size)
pygame.display.set_caption("Dungeon Dreams Demo")
# Create the player
map_pix_size = 30
# Create all the levels
level_list = []
# level_list.append( Level_01(player) )
# Set the current level
current_level_no = 0
current_level = 0
# current_level = level_list[current_level_no]
active_sprite_list = pygame.sprite.Group()
# Loop until the user clicks the close button.
done = False
# Used to manage how fast the screen updates
clock = pygame.time.Clock()
all_sprites_list = pygame.sprite.LayeredDirty()
collid_list = pygame.sprite.LayeredDirty()
mobiles_list = pygame.sprite.Group()
m_attacks = pygame.sprite.Group()
area = None
image_files = glob.glob('HumanMage.PNG')
hud = Hud(screen)
player = Player(100,100,image_files,hud)
hud.display_player_stats(player.stats)
player.set_all_sprites(all_sprites_list)
screen_size = (screen.get_width(),screen.get_height())
m_fact = Monster_Factory(area,collid_list,50,screen_size,all_sprites_list,player)
map_tool = Map_Handler(screen,all_sprites_list,collid_list,player,mobiles_list,
m_fact,hud)
map_tool.build_area()
item_fact = map_tool.get_item_fact()
shift_x = 0
shift_y = 0
all_mobiles = m_fact.get_mobiles_group()
dam_mod = 1
#init path finding...
path_finder = a_star(collid_list,50)
player.group_add(all_mobiles)
image_files = glob.glob('*.PNG')
#init events for following and monsters, start at 3 seconds because
#player needs a second or two catch bearings
FOLLOW_EVENT = USEREVENT + 1
M_ATTACK_EVENT = USEREVENT + 2
pygame.time.set_timer(FOLLOW_EVENT, 3000)
pygame.time.set_timer(M_ATTACK_EVENT,3000)
game_start = False
#-------- Main Program Loop -----------
while not done:
#Probably would make a class just to handle
#client events.
#These handle the movements
keys = pygame.key.get_pressed()
if keys[pygame.K_h]:
player.changespeed(-1, 0)
if keys[pygame.K_l]:
player.changespeed(1, 0)
if keys[pygame.K_k]:
player.changespeed(0, -1)
if keys[pygame.K_j]:
player.changespeed(0, 1)
if keys[pygame.K_n]:
player.changespeed(1,1)
if keys[pygame.K_b]:
player.changespeed(-1,1)
if keys[pygame.K_y]:
player.changespeed(-1,-1)
if keys[pygame.K_u]:
player.changespeed(1,-1)
#More events, quit and attacks and stopping the player
#when the button goes up.
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
player.check_events(event)
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
r_attack = player.ranged_attack(all_sprites_list,
None,
player.r_attack_images,
dam_mod)
m_fact.set_check_attack(r_attack)
if event.type == pygame.KEYUP:
if event.key == pygame.K_h:
player.stop()
if event.key == pygame.K_y:
player.stop()
if event.key == pygame.K_k:
player.stop()
if event.key == pygame.K_u:
player.stop()
if event.key == pygame.K_l:
player.stop()
if event.key == pygame.K_n:
player.stop()
if event.key == pygame.K_j:
player.stop()
if event.key == pygame.K_b:
player.stop()
#Really for testing pathfinding, pathfinding is really for monsters.
if event.type == pygame.MOUSEBUTTONUP:
pos = pygame.mouse.get_pos()
player.follow_path(path_finder.get_path(player.get_pos(),pos),
map_pix_size,
pos)
#Monsters follow every two seconds to cut down on pathfinding
#Calculations
if event.type == FOLLOW_EVENT:
m_fact.monster_group_follow(player.get_pos())
pygame.time.set_timer(FOLLOW_EVENT, 2000)
#Attack every second which is kind of a lot still
#Otherwise player would get hurt too fast or too slow.
if event.type == M_ATTACK_EVENT:
m_attacks = m_fact.monsters_attack(player.get_pos())
player.set_check_attack(m_attacks)
pygame.time.set_timer(M_ATTACK_EVENT,1000)
#Move the player and then check for game end or picked up item.
player_pos = player.move(collid_list,all_mobiles)
lost = player.damaged()
m_fact.move_monsters(all_mobiles)
got_item = item_fact.is_picked_up()
#For now just one item and if it is picked up the player wins.
if got_item:
end_text = []
end_text.append('You Found the Scepter of Yendor and Won the Game!')
end_text.append('To replay press r!')
end_text.append('To quit press q!')
end_text.append('To continue press Space Bar!')
done = game_end(True,end_text,screen,map_tool)
map_tool.map_move(0,0)
player.stop()
player.ranged_item = 3
player.speed = 8
player.dam_mod = 10
elif(lost):
end_text = []
end_text.append('You perished!')
end_text.append('To replay press r!')
end_text.append('To quit press q!')
done = game_end(False,end_text,screen,map_tool)
if(map_tool.map_section_change(player_pos)):
area = map_tool.get_area()
m_fact.gen_monsters(area)
player.is_moving(map_pix_size)
all_mobiles.update(None,None)
if m_attacks:
m_attacks.update()
all_sprites_list.draw(screen)
clock.tick(25)
pygame.display.flip()
pygame.quit()
def __init__(self, game):
self.screen = pygame.display.set_mode((100 * 8, 300))
Board.__init__(self)
Hud.__init__(self, game)
class Game(GameState):
def do_setup(self, level):
super(Game, self).do_setup()
self.level = level
self.setup_panda()
self.level.setup_entities(self.entities)
self.setup_input()
self.setup_controllers()
self.setup_hud()
self.setup_logic()
self.enter_transition()
self.events.event('panda-escape').connect(self.enter_menu)
self.events.event('panda-p').connect(self.toggle_pause)
self.manager.enter_state(
GameMessage,
message=(('You have to kill %i pigeons in this level...\n' +
'Can you make it?') % self.total_pigeons))
def enter_transition(self):
self._transition_bg = ui.ImageEntity(entities=self.entities,
image='hud/red-bg.png')
self._transition_bg.alpha = 1.0
self._transition_bg.fade_out()
def leave_transition(self, next_st='menu'):
self._transition_bg.fade_in().add_next(
task.run(lambda: self.manager.leave_state(last_state=next_st)))
def enter_menu(self):
self.manager.enter_state('menu-noload', None, 'ingame')
@weak_slot
def on_kill_pigeon(self):
self.hud.dec_counter('pigeons', 1)
self.dead_pigeons += 1
if self.dead_pigeons >= self.total_pigeons:
self.win_game()
@weak_slot
def on_kill_boy(self):
self.fail_game(
random.choice([
'You are dead!', 'Was it that hard to stay alive?',
"Your soul is burning in hell..."
]))
@weak_slot
def on_finish_time(self):
self.fail_game(
random.choice([
'No more time for you!', 'Too slow man...',
'Hurry up the next time!'
]))
def win_game(self):
if self.manager.current == self:
self.manager.enter_state(
GameMessage, 'YOU WON!\n'
'This was a show-case level of an in-development game,\n'
'there is more to come in the future.', 'quit')
def fail_game(self, reason):
if self.manager.current == self:
msg = random.choice([
'LOOOOOOOOSER', 'You lost!', 'What a pity!',
'Hey, no luck today!'
])
self.manager.enter_state(GameMessage, reason + '\n' + msg, 'retry')
@weak_slot
def on_place_stick(self):
if self.player_ctl.can_place_stick:
self.num_sticks -= 1
if self.num_sticks == 0:
self.player_ctl.can_place_stick = False
self.hud.set_counter('sticks', self.num_sticks)
def highlight_stick_task(self, timer):
pos = self.player_ctl.get_place_position(5)
best = self.player_ctl.laser.best_stick(pos)
if best != self._curr_best_stick:
if self._curr_best_stick:
self._curr_best_stick.unhighlight()
if self.player_ctl.can_place_stick:
self._curr_best_stick = best
if best:
best.highlight()
return task.running
def do_update(self, timer):
super(Game, self).do_update(timer)
@weak_slot
def on_shader_change(self, cfg):
if cfg.value:
self.glow_filter.enable(self.manager.panda)
else:
self.glow_filter.disable()
@weak_slot
def on_control_change(self, cfg):
self.player_input.unassoc_action(cfg.name)
if cfg.value:
self.player_input.assoc(cfg.name, cfg.value)
def setup_panda(self):
self.glow_filter = shader.GlowFilter()
panda = self.manager.panda
if GlobalConf().path('game.shader').value:
self.glow_filter.enable(panda)
panda.relative_mouse()
panda.loop_music(self.level.music)
def setup_input(self):
self.player_input = GameInput()
self.camera_input = GameInput(CAMERA_INPUT_MAP)
self.events.connect(self.player_input)
self.events.connect(self.camera_input)
self.tasks.add(self.player_input)
self.tasks.add(self.camera_input)
self.player_input.assoc('on_steer', 'panda-mouse-move')
cfg = GlobalConf().path('game.player0.keys')
for c in cfg.childs():
if c.value:
self.player_input.assoc(c.name, c.value)
c.on_conf_change += self.on_control_change
GlobalConf ().path ('game.shader').on_conf_change += \
self.on_shader_change
def setup_controllers(self):
self.camera_ctl = CameraController(entities=self.entities,
camera=base.camera)
self.player_ctl = PlayerController(entities=self.entities,
delegate=self.level.boy)
self.level.boy.connect(self.camera_ctl)
self.camera_input.connect(self.camera_ctl)
self.player_input.connect(self.player_ctl)
def setup_hud(self):
self.hud = Hud(entities=self.entities)
self.hud.add_counter('clock', 'hud/clock.png')
self.hud.add_counter('pigeons', 'hud/pigeon.png')
self.hud.add_counter('sticks', 'hud/stick.png')
self.hud.hide()
def setup_logic(self):
total_pigeons = 0
for f in self.level.flocks:
total_pigeons += len(f.boids)
for b in f.boids:
b.on_death += self.on_kill_pigeon
self.total_pigeons = total_pigeons
self.dead_pigeons = 0
self.level.boy.on_death += self.on_kill_boy
self.num_sticks = self.level.max_sticks
self.player_ctl.on_place_stick_down += self.on_place_stick
self.hud.set_counter('sticks', self.num_sticks)
self.timer = self.tasks.add(
task.TimerTask(duration=self.level.max_time))
self.timer.on_tick = lambda: self.hud.set_counter(
'clock', int(self.timer.remaining))
self.timer.on_finish = self.on_finish_time
self.tasks.add(self.highlight_stick_task)
self._curr_best_stick = None
self.pigeon_food = []
def do_sink(self):
super(Game, self).do_sink()
if self.manager.current.state_name == 'menu-noload':
for x in self.entities.entities:
if isinstance(x, task.Task):
x.pause()
self.events.quiet = True
self.hud.soft_hide()
self.timer.pause()
def do_unsink(self, action='continue'):
super(Game, self).do_unsink()
self.manager.panda.relative_mouse()
self.tasks.resume()
for x in self.entities.entities:
if isinstance(x, task.Task):
x.resume()
if action == 'continue':
self.events.quiet = False
self.hud.soft_show()
self.timer.resume()
elif action == 'quit':
self.leave_transition()
elif action == 'retry':
self.leave_transition('game')
def do_release(self):
self.level.dispose() # TODO: To entity!
self.glow_filter.disable()
super(Game, self).do_release()
def main():
logg.info('Starting the main function')
#Instancing, etc.
main_view = View().from_rect(
FloatRect(0, 0, PP_WIDTH, PP_HEIGHT + BAR_HEIGHT))
window = RenderWindow(
VideoMode(PP_WIDTH * SCALE, (PP_HEIGHT + BAR_HEIGHT) * SCALE),
GAME_TITLE + ' v.' + GAME_VERSION)
window.framerate_limit = 61
window.view = main_view
# INITIALIZE TEXTURES HERE OR AFTER \o/
TEXTURE_WALL = Texture.load_from_file('main/walls.png')
TEXTURE_BAR = Texture.load_from_file('main/bar.png')
TEXTURE_HUDWEAPONS = Texture.load_from_file('main/hud_weapons.png')
TEXTURE_FACES = Texture.load_from_file('main/faces.png')
TEXTURE_NUMBERS = Texture.load_from_file('main/numbers.png')
TEXTURE_WEAPONS = Texture.load_from_file('main/weapons.png')
TEXTURE_ENEMIES = Texture.load_from_file('main/test.png')
#Create an instance for all game variables and loop functions
# and set the level to TESTLEVEL
game = Gameworld(TEXTURE_ENEMIES)
game.create_dict_map()
game.player.gamemap = game.current_level
game.init_physics()
game.physics.mob_bodies(game.entities)
#prepare the hud
hud = Hud(player=game.player,
background=TEXTURE_BAR,
faces=TEXTURE_FACES,
hudweapons=TEXTURE_HUDWEAPONS,
weapons=TEXTURE_WEAPONS,
numbers=TEXTURE_NUMBERS)
#prepare the wall textures
wall_sprites = game.create_wall_sprite_list(TEXTURE_WALL)
rays = Raycaster(player=game.player,
sprites=wall_sprites,
gamemap=game.current_level)
#prepare other stuff
player_action = ''
running = True
nofocus = False
##
# MAIN LOOP
##
logg.info('Main loop starting...')
while running:
#iterate events
for event in window.iter_events():
if event.type == Event.CLOSED or player_action == 'quit':
running = False
if event.type == Event.LOST_FOCUS:
nofocus = True
elif event.type == Event.GAINED_FOCUS:
nofocus = False
if event.type == Event.KEY_RELEASED:
if game.player.bob > 0: #level the headbobbing
game.player.bob -= .5
elif game.player.bob < 0:
game.player.bob += .5
game.player.strafing = False
#disable speed limiter for moving in 2 axii
window.clear(Color(235, 235, 235,
255)) #clear the window of everything
for sprite in wall_sprites: #draw walls
window.draw(sprite)
#draw entities here
for entity in game.entities:
if entity.visible == True:
for sprite_slice in entity.sprite:
window.draw(sprite_slice)
hud.display(window) #draw the hud
debug_txt = text('[' + str(draw_fps(frame)) + '] ' +
str("{0:.2f}".format(game.player.ux)) + '(' +
str(game.player.x) + '),' +
str("{0:.2f}".format(game.player.uy)) + '(' +
str(game.player.y) + '):' + str(game.player.heading),
style=1)
window.draw(debug_txt)
wall_sprites = rays.texture_slices(
rays.cast_rays(), wall_sprites,
game.player.bob) #determine which walls to display
#determine wich entities to display and prepare
for entity in game.entities: #calculate the distance of entities to the player
entity.distance_to_player(game.player)
# print(str(round(entity.distance, 2)) + " " + str(entity.x) + "," + str(entity.y))
game.entities.sort(key=lambda x: x.distance,
reverse=True) #sort entities based on the distance
for entity in game.entities:
entity.set_sprite_for_display(game.player, rays.distances)
###
# TIMERS
###
if game.player.attack_delay > 0 and game.player.attack == True:
game.player.attack_delay -= 1
elif game.player.attack == True and game.player.attack_delay == 0:
game.player.attack = False
game.player.attack_delay = 2
elif game.player.attack == False and game.player.attack_delay > 0:
game.player.attack_delay -= 1
if len(game.doors) != 0:
# print('lol doors')
for door in game.doors:
# print(door.openess)
state = door.open_close()
# print(state)
if state == 'done':
# print('removing doors')
game.doors.remove(door)
game.physics.world.ClearForces()
if not nofocus:
player_action = game.handle_keys() #player input
game.physics.world.Step(1.0 / 60.0, 10, 8)
game.player.update_position()
for entity in game.entities:
entity.update_position()
window.display() #blit to window
window.close()
logg.info('Terminating. Have a nice day.')
logg.info('Average FPS: %s', round(average_fps / all_frames, 2))
def setup_hud (self):
self.hud = Hud (entities = self.entities)
self.hud.add_counter ('clock', 'hud/clock.png')
self.hud.add_counter ('pigeons', 'hud/pigeon.png')
self.hud.add_counter ('sticks', 'hud/stick.png')
self.hud.hide ()
def setup_hud(self):
self.hud = Hud(entities=self.entities)
self.hud.add_counter('clock', 'hud/clock.png')
self.hud.add_counter('pigeons', 'hud/pigeon.png')
self.hud.add_counter('sticks', 'hud/stick.png')
self.hud.hide()
class Player:
def __init__(self,
dir_sprites,
dir_sounds,
dir_fonts,
lifes=constants['MAX_PLAYER_LIFES'],
hjump=constants['INITIAL_PLAYER_HJUMP'],
gravity=constants['INITIAL_PLAYER_GRAVITY'],
position=list(constants['START_POSITION_PLAYER'])):
self.hud = Hud(dir_sprites, dir_fonts, lifes=lifes)
self.sprites = {
'wait':
pygame.image.load(dir_sprites['player_wait']).convert_alpha(),
'run':
pygame.image.load(dir_sprites['player_run']).convert_alpha(),
'hurt':
pygame.image.load(dir_sprites['player_hurt']).convert_alpha()
}
#the following attribute will be modified in method _run...
self.sprite_base = self.sprites['wait']
self.sounds = {
'score_plus':
pygame.mixer.Sound(dir_sounds['sound_player_score_plus'])
}
self.attributes = {
'hjump': hjump,
'gravity': gravity,
'position': position
}
def collision(self, body2):
player_position = list(self.attributes['position'])
player_dimensions = [
self.sprite_base.get_width(),
self.sprite_base.get_height()
]
body2_position = list(body2.attributes['position'])
body2_dimensions = [
body2.sprite.get_width(),
body2.sprite.get_height()
]
player_rect = pygame.Rect(player_position, player_dimensions)
body2_rect = pygame.Rect(body2_position, body2_dimensions)
collided = player_rect.colliderect(body2_rect)
if collided:
if body2.attributes['type'] == 'obstacle':
self.hud.decrease_lifes(1)
#self.sounds['hurt'].play()
#body2 is a coin or life item...
elif body2.attributes['type'] == 'life':
self.hud.increase_lifes(body2.attributes['life_increase'])
#self.sounds['get_life'].play()
elif body2.attributes['type'] == 'bronze-coin':
self.hud.increase_score(body2.attributes['score_increase'])
#self.sounds['get_coin'].play()
elif body2.attributes['type'] == 'silver-coin':
self.hud.increase_score(body2.attributes['score_increase'])
#self.sounds['get_coin'].play()
elif body2.attributes['type'] == 'gold-coin':
self.hud.increase_score(body2.attributes['score_increase'])
#self.sounds['get_coin'].play()
#body2 exit of screen (exit from the user view)...
body2.attributes['position'][0] = -9000
def jump(self):
#self.sounds['jump'].play(maxtime=100)
self.attributes['position'][1] -= self.attributes['hjump']
def run(self):
st = ""
if self.sprite_base == self.sprites['wait']:
self.sprite_base = self.sprites['run']
st = "run"
elif self.sprite_base == self.sprites['run']:
self.sprite_base = self.sprites['wait']
st = "wait"
if self.hud.get_lifes() <= 0:
self.sprite_base = self.sprites['hurt']
st = "hurt"
elif self.sprite_base == self.sprites['hurt']:
#default configs when lifes > 0 but sprite_base == 'hurt'...
self.sprite_base = self.sprites['wait']
st = "wait"
return st
def fall(self):
if self.attributes['position'][1] < constants['START_POSITION_PLAYER'][
1]:
self.attributes['position'][1] += self.attributes['gravity']
touch_the_ground = self.attributes['position'][1] >= constants[
'START_POSITION_PLAYER'][1]
return touch_the_ground
def graphical_loop(self, constants, count_obstacles_passed, screen,
bodys_in_the_screen):
#run the graphical loop of the HUD...
self.hud.graphical_loop(constants, count_obstacles_passed, screen)
status_return = self.run()
#print(status_return)
for body in bodys_in_the_screen:
self.collision(body)
screen.blit(self.sprite_base, self.attributes['position'])
class MonorailGame:
STATE_INTRO, STATE_BEGIN, STATE_GAME, STATE_MENU, STATE_QUIT, STATE_STATS, STATE_TOTAL,\
STATE_DONE = range( 8 )
MOUSE_TIMEOUT = 25 * 3
def __init__( self, game_data ):
self.restart( game_data )
self.music_man = MusicManager()
# preload clock sounds and big explosion graphic
resman.get("game.clock_sound")
resman.get("game.clockring_sound")
resman.get("game.explosion_sprite")
def restart( self, game_data ):
"""Start a new game with the current game_data"""
self.game_data = game_data
self.state = MonorailGame.STATE_INTRO
self.scenario = self.game_data.get_quest().create_scenario(self.game_data.skill_level.value)
self.playfield = self.scenario.playfield
self.controller = ctrl.GroundControl( self.playfield )
self.init_goldcars()
self.hud = Hud( self.scenario, self.controller, self.game_data )
self.hud.start_intro_screen()
self.begin_timeout = 25 * 3
self.ingame_menu = None
self.gui_state = GuiState()
self.mouse_timeout = MonorailGame.MOUSE_TIMEOUT
self.is_paused = False
def init_goldcars( self ):
goldcar_names = []
controllers = []
for name, controller in self.game_data.goldcars:
goldcar_names.append( name )
controllers.append( controller )
for iq in self.game_data.get_quest().get_opponent_iqs():
goldcar_names.append( "" )
controllers.append( ctrl.AiController( None, iq ) )
self.playfield.add_goldcars( goldcar_names )
self.controller.add_controllers( controllers )
def do_tick( self, indev ):
if self.ingame_menu is None and not self.is_paused:
if self.game_data.is_single_player() or \
self.game_data.is_single_random():
SingleSwitch.feed_keys( indev )
# in singleplayer, all joystick buttons are keypress
for joy in indev.joys:
if joy.any_went_down():
indev.key.feed_down( K_SPACE )
if joy.any_went_up():
indev.key.feed_up( K_SPACE )
if self.state == MonorailGame.STATE_INTRO:
if self.hud.is_ready(): # or self.game_data.is_single_player():
self.hud.end_info()
self.state = MonorailGame.STATE_BEGIN
self.music_man.play()
elif self.state == MonorailGame.STATE_BEGIN:
if self.begin_timeout % 50 == 0:
random_spawn = not self.game_data.is_single_player();
spawns_left = self.playfield.spawn_next_goldcar( random_spawn )
if spawns_left:
self.begin_timeout += 50
self.controller.game_tick( indev )
self.playfield.game_tick()
# Start right away in single player
if self.game_data.is_single_player():
self.scenario.game_tick()
self.begin_timeout -= 1
if self.begin_timeout <= 0:
self.state = MonorailGame.STATE_GAME
if indev.mouse.has_moved():
self.mouse_timeout = MonorailGame.MOUSE_TIMEOUT
else:
self.mouse_timeout -= 1
elif self.state == MonorailGame.STATE_GAME:
self.controller.game_tick( indev )
self.playfield.game_tick()
self.scenario.game_tick()
if self.scenario.is_finished():
if not self.game_data.is_single_player():
self.hud.start_end_screen()
else:
self.game_data.get_quest().save_score( self.scenario )
skill = self.game_data.get_quest().get_skill( self.scenario )
self.game_data.skill_level.update( skill )
self.game_data.save_single_player_progress()
if self.scenario.has_won():
self.hud.start_win_screen()
else:
self.hud.start_lose_screen()
self.state = MonorailGame.STATE_STATS
self.mouse_timeout = MonorailGame.MOUSE_TIMEOUT
self.music_man.stop()
if indev.mouse.has_moved():
self.mouse_timeout = MonorailGame.MOUSE_TIMEOUT
else:
self.mouse_timeout -= 1
elif self.state == MonorailGame.STATE_STATS:
if self.hud.is_ready():
if not self.game_data.is_single_player():
self.game_data.add_total_scores( self.playfield )
self.hud.start_total_screen()
self.state = MonorailGame.STATE_TOTAL
else:
if self.scenario.has_won():
self.state = MonorailGame.STATE_DONE
else:
self.restart( self.game_data )
return
elif self.state == MonorailGame.STATE_TOTAL:
if self.hud.is_ready():
self.state = MonorailGame.STATE_DONE
elif self.state == MonorailGame.STATE_MENU:
pass
self.hud.game_tick( indev )
self.music_man.game_tick()
SingleSwitch.tick( indev, None )
if indev.key.went_down( K_ESCAPE ) or \
self.hud.menu_btn.went_down() or \
SingleSwitch.esc_went_down:
resman.get("gui.paper_sound").play()
self.ingame_menu = IngameMenu(self.game_data.is_single_player(), self.game_data)
elif self.ingame_menu is not None: # Ingame Menu
SingleSwitch.feed_keys( indev )
self.gui_state.update( indev, self.ingame_menu )
self.ingame_menu.tick( indev, self.gui_state )
if self.ingame_menu.is_done():
if self.ingame_menu.to_menu:
self.music_man.stop()
self.state = MonorailGame.STATE_MENU
elif self.ingame_menu.should_quit:
self.music_man.stop()
self.state = MonorailGame.STATE_QUIT
elif self.ingame_menu.to_next_level:
self.music_man.stop()
self.state = MonorailGame.STATE_DONE
self.ingame_menu = None
self.mouse_timeout = MonorailGame.MOUSE_TIMEOUT
# if indev.key.went_down( K_p ):
# self.is_paused = not self.is_paused
event.Event.update()
# for debugging
if self.is_paused:
self.controller.game_tick( indev )
def draw( self, surface, interpol, time_sec ):
#surface.fill( (0,0,0) )
frame = Frame( surface, time_sec, interpol )
if self.ingame_menu is not None or self.is_paused or\
self.state not in [MonorailGame.STATE_BEGIN, MonorailGame.STATE_GAME]:
frame.interpol = 0.0
frame.draw( self.playfield )
frame.draw( self.controller )
self.hud.draw( frame )
if self.ingame_menu is not None:
self.ingame_menu.draw( surface )
frame.draw( event.Event.instance )
def draw_mouse( self, surface, interpol, time_sec ):
if self.mouse_timeout > 0:
x, y = pygame.mouse.get_pos()
resman.get("gui_surf").draw( surface, Vec2D(x, y), (0,0,32,32) )
def mouse_down( self, button ):
pass
def is_done( self ):
return self.state == MonorailGame.STATE_DONE \
or self.state == MonorailGame.STATE_MENU \
or self.state == MonorailGame.STATE_QUIT
def __init__(self, app, screen):
# tock started out random, but now is an important variable.
# It is a frames count, used for periodic updates on certain
# frames.
self.p_max_health = 5
self.won = False
self.won_msg = "WINNER!"
self.particle_ban = False
self.wait_stop_count = -1 # -1 means do not count
self.wait_stop_max = 120 # wait this many frames after decay
# before showing menu
self.tock = 0
self.stage_e_bullet_odds = 15
self.mouse_rect = None
self.temp_rect = None
self.app = app
self.screen = screen
self.app.music_name = "intro.ogg"
# self.app.continue_music()
if self.app.settings['music']:
# self.app.music_loaded = self.app.music_name
# pygame.mixer.music.load(self.app.resource_find(
# self.music_name))
# pygame.mixer.music.play() # plays once PLUS repeats param
pass
left_border = 50
right_border = 50
w, h = screen.get_size()
self.world_rect = pygame.Rect(left_border, 0,
w-right_border-left_border, h)
self.bg = BackgroundManager(self.world_rect)
# Yay spritegroups! They make the world go round, and iterate.
# Basically each visible game object resides in its own special
# spritegroup & then all one needs to do is go through these &
# call functions & stuff.
# It makes sense in here *points to brain*
self.p_swarm = Swarm(self.world_rect)
self.particles = Swarm(self.world_rect)
self.explosion_images = self.app.load_seq('ex-medium')
self.shield_hit_images = self.app.load_seq('shield_hit-tiny')
self.damage_images = self.app.load_seq('ex-tiny')
# Load player sprite as image list.
self.p_unit_images = self.app.load_seq('pship')
# self.p_unit_images = []
# self.p_unit_images.append(self.load_file('pship.png'))
# self.p_unit_images.append(self.load_file('pship1.png'))
# self.p_unit_images.append(self.load_file('pship2.png'))
# self.p_unit_images.append(self.load_file('pship3.png'))
# Load enemy ship image.
self.e_ship_image = self.load_file('eship.png')
if self.app.settings['sounds']:
self.p_shoot_sound = self.app.load_file('p-weapon0.wav',
file_type='sound')
self.p_shoot_sound.set_volume(.3)
self.e_ex_sound = self.app.load_file('e-ex.wav',
file_type='sound')
self.p_ex_sound = self.app.load_file('p-ex.wav',
file_type='sound')
self.e_damage_sound = self.app.load_file('e-damage.wav',
file_type='sound')
self.e_shield_sound = self.app.load_file('e-shield.wav',
file_type='sound')
self.p_shield_sound = self.app.load_file('p-shield.wav',
file_type='sound')
self.p_damage_sound = self.app.load_file('p-damage.wav',
file_type='sound')
print("loaded sounds...")
self.menus = None
self.tock = 0
self.lagcount = 0
self.leftkeydown = 0
self.rightkeydown = 0
# self.enemylist = [] # list of dirty rects
self.swarm = Swarm(self.world_rect,
shoot_odds=self.stage_e_bullet_odds)
self.stage = Stage(self.swarm, self.p_swarm)
self.p_shot_image = self.load_file('p-laser.png')
self.e_shot_image = self.load_file('e-laser.png')
self.p_bullet_swarm = Swarm(self.world_rect)
self.e_bullet_swarm = Swarm(self.world_rect)
# self.bullet_width = 10
self.hud_rect = pygame.Rect(0, 0, 5, 150)
self.hud = Hud()
self.hud.generate_blip('player.score', 100,
fg_color=(255,243,207),
text_color=(192,180,180),
caption="SCORE")
self.hud.generate_blip('player.health', self.p_max_health,
fg_color=(0,255,42),
text_color=(192,180,180),
caption="SHIELD")
self.statcounter = self.hud.get_blip('player.score')
class Lienzo(gtk.DrawingArea):
def __init__(self, ventana):
super(Lienzo, self).__init__()
#Cambiar el color de fondo de la ventana
self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(0,0,0))
# Pedir el tamano de la ventana
self.set_size_request(WINDOW_SIZE,WINDOW_SIZE)
#Asignar la ventana que recibe de paramentro a la ventana que se
#utilizara en el lienzo
self.ventana=ventana
#expose-event es una propiedad de DrawingArea que le dice como
#dibujares, aqui le decimos que utilize nuestra funcion paint
#para ese evento en vez del que trae por defaul.
self.connect("expose-event", self.paint)
#reconocer cuando oprimes y sueltas el mouse
self.connect("button_press_event",self.button_press)
self.connect("button_release_event",self.button_release)
self.connect("motion_notify_event",self.actualizar_dragged)
self.set_events(gtk.gdk.BUTTON_PRESS_MASK|gtk.gdk.BUTTON_RELEASE_MASK|gtk.gdk.POINTER_MOTION_MASK)
self.hud=Hud()
self.minTimeToNextCell=200
self.maxTimeToNextCell=200
self.ticksToNextCell=random.randint(self.minTimeToNextCell,self.maxTimeToNextCell)
#cells
self.virus=[Virus(
random.randint(0,100-VIRUS_WIDTH),
random.randint(0,WINDOW_SIZE-CELL_HEIGHT),
) for i in xrange(TOTAL_VIRUS)]
self.virus[0].policy="Fuzzy"
self.virus[1].policy="Random"
self.cells=[]
self.draggingObject = None
self.objetoSeleccionado=[]
self.currentState="Running"
self.classificationList=["Target","Enemy","Food"]
self.trainingZoneLimit=WINDOW_SIZE-100
self.fnn = None
self.init_simulation()
self.run_simulation()
def actualizar_dragged(self,widget,event):
if self.draggingObject:
self.draggingObject.posX=event.x
self.draggingObject.posY=event.y
def on_timer(self):
self.update()
return True
def init_simulation(self):
"""Inicializacion de valores"""
self.reset()
gobject.timeout_add(20, self.on_timer)
def run_simulation(self,extra=0):
self.currentState="Running"
for cell in self.cells:
cell.width=20
cell.height=20
cell.velX=random.randint(1,5)/5.0
cell.velY=random.random()
break
def reset(self,extra=0):
self.currentState="Running"
self.trainingSet=[]
def update(self):
self.queue_draw()
cellsToPop=[]
for cell in self.cells:
cell.update(self.currentState)
if cell.posX+cell.width<0 or cell.isDead==True:
cellsToPop.append(cell)
for cell in cellsToPop:
self.cells.pop(indexOf(self.cells,cell))
for virus in self.virus:
if cell==virus.targetCell:
virus.targetCell=None
break
if self.currentState=="Running":
if self.ticksToNextCell<=0:
if len(self.cells)<MAX_CELLS:
self.ticksToNextCell=random.randint(self.minTimeToNextCell,self.maxTimeToNextCell)
newCell=Cell(WINDOW_SIZE,
random.randint(0,TRAINING_ZONE_LIMIT-CELL_HEIGHT))
newCell.velX=-(random.random()+3)
newCell.type="NormalCell"
self.cells.append(newCell)
else:
self.ticksToNextCell-=1
#update virus
for virus in self.virus:
if not virus.isDead:
virus.update(self.currentState)
if len(self.cells)>0 and virus.targetCell==None and virus.status=="Waiting1":
for cell in self.cells:
if cell.isAvailable:
virus.targetCell=cell
cell.isAvailable=False
break
def paint(self, widget, event):
"""Nuestro metodo de pintado propio"""
#Se crea un widget de cairo que despues se usara para desplegar
#todo en la ventana
cr = widget.window.cairo_create()
#Le decimos a cairo que pinte su widget por primera vez.
cr.set_source_rgb(0,0,0)
cr.paint()
#paint game info
cr.set_source_rgb(1,1,1)
cr.save()
cr.move_to(15,15)
text="To next cell: %d" % (self.ticksToNextCell)
cr.show_text(text)
cr.restore()
cr.set_source_rgb(1,1,1)
cr.move_to(100, 15)
cr.line_to(100,WINDOW_SIZE-15)
cr.set_line_width(0.6)
cr.stroke()
#pintar a los agentes
cr.set_line_width(1)
if self.currentState=="Training":
for i in xrange(len(self.classificationList)):
text=str(self.classificationList[i])
if i==0:
posXText=(self.divisionPoints[i])/2-(len(text)/2)*5
else:
posXText=(self.divisionPoints[i-1]+self.divisionPoints[i])/2-(len(text)/2)*5
posYText=15
cr.save()
cr.move_to(posXText,posYText)
cr.set_source_rgba(1,1,1,0.7)
cr.show_text(text)
cr.restore()
display_simulation(cr,[],self.cells)
self.hud.display_cells(cr,self.cells)
self.hud.display_viruses(cr, [])
if self.currentState=="Running":
for (cell,type) in self.trainingSet:
cell.paint(cr)
display_simulation(cr,self.virus,self.cells)
self.hud.display_cells(cr,self.cells)
self.hud.display_viruses(cr, self.virus)
#pintar efecto de selección sobre un agente
if self.objetoSeleccionado:
cr.set_line_width(2)
cr.set_source_rgba(random.random(), 1, random.random(), 0.3)
cr.rectangle(self.objetoSeleccionado.posX-20,self.objetoSeleccionado.posY-20,
self.objetoSeleccionado.width+40, self.objetoSeleccionado.height+40)
cr.stroke()
#paint score container
cr.set_line_width(2)
cr.set_source_rgba(1, 1, 1, 0.5)
cr.rectangle(100+15,15,570, 5)
cr.stroke()
score1=self.virus[0].score+0.00000001
score2=self.virus[1].score+0.00000001
total=score1+score2
#paint first gauge
cr.save()
width1=score1*570/total
cr.set_source_rgba(0, 1, 1, 1)
cr.rectangle(100+15,15,width1, 5)
cr.fill()
cr.move_to(100+15,35)
text="Fuzzy"
cr.show_text(text)
#paint second gauge
width2=570-width1
cr.set_source_rgba(1, 0.4, 0, 1)
cr.rectangle(100+15+width1,15,width2, 5)
cr.fill()
cr.move_to(670-25,35)
text="Random"
cr.show_text(text)
cr.restore()
#Para drag & drop
def button_press(self,widget,event):
if event.button == 1:
self.objetoSeleccionado=[]
lstTemp = self.virus+self.cells
for ob in lstTemp:
if ob.drag(event.x,event.y):
self.draggingObject = ob
self.objetoSeleccionado=ob
break
def button_release(self,widget,event):
if self.draggingObject:
self.draggingObject.drop(event.x,event.y)
self.draggingObject = None
def pausar(self):
self.corriendo=False
def correr(self):
self.corriendo=True
class World:
# This is the __init__
# its important.
def __init__(self, app, screen):
# tock started out random, but now is an important variable.
# It is a frames count, used for periodic updates on certain
# frames.
self.p_max_health = 5
self.won = False
self.won_msg = "WINNER!"
self.particle_ban = False
self.wait_stop_count = -1 # -1 means do not count
self.wait_stop_max = 120 # wait this many frames after decay
# before showing menu
self.tock = 0
self.stage_e_bullet_odds = 15
self.mouse_rect = None
self.temp_rect = None
self.app = app
self.screen = screen
self.app.music_name = "intro.ogg"
# self.app.continue_music()
if self.app.settings['music']:
# self.app.music_loaded = self.app.music_name
# pygame.mixer.music.load(self.app.resource_find(
# self.music_name))
# pygame.mixer.music.play() # plays once PLUS repeats param
pass
left_border = 50
right_border = 50
w, h = screen.get_size()
self.world_rect = pygame.Rect(left_border, 0,
w-right_border-left_border, h)
self.bg = BackgroundManager(self.world_rect)
# Yay spritegroups! They make the world go round, and iterate.
# Basically each visible game object resides in its own special
# spritegroup & then all one needs to do is go through these &
# call functions & stuff.
# It makes sense in here *points to brain*
self.p_swarm = Swarm(self.world_rect)
self.particles = Swarm(self.world_rect)
self.explosion_images = self.app.load_seq('ex-medium')
self.shield_hit_images = self.app.load_seq('shield_hit-tiny')
self.damage_images = self.app.load_seq('ex-tiny')
# Load player sprite as image list.
self.p_unit_images = self.app.load_seq('pship')
# self.p_unit_images = []
# self.p_unit_images.append(self.load_file('pship.png'))
# self.p_unit_images.append(self.load_file('pship1.png'))
# self.p_unit_images.append(self.load_file('pship2.png'))
# self.p_unit_images.append(self.load_file('pship3.png'))
# Load enemy ship image.
self.e_ship_image = self.load_file('eship.png')
if self.app.settings['sounds']:
self.p_shoot_sound = self.app.load_file('p-weapon0.wav',
file_type='sound')
self.p_shoot_sound.set_volume(.3)
self.e_ex_sound = self.app.load_file('e-ex.wav',
file_type='sound')
self.p_ex_sound = self.app.load_file('p-ex.wav',
file_type='sound')
self.e_damage_sound = self.app.load_file('e-damage.wav',
file_type='sound')
self.e_shield_sound = self.app.load_file('e-shield.wav',
file_type='sound')
self.p_shield_sound = self.app.load_file('p-shield.wav',
file_type='sound')
self.p_damage_sound = self.app.load_file('p-damage.wav',
file_type='sound')
print("loaded sounds...")
self.menus = None
self.tock = 0
self.lagcount = 0
self.leftkeydown = 0
self.rightkeydown = 0
# self.enemylist = [] # list of dirty rects
self.swarm = Swarm(self.world_rect,
shoot_odds=self.stage_e_bullet_odds)
self.stage = Stage(self.swarm, self.p_swarm)
self.p_shot_image = self.load_file('p-laser.png')
self.e_shot_image = self.load_file('e-laser.png')
self.p_bullet_swarm = Swarm(self.world_rect)
self.e_bullet_swarm = Swarm(self.world_rect)
# self.bullet_width = 10
self.hud_rect = pygame.Rect(0, 0, 5, 150)
self.hud = Hud()
self.hud.generate_blip('player.score', 100,
fg_color=(255,243,207),
text_color=(192,180,180),
caption="SCORE")
self.hud.generate_blip('player.health', self.p_max_health,
fg_color=(0,255,42),
text_color=(192,180,180),
caption="SHIELD")
self.statcounter = self.hud.get_blip('player.score')
def load_file(self, name):
return self.app.load_file(name)
def on_exit(self):
print("on_exit...")
# Clears all the variables
def clear_vars(self):
# print("clear_vars: world_rect: " + str(self.world_rect))
self.p_start_x = self.world_rect.width / 2
self.p_start_y = self.world_rect.height - 60
self.bend_y = float(self.p_start_y)
# print("clear_vars: p_start_y: " + str(self.p_start_y))
self.bend_rate = 0.02
self.leftkeydown = 0
self.rightkeydown = 0
if self.p_unit is not None:
self.hud.set_blip_value('player.health', self.p_unit.health)
else:
print("WARNING: clear_vars failed to set bar since no" +
" player unit exists")
self.statcounter.set_val(0)
self.stage.set_stage_number(-1) # hax
self.stage_e_bullet_odds = 100
self.swarm.empty()
self.p_bullet_swarm.empty()
self.p_swarm.empty()
self.particles.empty()
self.e_bullet_swarm.empty()
# Define function to draw player ship on X, Y plane
def draw_player_units(self):
self.p_swarm.draw(self.screen)
# Define function to move the enemy ship
def emove(self):
self.swarm.draw(self.screen) # use spritegroup draw method
# Draws all the enemys you ask it
def generate_enemies(self):
print("generating enemies...")
# Some recursive loops:
xmin = self.world_rect.left
xmax = self.world_rect.right
ymin = self.world_rect.top
stage_data = self.stage.get_data()
self.e_ship_image = self.app.load_file(stage_data['e']+".png")
enemy_width, enemy_height = self.e_ship_image.get_size()
enemy_spacing_x = 15
enemy_spacing_y = 10
init_enemy_speed = 3
angle = -90 # cartesian
self.app.music_name = stage_data['music']
# if self.app.music_name == 'intro.ogg':
# self.app.continue_music() # force song change
e_max_health = stage_data['e_h']
for enemycol in range(stage_data['x_e_count']):
# Now for the rows
for enemyrow in range(stage_data['y_e_count']):
# Make a new enemy object:
new_enemy = Entity(self.app,
'eship', [self.e_ship_image],
init_enemy_speed, angle,
self.swarm, e_max_health,
self.explosion_images, self.particles,
ai_enable=True,
value=stage_data['e_h'],
ex_sound=self.e_ex_sound)
new_enemy.set_xy(
xmin +
enemycol * (enemy_width +
enemy_spacing_x),
ymin +
enemyrow * (enemy_height +
enemy_spacing_y) - 150
)
new_enemy.set_range(
xmin +
enemycol * (enemy_width +
enemy_spacing_x),
xmax -
(stage_data['x_e_count'] - enemycol) *
(enemy_height +
enemy_spacing_x)
)
# Now add the temp enemy to the array and we're good to
# go
self.swarm.add(new_enemy)
# So I'm trying out having the program check for collisions, instead
# of the enemy objects i think i might switch to the objects, but
# still keep this function just hand the computing to the object
def test_collision(self):
part_speed = 1
part_angle = -90
part_health = 1
e_hit = pygame.sprite.groupcollide(self.swarm,
self.p_bullet_swarm,
0, 0)
for sprite, bullets in e_hit.items():
# print("removed " + str(bullet)
for bullet in bullets:
was_alive = sprite.get_is_alive()
prev_health = sprite.health
if sprite.get_is_alive():
sprite.set_hit(1)
damage = prev_health - sprite.health
poof = self.shield_hit_images
temper_sound = self.e_shield_sound
if damage > 0:
poof = self.damage_images
temper_sound = self.e_damage_sound
if not was_alive:
break
point = pygame.sprite.collide_mask(sprite,
bullet)
if ((point is not None) and
(not self.particle_ban)):
particle = Entity(self.app, 'particle',
poof,
part_speed,
part_angle, self.particles,
part_health,
None,
None,
anim_done_remove=True,
temper_sound=temper_sound)
particle.temper = 1 # start particle death
x1, y1 = sprite.get_pos() # top left
x = x1 + point[0] - particle.rect.width / 2
y = y1 + point[1] - particle.rect.height / 2
particle.set_xy(x, y)
self.particles.add(particle)
if not sprite.get_is_alive():
points = sprite.take_value() # only once & if health 0
if points > 0:
self.statcounter.add_value(points)
self.p_bullet_swarm.remove(bullets)
p_hit = pygame.sprite.groupcollide(self.p_swarm,
self.e_bullet_swarm,
0, 0)
for sprite, bullets in p_hit.items():
for bullet in bullets:
was_alive = sprite.get_is_alive()
prev_health = sprite.health
if sprite.get_is_alive():
sprite.set_hit(1)
damage = prev_health - sprite.health
poof = self.shield_hit_images
temper_sound = self.p_shield_sound
if damage > 0:
poof = self.damage_images
temper_sound = self.p_damage_sound
self.hud.set_blip_value('player.health',
self.p_unit.health)
# New in pygame 1.8.0:
point = pygame.sprite.collide_mask(sprite, bullet)
if not was_alive:
break
if (point is not None) and (not self.particle_ban):
particle = Entity(self.app, 'particle',
poof,
part_speed,
part_angle, self.particles,
part_health,
None,
None,
anim_done_remove=True,
temper_sound=temper_sound)
particle.temper = 1 # start particle death
x1, y1 = sprite.get_pos() # top left
x = x1 + point[0] - particle.rect.width / 2
y = y1 + point[1] - particle.rect.height / 2
particle.set_xy(x, y)
self.particles.add(particle)
# if pygame.sprite.spritecollideany(self.p_unit,
# self.e_bullet_swarm):
# self.p_unit.set_hit(1)
# self.hud.set_blip_value('player.health',
# self.p_unit.health)
# if there are no enemys left, go to the next stage
def check_done(self):
if not self.swarm:
if self.stage.is_last_stage():
if not self.won:
self.won = True # TODO: make ending screen
# self.app.music_name = 'victory.ogg'
# if self.app.music_name == 'intro.ogg':
# self.app.continue_music() # force song change
self.app.music_name = None # stop repeating
self.app.check_music() # apply None to loop
self.app.queue_music('victory.ogg', 1)
if not self.won:
self.stage.next_stage()
if self.stage_e_bullet_odds > 15:
self.stage_e_bullet_odds -= 15
self.generate_enemies()
# checks to see if we can expand the ranges of the bots so its nice
# and.... umm... nice.
def check_rows(self):
if self.tock % 20 == 0:
# simple sorting algorithm to find the highest values
xmin = self.world_rect.left
xmax = self.world_rect.right
highest = xmin
lowest = xmax
for enemy in self.swarm:
if enemy.get_range()[1] > highest:
highest = enemy.get_range()[1]
if enemy.get_range()[0] < lowest:
lowest = enemy.get_range()[0]
highest = xmax - highest
lowest = lowest - xmin
if highest != 0 or lowest != 0:
# makes things |--| this much more efficient
for enemy in self.swarm:
erange = enemy.get_range()
enemy.set_range(erange[0]-lowest,
erange[1]+highest)
# major hack just to get this thing playable..... sorry
def again(self):
if self.hud.get_blip_value('player.health') <= 0:
self.particle_ban = True
if self.p_unit.get_is_decayed():
self.particle_ban = True
# also wait for particles to finish for prettier ending
if len(self.particles) < 1:
if self.wait_stop_count < 0:
print("player unit decayed, counting down to menu")
self.wait_stop_count = 0
# return False
if self.wait_stop_count >= 0:
self.wait_stop_count += 1
if self.wait_stop_count > self.wait_stop_max:
return False
if self.won:
if self.wait_stop_count < 0:
print("won game, counting down to menu")
self.wait_stop_count = 0
return True
# this is called if the player initiates shooting
def pshoot(self):
# sx = self.p_unit.rect.centerx -
# self.p_shot_image.rect.width / 2
# sy = self.p_unit.rect.top +
# self.p_shot_image.rect.height * .75
if self.p_unit.get_is_alive():
self.p_unit.shoot(self.p_shot_image,
self.p_bullet_swarm)
# self.p_unit.shoot_from(self.p_shot_image,
# self.p_bullet_swarm,
# sx, sy, self.p_unit.angle)
def draw_bullets(self):
self.p_bullet_swarm.draw(self.screen)
self.e_bullet_swarm.draw(self.screen)
def draw_hud(self):
if self.tock % 5 == 0:
self.hud.update()
self.hud.draw(self.screen)
# Goes through all the objects and makes each of them move as
# necessary
def tick(self):
self.bend_y += self.bend_rate
bend_max = 5.0
if self.bend_rate < 0.0:
self.bend_rate -= .02
else:
self.bend_rate += .02
if ((self.bend_y > self.p_start_y + bend_max) or
(self.bend_y < self.p_start_y)):
if self.bend_rate < 0.0:
self.bend_rate = .02
self.bend_y = float(self.p_start_y)
else:
self.bend_rate = -.02
self.bend_y = float(self.p_start_y) + bend_max
self.p_unit.set_xy(self.p_unit.get_pos()[0],
int(self.bend_y+.5))
self.p_bullet_swarm.update()
self.swarm.update()
self.e_bullet_swarm.update()
######################
# Here are a bunch of metafunctions.
# I break it up so its really easy to add new features,
# like if we ant a counter? add something to check() and draw().
# All of these are called once per frame.
def check(self):
self.check_done()
self.test_collision()
self.check_rows()
self.bg.update()
if self.p_unit.get_is_alive():
self.swarm.shoot(self.e_shot_image, self.e_bullet_swarm)
self.p_unit.update()
for particle in self.particles:
particle.update()
def draw(self):
self.screen.fill(self.bg.bg_color)
# if self.world_rect is not None:
# self.screen.fill((64, 64, 64), self.world_rect)
self.bg.draw(self.screen)
self.draw_bullets()
self.draw_player_units()
self.emove()
self.particles.draw(self.screen)
self.draw_hud()
# if self.p_unit is not None:
# if self.p_unit.rect is not None:
# self.screen.fill((128, 128, 128), self.p_unit.rect)
# if self.mouse_rect is not None:
# self.screen.fill((255, 255, 255), self.mouse_rect)
# if self.temp_rect is not None:
# self.screen.fill((128, 0, 0), self.temp_rect)
# does just what it sounds like.....
def clear_screen(self):
self.screen.fill(self.bg.bg_color)
# pygame.display.flip()
# for debugging info mostly
def dispvars(self):
print("The Enemy SpriteGroup size is:" +
str(len(self.swarm.sprites())))
print("The Player Bullet Array size is:" +
str(len(self.p_bullet_swarm.sprites())))
print("The Enemy Bullet Array size is:" +
str(len(self.e_bullet_swarm.sprites())))
# does lots and lots of stuff, it really needs to be cleaned up
def process_events(self, events):
# print("input: self.p_unit.rect: " + str(self.p_unit.rect))
xmin = self.world_rect.left
xmax = self.world_rect.right
smooth_scroll_var1 = 10
smooth_scroll_var2 = 2
pygame.event.pump() # redraw Window so OS knows not frozen
self.app.check_music()
pause_menu_strings = ["RESUME", "ABOUT", "HELP", "EXIT"]
if self.won:
pause_menu_strings.insert(0, self.won_msg)
for event in events:
if event.type == QUIT:
self.on_exit()
sys.exit(0)
if event.type == pygame.MOUSEMOTION:
pygame.event.get()
prev_pos = self.p_unit.get_pos()
tempx = (pygame.mouse.get_pos()[0] -
self.p_unit.rect.width / 2)
# *Just to make sure we don't get the ship way out:
if tempx + self.p_unit.rect.width > xmax:
# if its outside the world,
# just stick it as far as possible
self.p_unit.set_xy(xmax - self.p_unit.rect.width,
prev_pos[1])
elif tempx < xmin:
self.p_unit.set_xy(xmin, prev_pos[1])
elif abs(tempx-self.p_start_x) > \
smooth_scroll_var1:
# smooth scrolling if the mouse gets far
# from the ship
self.p_unit.set_xy(
prev_pos[0] +
(tempx-prev_pos[0]) /
smooth_scroll_var2,
prev_pos[1])
else:
# if it gets down to this point,
# we've passed all sanity checks so just move it
self.p_unit.set_xy(tempx, prev_pos[1])
elif event.type == pygame.MOUSEBUTTONDOWN:
self.pshoot()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
self.menus.show_dialog(pause_menu_strings)
if event.key == pygame.K_p:
self.menus.show_dialog(pause_menu_strings)
if event.key == pygame.K_ESCAPE:
self.menus.show_dialog(pause_menu_strings)
# keyboard controls
if event.key == pygame.K_LEFT:
self.leftkeydown = 1
if event.key == pygame.K_RIGHT:
self.rightkeydown = 1
if event.key == pygame.K_SPACE:
self.pshoot()
elif event.type == pygame.KEYUP:
if event.key == pygame.K_LEFT:
self.leftkeydown = 0
if event.key == pygame.K_RIGHT:
self.rightkeydown = 0
elif event.type == pygame.USEREVENT:
if event.code == pygame.USEREVENT_DROPFILE:
print("Tried to open file on MacOS (this should" +
" never happen:")
print(" " + str(event))
else: # should be event.code 0
self.app.continue_music()
print("music queue ended in game:")
if event.code != 0:
print("unknown USEREVENT event.code: " +
str(event.code))
if self.leftkeydown:
self.p_unit.move_one(-1, self.world_rect)
if self.rightkeydown:
self.p_unit.move_one(1, self.world_rect)
pygame.event.clear()
####################################################################
def start(self, menus):
self.won = False
self.particle_ban = False
self.wait_stop_count = -1 # -1 means do not count down to menu
self.menus = menus
p_speed = 10
self.p_unit = Entity(self.app, 'pship', self.p_unit_images,
p_speed, 90.0,
self.p_swarm, self.p_max_health,
self.explosion_images,
self.particles,
ex_sound = self.p_ex_sound)
self.p_unit.shoot_sound = self.p_shoot_sound
print("Clearing vars...")
self.clear_vars() # does reset player unit (p_unit) position
self.p_swarm.add(self.p_unit)
self.p_unit.set_xy(self.p_start_x, self.p_start_y)
print("Starting main event loop...")
self.loop()
# Yeah see this one does all of the work
def loop(self):
# Start loop
REFRESH_TIME = self.app.get_fps() * 3
while (not self.menus.get_bool('exit')) and (self.again()):
# Refresh screen periodically
if self.tock >= REFRESH_TIME:
# self.clear_screen()
self.tock = 0
self.tock += 1
# Check everythign and see if changes need to be made
self.check()
# Draw bullets
self.draw()
# Move everything
self.tick()
# Initiate input function
self.process_events(pygame.event.get())
# applies the smart screen updating
pygame.display.update()
# TODO: ? pygame.display.update(self.enemylist)
# self.enemylist = []
# Pauses and waits
timeittook = self.app.clock.tick(self.app.get_fps())
from hud import Hud
from scene import Scene
from window import Window
from character import Character
# Create a grid with a specific atlas.
g = Grid(10, 10, 50, 50, "terrain_atlas.json")
# Create a character.
goo = Character("goo", "../images/goo_hl.gif", 7, 7, "animation")
g.add_character(goo, 5, 5)
goo.scale(.10)
# Create a few HUDs.
meter_hud = Hud(x_offset=15,
y_offset=80,
hud_image_loc="../images/ui/hud-test.png")
heart_hud0 = Hud(x_offset=120,
y_offset=40,
hud_image_loc="../images/ui/heart.png")
heart_hud0.image.scale = 0.55
heart_hud1 = Hud(x_offset=140,
y_offset=40,
hud_image_loc="../images/ui/heart.png")
heart_hud1.image.scale = 0.55
huds = [meter_hud, heart_hud0, heart_hud1]
# Create a scene with a grid and some huds attached.
s = Scene(g, huds)
# Create the window.
def __init__(self):
"""initialise the engine"""
ShowBase.__init__(self)
base.notify.info("Version {}".format(versionstring))
FSM.__init__(self, "FSM-Game")
#
# BASIC APPLICATION CONFIGURATIONS
#
# disable pandas default camera driver
self.disableMouse()
# set antialias for the complete sceen to automatic
self.render.setAntialias(AntialiasAttrib.MAuto)
# shader generator
render.setShaderAuto()
# Enhance font readability
DGG.getDefaultFont().setPixelsPerUnit(100)
# get the displays width and height for later usage
self.dispWidth = self.pipe.getDisplayWidth()
self.dispHeight = self.pipe.getDisplayHeight()
#
# CONFIGURATION LOADING
#
# load given variables or set defaults
# check if particles should be enabled
# NOTE: If you use the internal physics engine, this always has
# to be enabled!
particles = ConfigVariableBool("particles-enabled", True).getValue()
if particles:
self.enableParticles()
def setFullscreen():
"""Helper function to set the window fullscreen
with width and height set to the screens size"""
# set window properties
# clear all properties not previously set
base.win.clearRejectedProperties()
# setup new window properties
props = WindowProperties()
# Fullscreen
props.setFullscreen(True)
# set the window size to the screen resolution
props.setSize(self.dispWidth, self.dispHeight)
# request the new properties
base.win.requestProperties(props)
# Set the config variables so we correctly store the
# new size and fullscreen setting later
winSize = ConfigVariableString("win-size")
winSize.setValue("{} {}".format(self.dispWidth, self.dispHeight))
fullscreen = ConfigVariableBool("fullscreen")
fullscreen.setValue(True)
# Render a frame to make sure the fullscreen is applied
# before we do anything else
self.taskMgr.step()
# make sure to propagate the new aspect ratio properly so
# the GUI and other things will be scaled appropriately
aspectRatio = self.dispWidth / self.dispHeight
self.adjustWindowAspectRatio(aspectRatio)
# check if the config file hasn't been created
if not os.path.exists(prcFile):
setFullscreen()
# automatically safe configuration at application exit
#base.exitFunc = self.__writeConfig
#
# INITIALIZE GAME CONTENT
#
base.cTrav = CollisionTraverser("base collision traverser")
base.pusher = CollisionHandlerPusher()
self.menu = Menu()
self.credits = Credits()
self.charSelection = CharacterSelection()
self.levelSelection = LevelSelection()
self.koScreen = KoScreen()
self.hud = Hud()
self.menuMusic = loader.loadMusic("assets/audio/menuMusic.ogg")
self.menuMusic.setLoop(True)
self.fightMusic = loader.loadMusic("assets/audio/fightMusic.ogg")
self.fightMusic.setLoop(True)
base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
#
# EVENT HANDLING
#
# By default we accept the escape key
self.accept("escape", self.__escape)
#
# ENTER GAMES INITIAL FSM STATE
#
self.request("Menu")
class Game():
def __init__(self, _parent=None):
self.parent = _parent
# Containers
self.game_objects = {}
self.game_doors = {}
self.game_objects_np = render.attachNewNode("Game_Objects")
self.game_doors_np = render.attachNewNode("Player_Doors")
self.game_doors_np.setPos(0, 0, 0)
self.game_counter_node = None
self.game_collector_nodes = []
self.redDudesCount = 0
self.blueDudesCount = 0
# Physics world
self.physics_world = None
self.builder = Builder(self)
# level lights
self.directLight = None
# Dude class
self.dude = None
self.spawnPoints = self.builder.spawnPoints
# HUD
self.hud = Hud()
# Lightshow
self.elapsed = 0.0
def start(self, levelID, winCondition=25):
self.winCondition = winCondition
self.loadLevel("assets/level{}".format(levelID))
self.loadLights()
# player
self.loadPlayer("default")
self.loadDude()
# Timer
taskMgr.add(self.update, "Game_Update_Task", 0)
self.hud.show()
# start the Lightshow
taskMgr.add(self.discoLightTask, "the lightshow")
def stop(self):
self.player.stop()
self.dude.stop()
self.builder.cleanup()
self.physics_world = None
render.clearLight()
self.directLight = None
self.hud.hide()
taskMgr.remove("the lightshow")
def update(self, task):
if self.game_counter_node is None:
return
ghost = self.game_counter_node.node()
for node in ghost.getOverlappingNodes():
if "red" in node.name:
self.redDudesCount += 1
self.physics_world.removeRigidBody(self.dude.dudes[node.name].node())
self.dude.dudes[node.name].removeNode()
self.hud.update(self.redDudesCount, self.blueDudesCount)
del self.dude.dudes[node.name]
break
elif "blue" in node.name:
self.blueDudesCount += 1
self.physics_world.removeRigidBody(self.dude.dudes[node.name].node())
self.dude.dudes[node.name].removeNode()
self.hud.update(self.redDudesCount, self.blueDudesCount)
del self.dude.dudes[node.name]
break
if self.redDudesCount > self.blueDudesCount:
base.messenger.send("lostGame")
return Task.done
elif self.blueDudesCount >= self.winCondition:
base.messenger.send("wonGame")
return Task.done
for collectorGhostNP in self.game_collector_nodes:
collectorGhost = collectorGhostNP.node()
for node in collectorGhost.getOverlappingNodes():
if "red" in node.name:
self.physics_world.removeRigidBody(self.dude.dudes[node.name].node())
self.dude.dudes[node.name].removeNode()
self.hud.update(self.redDudesCount, self.blueDudesCount)
del self.dude.dudes[node.name]
return Task.cont
def setPhysicsWorld(self, _physicsworld):
self.physics_world = _physicsworld
#### LOADERS ####
def loadLevel(self, _filename):
self.builder.parseEggFile(_filename)
def loadLights(self):
# Set a simple light
dlight = DirectionalLight('DirectLight')
dlnp = render.attachNewNode(dlight)
dlnp.setHpr(-30, 0, 0)
render.setLight(dlnp)
self.directLight = dlnp
self.discoLights = []
p1 = PointLight("PointLight1")
p1.setColor(VBase4(1, 0, 0, 1))
p1.setAttenuation((0.08, 0, 0.05))
p1np = render.attachNewNode(p1)
p1np.setPos(0, -5, 0)
render.setLight(p1np)
self.discoLights.append(p1)
p2 = PointLight("PointLight2")
p2.setColor(VBase4(0, 1, 0, 1))
p2.setAttenuation((0.08, 0, 0.05))
p2np = render.attachNewNode(p2)
p2np.setPos(5, -5, 0)
render.setLight(p2np)
self.discoLights.append(p2)
p3 = PointLight("PointLight3")
p3.setColor(VBase4(0, 0, 1, 1))
p3.setAttenuation((0.08, 0, 0.05))
p3np = render.attachNewNode(p3)
p3np.setPos(-5, -5, 0)
render.setLight(p3np)
self.discoLights.append(p3)
p4 = PointLight("PointLight4")
p4.setColor(VBase4(0, 0, 1, 1))
p4.setAttenuation((0.08, 0, 0.05))
p4np = render.attachNewNode(p4)
p4np.setPos(-5, -5, 5)
render.setLight(p4np)
self.discoLights.append(p4)
p5 = PointLight("PointLight1")
p5.setColor(VBase4(0, 0, 1, 1))
p5.setAttenuation((0.08, 0, 0.05))
p5np = render.attachNewNode(p5)
p5np.setPos(0, -5, 5)
render.setLight(p5np)
self.discoLights.append(p5)
p6 = PointLight("PointLight1")
p6.setColor(VBase4(0, 0, 1, 1))
p6.setAttenuation((0.08, 0, 0.05))
p6np = render.attachNewNode(p6)
p6np.setPos(5, -5, 5)
render.setLight(p6np)
self.discoLights.append(p6)
def discoLightTask(self, task):
self.elapsed += globalClock.getDt()
if self.elapsed > 0.75:
for light in self.discoLights:
newcolor = choice(
[VBase4(0, 0, 1, 1),
VBase4(0, 1, 0, 1),
VBase4(1, 0, 0, 1),
VBase4(0, 1, 1, 1),
VBase4(1, 0, 1, 1),
VBase4(1, 1, 0, 1),]
)
light.setColor(newcolor)
self.elapsed = 0.0
return task.cont
def loadPlayer(self, _name):
self.player = Player(self)
self.player.start()
def loadDude(self):
self.dude = Dude(self)
self.dude.start()
class Game (GameState):
def do_setup (self, level):
super (Game, self).do_setup ()
self.level = level
self.setup_panda ()
self.level.setup_entities (self.entities)
self.setup_input ()
self.setup_controllers ()
self.setup_hud ()
self.setup_logic ()
self.enter_transition ()
self.events.event ('panda-escape').connect (self.enter_menu)
self.events.event ('panda-p').connect (self.toggle_pause)
self.manager.enter_state (
GameMessage, message =
(('You have to kill %i pigeons in this level...\n' +
'Can you make it?') % self.total_pigeons))
def enter_transition (self):
self._transition_bg = ui.ImageEntity (entities = self.entities,
image = 'hud/red-bg.png')
self._transition_bg.alpha = 1.0
self._transition_bg.fade_out ()
def leave_transition (self, next_st = 'menu'):
self._transition_bg.fade_in ().add_next (task.run (lambda:
self.manager.leave_state (last_state = next_st)))
def enter_menu (self):
self.manager.enter_state ('menu-noload', None, 'ingame')
@weak_slot
def on_kill_pigeon (self):
self.hud.dec_counter ('pigeons', 1)
self.dead_pigeons += 1
if self.dead_pigeons >= self.total_pigeons:
self.win_game ()
@weak_slot
def on_kill_boy (self):
self.fail_game (random.choice (['You are dead!',
'Was it that hard to stay alive?',
"Your soul is burning in hell..."]))
@weak_slot
def on_finish_time (self):
self.fail_game (random.choice (['No more time for you!',
'Too slow man...',
'Hurry up the next time!']))
def win_game (self):
if self.manager.current == self:
self.manager.enter_state (
GameMessage,
'YOU WON!\n'
'This was a show-case level of an in-development game,\n'
'there is more to come in the future.',
'quit')
def fail_game (self, reason):
if self.manager.current == self:
msg = random.choice (['LOOOOOOOOSER', 'You lost!', 'What a pity!',
'Hey, no luck today!'])
self.manager.enter_state (GameMessage, reason + '\n' + msg, 'retry')
@weak_slot
def on_place_stick (self):
if self.player_ctl.can_place_stick:
self.num_sticks -= 1
if self.num_sticks == 0:
self.player_ctl.can_place_stick = False
self.hud.set_counter ('sticks', self.num_sticks)
def highlight_stick_task (self, timer):
pos = self.player_ctl.get_place_position (5)
best = self.player_ctl.laser.best_stick (pos)
if best != self._curr_best_stick:
if self._curr_best_stick:
self._curr_best_stick.unhighlight ()
if self.player_ctl.can_place_stick:
self._curr_best_stick = best
if best:
best.highlight ()
return task.running
def do_update (self, timer):
super (Game, self).do_update (timer)
@weak_slot
def on_shader_change (self, cfg):
if cfg.value:
self.glow_filter.enable (self.manager.panda)
else:
self.glow_filter.disable ()
@weak_slot
def on_control_change (self, cfg):
self.player_input.unassoc_action (cfg.name)
if cfg.value:
self.player_input.assoc (cfg.name, cfg.value)
def setup_panda (self):
self.glow_filter = shader.GlowFilter ()
panda = self.manager.panda
if GlobalConf ().path ('game.shader').value:
self.glow_filter.enable (panda)
panda.relative_mouse ()
panda.loop_music (self.level.music)
def setup_input (self):
self.player_input = GameInput ()
self.camera_input = GameInput (CAMERA_INPUT_MAP)
self.events.connect (self.player_input)
self.events.connect (self.camera_input)
self.tasks.add (self.player_input)
self.tasks.add (self.camera_input)
self.player_input.assoc ('on_steer', 'panda-mouse-move')
cfg = GlobalConf ().path ('game.player0.keys')
for c in cfg.childs ():
if c.value:
self.player_input.assoc (c.name, c.value)
c.on_conf_change += self.on_control_change
GlobalConf ().path ('game.shader').on_conf_change += \
self.on_shader_change
def setup_controllers (self):
self.camera_ctl = CameraController (
entities = self.entities,
camera = base.camera)
self.player_ctl = PlayerController (
entities = self.entities,
delegate = self.level.boy)
self.level.boy.connect (self.camera_ctl)
self.camera_input.connect (self.camera_ctl)
self.player_input.connect (self.player_ctl)
def setup_hud (self):
self.hud = Hud (entities = self.entities)
self.hud.add_counter ('clock', 'hud/clock.png')
self.hud.add_counter ('pigeons', 'hud/pigeon.png')
self.hud.add_counter ('sticks', 'hud/stick.png')
self.hud.hide ()
def setup_logic (self):
total_pigeons = 0
for f in self.level.flocks:
total_pigeons += len (f.boids)
for b in f.boids:
b.on_death += self.on_kill_pigeon
self.total_pigeons = total_pigeons
self.dead_pigeons = 0
self.level.boy.on_death += self.on_kill_boy
self.num_sticks = self.level.max_sticks
self.player_ctl.on_place_stick_down += self.on_place_stick
self.hud.set_counter ('sticks', self.num_sticks)
self.timer = self.tasks.add (
task.TimerTask (duration = self.level.max_time))
self.timer.on_tick = lambda: self.hud.set_counter (
'clock', int (self.timer.remaining))
self.timer.on_finish = self.on_finish_time
self.tasks.add (self.highlight_stick_task)
self._curr_best_stick = None
self.pigeon_food = []
def do_sink (self):
super (Game, self).do_sink ()
if self.manager.current.state_name == 'menu-noload':
for x in self.entities.entities:
if isinstance (x, task.Task):
x.pause ()
self.events.quiet = True
self.hud.soft_hide ()
self.timer.pause ()
def do_unsink (self, action = 'continue'):
super (Game, self).do_unsink ()
self.manager.panda.relative_mouse ()
self.tasks.resume ()
for x in self.entities.entities:
if isinstance (x, task.Task):
x.resume ()
if action == 'continue':
self.events.quiet = False
self.hud.soft_show ()
self.timer.resume ()
elif action == 'quit':
self.leave_transition ()
elif action == 'retry':
self.leave_transition ('game')
def do_release (self):
self.level.dispose () # TODO: To entity!
self.glow_filter.disable ()
super (Game, self).do_release ()
def playGame(character1, character2):
pygame.init()
pygame.mixer.init()
pygame.mixer.music.load("Sound/07 - The Raising Fighting Spirit.ogg") #Background music "The Rising Fighting Spirit":http://downloads.khinsider.com/game-soundtracks/album/naruto-original-soundtrack-1
pygame.mixer.music.play(-1)
displaysurf = pygame.display.set_mode((WIDTH, HEIGHT))
clock = pygame.time.Clock()
player1=Character(PLAYER1_CONTROLS, IMAGES[character1], SOUNDS[character1], PLAYER1_POSITION)
player2=Character(PLAYER2_CONTROLS, IMAGES[character2], SOUNDS[character2], PLAYER2_POSITION)
HUD1_IMAGES=HUD_IMAGES.copy()
HUD1_IMAGES["icon"]=IMAGES[character1]["icon"]
HUD2_IMAGES=HUD_IMAGES.copy()
HUD2_IMAGES["icon"]=IMAGES[character2]["icon"]
player1_hud=Hud(HUD1_IMAGES, LEFT_HUD_POSITION)
player2_hud=Hud(HUD2_IMAGES, RIGHT_HUD_POSITION)
player2_hud.flip()
background=load_image("Background/training_background.png") #http://spritedatabase.net/game/1889
background=pygame.transform.scale(background, (WIDTH, HEIGHT))
player1_wins=load_image("Background/player1wins.png") #Used the folowing website to generate the win signs: http://www.dafont.com/ninja-naruto.font
player2_wins=load_image("Background/player2wins.png")
pygame.display.set_caption('Pybrawl')
game_over=False
while True: # main game loop
displaysurf.blit(background, (0,0))
clock.tick(FPS)
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
elif event.type == KEYDOWN and event.key == K_RETURN and game_over:
return
if player1.health==0:
game_over=True
pygame.mixer.music.stop()
displaysurf.blit(player2_wins, (172, 200))
if player2.health==0:
game_over=True
pygame.mixer.music.stop()
displaysurf.blit(player1_wins, (172, 200))
keys_status=pygame.key.get_pressed()
if game_over:
keys_status=[False for i in keys_status]
player1.update(keys_status)
player2.update(keys_status)
collide(player1, player2)
keep_inside(player1)
keep_inside(player2)
if player1.rect.centerx < player2.rect.centerx:
player1.direction="right"
player2.direction="left"
else:
player1.direction="left"
player2.direction="right"
player1_hud.update(player1.health/player1.max_health,
player1.mana/player1.max_mana)
player2_hud.update(player2.health/player2.max_health,
player2.mana/player2.max_mana)
player1.draw(displaysurf)
player2.draw(displaysurf)
player1_hud.draw(displaysurf)
player2_hud.draw(displaysurf)
pygame.display.update()
def main():
""" Main Program """
pygame.init()
# Set the height and width of the screen
size = [SCREEN_WIDTH, SCREEN_HEIGHT]
screen = pygame.display.set_mode(size)
pygame.display.set_caption("Dungeon Dreams Demo")
# Create the player
map_pix_size = 30
# Create all the levels
level_list = []
# level_list.append( Level_01(player) )
# Set the current level
current_level_no = 0
current_level = 0
# current_level = level_list[current_level_no]
active_sprite_list = pygame.sprite.Group()
# Loop until the user clicks the close button.
done = False
# Used to manage how fast the screen updates
clock = pygame.time.Clock()
all_sprites_list = pygame.sprite.LayeredDirty()
collid_list = pygame.sprite.LayeredDirty()
mobiles_list = pygame.sprite.Group()
m_attacks = pygame.sprite.Group()
area = None
image_files = glob.glob('HumanMage.PNG')
hud = Hud(screen)
player = Player(100, 100, image_files, hud)
hud.display_player_stats(player.stats)
player.set_all_sprites(all_sprites_list)
screen_size = (screen.get_width(), screen.get_height())
m_fact = Monster_Factory(area, collid_list, 50, screen_size,
all_sprites_list, player)
map_tool = Map_Handler(screen, all_sprites_list, collid_list, player,
mobiles_list, m_fact, hud)
map_tool.build_area()
item_fact = map_tool.get_item_fact()
shift_x = 0
shift_y = 0
all_mobiles = m_fact.get_mobiles_group()
dam_mod = 1
#init path finding...
path_finder = a_star(collid_list, 50)
player.group_add(all_mobiles)
image_files = glob.glob('*.PNG')
#init events for following and monsters, start at 3 seconds because
#player needs a second or two catch bearings
FOLLOW_EVENT = USEREVENT + 1
M_ATTACK_EVENT = USEREVENT + 2
pygame.time.set_timer(FOLLOW_EVENT, 3000)
pygame.time.set_timer(M_ATTACK_EVENT, 3000)
game_start = False
#-------- Main Program Loop -----------
while not done:
#Probably would make a class just to handle
#client events.
#These handle the movements
keys = pygame.key.get_pressed()
if keys[pygame.K_h]:
player.changespeed(-1, 0)
if keys[pygame.K_l]:
player.changespeed(1, 0)
if keys[pygame.K_k]:
player.changespeed(0, -1)
if keys[pygame.K_j]:
player.changespeed(0, 1)
if keys[pygame.K_n]:
player.changespeed(1, 1)
if keys[pygame.K_b]:
player.changespeed(-1, 1)
if keys[pygame.K_y]:
player.changespeed(-1, -1)
if keys[pygame.K_u]:
player.changespeed(1, -1)
#More events, quit and attacks and stopping the player
#when the button goes up.
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
player.check_events(event)
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
r_attack = player.ranged_attack(all_sprites_list, None,
player.r_attack_images,
dam_mod)
m_fact.set_check_attack(r_attack)
if event.type == pygame.KEYUP:
if event.key == pygame.K_h:
player.stop()
if event.key == pygame.K_y:
player.stop()
if event.key == pygame.K_k:
player.stop()
if event.key == pygame.K_u:
player.stop()
if event.key == pygame.K_l:
player.stop()
if event.key == pygame.K_n:
player.stop()
if event.key == pygame.K_j:
player.stop()
if event.key == pygame.K_b:
player.stop()
#Really for testing pathfinding, pathfinding is really for monsters.
if event.type == pygame.MOUSEBUTTONUP:
pos = pygame.mouse.get_pos()
player.follow_path(path_finder.get_path(player.get_pos(), pos),
map_pix_size, pos)
#Monsters follow every two seconds to cut down on pathfinding
#Calculations
if event.type == FOLLOW_EVENT:
m_fact.monster_group_follow(player.get_pos())
pygame.time.set_timer(FOLLOW_EVENT, 2000)
#Attack every second which is kind of a lot still
#Otherwise player would get hurt too fast or too slow.
if event.type == M_ATTACK_EVENT:
m_attacks = m_fact.monsters_attack(player.get_pos())
player.set_check_attack(m_attacks)
pygame.time.set_timer(M_ATTACK_EVENT, 1000)
#Move the player and then check for game end or picked up item.
player_pos = player.move(collid_list, all_mobiles)
lost = player.damaged()
m_fact.move_monsters(all_mobiles)
got_item = item_fact.is_picked_up()
#For now just one item and if it is picked up the player wins.
if got_item:
end_text = []
end_text.append(
'You Found the Scepter of Yendor and Won the Game!')
end_text.append('To replay press r!')
end_text.append('To quit press q!')
end_text.append('To continue press Space Bar!')
done = game_end(True, end_text, screen, map_tool)
map_tool.map_move(0, 0)
player.stop()
player.ranged_item = 3
player.speed = 8
player.dam_mod = 10
elif (lost):
end_text = []
end_text.append('You perished!')
end_text.append('To replay press r!')
end_text.append('To quit press q!')
done = game_end(False, end_text, screen, map_tool)
if (map_tool.map_section_change(player_pos)):
area = map_tool.get_area()
m_fact.gen_monsters(area)
player.is_moving(map_pix_size)
all_mobiles.update(None, None)
if m_attacks:
m_attacks.update()
all_sprites_list.draw(screen)
clock.tick(25)
pygame.display.flip()
pygame.quit()
def run():
pygame.init()
random.seed()
display_size = 800, 600
viewport_size = display_size[0], 600
black = 0, 0, 0
red = 255, 70, 70
green = 70, 255, 70
blue = 70, 70, 255
white = 255, 255, 255
l_green = 50, 255, 0
screen = pygame.display.set_mode(display_size)
screen.fill(black)
clock = Clock(readonly=False)
dbman = DBManager()
dbman.import_db("./db")
gfxman = GfxManager()
gfxman.import_gfx(dbman.get(), "./gfx")
stagemanager = StageManager()
stagemanager.import_stages("./stages")
stages = stagemanager.get()
groupmanager = GroupManager()
g_draw = groupmanager.add("draw", "OrderedUpdates")
g_ship = groupmanager.add("ship")
g_enemies = groupmanager.add("enemies")
g_enemy_projectiles = groupmanager.add("enemy_projectiles")
g_player_projectiles = groupmanager.add("player_projectiles")
g_beams = groupmanager.add("beams")
g_explosions = groupmanager.add("explosions")
g_shields = groupmanager.add("shields")
g_bonuses = groupmanager.add("bonuses")
hud = Hud(viewport_size)
g_enemies.add(Obstacle((60, 30)))
g_enemies.add(MovingObstacle((160, 80)))
g_bonuses.add(RechargeBonus((300, 200)))
g_bonuses.add(SuperShieldBonus((500, 300)))
g_bonuses.add(ShieldUpgradeBonus((500, 500)))
g_bonuses.add(ShieldUpgradeBonus((300, 500)))
ship = ref(PlayerShip((175, viewport_size[1] - 60), g_ship))
hud.setup_connections(ship())
back = SpaceBackground(viewport_size)
for stage_name in sorted(stages.keys()):
stage_clock = 0
while True:
for spawn_time in stages[stage_name]["spawn"]:
if spawn_time <= stage_clock:
while stages[stage_name]["spawn"][spawn_time]:
spawn = stages[stage_name]["spawn"][spawn_time].pop()
pos = spawn["x"], spawn["y"]
object_cls = eval(spawn["object_cls_name"])
if spawn["object_base_cls_name"]:
if spawn["object_base_cls_name"] == "Projectile":
if not spawn.has_key("object_params"):
raise ValueError, "Params for projectile '%s' in stage %s \
not set" % (
spawn["object_cls_name"],
stage_name,
)
if not spawn["object_params"].has_key("dir"):
raise ValueError, "Invalid 'dir' for projectile '%s' in \
stage %s" % (
spawn["object_cls_name"],
stage_name,
)
if not spawn["object_params"].has_key("collision_group"):
raise ValueError, "Invalid 'collision_group' for projectile \
'%s' in stage %s" % (
spawn["object_cls_name"],
stage_name,
)
params = spawn["object_params"]
dir = params["dir"]
g_coll = groupmanager.get(params["collision_group"])
object = object_cls(pos, dir, g_coll)
elif spawn["object_base_cls_name"] == "Bonus":
pass
else:
raise ValueError, "Invalid value '%s' for attrubite \
'object_base_cls_name' in stage %s" % (
spawn["object_base_cls_name"],
stage_name,
)
else:
object = object_cls(pos)
if spawn["bonus_cls_name"]:
if isinstance(object, BonusHolder):
object.set_bonus(spawn["bonus_cls_name"], spawn["bonus_params"])
else:
raise ValueError, "Instances of %s can not hold bonuses." % object.__class__.__name__
if spawn["mover_cls_name"]:
mover_cls = eval("mover.%s" % spawn["mover_cls_name"])
m = mover_cls(pos, object.max_speed, spawn["mover_params"])
object.set_mover(m)
for g in spawn["groups"]:
if g == "enemies":
g_enemies.add(object)
elif g == "explosions":
g_explosions.add(object)
elif g == "enemy_projectiles":
g_enemy_projectiles.add(object)
elif g == "player_projectiles":
g_player_projectiles.add(object)
# time management
clock.tick(40)
# clock.tick( float(sys.argv[1]) )
stage_clock += clock.get_time()
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
sys.exit()
elif event.key == pygame.K_s:
if ship():
ship().next_weapon()
elif event.key == pygame.K_a:
if ship():
ship().previous_weapon()
elif event.key == pygame.K_x:
if ship():
ship().activate_shield(True)
elif event.type == pygame.KEYUP:
if event.key == pygame.K_UP:
if ship():
ship().fly_up(False)
elif event.key == pygame.K_x:
if ship():
ship().activate_shield(False)
pressed_keys = pygame.key.get_pressed()
if pressed_keys[pygame.K_UP]:
if ship():
ship().fly_up(True)
if pressed_keys[pygame.K_DOWN]:
if ship():
ship().fly_down(viewport_size[1])
if pressed_keys[pygame.K_LEFT]:
if ship():
ship().fly_left()
if pressed_keys[pygame.K_RIGHT]:
if ship():
ship().fly_right(viewport_size[0])
if pressed_keys[pygame.K_z]:
if ship():
ship().shoot()
back.clear(screen, clear_bg)
back.update()
back.draw(screen)
# temp
# if ship():
# ship().damage(1)
#
g_draw.clear(screen, clear_bg)
hud.clear(screen, clear_bg)
g_draw.update()
hud.update()
g_draw.draw(screen)
hud.draw(screen)
pygame.display.flip()
walltorch_bottomright.rect.y = 64 * 7
walltorch_lefttop = WallTorch(Character.Direction.LEFT)
walltorch_lefttop.rect.x = 0
walltorch_lefttop.rect.y = 64 * 2
walltorch_leftbottom = WallTorch(Character.Direction.LEFT)
walltorch_leftbottom.rect.x = 0
walltorch_leftbottom.rect.y = 64 * 5
cricket = Cricket()
cricket.loadSprites()
crabzone = Rect(left_wall.rect.right + 64, top_wall.rect.bottom + 64, right_wall.rect.left - left_wall.rect.width - 128, bottom_wall.rect.top - top_wall.rect.height - 128)
crabspawner = CrabSpawner(crabzone)
hud_space = Rect(0, bottom_wall.rect.bottom, width, height - left_wall.rect.height)
hud = Hud(hud_space)
hud.registerListeners(cricket, crabspawner)
clock = pygame.time.Clock()
#display.fill(blue)
pygame.display.flip()
while 1:
clock.tick(60)
for event in pygame.event.get():
if event.type == pygame.QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
sys.exit()
if((event.type == KEYDOWN) or (event.type == KEYUP)):
keyhandler.handle(event)
class Main(ShowBase, FSM):
"""Main function of the application
initialise the engine (ShowBase)"""
def __init__(self):
"""initialise the engine"""
ShowBase.__init__(self)
FSM.__init__(self, "FSM-Game")
#
# BASIC APPLICATION CONFIGURATIONS
#
# disable pandas default camera driver
self.disableMouse()
# set background color to black
self.setBackgroundColor(0, 0, 0)
# set antialias for the complete sceen to automatic
self.render.setAntialias(AntialiasAttrib.MAuto)
# shader generator
render.setShaderAuto()
#
# CONFIGURATION LOADING
#
# load given variables or set defaults
# check if audio should be muted
mute = ConfigVariableBool("audio-mute", False).getValue()
if mute:
self.disableAllAudio()
else:
self.enableAllAudio()
# check if particles should be enabled
particles = ConfigVariableBool("particles-enabled", True).getValue()
if particles:
self.enableParticles()
# check if the config file hasn't been created
if not os.path.exists(prcFile):
# get the displays width and height
w = self.pipe.getDisplayWidth()
h = self.pipe.getDisplayHeight()
# set window properties
# clear all properties not previously set
base.win.clearRejectedProperties()
# setup new window properties
props = WindowProperties()
# Fullscreen
props.setFullscreen(True)
# set the window size to the screen resolution
props.setSize(w, h)
# request the new properties
base.win.requestProperties(props)
elif base.appRunner:
# As when the application is started as appRunner instance
# it doesn't respect our loadPrcFile configurations specific
# to the window, hence we need to manually set them here.
for dec in range(mainConfig.getNumDeclarations()):
#TODO: Check for all window specific variables like
# fullscreen, screen size, title and window
# decoration that you have in your configuration
# and set them by your own.
if mainConfig.getVariableName(dec) == "fullscreen":
if not mainConfig.getDeclaration(dec).getBoolWord(0): break
# get the displays width and height
w = self.pipe.getDisplayWidth()
h = self.pipe.getDisplayHeight()
# set window properties
# clear all properties not previously set
base.win.clearRejectedProperties()
# setup new window properties
props = WindowProperties()
# Fullscreen
props.setFullscreen(True)
# set the window size to the screen resolution
props.setSize(w, h)
# request the new properties
base.win.requestProperties(props)
break
# automatically safe configuration at application exit
base.exitFunc = self.__writeConfig
# due to the delayed window resizing and switch to fullscreen
# we wait some time until everything is set so we can savely
# proceed with other setups like the menus
if base.appRunner:
# this behaviour only happens if run from p3d files and
# hence the appRunner is enabled
taskMgr.doMethodLater(0.5,
self.postInit,
"post initialization",
extraArgs=[])
else:
self.postInit()
def postInit(self):
#
# initialize game content
#
base.cTrav = CollisionTraverser("base collision traverser")
base.pusher = CollisionHandlerPusher()
self.menu = Menu()
self.credits = Credits()
self.charSelection = CharacterSelection()
self.levelSelection = LevelSelection()
self.koScreen = KoScreen()
self.hud = Hud()
self.menuMusic = loader.loadMusic("assets/audio/menuMusic.ogg")
self.menuMusic.setLoop(True)
self.fightMusic = loader.loadMusic("assets/audio/fightMusic.ogg")
self.fightMusic.setLoop(True)
base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
#
# Event handling
#
self.accept("escape", self.__escape)
#
# Start with the menu
#
self.request("Menu")
#
# FSM PART
#
def enterMenu(self):
show_cursor()
self.accept("Menu-Start", self.request, ["CharSelection"])
self.accept("Menu-Credits", self.request, ["Credits"])
self.accept("Menu-Quit", self.quit)
self.ignore("KoScreen-Back")
self.koScreen.hide()
self.menu.show()
if self.menuMusic.status() != AudioSound.PLAYING:
self.menuMusic.play()
if self.fightMusic.status() == AudioSound.PLAYING:
self.fightMusic.stop()
def exitMenu(self):
self.ignore("Menu-Start")
self.ignore("Menu-Credits")
self.ignore("Menu-Quit")
self.menu.hide()
def enterCredits(self):
self.accept("Credits-Back", self.request, ["Menu"])
self.koScreen.hide()
self.credits.show()
def exitCredits(self):
self.ignore("Credits-Back")
self.credits.hide()
def enterCharSelection(self):
self.accept("CharSelection-Back", self.request, ["Menu"])
self.accept("CharSelection-Start", self.request, ["LevelSelection"])
self.charSelection.show()
def exitCharSelection(self):
self.ignore("CharSelection-Start")
self.ignore("CharSelection-Back")
self.charSelection.hide()
self.selectedChar1 = self.charSelection.selectedCharacter1
self.selectedChar2 = self.charSelection.selectedCharacter2
def enterLevelSelection(self):
self.accept("LevelSelection-Back", self.request, ["CharSelection"])
self.accept("LevelSelection-Start", self.request, ["Game"])
self.levelSelection.show()
def exitLevelSelection(self):
self.ignore("LevelSelection-Start")
self.ignore("LevelSelection-Back")
self.levelSelection.hide()
def enterGame(self):
# main game code should be called here
self.arena = Arena(self.levelSelection.selectedLevel)
self.arena.start()
self.camera.setPos(0, -5, 1.25)
self.player = Player(0, self.selectedChar1, "p1")
self.player2 = Player(1, self.selectedChar2, "p2")
self.player.setEnemy(self.player2.collisionNodeName)
self.player2.setEnemy(self.player.collisionNodeName)
self.player.start(self.arena.getStartPos(1))
self.player2.start(self.arena.getStartPos(2))
self.taskMgr.add(self.updateWorldCam, "world camera update task")
self.accept("gameOver", self.gameOver)
self.hud.show()
def lifeChanged(charId, health):
base.messenger.send("hud_setLifeBarValue", [charId, health])
self.accept("lifeChanged", lifeChanged)
hide_cursor()
if self.fightMusic.status() != AudioSound.PLAYING:
self.fightMusic.play()
if self.menuMusic.status() == AudioSound.PLAYING:
self.menuMusic.stop()
def exitGame(self):
# cleanup for game code
self.taskMgr.remove("world camera update task")
self.player.stop()
self.player2.stop()
del self.player
del self.player2
self.arena.stop()
self.ignore("gameOver")
self.ignore("lifeChanged")
self.hud.hide()
#
# FSM PART END
#
#
# BASIC FUNCTIONS
#
def gameOver(self, LoosingCharId):
show_cursor()
winningChar = 1
if LoosingCharId == 0:
winningChar = 2
self.accept("KoScreen-Back", self.request, ["Credits"])
self.koScreen.show(winningChar)
def updateWorldCam(self, task):
playerVec = self.player.getPos() - self.player2.getPos()
playerDist = playerVec.length()
x = self.player.getX() + playerDist / 2.0
self.camera.setX(x)
zoomout = False
if not self.cam.node().isInView(self.player.getPos(self.cam)):
camPosUpdate = -2 * globalClock.getDt()
self.camera.setY(self.camera, camPosUpdate)
zoomout = True
if not self.cam.node().isInView(self.player2.getPos(self.cam)):
camPosUpdate = -2 * globalClock.getDt()
self.camera.setY(self.camera, camPosUpdate)
zoomout = True
if not zoomout:
if self.camera.getY() < -5:
camPosUpdate = 2 * globalClock.getDt()
self.camera.setY(self.camera, camPosUpdate)
return task.cont
def __escape(self):
if self.state == "Menu":
self.quit()
elif self.state == "LevelSelection":
self.request("CharSelection")
else:
self.request("Menu")
def quit(self):
"""This function will stop the application"""
self.userExit()
def __writeConfig(self):
"""Save current config in the prc file or if no prc file exists
create one. The prc file is set in the prcFile variable"""
page = None
#TODO: get values of configurations here
particles = "#f" if not base.particleMgrEnabled else "#t"
volume = str(round(base.musicManager.getVolume(), 2))
mute = "#f" if base.AppHasAudioFocus else "#t"
#TODO: add any configuration variable name that you have added
customConfigVariables = [
"", "particles-enabled", "audio-mute", "audio-volume"
]
if os.path.exists(prcFile):
# open the config file and change values according to current
# application settings
page = loadPrcFile(Filename.fromOsSpecific(prcFile))
removeDecls = []
for dec in range(page.getNumDeclarations()):
# Check if our variables are given.
# NOTE: This check has to be done to not loose our base or other
# manual config changes by the user
if page.getVariableName(dec) in customConfigVariables:
decl = page.modifyDeclaration(dec)
removeDecls.append(decl)
for dec in removeDecls:
page.deleteDeclaration(dec)
# NOTE: particles-enabled and audio-mute are custom variables and
# have to be loaded by hand at startup
# Particles
page.makeDeclaration("particles-enabled", particles)
# audio
page.makeDeclaration("audio-volume", volume)
page.makeDeclaration("audio-mute", mute)
else:
# Create a config file and set default values
cpMgr = ConfigPageManager.getGlobalPtr()
page = cpMgr.makeExplicitPage("%s Pandaconfig" % appName)
# set OpenGL to be the default
page.makeDeclaration("load-display", "pandagl")
# get the displays width and height
w = self.pipe.getDisplayWidth()
h = self.pipe.getDisplayHeight()
# set the window size in the config file
page.makeDeclaration("win-size", "%d %d" % (w, h))
# set the default to fullscreen in the config file
page.makeDeclaration("fullscreen", "1")
# particles
page.makeDeclaration("particles-enabled", "#t")
# audio
page.makeDeclaration("audio-volume", volume)
page.makeDeclaration("audio-mute", "#f")
# create a stream to the specified config file
configfile = OFileStream(prcFile)
# and now write it out
page.write(configfile)
# close the stream
configfile.close()
class GameScreen(Events):
"""docstring for GameScreen"""
def __init__(self, window):
super(GameScreen, self).__init__()
self.window = window
self.camera = Camera(window)
self.player = player.Player()
self.proj_viewer = ProjectileViewer(self.send_center)
self.controls = {}
self.controls_old = {}
self.map = Map('blank')
#self.player.spawn(100, 100)
self.time = 0
self.moves = moves(1024)
self.index = [0]
self.head = [0]
#other players
self.players = {}
self.specs = {}
#crosshair
self.cross = CrossHair()
self.isSpec = True
self.hud = Hud()
self.gs_view = GameStateViewer(self.players, self.hud.update_prop,
self.hud.set_score)
def update(self, dt):
dt = int(dt * 1000000) / 1000000.
if self.controls['esc'] and not self.controls_old['esc']:
self.send_message('menu_transition_+', (GameMenu, self.isSpec))
if self.controls['rdy'] and not self.controls_old['rdy']:
if not self.isSpec:
self.ready_up()
if self.controls['chat'] and not self.controls_old['chat']:
self.send_message('menu_transition_+',
(ChatScreen, self.window))
self.update_keys()
self.on_update(dt)
def update_physics(self, dt, state=False, input=False):
playergen = (player.rect for player in self.players.itervalues())
mapgen = (rect for rect in self.map.quad_tree.retrieve([],
self.player.rect))
rectgen = chain(playergen, mapgen)
self.player.update(dt, rectgen, state, input)
return self.player.state
def update_state_only(self, state):
self.player.state.update(0, state)
def update_keys(self):
for key_, value in self.controls.items():
self.controls_old[key_] = value
def from_server(self, data):
typ, data = data
if typ == proto.playerUpdate:
ind, time, s_state, inpt, weaponinfo = data
smove = move(time, inpt, s_state)
if ind == self.player.id:
correct_client(self.update_physics, smove, self.moves,
self.head, self.index[0],
self.update_state_only)
self.player.weapons.from_server(weaponinfo)
else:
#try:
self.players[ind].client_update(s_state)
self.players[ind].input = inpt
#except KeyError:
# pass
elif typ == proto.projectile:
self.proj_viewer.process_proj(data)
elif typ == proto.newPlayer:
gs, data = data
if gs == proto.goesSpec:
ind, name, colstring = data
new = player.Player()
new.name = name
new.id = ind
new.set_color(colstring)
self.specs[ind] = new
#if there are existing players on the server
elif gs == proto.wantsJoin:
ind, name, state, time, colstring = data
new = player.Player()
new.name = name
new.state = state
new.time = time
new.id = ind
new.set_color(colstring)
new.rect.update_color(new.color)
self.players[ind] = new
print 'new player: %s' % name
self.gs_view.to_team(ind)
elif typ == proto.disconnect:
ind = data
if ind in self.players:
self.gs_view.leave(ind)
del self.players[ind]
elif ind in self.specs:
del self.specs[ind]
elif typ == proto.stateUpdate:
gametime, data = data
gs, ind = data
self.gs_view.set_time(gametime)
if gs == proto.wantsJoin:
if ind == self.player.id:
self.send_message('menu_transition_-')
self.player.state.isDead = False
self.trans_to_game()
else:
self.players[ind] = self.specs[ind]
del self.specs[ind]
self.gs_view.to_team(ind)
elif gs == proto.goesSpec:
if ind == self.player.id and self.isSpec:
pass
elif ind == self.player.id and not self.isSpec:
self.send_message('menu_transition_-')
self.trans_to_spec()
else:
self.specs[ind] = self.players[ind]
self.gs_view.leave(ind)
del self.players[ind]
elif gs == proto.isDead:
ind, killer, weapon = ind
if ind == self.player.id:
self.player.die()
else:
self.players[ind].die()
self.gs_view.score(ind, killer, weapon)
elif gs == proto.spawns:
ind, pos = ind
if ind == self.player.id:
self.player.spawn(*pos)
else:
self.players[ind].spawn(*pos, other=True)
elif gs == proto.isReady:
ind, name = ind
self.gs_view.is_ready(ind, name)
elif gs == proto.countDown:
self.player.freeze()
elif gs == proto.inProgress:
self.gs_view.start_game()
elif gs == proto.warmUp:
self.gs_view.to_warmup()
elif typ == proto.mapUpdate:
ind, itemid, gt, spawn = data
self.gs_view.set_time(gt)
if ind == self.player.id:
if isinstance(self.map.items[itemid], Triangle):
st = self.map.items[itemid].keystr
if not st in self.player.weapons.weapons:
self.player.weapons.pickup(st)
else:
self.player.weapons.apply(st, self.player)
self.map.serverupdate(itemid, spawn)
elif typ == proto.chat:
ind, msg = data
if ind == self.player.id:
name = self.player.name
color = self.player.color
elif ind in self.players:
name = self.players[ind].name
color = self.players[ind].color
else:
name = self.specs[ind].name
color = self.specs[ind].color
#chatdata = ' '.join((name + ':', '\t', msg))
chatdata = (name, color, msg)
self.hud.update_prop(chat=chatdata)
def send_to_client(self, dt):
temp_input = proto.Input()
self.time += int(dt * 1000000)
temp_input.CopyFrom(self.player.input)
c_move = move(self.time, temp_input, self.player.state.copy())
try:
self.moves[self.index[0]] = c_move
except IndexError:
self.moves.append(c_move)
self.moves.advance(self.index)
self.send_message('input', (self.player.input, self.time))
def spec_send(self, dt):
self.send_message('input', (proto.Input(), self.time))
def draw(self):
self.on_draw()
def on_connect(self, msg):
ind, mapname, name = msg
self.player.get_id(ind, name)
self.map = Map(mapname)
print 'connected with id: ' + str(self.player.id)
#self.send_message('input', (self.player.input, 1337))
self.gs_view.init_self(ind)
self.trans_to_spec()
def try_join(self):
msg = proto.Message()
msg.type = proto.stateUpdate
plr = proto.Player()
plr.id = self.player.id
msg.player.CopyFrom(plr)
if self.isSpec:
msg.gameState = proto.wantsJoin
else:
msg.gameState = proto.goesSpec
self.send_message('other', msg)
def ready_up(self):
msg = proto.Message()
msg.type = proto.stateUpdate
plr = proto.Player()
plr.id = self.player.id
msg.player.CopyFrom(plr)
msg.gameState = proto.isReady
self.send_message('other', msg)
def send_chat(self, chatmsg):
msg = proto.Message()
msg.type = proto.chat
plr = proto.Player()
plr.id = self.player.id
plr.chat = chatmsg
msg.player.CopyFrom(plr)
self.send_message('other', msg)
def on_update(self, dt):
pass
def on_draw(self):
pass
def idle_update(self, dt):
self.send_to_client(dt)
self.gs_view.update(dt)
self.hud.update(dt)
def trans_to_spec(self):
self.on_update = self.spec_update
self.on_draw = self.spec_draw
self.isSpec = True
self.player.state.hook_hud(self.hud.update_prop)
self.hud.init_spec()
def trans_to_game(self):
self.on_update = self.game_update
self.on_draw = self.game_draw
self.isSpec = False
self.player.weapons.hook_hud(self.hud.update_prop)
self.player.state.hook_hud(self.hud.update_prop)
self.gs_view.add_self(self.player)
self.hud.init_player(self.players)
def game_update(self, dt):
self.update_physics(dt)
self.camera.update(dt, self.player.state)
self.send_to_client(dt)
self.proj_viewer.update(dt)
self.gs_view.update(dt)
self.hud.update(dt)
def game_draw(self):
self.camera.set_camera()
for plr in self.players.itervalues():
plr.draw()
self.player.draw()
self.proj_viewer.draw()
self.map.draw()
self.camera.set_static()
self.hud.draw()
self.cross.draw(*self.camera.mpos)
def spec_update(self, dt):
self.player.specupdate(dt)
self.camera.update(dt, self.player.state)
#self.send_to_client(dt)
self.spec_send(dt)
self.proj_viewer.update(dt)
self.gs_view.update(dt)
self.hud.update(dt)
def spec_draw(self):
self.camera.set_camera()
for plr in self.players.itervalues():
plr.draw()
self.proj_viewer.draw()
self.map.draw()
self.camera.set_static()
self.hud.draw()
def send_center(self, ind):
if ind == self.player.id:
pl = self.player
return pl.rect.center, (pl.input.mx, pl.input.my)
else:
pl = self.players[ind]
return pl.rect.center, (pl.input.mx, pl.input.my)
class BasicMovement(Display):
def __init__(self):
self.framerate = 0
self.number_meanies = 16
self.display = Display()
self.hud = Hud()
self.meanie_list = []
pygame.key.set_repeat(100,5)
self.meanies = pygame.sprite.Group()
self.player = Charactor("held.png", self.display)
self.player.speed = 2
self.init_floors()
self.init_ladders()
self.barrels = pygame.sprite.Group()
self.init_barrels()
self.testgroup = pygame.sprite.Group()
self.init_meanies(0)
def init_floors(self):
self.steine = pygame.sprite.Group()
c = 0
for y in range (300, self.display.bgmax[1], 200):
if c % 2 == 0:
for x in range(self.display.bgmax[0]/2 + 64, self.display.bgmax[0], 32):
s = Boden1([x,y])
self.steine.add(s)
else:
for x in range(64, self.display.bgmax[0]/2, 32):
s = Boden1([x,y])
self.steine.add(s)
c += 1
del c
## Place a Floor at bottom of level
for x in range(0,self.display.bgmax[0],32):
s = Boden1([x, self.display.bgmax[1]-16])
self.steine.add(s)
def init_ladders(self):
self.ladders = pygame.sprite.Group()
for x in range(50, 700, 500):
for y in range(0, self.display.bgmax[1], 32):
i = Leiter([x,y])
self.ladders.add(i)
def init_barrels(self):
for y in range(87, self.display.bgmax[1], 200):
x = random.randint(0, self.display.bgmax[0])
s = Fass([200, y])
self.barrels.add(s)
def init_meanies(self, counter):
move_index = 0
while counter < self.number_meanies:
mx = random.randint( 0, self.display.bgmax[0]-40 )
my = random.randint( 0, self.display.bgmax[1]-40 )
meanie = Meanie()
meanie.state.set_random_move_index()
meanie.rect.center = mx,my
self.testgroup.add(meanie)
if meanie.overlaps(self.testgroup):
self.testgroup.remove(meanie)
meanie.kill()
self.init_meanies(counter)
else:
self.meanie_list.insert(counter,meanie)
self.meanies.add(self.meanie_list[counter])
counter += 1
if counter == self.number_meanies:
self.start_game()
def start_game(self):
del self.testgroup
self.gameRunning = True
self.mainloop()
def mainloop(self):
self.clock = pygame.time.Clock()
self.player.rect.center = [120,220]
while self.gameRunning:
dirty = []
self.clock.tick(FPS)
self.framerate = self.clock.get_fps()
self.display.paint_background(dirty)
self.player.state.set_current_state(self)
# blit player on screen
d = self.display.paint_sprite(self.player)
dirty.insert(len(dirty), d)
self.steine.update()
self.ladders.update()
self.barrels.update(self)
self.meanies.update(self, dirty)
self.hud.showinfo(self, dirty)
for e in pygame.event.get():
if e.type == QUIT:
self.gameRunning = False
pygame.quit()
sys.exit()
elif e.type == KEYDOWN:
if e.key == K_ESCAPE:
self.gameRunning = False
pygame.quit()
sys.exit()
elif e.key == K_UP and self.player.state.climbing:
self.player.movement[1]= - self.player.speed
elif e.key == K_DOWN and not self.player.state.falling and self.player.state.climbing:
self.player.movement[1]= self.player.speed
elif e.key == K_LEFT:
if self.player.state.falling:
self.player.movement[0] = - self.player.speed/2
else:
self.player.movement[0] = - self.player.speed
elif e.key == K_RIGHT:
if self.player.state.falling:
self.player.movement[0] = self.player.speed/2
else:
self.player.movement[0] = self.player.speed
elif e.type == KEYUP:
if e.key == K_UP or e.key == K_DOWN:
self.player.movement[1] = 0
elif e.key == K_LEFT or e.key == K_RIGHT:
self.player.movement[0] = 0
self.player.update(self)
pygame.display.update(dirty)
def __init__(self, player):
self.level_type = "none"
self.background = None
self.player = player
self.hud = Hud()
