def bersihkanInGame(cont):
#disable pulse mode of all sensors of all objects
scene = bge.logic.getCurrentScene()
print('disabling usePosPulseMode of allObjects')
for i in scene.objects:
for j in i.sensors:
j.usePosPulseMode = False
print("removing all objects parent in inGame scene...")
for i in scene.objects:
i.removeParent()
var.tikets = ['inf', 10, 10]
var.navigator = None
var.waymesh = None
var.waypoints = []
try:
#removing scene HUD
print('removing HUD...')
HUD.end()
except AttributeError:
print('HUD may not exist, ignoring...')
#end all of objects of scene
print('removing all objects...')
for i in scene.objects:
if i != cont.owner:
i.endObject()
# - section of variables cleaning -
bersihkan = True
if bersihkan == True:
pass
def show(lvl):
"""
Display level on screen
@param lvl: Dictionnary containing all information about one \"Level\" object
@type lvl: dict
@return: -
@rtype: void
"""
assertLevel(lvl)
Object.show(lvl["bgItem0"])
Object.show(lvl["bgItem1"])
#showBackground(lvl,lvl["bgItem0"])
#showBackground(lvl,lvl["bgItem1"])
Object.show(lvl["fgItem0"])
Object.show(lvl["fgItem1"])
for a in lvl["enemyList"]:
Enemy.show(a)
Player.show(lvl["playerItem"])
HUD.show(lvl["HUD"])
return
def draw(self):
self.orientWorld()
for item in self.simulation.world.all:
Render.render(item)
HUD.draw(self.zoomedShip)
self.drawSidebar()
def nodeInit(self):
self.sg = self.view.getSceneGraph()
self.coord = CoinNodes.coordinate3Node([(0, 0, 0)])
self.markers = CoinNodes.markerSetNode((1, 0.35, 0.8), 70)
self.polygon = coin.SoLineSet(
) #CoinNodes.sensorPolyNode((0.0,0.5,0.0),1)
#self.polygon.transparency = 0.7
#self.polygon.linkTo(self.coord)
self.switch = coin.SoSwitch()
self.empty = coin.SoSeparator()
self.sepa = coin.SoSeparator()
self.switch.addChild(self.sepa)
self.switch.addChild(self.empty)
self.switch.whichChild = 0
self.sepa.addChild(self.coord)
self.sepa.addChild(self.markers)
self.sg.addChild(self.switch)
self.info = [
"LMB : add pole", "Del : remove last pole",
"I / D : Increase / Decrease degree", "Left CTRL : snap",
"Enter : Accept", "Esc : Abort"
]
self.Block1 = HUD.textArea()
self.Block1.setFont("Sans", 12.0, (0., 0., 0.))
self.Block1.text = self.info + ["Degree : %s" % self.curve.Degree]
self.myHud = HUD.HUD()
self.myHud.addBlock(self.Block1)
self.myHud.add()
class HUDWindow():
def __init__(self, main):
#print 'In HUDWindow() __init__'
#Create HUD background screen
self.hud = HUD()
self.main = main
#Create canvas on which HUD image will be drawn and load basic image
self.canvas = Canvas(self.main, width=HUD_WIDTH, height=HUD_HEIGHT)
self.canvas.grid(row=0, column=0)
self.image = ImageTk.PhotoImage(self.hud.scope_canvas.display_image)
self.canvas_image = self.canvas.create_image(0,
0,
anchor=NW,
image=self.image)
#Call redraw initially
self.main.after(1000, self.redraw)
def redraw(self):
#print 'In HUDWindow() redraw'
#TEMP
#END TEMP
#Create updated HUD image according to current data
self.hud.work()
redraw_image = ImageTk.PhotoImage(self.hud.scope_canvas.display_image)
self.canvas.itemconfig(self.canvas_image, image=redraw_image)
#Hang onto new image to avoid garbage collector
self.image = redraw_image
#Call redraw after delay
self.main.after(100, self.redraw)
class TestApp(Label):
def __init__(self, **kwargs):
super(TestApp, self).__init__(**kwargs)
Window.bind(on_key_down=self.onKeyDown)
self.key_label = CoreLabel(text='', font_size=15)
self.hud = HUD(self.canvas)
self.gps_status_label = CoreLabel(text='', font_size=12)
self.gps_location_label = CoreLabel(text='', font_size=12)
self.uid_label = CoreLabel(text='UID: ', font_size=12)
self.my_lat = 0
self.my_lon = 0
self.my_heading = 0
def onKeyDown(self, something, keycode, text, something_else, modifiers,
**kwargs):
print('The key', keycode, 'have been pressed')
print(' - text is %r' % text)
print(' - modifiers are %r' % modifiers)
self.hud.scope_canvas.camera.setZoom(int(keycode))
if keycode == ENTER:
self.hud.myUID = self.hud.data.pickUID(self.hud.myUID)
self.uid_label.text = 'UID: ' + str(self.hud.myUID)
###TODO: Include pickUID(keycode)
def updateDisplay(self, text):
print 'Inside updateDisplay'
self.hud.my_lat = self.my_lat
self.hud.my_lon = self.my_lon
self.hud.my_heading = self.my_heading
self.canvas.clear() #Clears canvas for fresh draw
self.hud.scope_canvas.paintDisplayBackground(
) #Reinitializes the canvas with HUD background
self.hud.work(
) #Retrieves data and draws appropriately on HUD background canvas
#TEMPORARY label drawing for debugging purposes
with self.canvas:
#Display gps_location
Color(.5, 1, 0, mode='rgb')
self.gps_location_label.refresh()
texture = self.gps_location_label.texture
texture_size = list(texture.size)
Rectangle(pos=(BAR_TEXT_OFFSET + 10, GRAPH_OFFSET_TOP_BOTTOM),
texture=texture,
size=texture_size)
#Display UID
Color(.5, 1, 0, mode='rgb')
self.uid_label.refresh()
texture = self.uid_label.texture
texture_size = list(texture.size)
Rectangle(pos=(HUD_WIDTH - BAR_TEXT_OFFSET - GRAPH_WIDTH - 100,
GRAPH_OFFSET_TOP_BOTTOM - 20),
texture=texture,
size=texture_size)
def __init__(self, **kwargs):
super(TestApp, self).__init__(**kwargs)
Window.bind(on_key_down=self.onKeyDown)
self.key_label = CoreLabel(text='', font_size=15)
self.hud = HUD(self.canvas)
self.gps_status_label = CoreLabel(text='', font_size=12)
self.gps_location_label = CoreLabel(text='', font_size=12)
self.uid_label = CoreLabel(text='UID: ', font_size=12)
self.my_lat = 0
self.my_lon = 0
self.my_heading = 0
def subMunculkan(cont):
own = cont.owner
print('\nend of spawning object')
print("..........................................")
own['endAdding'] = None
#for i in dir(HUD): print(i)
HUD.addHUD()
#print(scene.objects)
#print(bge.logic.getSceneList())
#cekKamus(cont)
var.status = 'loadgameobject'
#obj.addLookAt()
own.endObject()
def init():
global screen, fonts, resolution, camera
resx, resy = settings.get_resolution()
resolution = [resx, resy]
# Create camera
camera = Camera([0, 0], 1, resolution)
# Create the game screen
screen = pygame.display.set_mode(resolution)
# Set window info
pygame.display.set_icon(screen)
pygame.display.set_caption('Solaris')
# Generate fonts
pygame.font.init()
for i in range(0, 10):
fonts.append(pygame.font.SysFont('Arial', i * 10))
# Make the main menu
global action_listener
action_listener = ActionListener()
global current_menu
current_menu = Menu.main_menu(fonts, resolution, action_listener)
global star_systems, nearest_system
star_systems = Bodies.generate_systems(10, action_listener)
nearest_system = star_systems[0]
global player
player = Bodies.Player([500, 500], (255, 100, 100), 3, [0, 0],
action_listener)
global current_hud
current_hud = HUD.test_hud(fonts, resolution, action_listener)
def get_newgame():
'''returns the game scene'''
scene = Scene()
# model
model = GameModel()
# controller
ctrl = GameCtrl(model)
# view
hud = HUD()
view = GameView(model, hud)
# set controller in model
model.set_controller(ctrl)
# add controller
scene.add(ctrl, z=1, name="controller")
# add view
scene.add(hud, z=3, name="hud")
scene.add(BackgroundLayer(), z=0, name="background")
scene.add(view, z=2, name="view")
return scene
def __init__(self, file_path):
super(Scene, self).__init__()
pygame.mixer.init(44100, -16, 4, 2048)
self.position = ['goalkeeper', 'defender', 'midfielder', 'attacker']
self.all_object_list = pygame.sprite.LayeredUpdates()
self.selection_circle = [] # Prototype
self.left_player = Player() # Prototype
self.right_player = Player() # Prototype
self.teams = collections.defaultdict(dict)
self.field = Object()
self.field_border = Object()
self.goal = []
self.ball = Ball()
self.hud = HUD()
self.goal_image = EffectObject()
self.formation = {Team_side.LEFT: [1, 4, 3, 3], Team_side.RIGHT: [1, 4, 4, 2]}
self.sound_list = dict()
# Game config
self.game_mode = Game_mode.PvP
self.P1_controlled_team = Team_side.LEFT
self.P1_controlled_position = 'midfielder'
self.P2_controlled_team = Team_side.RIGHT
self.P2_controlled_position = 'midfielder'
# Load scene's resources
self.read_scene(file_path)
def nodeInit(self):
self.sg = self.view.getSceneGraph()
self.coord = CoinNodes.coordinate3Node([(0,0,0)])
self.markers = CoinNodes.markerSetNode((1,0.35,0.8),70)
self.polygon = coin.SoLineSet() #CoinNodes.sensorPolyNode((0.0,0.5,0.0),1)
#self.polygon.transparency = 0.7
#self.polygon.linkTo(self.coord)
self.switch = coin.SoSwitch()
self.empty = coin.SoSeparator()
self.sepa = coin.SoSeparator()
self.switch.addChild(self.sepa)
self.switch.addChild(self.empty)
self.switch.whichChild = 0
self.sepa.addChild(self.coord)
self.sepa.addChild(self.markers)
self.sg.addChild(self.switch)
self.info = ["LMB : add pole",
"Del : remove last pole",
"I / D : Increase / Decrease degree",
"Left CTRL : snap",
"Enter : Accept",
"Esc : Abort"]
self.Block1 = HUD.textArea()
self.Block1.setFont("Sans", 12.0, (0.,0.,0.))
self.Block1.text = self.info + ["Degree : %s"%self.curve.Degree]
self.myHud = HUD.HUD()
self.myHud.addBlock(self.Block1)
self.myHud.add()
def setTarget(self,target):
if not target == None:
self.target=target
self.mira= HUD.mira(self.img)
else:
self.target = None
self.mira = None
def __init__(self, main):
#print 'In HUDWindow() __init__'
#Create HUD background screen
self.hud = HUD()
self.main = main
#Create canvas on which HUD image will be drawn and load basic image
self.canvas = Canvas(self.main, width=HUD_WIDTH, height=HUD_HEIGHT)
self.canvas.grid(row=0, column=0)
self.image = ImageTk.PhotoImage(self.hud.scope_canvas.display_image)
self.canvas_image = self.canvas.create_image(0,
0,
anchor=NW,
image=self.image)
#Call redraw initially
self.main.after(1000, self.redraw)
def __init__(self, **kwargs):
super(TestApp, self).__init__(**kwargs)
Window.bind(on_key_down=self.onKeyDown)
Window.bind(on_touch_down=self.onTouch) #TOUCH CAPABILITY
self.touch_count = 0 #TOUCH CAPABILITY DEBUGGING COUNTER
self.touch_count_label = CoreLabel(
text='', font_size=15) #TOUCH CAPABILITY DEBUGGING COUNTER
self.key_label = CoreLabel(text='', font_size=15)
self.hud = HUD(self.canvas)
self.gps_status_label = CoreLabel(text='', font_size=12)
self.gps_location_label = CoreLabel(text='', font_size=12)
self.uid_label = CoreLabel(text='UID: ', font_size=12)
self.my_lat = 0
self.my_lon = 0
self.my_heading = 0
self.my_accuracy = 0
self.DEBUG = True
def setTarget(self,target):
if not target == None:
self.target=target
self.mira= HUD.mira(self.imagenesDelJuego)
else:
self.target = None
self.mira = None
def __init__(self,img):
Util.Object.__init__(self)
self.imagen=img.imgEscudo
self.vista=6
self.centro = None
self.atenuador=0
self.alive=True
self.energia= 5
self.hud = HUD.barraDeVida(img,Util.Vector(0,0))
def main():
from Mediator import Mediator
pygame.init()
WINDOW_SIZE = (1024, 768)
clock = pygame.time.Clock()
screen = pygame.display.set_mode(WINDOW_SIZE, 0, 32)
display = pygame.Surface((256, 192))
player = Player(display, 'player', Mediator)
print(Mediator.i)
Mediator.all_game_entities.append(player)
gameMap = GameMap(display, 'tiles', Mediator, player)
hud = HUD(display, player)
while True:
display.fill((57, 138, 215))
Mediator.all_game_tiles.clear()
gameMap.draw_map()
hud.draw_overlay()
for object in Mediator.all_game_entities:
object.loop()
object.draw()
Mediator.all_game_entities = [
object for object in Mediator.all_game_entities
if object not in Mediator.to_be_removed
]
Mediator.to_be_removed.clear()
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit(
0
) #TODO remember to exit with a code so we dont throw an exception i think
surf = pygame.transform.scale(display, WINDOW_SIZE)
screen.blit(surf, (0, 0))
pygame.display.update()
clock.tick(60)
def combat(player, enemy):
mouseX = 0
mouseY = 0
clicked = False
attackButton = Button("src/art/attack_button.png", (WINDOWWIDTH / 2, 600))
playerDamage = 0
enemyDamage = 0
lastDamage = 0
while (True):
#event handler
for event in pygame.event.get():
if event.type == QUIT:
terminate()
elif event.type == MOUSEBUTTONUP:
mouseX, mouseY = event.pos
clicked = True
#event controller
if attackButton.rect.collidepoint((mouseX, mouseY)) and clicked:
clicked = False
playerDamage = player.attack('standard')
enemyDamage = enemy.attack(numpy.random.choice(('standard', )))
lastDamage = enemyDamage
#wombat controller
enemy.health -= playerDamage
player.health -= enemyDamage
if enemy.health <= 0:
fightWon(enemy)
return
if player.health <= 0:
showGameOver()
#drawing
DISPLAYSURF.fill(BLACK)
DISPLAYSURF.blit(pygame.image.load("src/art/combat_floor.png"),
(0, 0, 1600, 900))
drawFight(player, enemy)
DISPLAYSURF.blit(attackButton.image, attackButton.rect)
#drawCombatHUD(player.health, player.mana)
#drawEnemyHUD(enemy.name, enemy.health)
comDisp.drawHUDWin(DISPLAYSURF)
comDisp.healthBar(DISPLAYSURF, player.health * 7, player.health)
comDisp.manaBar(DISPLAYSURF)
comDisp.damageInfo(DISPLAYSURF, enemyDamage, enemy.health, lastDamage)
pygame.display.update()
#Reset variables
playerDamage = 0
enemyDamage = 0
FPSCLOCK.tick(FPS)
def __init__(self): super(Scene, self).__init__() self.all_object_list = pygame.sprite.Group() self.troll_list = pygame.sprite.Group() self.bullet_list = pygame.sprite.Group() self.player = Player() self.background = Object() self.hud = HUD() self.score = 0 self.game_over = False
def __init__(self):
self.mHUD = HUD()
self.actualLevel = 0
self.portalTiles = None
self.cityTiles = None
self.selectedTower = ""
self.selectedSkill = ""
mE.updateOnPause = ["Mouse", "Button","InfoTabBar", "SkillTimeStop"]
self.playerWins = True
pass
def nodeInit(self):
self.sg = self.view.getSceneGraph()
self.coord = CoinNodes.coordinate3Node([(0, 0, 0)])
self.markers = CoinNodes.markerSetNode((1, 0.35, 0.8), 70)
self.polygon = CoinNodes.sensorPolyNode((0.0, 0.5, 0.0), 1)
self.polygon.transparency = 0.7
self.polygon.linkTo(self.coord)
self.sg.addChild(self.coord)
self.sg.addChild(self.markers)
self.info = [
"LMB : add pole", "Del : remove last pole",
"Page Up / Down : degree", "Left CTRL : snap", "Enter : Accept",
"Esc : Abort"
]
self.Block1 = HUD.textArea()
self.Block1.setFont("Sans", 10.0, (0., 0., 0.))
self.Block1.text = self.info + ["Degree : %s" % self.curve.Degree]
self.myHud = HUD.HUD()
self.myHud.addBlock(self.Block1)
self.myHud.add()
def __init__(self):
pygame.init()
# Initializing file manager and loading icon
self.fileManager = FileManager.FileManager('Textures', 'Sounds')
# Display properties
pygame.display.set_icon(self.fileManager.icon)
self.screen = pygame.display.set_mode((800, 600))
pygame.display.set_caption('Pulse')
# Setting background
self.fileManager.loadBackground()
self.background = self.fileManager.backgroundTexture
# Display update
self.cleanWindow()
pygame.display.flip()
# Initializing game files
self.fileManager.loadGameFiles()
# Initializing game objects
self.gameObjects = GameObjects.GameObjects()
# Initializing level manager
self.levelManager = LevelManager.LevelManager(self.fileManager,
self.gameObjects)
# Initializing menues
self.menues = Menues.Menues(self.fileManager, self.levelManager)
# Initializing HUD
self.HUD = pygame.sprite.RenderPlain()
self.HUDObject = HUD.HUD(self.levelManager.currentLevel(), True)
self.HUD.add(self.HUDObject)
# Adding notifieras to gameObjects
self.gameObjects.addNotifier(self.HUDObject)
self.gameObjects.addNotifier(self.levelManager)
# Initializing clock
self.clock = pygame.time.Clock()
# Game running. Showing nenu on False.
self.gameRunning = False
# Starting music
pygame.mixer.music.play(-1)
# Showing main menu
self.menues.main()
def __init__(self): super(Scene, self).__init__() pygame.mixer.init(44100, -16, 4, 2048) self.all_object_list = pygame.sprite.LayeredUpdates() self.zombie_list = pygame.sprite.Group() self.blood_splash = BloodSplash() self.background = Object() self.player = Player() self.zombie_sprite = [] self.grave_list = [] self.hud = HUD() self.sound_list = dict() self.bg_music = pygame.mixer.music self.game_over = False self.time = pygame.time.get_ticks()
def Debug_modeINIT(self):
self.zombies = []
self.level_cam()
self.pistol = gc.Gun(self.screen, self.mouse, 'pistol', -1)
self.AR = gc.Gun(self.screen, self.mouse, 'AR', 50)
self.SG = gc.Gun(self.screen, self.mouse, 'shootgun', 25)
self.pistol.InHands = True
self.guns = [self.pistol, self.AR, self.SG]
self.player = hc.Players_Hero('Синий', self.screen, self.guns)
self.hud = HUD.HUD(self.screen, self.hud_sprites,
100, self.player.GunType)
self.pistol.Taken = True
def load(self):
self.loadMenuAnimations()
self.loadMenuSounds()
self.splash = Entity()
mE.mEntityManager.addEntity(self.splash, "SplashScreen", "SplashScreen")
mE.mAnimationManager.setEntityAnimation(self.splash, "SplashScreen")
self.mHud = HUD()
self.background = Entity()
mE.mEntityManager.addEntity(self.background, "Background", "BG")
mE.mAnimationManager.setEntityAnimation(self.background, "Background")
self.mHud.addButton(self.startGame, None, Vec2d(100 + 44,100 + 200), "PlayButton", Vec2d(192,64))
self.mHud.addButton(self.endGame, None, Vec2d(180 + 44,240 + 200), "QuitButton", Vec2d(192,64))
mE.mAnimationManager.addAnimation(lImagesHPBarEnemyS[0], lImagesHPBarEnemyS[1], "CooldownBarStart")
mE.mAnimationManager.addAnimation(lImagesHPBarEnemyE[0], lImagesHPBarEnemyE[1], "CooldownBarEnd")
mE.mAnimationManager.addAnimation(lImagesHPBarEnemyM[0], lImagesHPBarEnemyM[1], "CooldownBarMiddle")
mE.mEntityManager.defineLayerOrder(["Splash","BG"])
class Execute:
screen = pygame.display.set_mode((constants.WIDTH, constants.HEIGHT))
clock = pygame.time.Clock()
fps = 300
cross = HUD.Crosshair()
pygame.mouse.set_visible(False)
player = live_objects.Player((50, 200))
player.weapon = weapons.Knife(player)
floor = environment.Floor((0, constants.HEIGHT - 20), (constants.WIDTH, 20))
second_floor = environment.Floor((constants.WIDTH - 150 - 700, 150), (700, 20))
ceiling = environment.Floor((0, 0), (constants.WIDTH, 20))
left_wall = environment.Wall((0, 0), (20, constants.HEIGHT))
middle_wall = environment.Wall((constants.WIDTH - 150, 150), (20, constants.HEIGHT - 270))
right_wall = environment.Wall((constants.WIDTH - 20, 0), (20, constants.HEIGHT))
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
if event.type == pygame.KEYDOWN or event.type == pygame.KEYUP:
player.command()
if event.type == pygame.MOUSEMOTION:
cross.draw(event.pos)
player.rotate_weapon(event.pos)
if event.type == pygame.MOUSEBUTTONDOWN:
player.shoot(event.pos)
screen.fill('black')
sprites.all_sprites.update()
sprites.all_sprites.draw(screen)
clock.tick(fps)
pygame.display.flip()
class GameManager:
def __init__(self):
self.mHUD = HUD()
self.actualLevel = 0
self.portalTiles = None
self.cityTiles = None
self.selectedTower = ""
self.selectedSkill = ""
mE.updateOnPause = ["Mouse", "Button","InfoTabBar", "SkillTimeStop"]
self.playerWins = True
pass
def load(self):
mE.setGlobalVariable("Money",10)
mE.mGlobalVariables["EndGame"] = False
self.loadAnimations()
self.loadUI()
self.loadMap()
self.loadSounds()
self.loadParticles()
def loadParticles(self):
mE.mParticleManager.addUpdateFunction(lImagesSlowParticle[0], lImagesSlowParticle[1], cascate , "cascate")
#Explosions
mE.mParticleManager.addUpdateFunction(lImagesCommonExplosion[0], lImagesCommonExplosion[1], explosion , "commonExplosion")
mE.mParticleManager.addUpdateFunction(lImagesSlowParticle[0], lImagesSlowParticle[1], explosion , "slowExplosion")
mE.mParticleManager.addUpdateFunction(lImagesPoisonParticle[0], lImagesPoisonParticle[1], explosion , "poisonExplosion")
mE.mParticleManager.addUpdateFunction(lImagesFarmParticle[0], lImagesFarmParticle[1], explosion , "farmExplosion")
mE.mParticleManager.addUpdateFunction(lImagesHealParticle[0], lImagesHealParticle[1], spin , "healParticle")
mE.mParticleManager.addUpdateFunction(lImagesSmokeParticle[0], lImagesSmokeParticle[1], spin , "Smoke")
mE.mParticleManager.addUpdateFunction(lImagesMeteorParticle[0], lImagesMeteorParticle[1], cascate , "MeteorCascate")
def loadSounds(self):
mE.mJukebox.LoadSong(levelSong, "LevelSong")
mE.mJukebox.LoadSong(bossFight, "BossFight")
mE.mJukebox.LoadSound(newTowerSound, "NewTower")
mE.mJukebox.LoadSound(destructedTower, "TowerDown")
mE.mJukebox.LoadSound(error, "Error")
mE.mJukebox.LoadSound(damage, "Damage")
mE.mJukebox.LoadSound(magic, "Magic")
mE.mJukebox.LoadSound(teleport, "Teleport")
mE.mJukebox.LoadSound(heart, "Heart")
mE.mJukebox.LoadSound(heal, "Heal")
mE.mJukebox.LoadSound(timeRunning, "TimeRunning")
mE.mJukebox.LoadSound(alarmClock, "AlarmClock")
mE.mJukebox.LoadSound(explosionSound, "Explosion")
mE.mGlobalVariables["General"] = GeneralVoices()
for monsterSound in lMonstersSounds:
mE.mJukebox.LoadSound(monsterSound[0], monsterSound[1])
def loadAnimations(self):
#Especial Tiles Animations
mE.mAnimationManager.addAnimation(lImagesPortal[0], lImagesPortal[1], "Portal")
mE.mAnimationManager.addAnimation(lImagesVillage[0], lImagesVillage[1], "Village")
#Towers
mE.mAnimationManager.addAnimation(lImagesSlowTower[0], lImagesSlowTower[1], "SlowTower")
mE.mAnimationManager.addAnimation(lImagesDamageTower[0], lImagesDamageTower[1], "HitTower")
mE.mAnimationManager.addAnimation(lImagesPoisonTower[0], lImagesPoisonTower[1], "PoisonTower")
mE.mAnimationManager.addAnimation(lImagesFarmTower[0], lImagesFarmTower[1], "FarmTower")
#Enemys Animation
for mAni in lMonstersStats:
mE.mAnimationManager.addAnimation(mAni["Animation"]["Up"][0], mAni["Animation"]["Up"][1], mAni["AnimationTag"]+"Up")
mE.mAnimationManager.addAnimation(mAni["Animation"]["Down"][0], mAni["Animation"]["Down"][1], mAni["AnimationTag"]+"Down")
mE.mAnimationManager.addAnimation(mAni["Animation"]["Left"][0], mAni["Animation"]["Left"][1], mAni["AnimationTag"]+"Left")
mE.mAnimationManager.addAnimation(mAni["Animation"]["Right"][0], mAni["Animation"]["Right"][1], mAni["AnimationTag"]+"Right")
mE.mAnimationManager.addAnimation(lImagesTombstone[0],lImagesTombstone[1], "Tombstone")
#UI
mE.mAnimationManager.addAnimation(lImagesMouse[0],lImagesMouse[1], "Mouse")
mE.mAnimationManager.addAnimation(lImagesMouseHit[0],lImagesMouseHit[1], "MouseHit")
mE.mAnimationManager.addAnimation(lImagesMouseSlow[0],lImagesMouseSlow[1], "MouseSlow")
mE.mAnimationManager.addAnimation(lImagesMousePoison[0],lImagesMousePoison[1], "MousePoison")
mE.mAnimationManager.addAnimation(lImagesMuteButtonOn[0],lImagesMuteButtonOn[1], "MuteButtonON")
mE.mAnimationManager.addAnimation(lImagesMuteButtonOff[0],lImagesMuteButtonOff[1], "MuteButtonOFF")
mE.mAnimationManager.addAnimation(lImagesTabBar[0],lImagesTabBar[1], "TabBar")
mE.mAnimationManager.addAnimation(lImagesBottomBar[0],lImagesBottomBar[1], "BottomBar")
mE.mAnimationManager.addAnimation(lImagesMoneyBar [0],lImagesMoneyBar[1], "MoneyUIBar")
#Icons
mE.mAnimationManager.addAnimation(lImagesSlowIcon[0], lImagesSlowIcon[1], "SlowIcon")
mE.mAnimationManager.addAnimation(lImagesDamageIcon[0], lImagesDamageIcon[1], "DamageIcon")
mE.mAnimationManager.addAnimation(lImagesPoisonIcon[0], lImagesPoisonIcon[1], "PoisonIcon")
mE.mAnimationManager.addAnimation(lImagesFarmIcon[0], lImagesFarmIcon[1], "FarmIcon")
mE.mAnimationManager.addAnimation(lImagesTimeStopIcon[0], lImagesTimeStopIcon[1], "TimeStopIcon")
mE.mAnimationManager.addAnimation(lImagesHealIcon[0], lImagesHealIcon[1], "HealIcon")
mE.mAnimationManager.addAnimation(lImagesFireBallIcon[0], lImagesFireBallIcon[1], "FireBallIcon")
#HealthBars Enemysself.selectedSkill
mE.mAnimationManager.addAnimation(lImagesHPBarEnemyS[0], lImagesHPBarEnemyS[1], "EnemyHealthBarStart")
mE.mAnimationManager.addAnimation(lImagesHPBarEnemyE[0], lImagesHPBarEnemyE[1], "EnemyHealthBarEnd")
mE.mAnimationManager.addAnimation(lImagesHPBarEnemyM[0], lImagesHPBarEnemyM[1], "EnemyHealthBarMiddle")
#HealthBars Towers
mE.mAnimationManager.addAnimation(lImagesHPBarTowerS[0], lImagesHPBarTowerS[1], "TowerHealthBarStart")
mE.mAnimationManager.addAnimation(lImagesHPBarTowerE[0], lImagesHPBarTowerE[1], "TowerHealthBarEnd")
mE.mAnimationManager.addAnimation(lImagesHPBarTowerM[0], lImagesHPBarTowerM[1], "TowerHealthBarMiddle")
#CooldownBars Towers
mE.mAnimationManager.addAnimation(lImagesHPBarTowerS[0], lImagesHPBarTowerS[1], "CooldownBarStart")
mE.mAnimationManager.addAnimation(lImagesHPBarTowerE[0], lImagesHPBarTowerE[1], "CooldownBarEnd")
mE.mAnimationManager.addAnimation(lImagesHPBarTowerM[0], lImagesHPBarTowerM[1], "CooldownBarMiddle")
#ProgressBar
mE.mAnimationManager.addAnimation(lImagesProgressStart[0], lImagesProgressStart[1], "ProgressBarStart")
mE.mAnimationManager.addAnimation(lImagesProgressMiddle[0], lImagesProgressMiddle[1], "ProgressBarMiddle")
mE.mAnimationManager.addAnimation(lImagesProgressEnd[0], lImagesProgressEnd[1], "ProgressBarEnd")
mE.mAnimationManager.addAnimation(lImagesProgressBarMF[0], lImagesProgressBarMF[1], "ProgressBarMF")
mE.mAnimationManager.addAnimation(lImagesProgressBarEF[0], lImagesProgressBarEF[1], "ProgressBarEF")
#Projectiles
mE.mAnimationManager.addAnimation(lImagesSimpleProjectil[0],lImagesSimpleProjectil[1], "SimpleProjectil")
mE.mAnimationManager.addAnimation(lImagesSlowProjectil[0],lImagesSlowProjectil[1], "SlowProjectil")
mE.mAnimationManager.addAnimation(lImagesPoisonProjectil[0],lImagesPoisonProjectil[1], "PoisonProjectil")
mE.mAnimationManager.addAnimation(lImagesFarmProjectil[0],lImagesFarmProjectil[1], "FarmProjectil")
mE.mAnimationManager.addAnimation(lImagesFireBall[0],lImagesFireBall[1], "FireBall")
#HealthBar City
mE.mEntityManager.defineLayerOrder(["Tombstone","Towers", "Monsters", "BackUI", "UI"])
def setPortalCoordinates(self):
self.portalTiles = mE.mMapManager.getTiles("3")
mapPortal = self.portalTiles[0][0]
portalCoord = self.portalTiles[0][1][0]
portalCoord = mapPortal.toMapCoordinate(portalCoord.position)
portalCoord = (0,portalCoord[0] * tileWidth,portalCoord[1] * tileHeigth)
#Create a global variable PortalCoord who have the position of the portal
mE.setGlobalVariable("PortalCoord", portalCoord)
mE.setGlobalVariable("PortalMapCoord", mapPortal)
def setCityCoordinates(self): #Do the same thing with City Coordinates
self.cityTiles = mE.mMapManager.getTiles("4")
mapCity = self.cityTiles[0][0]
cityCoord = self.cityTiles[0][1][0]
cityCoord = mapCity.toMapCoordinate(cityCoord.position)
cityCoord = (0,cityCoord[0] * tileWidth, cityCoord[1] * tileHeigth)
mE.setGlobalVariable("CityCoord", cityCoord)
mE.setGlobalVariable("CityMapCoor", mapCity)
def loadUI(self):
self.mHUD.loadEntitys()
#Load the fonts
mE.mTextManager.addFont(pygame.font.Font(None,16), "None14")
mE.mTextManager.addFont(pygame.font.Font(None,20), "None20")
mE.mTextManager.addFont(pygame.font.Font(None,28), "None32")
#Create the bottomBar
bottomBar = Entity()
mE.mEntityManager.addEntity(bottomBar,"BottomBar","UI")
mE.mAnimationManager.setEntityAnimation(bottomBar, "BottomBar")
bottomBar.setPosition(50 ,686)
self.icons = {}
#Create the SlowIcon
slowButton = self.mHUD.addCooldownButton(self.selectTower, "Slow",Vec2d(79,712),"SlowIcon", Vec2d(34,34), )
slowButton.cooldownBar.setPosition(Vec2d(86,751))
self.icons["Slow"] = slowButton
#Create DamageIcon
hitButton = self.mHUD.addCooldownButton(self.selectTower, "Hit", Vec2d(123 , 712), "DamageIcon", Vec2d(34,34))
hitButton.cooldownBar.setPosition(Vec2d(130,751))
self.icons["Hit"] = hitButton
#Create PoisonIcon
poisonButton = self.mHUD.addCooldownButton(self.selectTower, "Poison", Vec2d(167 , 712), "PoisonIcon", Vec2d(34,34), cooldown = 15.0)
poisonButton.cooldownBar.setPosition(Vec2d(174,751))
self.icons["Poison"] = poisonButton
#Create FarmIcon
farmButton = self.mHUD.addCooldownButton(self.selectTower, "Farm", Vec2d(211, 712), "FarmIcon", Vec2d(34,34))
farmButton.cooldownBar.setPosition(Vec2d(218,751))
self.icons["Farm"] = farmButton
#Create the bottomBar
skillBar = Entity()
mE.mEntityManager.addEntity(skillBar,"BottomBar","UI")
mE.mAnimationManager.setEntityAnimation(skillBar, "BottomBar")
skillBar.setPosition(424 + 180,686)
self.skillIcons = {}
#Create the TimeStopIcon
timeStopButton = self.mHUD.addCooldownButton(self.selectSkill, "TimeStop",Vec2d(79-50+ 424+180,712),"TimeStopIcon", Vec2d(34,34), cooldown = 180.0)
timeStopButton.cooldownBar.setPosition(Vec2d(86-50+ 424+180,751))
self.skillIcons["TimeStop"] = timeStopButton
#Create the HealIcon
healButton = self.mHUD.addCooldownButton(self.selectSkill, "Heal",Vec2d(123-50+ 424+180,712),"HealIcon", Vec2d(34,34), cooldown = 90.0)
healButton.cooldownBar.setPosition(Vec2d(130-50+ 424+180,751))
self.skillIcons["Heal"] = healButton
#Create the FireBallIcon
fireBallButton = self.mHUD.addCooldownButton(self.selectSkill, "FireBall",Vec2d(167-50+ 424+180,712),"FireBallIcon", Vec2d(34,34), cooldown = 300.0)
fireBallButton.cooldownBar.setPosition(Vec2d(174-50+ 424+180,751))
self.skillIcons["FireBall"] = fireBallButton
#Add TabBar for tower stats
self.tabBar = TabBar()
tabBarPos = (1024, 80)
self.tabBar.setMinDesloc(tabBarPos[0],tabBarPos[1])
self.tabBar.setMaxDesloc(tabBarPos[0]-180,tabBarPos[1])
self.tabBar.vecMaxSpeedDesloc = 10
self.mHUD.addTabBar(self.tabBar, "Info")
#Create the texts for tower stats
self.addTextTabBar((tabBarPos[0] +10,120),"Description0")
self.addTextTabBar((tabBarPos[0] +10,140),"Description1")
self.addTextTabBar((tabBarPos[0] +10,160),"Description2")
self.pauseUI = Text()
self.pauseUI.setPosition(500, 200)
mE.mTextManager.addText(self.pauseUI,"PauseUI")
mE.mTextManager.setTextFont("PauseUI", "None32")
#Add a circle around the mouse
self.circle = Circle()
self.circle.color = (55,151,125)
mE.mPrimitiveManager.addPrimitive(self.circle, "MouseCircle")
#Add the Twinkle little text
self.tText = createTwinkleText("- Shapen the arrows - ","None32")
self.tText.startTwinkle()
self.tText.setPosition(400,200)
mE.mEntityManager.addEntity(self.tText, "TwinkleText")
#Add the money ui bar
moneyBar = Entity()
mE.mEntityManager.addEntity(moneyBar,"MoneyUIBar","UI")
mE.mAnimationManager.setEntityAnimation(moneyBar, "MoneyUIBar")
moneyBar.setPosition(424,710)
#Add texts to HUD
self.moneyUI = Text()
self.moneyUI.color = (255,255,255)
self.mHUD.addText(self.moneyUI, "Money", "None32", "MoneyUI")
self.moneyUI.setPosition(470, 725)
#Create Mute Button
self.muteButton = self.mHUD.addButton(toggleSound,None, Vec2d(960,6), "MuteButtonON", Vec2d(34,34))
self.muteButton.params = self.muteButton
def addTextTabBar(self, position, tag):
t = Text()
t.color = (255,255,255)
t.setPosition(position)
self.tabBar.addEntity(t)
mE.mTextManager.addText(t,tag)
mE.mTextManager.setTextFont(tag, "None14")
def gameLoop(self):
self.end = False
mE.mJukebox.PlaySong("LevelSong",True)
#mE.mJukebox.PlaySong("BossFight")
while not self.end:
mE.update()
if(mE.keyboard.isPressed(pygame.K_ESCAPE)):
self.selectedTower = ""
self.selectedSkill = ""
mouse = self.mHUD.mouseEntity
mE.mAnimationManager.setEntityAnimation(mouse,"Mouse")
#self.end = True
if(self.selectedTower != "" and self.canPutTower()):
mousePosition = mE.mouse.getPosition()
self.circle.position = (mousePosition[0], mousePosition[1])
self.circle.radius = dicTowers[self.selectedTower]["Range"]
if(mE.mouse.isPressed("LEFT")):
self.createTower(self.selectedTower, mousePosition)
elif(self.selectedSkill != "" and self.canCastSkill()):
mousePosition = mE.mouse.getPosition()
self.circle.position = (mousePosition[0], mousePosition[1])
self.circle.radius = dicSkills[self.selectedSkill]["Range"]
if(mE.mouse.isPressed("LEFT")):
self.castSkill(self.selectedSkill, mousePosition)
else:
self.circle.position = (-2,-2)
self.circle.radius = (1)
if(self.isOver()):
break
print "Game Over"
if(mE.keyboard.isPressed(pygame.K_UP)):
self.playerWins = False
break
self.showInfo()
self.addTimeCash()
#print self.tText.text.content
self.mHUD.update()
mE.render()
def canPutTower(self):
mouse = self.mHUD.mouseEntity
lCollisionTowerMouse = mE.mEntityManager.collision("Mouse", "Tower")
lCollisionMouseWalkable = []
for t in walkable:
lCollisionMouseWalkable += mE.mMapManager.getCollisions(mouse, t)
if(not lCollisionTowerMouse and not self.icons[self.selectedTower].cooldownBar.isActive() and lCollisionMouseWalkable):
return True
return False
def canCastSkill(self):
mouse = self.mHUD.mouseEntity
lCollisionMouseWalkable = []
for t in walkable:
lCollisionMouseWalkable += mE.mMapManager.getCollisions(mouse, t)
if(not self.skillIcons[self.selectedSkill].cooldownBar.isActive() and lCollisionMouseWalkable):
return True
return False
def showInfo(self):
lCollisionIconMouse = mE.mEntityManager.collision("Mouse", "Button")
if(lCollisionIconMouse):
button = lCollisionIconMouse[0][1]
if(button != self.muteButton):
self.showDescription(button.params)
else:
self.tabBar.disappear()
def addTimeCash(self):
pass
def castSkill(self, tag, position = Vec2d(0,0)):
params = {"Position": position, "Range": dicSkills[tag]["Range"]}
dicSkills[tag]["Function"](params)
self.skillIcons[self.selectedSkill].activeCooldown()
def createTower(self,tag,position = Vec2d(0,0)):
global mE
global dicTowers
#If have money
if(mE.mGlobalVariables["Money"] >= dicTowers[tag]["Cost"]):
#Update the UI
mE.mGlobalVariables["Money"] += -dicTowers[tag]["Cost"]
self.moneyUI.content = "Money: " + str(mE.mGlobalVariables["Money"])
#Create the tower
t = Tower()
mE.mAnimationManager.setEntityAnimation(t, tag+"Tower")
mE.mEntityManager.addEntity(t,"Tower", "Towers")
t.tag = tag
t.towerEffect = dicTowers[tag]["Effect"]
#t.hp.maxHealth = dicTowers[tag]["HP"]
#t.hp.health = dicTowers[tag]["HP"]
t.slow = dicTowers[tag]["Slow"]
t.poison = dicTowers[tag]["PoisonDamage"]
t.damage = dicTowers[tag]["HitDamage"]
t.cooldownShoot = dicTowers[tag]["Cooldown"]
t.range = dicTowers[tag]["Range"]
t.hp = HealthBar(dicTowers[tag]["HP"])
t.hp.addToEntityManager()
t.hp.setAnimation("TowerHealthBarStart", "TowerHealthBarEnd", "TowerHealthBarMiddle")
if(dicTowers[tag]["ChooseMethod"] != None):
t.chooseTargetMethod = dicTowers[tag]["ChooseMethod"]
t.setCollisionBlock(Vec2d(tileWidth,tileHeigth))
t.setPosition(position)
t.setCenterBoundingCircle(32,32)
t.setRadiusBoundingCircle(32)
#Put on Graph
graph = mE.mGlobalVariables["Graph"]
graph.changeWeight(t.graphPosition,100)
self.recalculateRouteAllMonsters()
#Start iconCooldown
self.icons[self.selectedTower].activeCooldown()
mE.mJukebox.PlaySound("NewTower")
return t
else:
mE.mJukebox.PlaySound("Error")
def recalculateRouteAllMonsters(self):
monsters = mE.mEntityManager.getTagEntitys("Monster")
for m in monsters:
m.recalculateRoute()
def selectTower(self,params):
self.selectedSkill = ""
self.selectedTower = params
mouse = self.mHUD.mouseEntity
mE.mAnimationManager.setEntityAnimation(mouse,"Mouse"+ params)
def selectSkill(self,params):
self.selectedSkill = params
self.selectedTower = ""
mouse = self.mHUD.mouseEntity
mE.mAnimationManager.setEntityAnimation(mouse, "Mouse")
def showDescription(self, params):
tDescription0 = mE.mTextManager.texts["Description0"]
tDescription0.content = Descriptions[params][0]
tDescription1 = mE.mTextManager.texts["Description1"]
tDescription1.content = Descriptions[params][1]
tDescription2 = mE.mTextManager.texts["Description2"]
tDescription2.content = Descriptions[params][2]
self.tabBar.appear()
def loadTileset(self, tileset, mMap):
global tilesets
for tile in tilesets[tileset]:
animation = tilesets[tileset][tile]["Animation"]
symbol = tilesets[tileset][tile]["Symbol"]
mMap.mAnimationManager.addAnimation( animation[0], animation[1], tile )
mMap.createFactoryTile(Tile, {}, tile, symbol)
mMap.mAnimationManager.addAnimation(lImagesPortal[0],lImagesPortal[1],"Portal")
mMap.mAnimationManager.addAnimation(lImagesVillage[0],lImagesVillage[1],"City")
mMap.createFactoryTile(Portal, {"ParticleManager": mE.mParticleManager , "Waves": self.waves}, "Portal", "3")
mMap.createFactoryTile(City, {}, "City", "4")
def loadMap(self):
global graph
global lMaps
global PortalGraph
global mE
self.actualMap = lMaps[self.actualLevel]
mapFile = self.actualMap[0]
waveFile = self.actualMap[1]
tileset = self.actualMap[2]
#Load the wave
f = open(waveFile).read().split('\n')
self.nWaves = len(f)-1
self.waves = {}
i = 0
for line in f:
l = line.split('\t')
self.waves[i] = []
for enemy in l:
self.waves[i] += [int(enemy)]
i +=1
#Load the map
i = 0
for m in mapFile:
mMap = Map(tileWidth,tileHeigth, 0,0)
self.loadTileset(tileset, mMap)
mMap.loadMap(m)
mE.mMapManager.addMap(mMap, m)
i += 1
#Put the layers on order...
mE.mMapManager.setMapLayers(mapFile)
graph = TowerDefenseGraph()
graph.walkable = walkable
graph.loadGraphFromMaps(mapFile, tileWidth, tileHeigth)
#graph.loadWeigths()
mE.mGlobalVariables["Graph"] = graph
self.setPortalCoordinates()
self.setCityCoordinates()
def isOver(self):
#if there is no monster alive
monster = mE.mEntityManager.getTagEntitys("Monster")
#if there is no monster to spawn
pTile = self.portalTiles[0][1][0]
if(not pTile.gonnaSpawnMore() and monster == []):
#the player wins
self.playerWins = True
return True
if(mE.mGlobalVariables["EndGame"]):
self.playersWins = False
return True
#if the city has no more hp
#the player loose
self.playerWins = False
return False
def saveGame(self):
pass
class Game:
def __init__(self):
global graph
self.end = False
self.mStageSelection = StageSelection()
self.mGameManager = GameManager()
self.tIniLoop = mE.getGameTime()
def startGame(self):
global PortalGraph
mE.pushState()
self.mStageSelection.load()
self.mStageSelection.update()
mE.popState()
mE.mJukebox.PlaySong("MenuSong")
def load(self):
self.loadMenuAnimations()
self.loadMenuSounds()
self.splash = Entity()
mE.mEntityManager.addEntity(self.splash, "SplashScreen", "SplashScreen")
mE.mAnimationManager.setEntityAnimation(self.splash, "SplashScreen")
self.mHud = HUD()
self.background = Entity()
mE.mEntityManager.addEntity(self.background, "Background", "BG")
mE.mAnimationManager.setEntityAnimation(self.background, "Background")
self.mHud.addButton(self.startGame, None, Vec2d(100 + 44,100 + 200), "PlayButton", Vec2d(192,64))
self.mHud.addButton(self.endGame, None, Vec2d(180 + 44,240 + 200), "QuitButton", Vec2d(192,64))
mE.mAnimationManager.addAnimation(lImagesHPBarEnemyS[0], lImagesHPBarEnemyS[1], "CooldownBarStart")
mE.mAnimationManager.addAnimation(lImagesHPBarEnemyE[0], lImagesHPBarEnemyE[1], "CooldownBarEnd")
mE.mAnimationManager.addAnimation(lImagesHPBarEnemyM[0], lImagesHPBarEnemyM[1], "CooldownBarMiddle")
mE.mEntityManager.defineLayerOrder(["Splash","BG"])
def loadMenuAnimations(self):
mE.mAnimationManager.addAnimation(lImagesSplashScreen[0],lImagesSplashScreen[1],"SplashScreen")
mE.mAnimationManager.addAnimation(lImagesBackground[0],lImagesBackground[1],"Background")
mE.mAnimationManager.addAnimation(lImagesPlayButton[0],lImagesPlayButton[1],"PlayButton")
mE.mAnimationManager.addAnimation(lImagesOptionsButton[0],lImagesOptionsButton[1],"OptionsButton")
mE.mAnimationManager.addAnimation(lImagesQuitButton[0],lImagesQuitButton[1],"QuitButton")
mE.mAnimationManager.addAnimation(lImagesButton[0],lImagesButton[1], "Button")
mE.mAnimationManager.addAnimation(lImagesMouse[0],lImagesMouse[1], "Mouse")
def loadMenuSounds(self):
mE.mJukebox.LoadSong(menuSong, "MenuSong")
mE.mJukebox.LoadSound(bubbleSound, "BubbleSound")
mE.mJukebox.PlaySound("BubbleSound")
def menuLoop(self):
global mE
self.end = False
mE.mJukebox.PlaySong("MenuSong")
while not self.end:
mE.update()
if(mE.getGameTime() - self.tIniLoop >= 3.0 and self.splash != None):
mE.mEntityManager.removeEntity(self.splash, "SplashScreen")
self.splash = None
self.mHud.update()
mE.render()
print "Acabou"
def endGame(self):
self.end = True
class Scene(State):
def __init__(self, file_path):
super(Scene, self).__init__()
pygame.mixer.init(44100, -16, 4, 2048)
self.position = ['goalkeeper', 'defender', 'midfielder', 'attacker']
self.all_object_list = pygame.sprite.LayeredUpdates()
self.selection_circle = [] # Prototype
self.left_player = Player() # Prototype
self.right_player = Player() # Prototype
self.teams = collections.defaultdict(dict)
self.field = Object()
self.field_border = Object()
self.goal = []
self.ball = Ball()
self.hud = HUD()
self.goal_image = EffectObject()
self.formation = {Team_side.LEFT: [1, 4, 3, 3], Team_side.RIGHT: [1, 4, 4, 2]}
self.sound_list = dict()
# Game config
self.game_mode = Game_mode.PvP
self.P1_controlled_team = Team_side.LEFT
self.P1_controlled_position = 'midfielder'
self.P2_controlled_team = Team_side.RIGHT
self.P2_controlled_position = 'midfielder'
# Load scene's resources
self.read_scene(file_path)
def init(self):
# Set teams info
# Left team
self.game_mode = self.get_shared_var('mode')
self.formation[self.P1_controlled_team] = self.get_shared_var('P1_formation')
team1_id = self.get_shared_var('P1_team_ID')
self.hud.set_left_team_name(Team_name[team1_id])
self.left_player.setImage(ResourceManager.instance().image_path_list[56 + team1_id])
# Right team
self.formation[self.P2_controlled_team] = self.get_shared_var('P2_formation')
team2_id = self.get_shared_var('P2_team_ID')
self.hud.set_right_team_name(Team_name[team2_id])
self.right_player.setImage(ResourceManager.instance().image_path_list[56 + team2_id])
# Calculate players and ball position
self.calculate_position()
# Set controlled team
self.controlled_team = Team_side.LEFT
# Randomize ball direction
self.ball.set_angle(random.randrange(0, 360, 20))
# Game control
self.game_over = False
self.match_state = Match_state.KICKOFF
self.match_time = 120000
self.time = self.match_time
# Reset score
self.hud.reset_score()
# Set background music
pygame.mixer.stop()
self.sound_list['background'].play().set_endevent(pygame.constants.USEREVENT)
def process_key_press(self, key):
if key[pygame.K_w]:
apply_all(self.teams[self.P1_controlled_team][self.P1_controlled_position], 'move_up')
if key[pygame.K_s]:
apply_all(self.teams[self.P1_controlled_team][self.P1_controlled_position], 'move_down')
if key[pygame.K_UP]:
apply_all(self.teams[self.P2_controlled_team][self.P2_controlled_position], 'move_up')
if key[pygame.K_DOWN]:
apply_all(self.teams[self.P2_controlled_team][self.P2_controlled_position], 'move_down')
def process_events(self, event):
if event.type == pygame.USEREVENT:
self.sound_list['background'].play()
elif event.type == pygame.MOUSEBUTTONDOWN:
return ''
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
if self.is_running:
self.pause()
else:
self.resume()
elif event.key == pygame.K_a:
apply_all(self.teams[self.P1_controlled_team][self.P1_controlled_position], 'stop')
self.P1_controlled_position = self.position[max(0, self.position.index(self.P1_controlled_position) - 1)]
elif event.key == pygame.K_d:
apply_all(self.teams[self.P1_controlled_team][self.P1_controlled_position], 'stop')
self.P1_controlled_position = self.position[min(3, self.position.index(self.P1_controlled_position) + 1)]
elif event.key == pygame.K_LEFT:
apply_all(self.teams[self.P2_controlled_team][self.P2_controlled_position], 'stop')
self.P2_controlled_position = self.position[min(3, self.position.index(self.P2_controlled_position) + 1)]
elif event.key == pygame.K_RIGHT:
apply_all(self.teams[self.P2_controlled_team][self.P2_controlled_position], 'stop')
self.P2_controlled_position = self.position[max(0, self.position.index(self.P2_controlled_position) - 1)]
elif event.type == pygame.KEYUP:
if event.key == pygame.K_w or event.key == pygame.K_s:
apply_all(self.teams[self.P1_controlled_team][self.P1_controlled_position], 'stop')
elif event.key == pygame.K_UP or event.key == pygame.K_DOWN:
if self.game_mode is Game_mode.PvP:
apply_all(self.teams[self.P2_controlled_team][self.P2_controlled_position], 'stop')
def update(self):
if (not self.is_running):
return
if self.match_state == Match_state.KICKOFF:
self.sound_list['whistle'].play()
pygame.time.delay(1500)
self.match_state = Match_state.PLAYING
elif self.match_state == Match_state.PLAYING:
# Logic processing
self.time -= 1000 / 60
if self.time <= 0.0:
self.match_state = Match_state.KICKOFF
self.reset_game()
self.hud.set_time(int(self.time))
self.process_ball()
elif self.match_state == Match_state.GOAL:
goal_image = self.goal_image.clone()
goal_image.set_appear_time(500)
goal_image.show()
self.all_object_list.add(goal_image)
self.match_state = Match_state.KICKOFF
self.reset_game()
# Update all objects
self.all_object_list.update()
self.hud.update()
def draw(self, screen):
screen.fill(BLACK)
self.all_object_list.draw(screen)
apply_all(self.teams[self.P1_controlled_team][self.P1_controlled_position], 'show_selection_circle', screen)
if self.game_mode is Game_mode.PvP:
apply_all(self.teams[self.P2_controlled_team][self.P2_controlled_position], 'show_selection_circle', screen)
self.hud.draw(screen)
def reset_game(self):
self.calculate_position()
self.match_state = Match_state.KICKOFF
#--------------------------------------LOGIC PROCESSING SECTION-----------------------------------------------
def process_ball(self):
# Check if hit goals
if (pygame.sprite.collide_mask(self.ball, self.goal[0])) is not None:
self.sound_list['goal'].play()
self.hud.update_right_score()
self.match_state = Match_state.GOAL
return
elif pygame.sprite.collide_mask(self.ball, self.goal[1]) is not None:
self.sound_list['goal'].play()
self.hud.update_left_score()
self.match_state = Match_state.GOAL
return
# Check if hit field's border
self.process_collide_border()
# Check if hit players
player_list = [players for sublist in (list(self.teams[Team_side.LEFT].values()) + list(self.teams[Team_side.RIGHT].values())) for players in sublist]
hit_player = pygame.sprite.spritecollideany(self.ball, player_list, pygame.sprite.collide_circle)
if hit_player is not None:
self.sound_list['ball_kick'].play()
self.ball.collide_object(hit_player)
# Process AI list(chain(*self.teams[Team_side.LEFT].values()))
"""for position in self.teams[Team_side.RIGHT].keys():
action = 'move_up' if random.randrange(0, 2) is 0 else 'move_down'
apply_all(self.teams[Team_side.RIGHT][position], action)"""
def process_collide_border(self):
"""Check if ball touch field's border and calculate rebound direction
"""
ball_pos = self.ball.get_pos()
if ball_pos[0] < 50:
self.ball.move_to(51, self.ball.get_pos()[1])
self.ball.toggle_x_vel()
elif (ball_pos[0] + self.ball.get_width()) > SCREEN_WIDTH - 50:
self.ball.move_to(SCREEN_WIDTH - 51 - self.ball.get_width(), self.ball.get_pos()[1])
self.ball.toggle_x_vel()
elif ball_pos[1] < 20:
self.ball.move_to(self.ball.get_pos()[0], 21)
self.ball.toggle_y_vel()
elif (ball_pos[1] + self.ball.get_height()) > SCREEN_HEIGHT - 20:
self.ball.move_to(self.ball.get_pos()[0], SCREEN_HEIGHT - 21 - self.ball.get_height())
self.ball.toggle_y_vel()
def calculate_position(self):
"""Calculate and move ball and players to the right position
"""
# Calculate ball postion
x = (SCREEN_WIDTH - self.ball.get_width()) // 2
y = (SCREEN_HEIGHT - 8 - self.ball.get_height()) // 2
self.ball.move_to(x, y)
# Generate and calculate red team players
for i in range(len(self.formation[Team_side.LEFT])):
if len(self.teams[Team_side.LEFT]) == 4:
apply_all(self.teams[Team_side.LEFT][self.position[i]], 'kill')
self.teams[Team_side.LEFT].update({self.position[i]: []})
# Calculate offset
x_offset = 100
y_offset = (self.field.get_height() - 8 - self.left_player.get_height() * self.formation[Team_side.LEFT][i]) // (self.formation[Team_side.LEFT][i] + 1)
for j in range(self.formation[Team_side.LEFT][i]):
# Calculate position
x = self.left_player.get_pos()[0] + (x_offset * (i ** 1.69))
y = y_offset * (j + 1) + self.left_player.get_height() * j + 4
self.teams[Team_side.LEFT][self.position[i]].append(self.left_player.clone())
self.teams[Team_side.LEFT][self.position[i]][j].move_to(x, y)
self.teams[Team_side.LEFT][self.position[i]][-1].set_layer(1)
self.teams[Team_side.LEFT][self.position[i]][-1].set_radius()
self.teams[Team_side.LEFT][self.position[i]][j].set_max_offset(y_offset - 20)
self.all_object_list.add(self.teams[Team_side.LEFT][self.position[i]][-1])
# Generate and calculate blue team players
for i in range(len(self.formation[Team_side.RIGHT])):
if len(self.teams[Team_side.RIGHT]) == 4:
apply_all(self.teams[Team_side.RIGHT][self.position[i]], 'kill')
self.teams[Team_side.RIGHT].update({self.position[i]: []})
# Calculate offset
x_offset = 100
y_offset = (self.field.get_height() - 8 - self.right_player.get_height() * self.formation[Team_side.RIGHT][i]) // (self.formation[Team_side.RIGHT][i] + 1)
for j in range(self.formation[Team_side.RIGHT][i]):
# Calculate position
x = self.right_player.get_pos()[0] - (x_offset * (i ** 1.69))
y = y_offset * (j + 1) + self.right_player.get_height() * j + 4
self.teams[Team_side.RIGHT][self.position[i]].append(self.right_player.clone())
self.teams[Team_side.RIGHT][self.position[i]][j].move_to(x, y)
self.teams[Team_side.RIGHT][self.position[i]][-1].set_layer(1)
self.teams[Team_side.RIGHT][self.position[i]][-1].set_radius()
self.teams[Team_side.RIGHT][self.position[i]][j].set_max_offset(y_offset - 20)
self.all_object_list.add(self.teams[Team_side.RIGHT][self.position[i]][-1])
# Assign selection_circle to each player
# Left team
for player in [players for sublist in list(self.teams[Team_side.LEFT].values()) for players in sublist]:
player.selection_circle = self.selection_circle[0].clone()
# Right team
for player in [players for sublist in list(self.teams[Team_side.RIGHT].values()) for players in sublist]:
player.selection_circle = self.selection_circle[1].clone()
#----------------------------------------READ FILE SECTION-----------------------------------------------------
def read_scene(self, file_path):
with open(file_path) as file:
self.read_hud(file)
self.read_field(file)
self.read_red_team(file)
self.read_blue_team(file)
self.read_selection_circle(file)
self.read_ball(file)
self.read_effect(file)
self.read_sound(file)
def read_hud(self, file):
file.readline()
hud_id = int(file.readline().strip().split(' ')[1])
self.hud.init(ResourceManager.instance().hud_path_list[hud_id])
def read_field(self, file):
# Read field
file.readline()
image_id = int(file.readline().strip().split(' ')[1])
self.field.init('Image', file_name = ResourceManager.instance().image_path_list[image_id])
self.field.scale_to(SCREEN_WIDTH, SCREEN_HEIGHT)
self.all_object_list.add(self.field)
# Read goal
file.readline()
image_id_1, image_id_2 = list(map(int, file.readline().strip().split(' ')[1:]))
self.goal.append(Object())
self.goal[-1].init('Image', file_name = ResourceManager.instance().image_path_list[image_id_1])
self.goal[-1].scale_to(SCREEN_WIDTH, SCREEN_HEIGHT)
self.goal[-1].set_layer(-1)
self.goal.append(Object())
self.goal[-1].init('Image', file_name = ResourceManager.instance().image_path_list[image_id_2])
self.goal[-1].scale_to(SCREEN_WIDTH, SCREEN_HEIGHT)
self.goal[-1].set_layer(-1)
self.all_object_list.add(self.goal)
def read_red_team(self, file):
self.teams[Team_side.LEFT] = dict()
file.readline()
image_id = int(file.readline().strip().split(' ')[1])
# Prototype
self.left_player.init('Image', file_name = ResourceManager.instance().image_path_list[image_id])
self.left_player.rotate(float(file.readline().strip().split(' ')[1]))
self.left_player.scale(*map(float, file.readline().strip().split(' ')[1:]))
self.left_player.translate(*map(int, file.readline().strip().split(' ')[1:]))
def read_blue_team(self, file):
self.teams[Team_side.RIGHT] = dict()
file.readline()
image_id = int(file.readline().strip().split(' ')[1])
# Prototype
self.right_player.init('Image', file_name = ResourceManager.instance().image_path_list[image_id])
self.right_player.rotate(float(file.readline().strip().split(' ')[1]))
self.right_player.scale(*map(float, file.readline().strip().split(' ')[1:]))
self.right_player.translate(*map(int, file.readline().strip().split(' ')[1:]))
def read_selection_circle(self, file):
file.readline()
image_id = list(map(int, (file.readline().strip().split(' ')[1:])))
image_id_green = image_id[0]
image_id_red = image_id[1]
# Green circle
self.selection_circle.append(Object())
self.selection_circle[-1].init('Image', file_name = ResourceManager.instance().image_path_list[image_id_green], alpha = True)
self.selection_circle[-1].rotate(float(file.readline().strip().split(' ')[1]))
self.selection_circle[-1].scale(*map(float, file.readline().strip().split(' ')[1:]))
self.selection_circle[-1].translate(*map(int, file.readline().strip().split(' ')[1:]))
# Red circle
self.selection_circle.append(self.selection_circle[-1].clone())
self.selection_circle[-1].setImage(ResourceManager.instance().image_path_list[image_id_red])
def read_ball(self, file):
file.readline()
image_id = int(file.readline().strip().split(' ')[1])
self.ball.init('Image', file_name = ResourceManager.instance().image_path_list[image_id], alpha = True)
self.ball.rotate(float(file.readline().strip().split(' ')[1]))
self.ball.scale(*map(float, file.readline().strip().split(' ')[1:]))
self.ball.translate(*map(int, file.readline().strip().split(' ')[1:]))
self.ball.set_radius()
self.all_object_list.add(self.ball)
def read_effect(self, file):
file.readline()
image_id = int(file.readline().strip().split(' ')[1])
self.goal_image.init('Image', file_name = ResourceManager.instance().image_path_list[image_id], alpha = True)
self.goal_image.rotate(float(file.readline().strip().split(' ')[1]))
self.goal_image.scale(*map(float, file.readline().strip().split(' ')[1:]))
self.goal_image.translate(*map(int, file.readline().strip().split(' ')[1:]))
self.goal_image.set_layer(5)
def read_sound(self, file):
sound_num = int(file.readline().strip().split(' ')[1])
for i in range(sound_num):
sound_type = file.readline().strip().replace('#', '')
sound_id = int(file.readline().strip().split(' ')[1])
sound = pygame.mixer.Sound(ResourceManager.instance().sound_path_list[sound_id])
self.sound_list.update({sound_type: sound})
pygame.display.set_caption("CastleThing")
"""
def generateColor(f):#0<f<1
g = f+1.0/3
h = g+1.0/3
return [127*(1+cos(f*2*pi)),127*(1+cos(g*2*pi)),127*(1+cos(h*2*pi))]
"""
universe = CreateUniverse()
gc = GraphicConfig()
gc.mainSurface = window
gc.trailSurface = trails
gc.hudSurface = hud
gc.font = pygame.font.Font(None, 20)
hud = HUD()
weapons = {}
weapons[K_1] = Bullet
weapons[K_2] = SplitBullet
weapons[K_3] = AngleBullet
weapons[K_4] = CarpetBomb
weapons[K_5] = PineappleBomb
weapons[K_6] = Frag
weapons[K_7] = PowerBullet
weapons[K_p] = PlayerSpawn
ammo = {}
ammo[Bullet] = 1000
ammo[SplitBullet] = 10000
ammo[AngleBullet] = 1000
ammo[PowerBullet] = 1000
def main():
pygame.init()
# Constant variables
SCREEN_SIZE = (600, 800)
DISPLAY_SIZE = (300, 400)
DARK_GREY = (50, 50, 50)
RUNNING = True
FPS = 60
timer = 0
fpsClock = pygame.time.Clock()
#The real screen
screen = pygame.display.set_mode(SCREEN_SIZE)
#To cast to
display = pygame.Surface((DISPLAY_SIZE))
player = Player(display, 'player')
generator = Generator(display)
Soundplayer.load_music(Soundplayer())
Soundplayer.play_music(Soundplayer())
hud = HUD(display, player, DISPLAY_SIZE, generator)
menu = Menu(display, DISPLAY_SIZE)
# Title and Icon
pygame.display.set_caption("The Falcon")
icon = pygame.image.load(
menu.resource_path('Game/sprites/playerLV1.png'))
pygame.display.set_icon(icon)
## git ignore
while RUNNING:
## Draw Menu ##
if menu.get_menu:
menu.draw_background()
menu.draw_menu()
for event in pygame.event.get():
if event.type == pygame.QUIT:
RUNNING = False
pygame.quit()
sys.exit()
menu.menu_input(event)
if not menu.get_menu:
Mediator.all_game_objects.append(player)
surf = pygame.transform.scale(display, SCREEN_SIZE)
screen.blit(surf, (0, 0))
pygame.display.update()
else:
## Game loop ##
for event in pygame.event.get():
if event.type == pygame.QUIT:
RUNNING = False
menu.draw_background_scrolling(display, DISPLAY_SIZE)
for object in Mediator.all_game_objects:
object.loop()
object.draw()
generator.generate()
Mediator.all_game_objects = [
i for i in Mediator.all_game_objects
if i not in Mediator.to_be_removed
]
hud.draw_HUD()
Mediator.to_be_removed.clear()
## Check if player is dead or game is completed
if player.player_dead() or generator.get_game_complete():
generator = Generator(display)
hud = HUD(display, player, DISPLAY_SIZE, generator)
Mediator.all_game_objects.clear()
menu.player_dead()
player.reset_player()
surf = pygame.transform.scale(display, SCREEN_SIZE)
screen.blit(surf, (0, 0))
pygame.display.update()
fpsClock.tick(FPS)
gameLoad.get_canvas_size()
#Setup and classes
text = TEXT.Text(0, 0, "YOU WON", SETTINGS.WHITE, "DUGAFONT.ttf", 48)
beta = TEXT.Text(5, 5, "META ALFA BUILD V.1.6", SETTINGS.WHITE,
"DUGAFONT.ttf", 20)
text.update_pos(
SETTINGS.canvas_actual_width / 2 - text.layout.get_width() / 2,
SETTINGS.canvas_target_height / 2 - text.layout.get_height() / 2)
#Classes for later use
gameMap = MAP.Map(SETTINGS.levels_list[SETTINGS.current_level].array)
gameCanvas = Canvas(SETTINGS.canvas_map_width, SETTINGS.canvas_map_height)
gamePlayer = PLAYER.Player(SETTINGS.player_pos)
gameRaycast = RAYCAST.Raycast(gameCanvas.canvas, gameCanvas.window)
gameInv = INVENTORY.inventory({'bullet': 150, 'shell': 25, 'ferromag': 50})
gameHUD = HUD.hud()
#More loading - Level specific
gameLoad.load_new_level()
#Controller classes
menuController = MENU.Controller(gameCanvas.window)
musicController = MUSIC.Music()
tutorialController = TUTORIAL.Controller()
#Run at last
main_loop()
def tick(self, dt):
HUD.clear()
self.simulation.tick()
def Level(levelName, saveName):
"""
\"Level\" type constructor
@param levelName: levelName containing all informations about the level
@type levelName: str
@param saveName: Path to save levelName of current player
@type saveName: str
@return: Dictionnary containing all informations about level
@rtype: dict
"""
assert type("Levels/" + levelName) is str
lsFiles = os.listdir("Levels/" + levelName)
assert "background.pic" in lsFiles, "Load level from %r failed : missing file : background.pic" % levelName
assert "foreground.pic" in lsFiles, "Load level from %r failed : missing file : foreground.pic" % levelName
bgItem0 = Item.Item(
Tools.createDatasFromPic("Levels/" + levelName + "/background.pic",
True), 0, 0, [70, 70, 70], fgSpeed + 30)
bgItem1 = Item.Item(
Tools.createDatasFromPic("Levels/" + levelName + "/background.pic",
True), Item.getBaseWidth(bgItem0), 0,
[70, 70, 70], fgSpeed + 30)
fgItem0 = Item.Item(
Tools.createDatasFromPic("Levels/" + levelName + "/foreground.pic"), 0,
0, [0, 170, 0], fgSpeed)
fgItem1 = Item.Item(
Tools.createDatasFromPic("Levels/" + levelName + "/foreground.pic"),
Item.getBaseWidth(fgItem0) - 1, 0, [0, 170, 0], fgSpeed)
playerItem = loadPlayer(saveName)
object = {
"levelName": levelName,
"bgItem0": bgItem0,
"bgItem1": bgItem1,
"fgItem0": fgItem0,
"fgItem1": fgItem1,
"playerItem": playerItem,
"keyBinder": None,
"enemyList": [],
"playerScore": 0
}
kb = KeyBinder.KeyBinder(levelName[levelName.rfind("/") + 1:])
KeyBinder.addAction(kb, "z", movePlayerUp, object)
KeyBinder.addAction(kb, "q", movePlayerLeft, object)
KeyBinder.addAction(kb, "s", movePlayerDown, object)
KeyBinder.addAction(kb, "d", movePlayerRight, object)
object["keyBinder"] = kb
Item.setVX(object["playerItem"], 2.)
Item.setVY(object["playerItem"], 1.)
#load datas from config file :
file = open("Levels/" + levelName + "/config", "r")
content = file.read()
file.close()
exec(content)
object["scoreObjective"] = scoreObjective
object["maxEnemysNumber"] = maxEnemysNumber
object["availableEnemys"] = availableEnemys
hud = HUD.HUD(scoreObjective, Player.getMaxLife(playerItem))
object["HUD"] = hud
#print start screen
Tools.sysExec("clear")
startText = "\033[18;" + str(
int(round((Object.SCREEN_WIDTH / 2) + (len(str(scoreObjective)) / 2)))
) + "H\033[4;1m\033[38;2;200;0;0m" + str(scoreObjective) + "\033[0m"
Menu.printScreen("Pictures/startLevelScreen.pic", 110)
sys.stdout.write(startText)
print("")
KeyBinder.waitForKeyPressed()
for i in range(0, maxEnemysNumber):
addEnemy(object)
return object
def interact(lvl):
"""
Interaction inside the level
@param lvl: Dictionnary containing all information about one \"Level\" object
@type lvl: dict
@return: Code corresponding to level state : -1=Error; 0=In progress ; 1=Lose ; 2=Win
@rtype: int
"""
assertLevel(lvl)
if (lvl["playerScore"] >= lvl["scoreObjective"]):
time.sleep(0.7)
KeyBinder.clearBuffer()
Menu.printScreen("Pictures/winText.pic", 45, "\033[1;92m")
KeyBinder.waitForKeyPressed()
return 2
if (Player.getLife(lvl["playerItem"]) <= 0):
time.sleep(0.7)
KeyBinder.clearBuffer()
Menu.printScreen("Pictures/loseText.pic", 45, "\033[1;31;7;5m")
KeyBinder.waitForKeyPressed()
return 1
KeyBinder.interact(lvl["keyBinder"])
Item.move(lvl["bgItem0"], dt)
Item.move(lvl["bgItem1"], dt)
Item.move(lvl["fgItem0"], dt)
Item.move(lvl["fgItem1"], dt)
# ------- Manage background and foreground
x = Object.getX(lvl["bgItem1"])
baseWidth = Item.getBaseWidth(lvl["bgItem0"])
#place part 1 of the background after the part 0
if (x <= -baseWidth):
Object.setX(lvl["bgItem1"], baseWidth + Object.getX(lvl["bgItem0"]))
#place part 0 of the background after the part 1
x = Object.getX(lvl["bgItem0"])
if (x <= -baseWidth):
Object.setX(lvl["bgItem0"], baseWidth + Object.getX(lvl["bgItem1"]))
x = Object.getX(lvl["fgItem1"])
baseWidth = Item.getBaseWidth(lvl["fgItem0"])
#place part 1 of the foreground after the part 2
if (x <= -baseWidth):
Object.setX(lvl["fgItem1"],
baseWidth + Object.getX(lvl["fgItem0"]) - 1)
#place part 2 of the foreground after the part 1
x = Object.getX(lvl["fgItem0"])
if (x <= -baseWidth):
Object.setX(lvl["fgItem0"],
baseWidth + Object.getX(lvl["fgItem1"]) - 1)
Player.interact(lvl["playerItem"])
# ----------- Manage enemys
for i in lvl["enemyList"]:
if (Object.getX(i) < -Item.getBaseWidth(i)):
Enemy.kill(i)
if (Enemy.interact(i)
): #if enemy dead and all his shots have disappeared
lvl["enemyList"].remove(i)
while (countAliveEnemys(lvl) < lvl["maxEnemysNumber"]):
addEnemy(lvl)
# ----------- Manage collisions
#collisions between player and foreground
if (Item.tryCollide(lvl["fgItem0"], lvl["playerItem"])
or Item.tryCollide(lvl["fgItem1"], lvl["playerItem"])):
Player.takeDamage(lvl["playerItem"], 50)
Player.giveImmute(lvl["playerItem"], 3)
#collisions btween players shots and...
for i in Player.getShotList(lvl["playerItem"]):
#player shot and foregrounds
if (Item.tryCollide(lvl["fgItem0"], i)
or Item.tryCollide(lvl["fgItem1"], i)):
delPlayerShot(lvl, i)
#player shot and enemys
for j in lvl["enemyList"]:
if (Item.tryCollide(i, j)):
Enemy.takeDamage(j, Player.getDamageValue(lvl["playerItem"]))
if (Enemy.getIsDead(j) == False
): #if enemy is not dead, del shot
delPlayerShot(lvl, i)
#if enemy destroyed
if (Enemy.getLife(j) == 0):
addPlayerScore(lvl, Enemy.getScoreValue(j))
Enemy.setLife(j, -1)
Enemy.kill(j)
#collisions btween enemys and ...
for j in lvl["enemyList"]:
for i in Enemy.getShotList(j):
#enemys shots and foreground
if (Item.tryCollide(lvl["fgItem0"], i)
or Item.tryCollide(lvl["fgItem1"], i)):
delEnemyShot(j, i)
#enemys shots and player
if (Item.tryCollide(i, lvl["playerItem"])):
Player.takeDamage(lvl["playerItem"], Enemy.getDamageValue(j))
delEnemyShot(j, i)
HUD.refreshValues(lvl["HUD"], Player.getLife(lvl["playerItem"]),
lvl["playerScore"])
return 0
class Scene(State):
def __init__(self):
super(Scene, self).__init__()
pygame.mixer.init(44100, -16, 4, 2048)
self.all_object_list = pygame.sprite.LayeredUpdates()
self.zombie_list = pygame.sprite.Group()
self.blood_splash = BloodSplash()
self.background = Object()
self.player = Player()
self.zombie_sprite = []
self.grave_list = []
self.hud = HUD()
self.sound_list = dict()
self.bg_music = pygame.mixer.music
self.game_over = False
self.time = pygame.time.get_ticks()
def init(self):
self.read_scene()
# Bring cursor to front
self.all_object_list.move_to_front(self.player)
# Set background music
self.sound_list['background'].play().set_endevent(pygame.constants.USEREVENT)
# Scale background to screen size
self.background.image = pygame.transform.scale(self.background.image, (SCREEN_WIDTH, SCREEN_HEIGHT))
def process_events(self, event):
if event.type == pygame.USEREVENT:
self.sound_list['background'].play()
elif event.type == pygame.MOUSEBUTTONDOWN:
self.sound_list['gunshot'].play()
self.process_raycast()
elif event.type == pygame.KEYDOWN:
if (event.key == pygame.K_p):
if self.is_running:
self.pause()
else:
self.resume()
def update(self):
if (not self.is_running):
return
# Process game
self.process_zombie()
# Update all objects
self.all_object_list.update(self.hud)
self.hud.update()
def draw(self, screen):
screen.fill(WHITE)
self.all_object_list.draw(screen)
apply_all(self.zombie_list.sprites(), 'show_timer', screen)
self.hud.draw(screen)
#--------------------------------------LOGIC PROCESSING SECTION-----------------------------------------------
def process_zombie(self):
# Randomly choose an interval between 0.5 to 1.5 second to spawn another zombie
if (pygame.time.get_ticks() - self.time >= random.randrange(1, 3) * 500):
# Random location for zombie
zombie_pos = random.randrange(0, len(self.grave_list))
# Check if grave's position already had zombie
if (not next((True for zombie in self.zombie_list.sprites() if zombie.pos == zombie_pos), False)):
# Randomly pick zombie from zombie sprite list
zombie = deepcopy(self.zombie_sprite[random.randrange(0, len(self.zombie_sprite))])
zombie.set_pos(zombie_pos)
# Set zombie to the right position
zombie.move_to(*self.grave_list[zombie_pos].get_pos())
zombie.translate(35, -10)
# Set zombie layer
zombie.set_layer(self.grave_list[zombie_pos]._layer - 1)
# Add to zombie list and object list
self.zombie_list.add(zombie)
self.all_object_list.add(zombie)
# Reset timer
self.time = pygame.time.get_ticks()
def process_raycast(self):
mouse_pos = pygame.mouse.get_pos()
hit_zombie = next((zombie for zombie in self.zombie_list.sprites() if zombie.collide_point(list(map(operator.sub, mouse_pos, zombie.get_pos())))), None)
if (hit_zombie is not None):
# Play zombie's death sound
self.sound_list['dying_scream'].play()
# Update hit count
self.hud.update_hit()
# Splash blood
blood = deepcopy(self.blood_splash)
blood.move_to(*self.player.get_pos())
blood.set_layer(self.all_object_list.get_top_layer() + 1)
blood.show()
self.all_object_list.add(blood)
hit_zombie.kill()
#----------------------------------------READ FILE SECTION-----------------------------------------------------
def read_scene(self):
with open(ResourceManager.scene_path_list[0]) as file:
self.read_hud(file)
self.read_background(file)
self.read_player(file)
self.read_grave(file)
self.read_zombie(file)
self.read_blood_splash(file)
self.read_sound(file)
def read_hud(self, file):
file.readline()
hud_id = int(file.readline().strip().split(' ')[1])
self.hud.init(ResourceManager.hud_path_list[hud_id])
def read_background(self, file):
file.readline()
image_id = int(file.readline().strip().split(' ')[1])
self.background.init('Image', file_name = ResourceManager.image_path_list[image_id])
self.all_object_list.add(self.background)
def read_player(self, file):
file.readline()
image_id = int(file.readline().strip().split(' ')[1])
self.player.init('Image', file_name = ResourceManager.image_path_list[image_id], alpha = True)
self.player.translate(*map(int, file.readline().strip().split(' ')[1:]))
self.player.rotate(float(file.readline().strip().split(' ')[1]))
self.player.scale(*map(float, file.readline().strip().split(' ')[1:]))
self.all_object_list.add(self.player)
def read_grave(self, file):
file.readline()
image_id = int(file.readline().strip().split(' ')[1])
grave = Object()
grave.init('Image', file_name = ResourceManager.image_path_list[image_id], alpha = True)
grave.translate(*map(int, file.readline().strip().split(' ')[1:]))
grave.rotate(float(file.readline().strip().split(' ')[1]))
grave.scale(*map(float, file.readline().strip().split(' ')[1:]))
for i in range(3):
for j in range(3):
self.grave_list.append(deepcopy(grave))
self.grave_list[-1].translate(200 * j, 100 * i)
self.grave_list[-1].set_layer(2 * (i + 1))
self.all_object_list.add(self.grave_list)
def read_zombie(self, file):
zombie_num = int(file.readline().strip().split(' ')[1])
for i in range(zombie_num):
image_id = int(file.readline().strip().split(' ')[1])
self.zombie_sprite.append(Zombie())
self.zombie_sprite[-1].init('Image', file_name = ResourceManager.image_path_list[image_id], alpha = True)
self.zombie_sprite[-1].translate(*map(int, file.readline().strip().split(' ')[1:]))
self.zombie_sprite[-1].rotate(float(file.readline().strip().split(' ')[1]))
self.zombie_sprite[-1].scale(*map(float, file.readline().strip().split(' ')[1:]))
def read_blood_splash(self, file):
file.readline()
blood_id = int(file.readline().strip().split(' ')[1])
self.blood_splash.init('Image', file_name = ResourceManager.image_path_list[blood_id], alpha = True)
self.blood_splash.translate(*map(int, file.readline().strip().split(' ')[1:]))
self.blood_splash.rotate(float(file.readline().strip().split(' ')[1]))
self.blood_splash.scale(*map(float, file.readline().strip().split(' ')[1:]))
def read_sound(self, file):
sound_num = int(file.readline().strip().split(' ')[1])
for i in range(sound_num):
sound_type = file.readline().strip().replace('#', '')
sound_id = int(file.readline().strip().split(' ')[1])
sound = pygame.mixer.Sound(ResourceManager.sound_path_list[sound_id])
self.sound_list.update({sound_type: sound})
def main():
pygame.init()
pygame.mixer.init()
# GET THE LIST
liste = parser.parse_level()
pygame.display.set_mode(get_coords(liste))
mainS = pygame.display.get_surface()
platformGroup = pygame.sprite.Group()
platformGroup, normGroup = add_platforms(platformGroup, liste)
checkGroup = platformGroup.copy()
checkGroup.add(normGroup)
# playa = playerC.Player((100, 200))
playa = create_main(liste)
enem = add_enemy(liste)
enemGroup = pygame.sprite.Group(enem)
# enemGroup.add(enem)
# Create collectible items
coll_itemG = pygame.sprite.Group()
coll_itemG = create_collectible_items(coll_itemG, liste)
slopeGroup = pygame.sprite.Group()
slopeGroup = add_slopes(slopeGroup)
actionG = add_action_items(liste)
actionG = pygame.sprite.Group(actionG)
otherG = add_other_items(liste)
otherG = pygame.sprite.Group(otherG)
extraG = add_extra(liste)
clock = pygame.time.Clock()
nowTime = 0 # current time
timeSum = 0 # sum of time
sp_blitpos = None
myCam = scrollerC.Camera(scrollerC.complex_camera, level_w, level_h)
# HUD
myBar = HUD.HealthBar((10, 0))
myCoinHUD = HUD.itemHUD(coinHUDPath, GOLD, (10, myBar.h + 10))
myKeyHUD = HUD.itemHUD(keyHUDPath, GREEN, (myCoinHUD.rect.width + 64, myBar.h + 10))
myCursor = cursorC.Cursor()
pygame.mouse.set_visible(False) # hide the actual mouse
# DUMMY DATA
OUTLIST = [0, 0]
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
handleQuit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
playa.jump()
elif event.key == pygame.K_z:
for enem in enemGroup:
if isinstance(enem, enemyC.Frog):
print("{} {}", enem.y_vel, enem.mutex)
elif event.key == pygame.K_x and playa.action_contact:
if playa.action_obj.type == "SWITCH":
playa.action_obj.used = not playa.action_obj.used
# DEBUG INFO
elif event.key == pygame.K_w:
print(" PL {} MS {}".format(playa.rect.center, playa.intMousePos))
elif event.type == pygame.MOUSEBUTTONDOWN:
playa.shoot_fire(myCam)
myCursor.clicked = True
keys = pygame.key.get_pressed()
curPos = pygame.mouse.get_pos()
mainS.fill(BLUE)
# Main updates
OUTLIST = playa.update(keys, myCam, mainS, checkGroup, actionG, slopeGroup, extraG)
myCam.update(playa)
# playa.canShift = False # remove player's ability to shift gravity
doRotate = OUTLIST[0]
nowTime = OUTLIST[1] # get current time
mainTime = time.time()
timeSum += mainTime - nowTime
# toogle canShift on if sufficient time has passed
if timeSum - (mainTime - nowTime) > 0.04:
timeSum = 0 # reset counter
playa.canShift = True
platformGroup.update(mainS, doRotate)
enemGroup.update(checkGroup, playa.powerGroup, playa, mainS, myCam)
# check for dead enems
for enemy in enemGroup:
if not enemy.alive:
enemGroup.remove(enemy)
coll_itemG.update(playa)
for item in coll_itemG:
if item.consumed:
coll_itemG.remove(item)
actionG.update()
otherG.update()
extraG.update()
switch_actlist = []
for item in actionG:
if item.type == "SWITCH":
switch_actlist.append(item)
for item in otherG:
if item.type == "DOOR":
toogleItemState(item, switch_actlist)
# apply camera
for each in checkGroup:
mainS.blit(each.image, myCam.use_cam(each))
sp_blitpos = myCam.use_cam(playa)
for enemy in enemGroup:
r1 = myCam.use_cam(enemy)
mainS.blit(enemy.image, r1)
for item in coll_itemG:
mainS.blit(item.image, myCam.use_cam(item))
for slope in slopeGroup:
mainS.blit(slope.image, myCam.use_cam(slope))
for each in actionG:
mainS.blit(each.image, myCam.use_cam(each))
for each in otherG:
mainS.blit(each.image, myCam.use_cam(each))
for each in extraG:
mainS.blit(each.image, myCam.use_cam(each))
mainS.blit(playa.image, myCam.use_cam(playa))
myCoinHUD.update("coins", playa, mainS)
myKeyHUD.update("keys", playa, mainS)
myBar.update(playa.health, mainS)
myCursor.final(mainS, curPos)
pygame.display.update()
clock.tick(60)
class TestApp(Label):
def __init__(self, **kwargs):
super(TestApp, self).__init__(**kwargs)
Window.bind(on_key_down=self.onKeyDown)
Window.bind(on_touch_down=self.onTouch) #TOUCH CAPABILITY
self.touch_count = 0 #TOUCH CAPABILITY DEBUGGING COUNTER
self.touch_count_label = CoreLabel(
text='', font_size=15) #TOUCH CAPABILITY DEBUGGING COUNTER
self.key_label = CoreLabel(text='', font_size=15)
self.hud = HUD(self.canvas)
self.gps_status_label = CoreLabel(text='', font_size=12)
self.gps_location_label = CoreLabel(text='', font_size=12)
self.uid_label = CoreLabel(text='UID: ', font_size=12)
self.my_lat = 0
self.my_lon = 0
self.my_heading = 0
self.my_accuracy = 0
self.DEBUG = True
def onTouch(self, touch, arg2):
if self.DEBUG:
print 'touch: ' + str(touch)
print 'arg2: ' + str(arg2)
if touch:
try:
self.hud.myUID = self.hud.data.pickUID(self.hud.myUID)
self.uid_label.text = 'UID: ' + str(self.hud.myUID)
if self.DEBUG: self.touch_count = self.touch_count + 1
except:
print 'Touch event not handled correctly'
def onKeyDown(self, something, keycode, text, something_else, modifiers,
**kwargs):
if self.DEBUG: print('The key', keycode, 'have been pressed')
if self.DEBUG: print(' - text is %r' % text)
if self.DEBUG: print(' - modifiers are %r' % modifiers)
self.hud.scope_canvas.camera.setZoom(int(keycode))
if keycode == ENTER:
self.hud.myUID = self.hud.data.pickUID(self.hud.myUID)
self.uid_label.text = 'UID: ' + str(self.hud.myUID)
def updateDisplay(self, text):
if self.DEBUG: print 'Inside updateDisplay'
self.hud.my_lat = self.my_lat
self.hud.my_lon = self.my_lon
self.hud.my_heading = self.my_heading
self.canvas.clear(
) #Alias for scope_canvas. Actually clears scope_canvas for fresh draw (naming convention can be misleading)
self.hud.scope_canvas.paintDisplayBackground(
) #Reinitializes the canvas with HUD background
self.hud.work(
) #Retrieves data and draws appropriately on HUD background canvas
#TEMPORARY label drawing for debugging purposes
if self.DEBUG:
with self.canvas:
#Display gps_location
Color(.5, 1, 0, mode='rgb')
self.gps_location_label.refresh()
texture = self.gps_location_label.texture
texture_size = list(texture.size)
Rectangle(pos=(BAR_TEXT_OFFSET + 10,
GRAPH_OFFSET_TOP_BOTTOM + 20),
texture=texture,
size=texture_size)
#Display UID
Color(.5, 1, 0, mode='rgb')
self.uid_label.refresh()
texture = self.uid_label.texture
texture_size = list(texture.size)
Rectangle(pos=(HUD_WIDTH - BAR_TEXT_OFFSET - GRAPH_WIDTH - 100,
GRAPH_OFFSET_TOP_BOTTOM - 20),
texture=texture,
size=texture_size)
#Display touch count
Color(.5, 1, 0, mode='rgb')
self.touch_count_label.text = str(self.touch_count)
self.touch_count_label.refresh()
texture = self.touch_count_label.texture
texture_size = list(texture.size)
Rectangle(pos=(HUD_WIDTH - GRAPH_WIDTH - BAR_TEXT_OFFSET - 35,
HUD_HEIGHT / 4),
texture=texture,
size=texture_size)
def playGame(screen, character, currentInfoText):
screen_rect = screen.get_rect()
level = LevelTutorial("level/tutorial/tutorial.txt", character, currentInfoText)
world = level.world
crashman = level.crashman
pygame.mouse.set_visible(True)
camera = Camera(screen, crashman.rect, level)
all_sprite = level.all_sprite
clock = pygame.time.Clock()
up = down = left = right = False
x, y = 0, 0
#randomly selects an enemy port
enemy_list=[]
activePortIndex=random.randrange(len(level.enemy_ports))
activePort=level.enemy_ports[activePortIndex]
#untilNextSpawn=level.spawn_delay
untilNextSpawn=0
totalTime=0
enemyCount=0
hud=HUD()
#this is the while true loop
while crashman.alive :
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
if event.type == KEYDOWN and (event.key == K_ESCAPE or event.key==K_RETURN):
up=down=left=right=False
pauseScreen(screen,character)
#control crashman
keys = pygame.key.get_pressed() #checking pressed keys
if keys[pygame.K_UP] or keys[pygame.K_SPACE]:
up=True
else:
up=False
if keys[pygame.K_DOWN]:
down=True
else:
down=False
if keys[pygame.K_LEFT]:
left=True
else:
left=False
if keys[pygame.K_RIGHT]:
right=True
else:
right=False
#sequential spawn order
if untilNextSpawn<=0 and enemyCount<level.enemy_max:
print "ENEMY HERE NOW"
e=Enemy(activePort[0],activePort[1],activePort[2],level)
enemy_list.append(e)
level.all_sprite.add(e)
world.append(e)
activePortIndex+=1
if activePortIndex>=len(level.enemy_ports):
activePortIndex=0
activePort=level.enemy_ports[activePortIndex]
untilNextSpawn=level.spawn_delay
enemyCount+=1
#random spawn order
"""if untilNextSpawn<=0 and enemyCount<level.enemy_max:
print "ENEMY HERE NOW"
e=Enemy(activePort[0],activePort[1],activePort[2],level)
enemy_list.append(e)
level.all_sprite.add(e)
world.append(e)
activePortIndex=random.randrange(len(level.enemy_ports))
activePort=level.enemy_ports[activePortIndex]
untilNextSpawn=level.spawn_delay
enemyCount+=1"""
#removes dead enemies
for e in enemy_list:
if e.alive==False:
print "ded del thjo"
enemy_list.remove(e)
all_sprite.remove(e)
world.remove(e)
enemyCount-=1
if e.freshkick==True:
hud.enemies_defeated+=1
hud.update()
e.freshkick=False
#timer and spawn countdown
#updates hud time
tpt = tps(clock, FPS)
totalTime+=tpt
if hud.time!=math.floor(totalTime):
hud.time=math.floor(totalTime)
hud.update()
if enemyCount<level.enemy_max:
untilNextSpawn-=tpt
print str(enemyCount)+": "+str(untilNextSpawn)
#DRAW ORDER:
#bg, world, elemental, hud
#camera.draw_sprites(screen, all_sprite)
level.drawBG(screen)
camera.draw_sprites_prio(screen, all_sprite, crashman)
if level.elemental:
level.elementalOverlay.draw(screen)
hud.draw(screen)
level.drawInfo(screen)
#final updates
crashman.update(up, down, left, right)
for e in enemy_list:
e.update(tpt)
camera.update()
pygame.display.flip()
#################################
#game complete
#pygame.display.flip()
playGame(screen,character, level.currentInfoBlock.infoText)
#Probably temporary object init
#SETTINGS.current_level = 5 #temporary
if __name__ == '__main__':
gameLoad = Load()
gameLoad.load_resources()
gameLoad.load_entities()
mapGenerator = GENERATION.Generator()
mapGenerator.generate_levels(5, 4)
gameLoad.get_canvas_size()
#Setup and classes
thanks = TEXT.Text(150, 250, "THANKS FOR PLAYING DUGA TECH DEMO",
SETTINGS.WHITE, "DUGAFONT.ttf", 24)
#Classes for later use
gameMap = MAP.Map(SETTINGS.levels_list[SETTINGS.current_level].array)
gameCanvas = Canvas(SETTINGS.canvas_map_width, SETTINGS.canvas_map_height)
gamePlayer = PLAYER.Player(SETTINGS.player_pos)
gameRaycast = RAYCAST.Raycast(gameCanvas.canvas, gameCanvas.window)
gameInv = INVENTORY.inventory({'bullet': 150, 'shell': 25, 'ferromag': 50})
gameHUD = HUD.hud(path.join('graphics', 'hud.png'))
#More loading - Level specific
gameLoad.load_new_level()
#Run at last
main_loop()
screen = pygame.display.set_mode(size)
sound_profile = Sounds()
Splash().start_screen(screen, GetImage('Rules.png').load_image())
motion_events_1 = [26, 4, 22, 7]
motion_events_2 = [82, 80, 81, 79]
change_event_1 = 44
change_event_2 = 229
forfeit_event_1 = 9
forfeit_event_2 = 228
board_width = 7
board_height = 7
board = Board(board_width, board_height, size)
hud = HUD.Hud(size, board_width * board.cell_size, screen)
game = Game.Game(board_width * board_height - 2, hud, sound_profile)
running = True
screen.fill((255, 255, 255))
board.render(screen)
board.set_players()
pygame.display.flip()
while running:
if game.won or game.check_end():
pass
else:
board.update(screen)
board.render(screen)
hud.draw(game, board.player1, board.player2)
def launch(self, diff):
print('Launching game ...')
self.screen = pygame.display.set_mode(
[self.screen_width, self.screen_height])
pygame.display.set_caption("Road to Mordor")
self.clock = pygame.time.Clock()
self.joueur = joueur_classe.Joueur("Player 1", "humain", 1)
self.joueurIA = joueur_classe.Joueur("Computer", "orc", 0)
self.hud = HUD.UserInterface(self.screen, self.joueur, self.joueurIA)
self.grille = grille_classe.Grille(
16, 20, diff, self.screen.subsurface((205, 50, 1000, 800)),
self.hud, self.joueurIA, self.joueur)
self.IA = IA.IA(self.grille, self.joueurIA)
self.ig_menu = ig_menu_classe.InGameMenu(self.screen)
self.rules = regles_classe.Regles(self.screen)
self.game_over = fin_jeu.Fin(self.screen)
pygame.mixer.music.load('Musique/Musiquedefond.mp3')
pygame.mixer.music.play(-1)
turn = 0
done = False
show_regles = False
show_gameOver = False
# -------- Main Program Loop -----------
keys_pressed = dict()
pygame.event.Event(pygame.USEREVENT, {'key': 0, 'unicode': ''})
while not done:
turn += 1
# --- Main event loop
for event in pygame.event.get():
#print('EVENT ', pygame.event.event_name(event.type))
if event.type == pygame.QUIT:
print('Ending game ... and QUIT !')
return False
elif event.type == pygame.KEYDOWN:
#keys_pressed[event.key] = {'key': event.key, 'unicode': event.unicode} # Create KEYPRESS events
if len(keys_pressed) > 0:
pygame.time.set_timer(pygame.USEREVENT, 150)
if self.paused:
if show_regles:
show_regles = False
else:
if event.key == pygame.K_RETURN:
res_m = self.ig_menu.getSelected()
if res_m == 0:
pygame.mixer.music.unpause()
self.paused = False
elif res_m == 1:
show_regles = True
elif res_m == 2:
self.paused = False
print('Ending game ...')
return True
elif event.key == pygame.K_ESCAPE:
self.paused = False
pygame.mixer.music.unpause()
elif event.key == pygame.K_LEFT:
self.ig_menu.selectPrev()
else:
self.ig_menu.switchSelected()
elif show_gameOver:
print('Ending game ...')
self.game_over.stop()
return True
else:
# Handle KEYDOWN
if event.unicode == 'd':
self.hud.selectNext()
elif event.unicode == 'q': # Q sur un Azerty
self.hud.selectPrev()
elif event.unicode == 'a': # A sur un Azerty
self.hud.switchMode()
elif event.unicode == '-':
print('- HEY !')
elif event.unicode == '.':
self.joueurIA.setVieChateau(0)
elif event.key == pygame.K_ESCAPE:
self.paused = True
pygame.mixer.music.pause()
elif event.key == pygame.K_UP:
self.grille.selectUp()
elif event.key == pygame.K_DOWN:
self.grille.selectDown()
elif event.key == pygame.K_LEFT:
self.grille.selectLeft()
elif event.key == pygame.K_RIGHT:
self.grille.selectRight()
elif event.key == pygame.K_RETURN:
if self.hud.canUse():
if self.hud.getMode() == 'towers':
if self.grille.canBuild(
self.grille.getSelected(),
self.joueur.getEquipe()):
tour = self.joueur.createBuild(
self.hud.getSelected(),
self.grille,
self.grille.getSelected())
if tour == False:
self.hud.showMessage(
"Argent insufisant ...", 70)
print('Argent insufisant')
else:
self.grille.place(tour)
self.hud.use()
else:
self.hud.showMessage(
"Placement impossible !", 70)
print('Placement impossible')
else:
if self.grille.canSpawn(
self.grille.getRoute(),
self.joueur.getEquipe()):
unit = self.joueur.createUnit(
self.hud.getSelected(),
self.grille,
self.grille.getRoute())
if unit == False:
self.hud.showMessage(
"Argent insufisant ...", 70)
print('Argent insufisant')
else:
self.grille.place(unit)
self.hud.use()
else:
self.hud.showMessage(
"Placement impossible !", 70)
print('Placement impossible')
else:
self.hud.showMessage("Cooldown en cours.", 70)
print('Cooldown en cours')
"""
elif event.type == pygame.KEYUP:
keys_pressed.pop(event.key) # Create KEYPRESS events
if len(keys_pressed)<=0:
pygame.time.set_timer(pygame.USEREVENT,0) # Remove timer
elif event.type == pygame.USEREVENT:
for key,item in keys_pressed.iteritems():
if key == pygame.K_UP:
self.grille.selectUp()
elif key == pygame.K_DOWN:
self.grille.selectDown()
elif key == pygame.K_LEFT:
self.grille.selectLeft()
elif key == pygame.K_RIGHT:
self.grille.selectRight()
"""
# --- Game logic should go here
#pygame.display.update()
self.screen.fill((75, 75, 75))
if self.paused:
if show_regles:
self.rules.draw()
else:
self.ig_menu.draw()
elif show_gameOver:
self.game_over.draw()
else:
self.grille.draw()
self.hud.draw()
if turn % 300 == 0:
self.joueur.recevoirArgent(100)
self.joueurIA.recevoirArgent(100)
if turn % 5 == 0:
self.IA.play()
if turn % 10 == 0:
self.grille.play()
# --- Check if the game is over
if self.joueur.getVieChateau() == 0 and not show_gameOver:
show_gameOver = True
pygame.mixer.music.stop()
self.game_over.start(False)
elif self.joueurIA.getVieChateau() == 0 and not show_gameOver:
show_gameOver = True
pygame.mixer.music.stop()
self.game_over.start(True)
# --- Go ahead and update the screen with what we've drawn.
pygame.display.flip()
# --- Limit to 60 frames per second
self.clock.tick(60)
# Close the window and quit.
print('Ending game ...')
return True
def on_draw(self):
arcade.start_render()
if self.empezado:
if self.pausado:
HUD.dibujar_hud_pausado(self.buffs_activos)
elif self.final_malo:
HUD.dibujar_hud_gameover(True)
elif self.jugador.muerto:
HUD.dibujar_hud_gameover(False)
else:
# Draw the background texture
arcade.draw_lrwh_rectangle_textured(0, 0,
SCREEN_WIDTH, SCREEN_HEIGHT,
self.rooms[self.current_room].background)
HUD.dibujar_hud(self.vida_jugador, self.carga_fantasmal_jugador)
if self.jugador.estado_fantasmal:
HUD.dibujar_contador_de_muerte(self.jugador.contador_de_muerte)
self.rooms[self.current_room].wall_list.draw()
self.player_list.draw()
self.bullet_list.draw()
self.lista_balas_laser.draw()
self.lista_balas_gas.draw()
self.lista_balas_boss.draw()
# Mostramos mensajes relacionados con los buffs que vayamos cogiendo
if self.recogido_buff1:
HUD.mostrar_mensaje_buff(1)
if self.contador_quitar_mensaje == 0:
self.recogido_buff1 = False
self.contador_quitar_mensaje = 600
else:
self.contador_quitar_mensaje -= 1
elif self.recogido_buff2:
HUD.mostrar_mensaje_buff(2)
if self.contador_quitar_mensaje == 0:
self.recogido_buff2 = False
self.contador_quitar_mensaje = 600
else:
self.contador_quitar_mensaje -= 1
elif self.recogido_buff3:
HUD.mostrar_mensaje_buff(3)
if self.contador_quitar_mensaje == 0:
self.recogido_buff3 = False
self.contador_quitar_mensaje = 600
else:
self.contador_quitar_mensaje -= 1
elif self.recogido_buff4:
HUD.mostrar_mensaje_buff(4)
if self.contador_quitar_mensaje == 0:
self.recogido_buff4 = False
self.contador_quitar_mensaje = 600
else:
self.contador_quitar_mensaje -= 1
elif self.recogido_buff5:
HUD.mostrar_mensaje_buff(5)
if self.contador_quitar_mensaje == 0:
self.recogido_buff5 = False
self.contador_quitar_mensaje = 600
else:
self.contador_quitar_mensaje -= 1
self.rooms[self.current_room].recargas_list.draw()
if self.rooms[self.current_room].buffs_list is not None:
self.rooms[self.current_room].buffs_list.draw()
HUD.dibujar_partes_artefacto(self.buffs_activos)
self.rooms[self.current_room].enemigos_list.draw()
self.rooms[self.current_room].boss_list.draw()
self.rooms[self.current_room].balas_list.draw()
if self.current_room == 68:
# Ponemos a la dama observando
if len(self.dama_list) == 0 and not self.ending_activado: # para poner solo 1 dama a la vez
self.dama_list.append(self.dama_fant_der)
if self.ending_activado:
if self.contador_espera_mover_dama == 0:
# Ponemos a la dama en la habitacion
if len(self.dama_list) == 0:
self.dama_list.append(self.dama_fant_abajo)
if self.contador_espera_poner_artefacto == 0:
# Ponemos el dispositivo fantasmal
disp_f = arcade.load_texture("sprites_master" + os.path.sep + "DISPOSITIVOFANTASMA.png")
arcade.draw_texture_rectangle(self.jugador.center_x, self.jugador.center_y + 100, 50,
50,
disp_f)
if self.contador_espera_transformar_dama == 0:
if self.dama_fant_abajo in self.dama_list:
self.dama_list.pop(0)
self.dama_list.append(self.dama_abajo)
if self.contador_espera_pantalla_final == 0:
# Dibujamos la pantalla final
self.dama_list.pop(0)
HUD.dibujar_pantalla_final()
else:
self.contador_espera_pantalla_final -= 1
else:
self.contador_espera_transformar_dama -= 1
else:
self.contador_espera_poner_artefacto -= 1
else:
self.contador_espera_mover_dama -= 1
self.dama_list.draw()
else:
if self.mirando_controles:
HUD.dibujar_controles()
else:
HUD.dibujar_pantalla_de_inicio()
class GameManager(object):
screen = None
buffer = None
gameObject = None
targetFPS = 60
clock = None
buttonHandler = None
hud = HUD.HUD()
drawHUD = True
piFaceManager = None
gameState = None
needQuit = False
sound = None
def __init__(self,
initialGameObject,
targetFPS,
buttonHandler,
piFaceManager,
test=False):
if test:
self.initializeTest()
else:
self.gameState = GameStateSaver.GameStateSaver()
self.gameObject = initialGameObject
self.hud.gameState = self.gameState
self.targetFPS = targetFPS
self.buttonHandler = buttonHandler
self.piFaceManager = piFaceManager
self.initialize()
return super(GameManager, self).__init__()
def setCurrentGameObject(self, gameObject):
if not gameObject.initialized:
pygame.time.set_timer(USEREVENT + 1, 0)
pygame.time.set_timer(USEREVENT + 2, 0)
gameObject.gameManager = self
gameObject.initialize()
self.buttonHandler.unlock()
self.gameObject = gameObject
self.gameObject.sound = self.sound
self.sound.resetGameObjectSound()
self.piFaceManager.setPlayerButtonColor(0, "off")
gameObject.switchedTo()
self.gameState.save()
def update(self, time, events):
self.gameObject.update(time, events)
self.hud.update(time, events)
def draw(self):
'''Draws current GameObject.
Since fbcon seems to have most performance on raspi but doesn't support double buffering,
a surface is used to simulate double buffering to prevent flickering (won't solve all problems though)'''
self.gameObject.draw(self.buffer)
if self.drawHUD:
self.hud.draw(self.buffer)
self.screen.blit(self.buffer, (0, 0))
def initialize(self):
pygame.init()
self.screen = pygame.display.set_mode(
(1024, 768),
pygame.DOUBLEBUF | pygame.HWSURFACE | pygame.FULLSCREEN)
pygame.mouse.set_visible(True)
self.buffer = pygame.Surface(self.screen.get_size())
self.buffer = self.buffer.convert()
self.buffer.fill((250, 0, 250))
self.screen.blit(self.buffer, (0, 0))
pygame.display.flip()
print "Using driver", pygame.display.get_driver()
print "Set SDL_VIDEODRIVER to change"
print "-----------------------------"
print "Driver Info:"
print pygame.display.Info()
self.clock = pygame.time.Clock()
self.hud.initialize()
self.sound = SoundObject.SoundObject(self.gameState.appdir)
self.gameObject.sound = self.sound
def initializeTest(self):
pygame.init()
self.screen = pygame.display.set_mode(
(1024, 768), pygame.DOUBLEBUF | pygame.HWSURFACE)
pygame.mouse.set_visible(True)
self.buffer = pygame.Surface(self.screen.get_size())
self.buffer = self.buffer.convert()
self.buffer.fill((250, 0, 250))
self.screen.blit(self.buffer, (0, 0))
pygame.display.flip()
print "Using driver", pygame.display.get_driver()
print "Set SDL_VIDEODRIVER to change"
print "-----------------------------"
print "Driver Info:"
print pygame.display.Info()
self.clock = pygame.time.Clock()
font = pygame.font.Font(pygame.font.get_default_font(), 45)
size = font.size("OK")
r = 0
g = 0
b = 255
tor = True
tog = False
tob = False
while 1:
if tor:
r += 1
b -= 1
if b == 0:
tor = False
tog = True
if tog:
g += 1
r -= 1
if r == 0:
tog = False
tob = True
if tob:
b += 1
g -= 1
if g == 0:
tob = False
tor = True
currentMillis = self.clock.tick(self.targetFPS)
events = pygame.event.get()
self.buffer.fill((r, g, b))
self.buffer.blit(font.render("OK", True, (255, 255, 255)),
((1024 - size[0]) / 2, (768 - size[1]) / 2))
self.screen.blit(self.buffer, (0, 0))
pygame.display.flip()
#Handle Input Events - FOR TESTING ONLY - Events have to be checked by the GameObjects...
for event in events:
if event.type == QUIT:
pygame.display.quit()
return
elif event.type == KEYDOWN and event.key == K_ESCAPE:
pygame.display.quit()
return
def run(self):
# try:
while 1:
currentMillis = self.clock.tick(self.targetFPS)
events = pygame.event.get()
self.update(currentMillis, events)
self.draw()
pygame.display.flip()
#Handle Input Events - FOR TESTING ONLY - Events have to be checked by the GameObjects...
for event in events:
if event.type == QUIT:
pygame.display.quit()
self.sound.resetGameObjectSound()
return
elif event.type == KEYDOWN and event.key == K_ESCAPE:
pygame.display.quit()
self.sound.resetGameObjectSound()
return
if self.needQuit:
pygame.display.quit()
self.sound.resetGameObjectSound()
return
from HUD import *
pygame.init()
WINDOW_SIZE = (1024,768)
clock = pygame.time.Clock()
screen = pygame.display.set_mode(WINDOW_SIZE,0,32)
display = pygame.Surface((256,192))
mediator = Mediator()
player = Player(display, 'player', mediator)
mediator.all_game_entities.append(player)
gameMap = GameMap(display, 'tiles', mediator, player)
hud = HUD(display,player)
while True:
display.fill((57, 138, 215))
mediator.all_game_tiles.clear()
gameMap.draw_map()
hud.draw_overlay()
for object in mediator.all_game_entities:
object.loop()
object.draw()
mediator.all_game_entities = [object for object in mediator.all_game_entities if object not in mediator.to_be_removed]
mediator.to_be_removed.clear()
from time import sleep
from HUD import *
from Game import Game
hud = HUD()
game = Game()
game.start()
while game.isRunning:
gameState = game.getState()
game.clearWithHUD()
game.update()
hud.update(gameState[0], gameState[1], gameState[2])
hud.print()
game.render()
# print(game.balls[0].position, game.balls[0].dir, game.balls[0].speed, " ")
sleep(0.06)
def run_Game():
main_menu = Main_menu()
pause_menu = Pause_menu()
main_menu.draw()
onMenu = 1
onGame = 0
tick = 0
while onMenu:
for ev in event.get():
if ev.type == QUIT:
display.quit()
quit()
return
elif ev.type == KEYDOWN:
if not first_screen(main_menu, ev):
if not second_screen(main_menu, ev):
third_screen(main_menu, ev)
main_menu.drawFocus()
if main_menu.current_screen == len(main_menu.screens):
onMenu = 0
onGame = 1
main_menu.current_screen -= 1
display.update()
clock.tick(60)
display.set_mode((1024, 700))
if main_menu.charSelect == 0:
player = WaveController()
else:
player = SpearBearer()
hud = HUD(player)
level = LevelOne()
level.draw()
camera = Camera(level.image.get_size()[0], level.image.get_size()[1])
while onGame:
if level.cleared() == 1:
player.hp = player.hpmax
player.mana = player.manamax
level = LevelTwo()
elif level.cleared() == 2:
player.hp = player.hpmax
player.mana = player.manamax
level = LevelTwoPointOne()
keys = key.get_pressed()
for ev in event.get():
if ev.type == QUIT:
display.quit()
quit()
return
elif ev.type == KEYDOWN:
if ev.key == K_p:
image.save(screen, path + "/.tmp/game.png")
pause_menu.paused()
elif ev.key == K_k:
all_sprites.remove(enemies)
enemies.empty()
else:
player.action(ev.key, tick)
if keys[K_DOWN]:
player.move_down()
level.update(player, 2)
if keys[K_UP]:
level.update(player, 3)
player.move_up()
if keys[K_RIGHT]:
player.move_right()
level.update(player, 1)
if keys[K_LEFT]:
player.move_left()
level.update(player, 0)
check_collisions()
level.draw()
player.update(tick)
all_sprites.draw(screen)
hud.draw(player)
enemies.update(player, tick)
spells.draw(screen)
e_spells.draw(screen)
display.update()
tick += 1
clock.tick(60)
quit()
