def init(self):
self.fighterGroup = pygame.sprite.Group(Fighter(self.width//2,self.height//2,0),
Fighter(self.width//2,self.height//2,1))
self.HealthBars = [HealthBar(0), HealthBar(1)]
self.attackGroup0 = pygame.sprite.Group()
self.attackGroup1 = pygame.sprite.Group()
self.attacks = [self.attackGroup0, self.attackGroup1]
def __init__(self, screen, level, number_level, save):
self.save = save
saved_time = self.save[str(number_level)]['last_time_start']
self.game_start_time = time.time(
) if saved_time is None else saved_time
self.number_level = number_level
self.screen = screen
self.level_pre = level
self.hb_gr = pygame.sprite.Group()
self.hb = HealthBar(self.hb_gr, (20, 20), 4)
self.clock_t = pygame.time.Clock()
self.clock = [0]
self.all_tiles = pygame.sprite.Group()
self.background_group = pygame.sprite.Group()
self.player, x_max, y_max = generate_level(
level,
self.all_tiles,
self.clock,
self.background_group,
pos_pl=self.save[str(number_level)]['last_pos'])
self.spites_start()
self.background = ForrestBackgroundMain(self.screen,
self.background_group,
self.clock, x_max)
self.background_front = ForrestBackgroundFront(self.screen,
self.background_group,
self.clock, x_max)
self.ifpause = False
def renderBlue(self, AIworld):
if not self._is_dead:
self.AIbehaviors.removeAi("pursue")
self.npc.detachNode()
print "Started delete procedure for npc ",
print self.id
self.npc.delete()
self.npc = Actor(
"models/priest", {
"walk": "models/priest-walk",
"attack": "models/priest-attack",
"hurt": "models/priest-hit",
"die": "models/priest-die"
})
self.npcTex = loader.loadTexture("models/tex/guard_blue.png")
self.npc.setTexture(self.npcTex)
self.npc.setScale(0.5, 0.5, 0.5)
self.npc.clearColor()
self.npc.clearColorScale()
self.npc.setColor(255, 0, 0, 0)
self.npc.setColorScale(255, 0, 0, 0)
self.npc.reparentTo(self.render)
self.npc.setPos(self.anchorx, self.anchory, self.anchorz)
AIworld.removeAiChar("npc" + str(self.id))
self.AIchar = AICharacter("npc" + str(self.id), self.npc, 100, 0.05, 5)
self.AIbehaviors = self.AIchar.getAiBehaviors()
AIworld.addAiChar(self.AIchar)
self.hb = HealthBar(1.5, value=self.health)
self.hb.setPos(0, 0, 18.1)
self.hb.reparentTo(self.npc)
def __init__(self, *args):
super(Swordsman, self).__init__(*args)
Character.set_health(self, Swordsman.MAX_HEALTH)
Character.set_speed(self, Swordsman.MOVE_SPEED)
actor = Actor(
"models/swordsman", {
"idle": "models/swordsman-idle",
"walk": "models/swordsman-walk",
"run": "models/swordsman-run",
"hurt": "models/swordsman-hurt",
"die": "models/swordsman-die",
"attack": "models/swordsman-attack"
})
team = Character.get_team(self)
if team == 0:
"""
actor = Actor("models/swordsman_red",
{"idle": "models/swordsman-idle",
"walk": "models/swordsman-walk",
"run": "models/swordsman-run",
"hurt": "models/swordsman-hurt",
"die": "models/swordsman-die",
"attack": "models/swordsman-attack"})
"""
tex = loader.loadTexture("models/textures/swordsman_red.png")
ts = actor.findTextureStage('*')
actor.setTexture(ts, tex, 1)
#ts = actor.findTextureStage('ts')
#actor.setTexture(ts, tex)
elif team == 1:
"""
actor = Actor("models/swordsman_blue",
{"idle": "models/swordsman-idle",
"walk": "models/swordsman-walk",
"run": "models/swordsman-run",
"hurt": "models/swordsman-hurt",
"die": "models/swordsman-die",
"attack": "models/swordsman-attack"})
"""
tex = loader.loadTexture("models/textures/swordsman_blue.png")
ts = actor.findTextureStage('*')
actor.setTexture(ts, tex, 1)
#ts = actor.findTextureStage('ts')
#actor.setTexture(ts, tex)
Character.set_actor(self, actor)
self.hb = HealthBar(1.5, value=Swordsman.MAX_HEALTH)
self.hb.reparentTo(self._floater)
self.hb.setValue(self.get_health())
self.model = loader.loadModel("models/circle")
self.model.setTransparency(True)
self.model.reparentTo(self._character)
self.model.setAlphaScale(0.5)
self.model.setScale(2)
self.model.setPos(0, 0, -10)
def renderBlue(self,AIworld):
if not self._is_dead:
self.AIbehaviors.removeAi("pursue")
self.npc.detachNode()
print "Started delete procedure for npc ",
print self.id
self.npc.delete()
self.npc = Actor("models/priest",
{"walk": "models/priest-walk", "attack":"models/priest-attack", "hurt":"models/priest-hit", "die":"models/priest-die"})
self.npcTex = loader.loadTexture("models/tex/guard_blue.png")
self.npc.setTexture(self.npcTex)
self.npc.setScale(0.5, 0.5, 0.5)
self.npc.clearColor()
self.npc.clearColorScale()
self.npc.setColor(255, 0, 0, 0)
self.npc.setColorScale(255, 0, 0, 0)
self.npc.reparentTo(self.render)
self.npc.setPos(self.anchorx,self.anchory,self.anchorz)
AIworld.removeAiChar("npc"+str(self.id))
self.AIchar = AICharacter("npc"+str(self.id),self.npc, 100, 0.05, 5)
self.AIbehaviors = self.AIchar.getAiBehaviors()
AIworld.addAiChar(self.AIchar)
self.hb = HealthBar(1.5, value=self.health)
self.hb.setPos(0, 0, 18.1)
self.hb.reparentTo(self.npc)
def __init__(self):
Globals.PLAYER_HEALTH = 100
Globals.PLAYER_SCORE = 0
Globals.REMAINING_TIME = 30000
self.tileEngine = TileEngine("test_def.txt", "test_map.txt", 1, 3)
self.camera = Camera(self.tileEngine, pygame.Rect(
0, 0, Globals.WIDTH, Globals.HEIGHT))
self.keyCode = None
self.testPoint = []
self.object_radius = \
self.camera.tileEngine.get_tile_rect().height * 1.5
self.direction = -1
self.has_collided = False
self.enemySprites = pygame.sprite.Group()
self.playerSprites = pygame.sprite.Group()
self.health = HealthBar()
self.score_timer = ScoreTimer()
for x in range(TileTest.NUM_ENEMY):
# fix the positions they are added in and everything else
# should work
self.enemySprites.add(Enemy(Globals.WIDTH, Globals.HEIGHT,
self.camera))
player_x = Globals.WIDTH / 2
player_y = int(Globals.HEIGHT -
self.camera.tileEngine.get_tile_rect().height * 3.5)
self.player = Player(
Globals.WIDTH,
Globals.HEIGHT,
player_x,
player_y,
self.score_timer
)
self.playerSprites.add(self.player)
def __init__(self, *args):
super(Axeman, self).__init__(*args)
Character.set_health(self, Axeman.MAX_HEALTH)
actor = Actor("models/axeman", {"idle": "models/axeman-idle",
"walk": "models/axeman-walk",
"run": "models/axeman-run" ,
"hurt": "models/axeman-hurt",
"die": "models/axeman-die",
"attack": "models/axeman-swing",
"special":"models/axeman-special-attack"})
Character.set_speed(self, Axeman.MOVE_SPEED)
# loda texture based on team
team = Character.get_team(self)
if team == 0:
tex = loader.loadTexture("models/textures/axeman_red.png")
ts = actor.findTextureStage("*")
actor.setTexture(ts, tex, 1)
elif team == 1:
tex = loader.loadTexture("models/textures/axeman_blue.png")
ts = actor.findTextureStage('*')
actor.setTexture(ts, tex, 1)
Character.set_actor(self, actor)
#attach axe
rightHand = self._character.exposeJoint(None, 'modelRoot', 'hand_ctrl_r')
axe = loader.loadModel("models/axe")
axe_tex = loader.loadTexture("models/textures/axe.png")
axe.setTexture(axe_tex, 1)
axe.setPos(-3.0, 0.6, -0.2)
axe.setHpr(0, -90, -90)
axe.setScale(10)
axe.reparentTo(rightHand)
axe.show()
self.hb = HealthBar(1.5, value=Axeman.MAX_HEALTH)
self.hb.reparentTo(self._floater)
self.hb.setValue(self.get_health())
model = loader.loadModel("models/circle")
model.setTransparency(True)
model.reparentTo(self._character)
model.setAlphaScale(0.5)
model.setScale(2)
model.setPos(0, 0, -10)
def __init__(self, controlPointId, id, anchorx, anchory, anchorz, render,
team):
self.id = id
self.anchorx = anchorx
self.anchory = anchory
self.anchorz = anchorz
self.controlPointId = controlPointId
self.target = None
self.isMoving = False
self.health = 200
self.isCurrentUser = False
self.damage = 8
self.attackTimer = 0
self._is_dead = False
self._team = team
self.render = render
'''Initializing NPC actors'''
self.npc = Actor(
"models/priest", {
"walk": "models/priest-walk",
"attack": "models/priest-attack",
"hurt": "models/priest-hit",
"die": "models/priest-die"
})
if self._team == 0:
self.npcTex = loader.loadTexture("models/tex/guard_red.png")
else:
self.npcTex = loader.loadTexture("models/tex/guard_blue.png")
self.npc.setTexture(self.npcTex)
self.npc.setScale(0.5, 0.5, 0.5)
self.npc.clearColor()
self.npc.clearColorScale()
self.npc.setColor(255, 0, 0, 0)
self.npc.setColorScale(255, 0, 0, 0)
self.npc.reparentTo(self.render)
self.npc.setPos(anchorx, anchory, anchorz)
self.AIchar = AICharacter("npc" + str(self.id), self.npc, 100, 0.05, 5)
self.AIbehaviors = self.AIchar.getAiBehaviors()
self.hb = HealthBar(1.5, value=self.health)
#self._floater = NodePath(PandaNode("char_info"))
#self._floater.reparentTo(self.npc)
self.hb.setPos(0, 0, 11.9)
self.hb.reparentTo(self.npc)
def __init__(self, *args):
super(Swordsman, self).__init__(*args)
Character.set_health(self, Swordsman.MAX_HEALTH)
Character.set_speed(self, Swordsman.MOVE_SPEED)
actor = Actor("models/swordsman",
{"idle": "models/swordsman-idle",
"walk": "models/swordsman-walk",
"run": "models/swordsman-run",
"hurt": "models/swordsman-hurt",
"die": "models/swordsman-die",
"attack": "models/swordsman-attack"})
team = Character.get_team(self)
if team == 0:
"""
actor = Actor("models/swordsman_red",
{"idle": "models/swordsman-idle",
"walk": "models/swordsman-walk",
"run": "models/swordsman-run",
"hurt": "models/swordsman-hurt",
"die": "models/swordsman-die",
"attack": "models/swordsman-attack"})
"""
tex = loader.loadTexture("models/textures/swordsman_red.png")
ts = actor.findTextureStage('*')
actor.setTexture(ts, tex, 1)
#ts = actor.findTextureStage('ts')
#actor.setTexture(ts, tex)
elif team == 1:
"""
actor = Actor("models/swordsman_blue",
{"idle": "models/swordsman-idle",
"walk": "models/swordsman-walk",
"run": "models/swordsman-run",
"hurt": "models/swordsman-hurt",
"die": "models/swordsman-die",
"attack": "models/swordsman-attack"})
"""
tex = loader.loadTexture("models/textures/swordsman_blue.png")
ts = actor.findTextureStage('*')
actor.setTexture(ts, tex, 1)
#ts = actor.findTextureStage('ts')
#actor.setTexture(ts, tex)
Character.set_actor(self, actor)
self.hb = HealthBar(1.5, value=Swordsman.MAX_HEALTH)
self.hb.reparentTo(self._floater)
self.hb.setValue(self.get_health())
self.model = loader.loadModel("models/circle")
self.model.setTransparency(True)
self.model.reparentTo(self._character)
self.model.setAlphaScale(0.5)
self.model.setScale(2)
self.model.setPos(0, 0, -10)
def __init__(self, *args):
super(Axeman, self).__init__(*args)
Character.set_health(self, Axeman.MAX_HEALTH)
actor = Actor("models/axeman", {"idle": "models/axeman-idle",
"walk": "models/axeman-walk",
"run": "models/axeman-run" ,
"hurt": "models/axeman-hurt",
"die": "models/axeman-die",
"attack": "models/axeman-swing",
"special":"models/axeman-special-attack"})
Character.set_speed(self, Axeman.MOVE_SPEED)
# loda texture based on team
team = Character.get_team(self)
if team == 0:
tex = loader.loadTexture("models/textures/axeman_red.png")
ts = actor.findTextureStage("*")
actor.setTexture(ts, tex, 1)
elif team == 1:
tex = loader.loadTexture("models/textures/axeman_blue.png")
ts = actor.findTextureStage('*')
actor.setTexture(ts, tex, 1)
Character.set_actor(self, actor)
#attach axe
rightHand = self._character.exposeJoint(None, 'modelRoot', 'hand_ctrl_r')
axe = loader.loadModel("models/axe")
axe_tex = loader.loadTexture("models/textures/axe.png")
axe.setTexture(axe_tex, 1)
axe.setPos(-3.0, 0.6, -0.2)
axe.setHpr(0, -90, -90)
axe.setScale(10)
axe.reparentTo(rightHand)
axe.show()
self.hb = HealthBar(1.5, value=Axeman.MAX_HEALTH)
self.hb.reparentTo(self._character)
model = loader.loadModel("models/circle")
model.setTransparency(True)
model.reparentTo(self._character)
model.setAlphaScale(0.5)
model.setScale(2)
model.setPos(0, 0, -10)
def __init__(self,controlPointId,id, anchorx, anchory, anchorz,render,team):
self.id = id
self.anchorx = anchorx
self.anchory = anchory
self.anchorz = anchorz
self.controlPointId = controlPointId
self.target = None
self.isMoving = False
self.health = 200
self.isCurrentUser = False
self.damage = 8
self.attackTimer = 0
self._is_dead = False
self._team = team
self.render = render
'''Initializing NPC actors'''
self.npc = Actor("models/priest",
{"walk": "models/priest-walk", "attack":"models/priest-attack", "hurt":"models/priest-hit", "die":"models/priest-die"})
if self._team==0:
self.npcTex = loader.loadTexture("models/tex/guard_red.png")
else:
self.npcTex = loader.loadTexture("models/tex/guard_blue.png")
self.npc.setTexture(self.npcTex)
self.npc.setScale(0.5, 0.5, 0.5)
self.npc.clearColor()
self.npc.clearColorScale()
self.npc.setColor(255, 0, 0, 0)
self.npc.setColorScale(255, 0, 0, 0)
self.npc.reparentTo(self.render)
self.npc.setPos(anchorx,anchory,anchorz)
self.AIchar = AICharacter("npc"+str(self.id),self.npc, 100, 0.05, 5)
self.AIbehaviors = self.AIchar.getAiBehaviors()
self.hb = HealthBar(1.5, value=self.health)
#self._floater = NodePath(PandaNode("char_info"))
#self._floater.reparentTo(self.npc)
self.hb.setPos(0, 0, 11.9)
self.hb.reparentTo(self.npc)
class Swordsman(Character):
ATK_RANGE = 8
BASIC_ATK_DMG = 15
SPECIAL_ATK_DMG = 30
MOVE_SPEED = 10
CHARGE_SPEED = 15
MAX_HEALTH = 100
FOV = 60
def __init__(self, *args):
super(Swordsman, self).__init__(*args)
Character.set_health(self, Swordsman.MAX_HEALTH)
Character.set_speed(self, Swordsman.MOVE_SPEED)
actor = Actor("models/swordsman",
{"idle": "models/swordsman-idle",
"walk": "models/swordsman-walk",
"run": "models/swordsman-run",
"hurt": "models/swordsman-hurt",
"die": "models/swordsman-die",
"attack": "models/swordsman-attack"})
team = Character.get_team(self)
if team == 0:
"""
actor = Actor("models/swordsman_red",
{"idle": "models/swordsman-idle",
"walk": "models/swordsman-walk",
"run": "models/swordsman-run",
"hurt": "models/swordsman-hurt",
"die": "models/swordsman-die",
"attack": "models/swordsman-attack"})
"""
tex = loader.loadTexture("models/textures/swordsman_red.png")
ts = actor.findTextureStage('*')
actor.setTexture(ts, tex, 1)
#ts = actor.findTextureStage('ts')
#actor.setTexture(ts, tex)
elif team == 1:
"""
actor = Actor("models/swordsman_blue",
{"idle": "models/swordsman-idle",
"walk": "models/swordsman-walk",
"run": "models/swordsman-run",
"hurt": "models/swordsman-hurt",
"die": "models/swordsman-die",
"attack": "models/swordsman-attack"})
"""
tex = loader.loadTexture("models/textures/swordsman_blue.png")
ts = actor.findTextureStage('*')
actor.setTexture(ts, tex, 1)
#ts = actor.findTextureStage('ts')
#actor.setTexture(ts, tex)
Character.set_actor(self, actor)
self.hb = HealthBar(1.5, value=Swordsman.MAX_HEALTH)
self.hb.reparentTo(self._floater)
self.hb.setValue(self.get_health())
self.model = loader.loadModel("models/circle")
self.model.setTransparency(True)
self.model.reparentTo(self._character)
self.model.setAlphaScale(0.5)
self.model.setScale(2)
self.model.setPos(0, 0, -10)
def basic_attack(self):
total_dmg = Swordsman.BASIC_ATK_DMG
swing_sound = loader.loadSfx("sound/Swoosh.mp3")
if self._atk_buff==1:
total_dmg *= 1.1
elif self._atk_buff==2:
total_dmg *= 1.25
sound_interval = SoundInterval(
swing_sound,
loop = 2 ,
duration = 0.6,
volume = 0.7,
startTime = 0
)
atk_interval1 = self._character.actorInterval("attack", startFrame=1, endFrame=26)
atk_interval2 = self._character.actorInterval("attack", startFrame=56, endFrame=80)
seq = Sequence(atk_interval1, atk_interval2)
if self._is_moving:
seq.append(Func(self.animate, 2))
seq2 = Sequence(Wait(0.5), sound_interval, sound_interval)
seq.start()
seq2.start()
return total_dmg
def special_attack(self):
total_dmg = Swordsman.SPECIAL_ATK_DMG
swing_sound = loader.loadSfx("sound/Swoosh.mp3")
if self._atk_buff==1:
total_dmg *= 1.1
elif self._atk_buff==2:
total_dmg *= 1.25
sound_interval = SoundInterval(
swing_sound,
loop = 2 ,
duration = 0.8,
volume = 0.7,
startTime = 0
)
atk_interval1 = self._character.actorInterval("attack", startFrame=1, endFrame=13)
atk_interval2 = self._character.actorInterval("attack", startFrame=38, endFrame=80)
seq = Sequence(atk_interval1, atk_interval2)
if self._is_moving:
seq.append(Func(self.animate, 2))
seq2 = Sequence(Wait(0.5), sound_interval, sound_interval)
seq.start()
seq2.start()
return total_dmg
def take_damage(self, health_change):
health = Character.get_health(self)
if health < health_change and not self._is_dead:
Character.set_health(self, 0)
self.hb.setValue(0)
hurt_interval = self._character.actorInterval("hurt")
death_interval = self._character.actorInterval("die")
seq = Sequence(hurt_interval, death_interval)
seq.append(Wait(2))
# add Func interval to place the character at a new location
seq.append(Func(self.respawn))
seq.start()
self._is_dead = True
#self._is_moving=2
else:
Character.set_health(self, health-health_change)
#self.hb.setValue(Character.get_health(self)-health_change)
self.hb.setValue(Character.get_health(self))
self._character.play("hurt")
def apply_def_buff(self):
if not self._is_dead:
health = Character.get_health(self)
if self._def_buff==1:
Character.set_health(self, health*1.1)
Swordsman.MAX_HEALTH = Swordsman.MAX_HEALTH*1.1
elif self._def_buff==2:
Character.set_health(self, health*1.25)
Swordsman.MAX_HEALTH = Swordsman.MAX_HEALTH*1.25
def unapply_def_buff(self):
if not self._is_dead:
if self._def_buff==0:
Swordsman.MAX_HEALTH = 100
elif Swordsman.MAX_HEALTH==125 and self._def_buff==1:
Swordsman.MAX_HEALTH = 110
health = Character.get_health(self)
if health > Swordsman.MAX_HEALTH:
health = Swordsman.MAX_HEALTH
def animate(self, anim_type):
if anim_type==0:
self._character.loop("idle")
elif anim_type==1:
self._character.loop("walk")
elif anim_type==2:
self._character.loop("run")
elif anim_type==3:
atk_interval1 = self._character.actorInterval("attack", startFrame=1, endFrame=26)
atk_interval2 = self._character.actorInterval("attack", startFrame=56, endFrame=80)
seq = Sequence(atk_interval1, atk_interval2)
seq.start()
elif anim_type==4:
atk_interval1 = self._character.actorInterval("attack", startFrame=1, endFrame=13)
atk_interval2 = self._character.actorInterval("attack", startFrame=38, endFrame=80)
seq = Sequence(atk_interval1, atk_interval2)
seq.start()
elif anim_type==5:
self._character.play("hurt")
elif anim_type==6:
self._character.play("die")
def respawn(self):
self._is_moving=2
self._character.loop("idle")
def redrawAll(self, screen):
self.fighterGroup.draw(screen)
for HealthBar in self.HealthBars:
HealthBar.drawHealth(screen)
for group in self.attacks:
group.draw(screen)
class Npc():
def __init__(self,controlPointId,id, anchorx, anchory, anchorz,render,team):
self.id = id
self.anchorx = anchorx
self.anchory = anchory
self.anchorz = anchorz
self.controlPointId = controlPointId
self.target = None
self.isMoving = False
self.health = 200
self.isCurrentUser = False
self.damage = 8
self.attackTimer = 0
self._is_dead = False
self._team = team
self.render = render
'''Initializing NPC actors'''
self.npc = Actor("models/priest",
{"walk": "models/priest-walk", "attack":"models/priest-attack", "hurt":"models/priest-hit", "die":"models/priest-die"})
if self._team==0:
self.npcTex = loader.loadTexture("models/tex/guard_red.png")
else:
self.npcTex = loader.loadTexture("models/tex/guard_blue.png")
self.npc.setTexture(self.npcTex)
self.npc.setScale(0.5, 0.5, 0.5)
self.npc.clearColor()
self.npc.clearColorScale()
self.npc.setColor(255, 0, 0, 0)
self.npc.setColorScale(255, 0, 0, 0)
self.npc.reparentTo(self.render)
self.npc.setPos(anchorx,anchory,anchorz)
self.AIchar = AICharacter("npc"+str(self.id),self.npc, 100, 0.05, 5)
self.AIbehaviors = self.AIchar.getAiBehaviors()
self.hb = HealthBar(1.5, value=self.health)
#self._floater = NodePath(PandaNode("char_info"))
#self._floater.reparentTo(self.npc)
self.hb.setPos(0, 0, 11.9)
self.hb.reparentTo(self.npc)
#self.hb.reparentTo(self.npc)
def renderBlue(self,AIworld):
if not self._is_dead:
self.AIbehaviors.removeAi("pursue")
self.npc.detachNode()
print "Started delete procedure for npc ",
print self.id
self.npc.delete()
self.npc = Actor("models/priest",
{"walk": "models/priest-walk", "attack":"models/priest-attack", "hurt":"models/priest-hit", "die":"models/priest-die"})
self.npcTex = loader.loadTexture("models/tex/guard_blue.png")
self.npc.setTexture(self.npcTex)
self.npc.setScale(0.5, 0.5, 0.5)
self.npc.clearColor()
self.npc.clearColorScale()
self.npc.setColor(255, 0, 0, 0)
self.npc.setColorScale(255, 0, 0, 0)
self.npc.reparentTo(self.render)
self.npc.setPos(self.anchorx,self.anchory,self.anchorz)
AIworld.removeAiChar("npc"+str(self.id))
self.AIchar = AICharacter("npc"+str(self.id),self.npc, 100, 0.05, 5)
self.AIbehaviors = self.AIchar.getAiBehaviors()
AIworld.addAiChar(self.AIchar)
self.hb = HealthBar(1.5, value=self.health)
self.hb.setPos(0, 0, 18.1)
self.hb.reparentTo(self.npc)
#self.hb.reparentTo(self.npc)
def renderRed(self,AIworld):
if not self._is_dead:
self.AIbehaviors.removeAi("pursue")
self.npc.detachNode()
self.npc.delete()
self.npc = Actor("models/priest",
{"walk": "models/priest-walk", "attack":"models/priest-attack", "hurt":"models/priest-hit", "die":"models/priest-die"})
self.npcTex = loader.loadTexture("models/tex/guard_red.png")
self.npc.setTexture(self.npcTex)
self.npc.setScale(0.5, 0.5, 0.5)
self.npc.clearColor()
self.npc.clearColorScale()
self.npc.setColor(255, 0, 0, 0)
self.npc.setColorScale(255, 0, 0, 0)
self.npc.reparentTo(self.render)
self.npc.setPos(self.anchorx,self.anchory,self.anchorz)
AIworld.removeAiChar("npc"+str(self.id))
self.AIchar = AICharacter("npc"+str(self.id),self.npc, 100, 0.05, 5)
self.AIbehaviors = self.AIchar.getAiBehaviors()
AIworld.addAiChar(self.AIchar)
AIworld.update()
self.hb = HealthBar(1.5, value=self.health)
self.hb.setPos(0, 0, 8.1)
self.hb.reparentTo(self.npc)
def switchTeam(self,AIworld):
print self.id,
print " from team ",
print self._team,
print " getting deleted."
if self._team==0:
self._team=1
self.renderBlue(AIworld)
else:
self._team=0
self.renderRed(AIworld)
if self.isCurrentUser:
main.freeDeadNpc(self.id)
self.target = None
self.isMoving = False
self.health = 200
self.isCurrentUser = False
self.damage = 8
self.attackTimer = 0
self._is_dead = False
def set_health(self, health):
self.health = health
def take_damage(self, health_change):
health = self.health
if health <= health_change and not self._is_dead:
self.killNpc()
else:
health = health-health_change
self.set_health(health)
self.hb.setValue(self.health)
self.npc.play("hurt")
def killNpc(self):
self.set_health(0)
self.hb.setValue(0)
self.AIbehaviors.removeAi("pursue")
hurt_interval = self.npc.actorInterval("hurt")
death_interval = self.npc.actorInterval("die")
seq = Sequence(hurt_interval, death_interval)
seq.start()
self.npc.pose("die",45)
self._is_dead = True
self.npc.detachNode()
if self.isCurrentUser:
main.freeDeadNpc(self.id)
#main.cManager.sendRequest(Constants.CMSG_NPCDEATH, [self.id])
print Constants.CMSG_NPCDEATH,
print " + ",
print self.id
def chaseTarget(self, target, status = False):
if(not self.isMoving):
self.target = target
self.AIbehaviors.pursue(self.target)
self.npc.loop("walk")
self.isMoving = True
self.isCurrentUser = status
def stopChase(self):
#self.AIbehaviors.pauseAi("pursue")
if not self._is_dead:
self.AIbehaviors.removeAi("pursue")
p1 = LerpHprInterval(self.npc, 4, Point3(180,0,0))
p2 = LerpPosInterval(self.npc, 4, Point3(self.anchorx, self.anchory, self.anchorz))
animInterval = self.npc.actorInterval("walk", loop = 1, duration=4)
p2.start()
p1.start()
animInterval.start()
self.isMoving = False
self.target = None
self.isCurrentUser = False
def givNPCDistance(self,charachter):
x = self.npc.getX()
y = self.npc.getY()
z = self.npc.getZ()
minDist = math.sqrt( (charachter.getX()-x)*(charachter.getX()-x) + (charachter.getY()-y)*(charachter.getY()-y) + (charachter.getZ()-z)*(charachter.getZ()-z) )
return minDist
def checkNpcIsAlive(self):
if(self.health>0):
return True
else:
return False
def shouldAttack(self,currentTime,cManager):
if not self._is_dead:
if self.isMoving:
if self.attackTimer>0:
self.attackTimer = self.attackTimer-currentTime
#print self.attackTimer
if self.AIbehaviors.behaviorStatus("pursue")=="done":
#self.npc.stop("walk")
#print self.npc.getAnimControl("walk")
if self.attackTimer<=0:
if self.npc.getAnimControl("walk").isPlaying():
self.npc.stop("walk")
if not self.npc.getAnimControl("attack").isPlaying():
#self.npc.loop("attack")
self.npc.play("attack")
self.attackTimer = 2
#myInterval = self.npc.actorInterval("attack")
#seq = Sequence(myInterval)
#seq.append(Wait(3))
#seq.start()
if self.isCurrentUser:
cManager.sendRequest(Constants.CMSG_NPCATTACK, [self.id, self.damage])
if self.AIbehaviors.behaviorStatus("pursue")=="active":
if self.npc.getAnimControl("attack").isPlaying():
self.npc.stop("attack")
if not self.npc.getAnimControl("walk").isPlaying():
self.npc.loop("walk")
#----------------characters/environment-------------------
man = Man(4, [40, 40])
man.haveNothing = True
zombies = []
robots = []
stick = Stick([125, 125])
stick2 = Stick([50, 420])
stick3 = Stick([660, 120])
stick4 = Stick([500, 450])
electricitys = []
maxelectricitys = 2
pistols = []
maxPistols = 5
projectiles = []
maxProjectiles = 2
healthBar = HealthBar([695, 2])
winBlock = WinBlock([790, 560])
if mode == "":
maxZombies = 15
maxRobots = 15
mode = "medium"
medium.clicked = True
medium.select()
while not run and not man.living and not man.win and not difficultyScreen:
for event in pygame.event.get():
if event.type == pygame.QUIT: sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
if singlePlayer.collidePt(event.pos):
def __init__(self,
definition_path,
map_path,
init_music_path=None,
music_path=None,
music_loops=-1,
has_timer=True,
should_fade_in=True,
mid=0):
self.has_timer = has_timer
self.keyCode = None
self.definition_path = definition_path
self.map_path = map_path
self.tile_engine = TileEngine(join(Level.MAP_BASE, definition_path),
join(Level.MAP_BASE, map_path))
self.camera = Camera(self.tile_engine,
pygame.Rect(0, 0, Globals.WIDTH, Globals.HEIGHT))
self.tile_rect = self.tile_engine.get_tile_rect()
self.enemySprites = pygame.sprite.Group()
self.playerSprites = pygame.sprite.Group()
self.turrets = list()
self.lights = list()
self.init_player()
self.init_enemies()
self.timer = None
if Globals.HEALTH_BAR is None:
Globals.HEALTH_BAR = HealthBar()
if Globals.HUD_MANAGER is None:
Globals.HUD_MANAGER = HUDManager()
self.black_surf = pygame.Surface(
(Globals.WIDTH, Globals.HEIGHT)).convert()
self.black_surf.fill((0, 0, 0))
self.fade_in = False
self.fade_out = False
self.showing_subtitle = False
self.alpha_factor = 300
self.should_fade_in = should_fade_in
self.pausing = False
self.going_back = False
self.score_counted = False
self.respawn_coords = [-1, -1]
self.timer = None
self.first_occur = True
self.find_respawn()
self.loader = AssetLoader('images', 'sounds')
self.switch_sound = self.loader.load_sound(Level.SWITCH_SOUND_PATH)
self.channel = None
self.music_loops = music_loops
self.music_handle = None
if music_path is not None:
self.background_music_handle = self.loader.load_sound(music_path)
self.music_handle = self.background_music_handle
else:
self.background_music_handle = None
if init_music_path is not None:
self.init_music_handle = self.loader.load_sound(init_music_path)
self.music_handle = self.init_music_handle
else:
self.init_music_handle = None
self.time_init = 0
self.start_on_stop = True
self.switched_sound = False
self.music_end_id = Level.MUSIC_END_ID_BASE + mid
self.can_open_doors = True
class Axeman(Character):
BASIC_ATK_DMG = 12
SPECIAL_ATK_DMG = 40
MAX_HEALTH = 120
ATK_RANGE = 8
MOVE_SPEED = 8
FOV = 60
def __init__(self, *args):
super(Axeman, self).__init__(*args)
Character.set_health(self, Axeman.MAX_HEALTH)
actor = Actor("models/axeman", {"idle": "models/axeman-idle",
"walk": "models/axeman-walk",
"run": "models/axeman-run" ,
"hurt": "models/axeman-hurt",
"die": "models/axeman-die",
"attack": "models/axeman-swing",
"special":"models/axeman-special-attack"})
Character.set_speed(self, Axeman.MOVE_SPEED)
# loda texture based on team
team = Character.get_team(self)
if team == 0:
tex = loader.loadTexture("models/textures/axeman_red.png")
ts = actor.findTextureStage("*")
actor.setTexture(ts, tex, 1)
elif team == 1:
tex = loader.loadTexture("models/textures/axeman_blue.png")
ts = actor.findTextureStage('*')
actor.setTexture(ts, tex, 1)
Character.set_actor(self, actor)
#attach axe
rightHand = self._character.exposeJoint(None, 'modelRoot', 'hand_ctrl_r')
axe = loader.loadModel("models/axe")
axe_tex = loader.loadTexture("models/textures/axe.png")
axe.setTexture(axe_tex, 1)
axe.setPos(-3.0, 0.6, -0.2)
axe.setHpr(0, -90, -90)
axe.setScale(10)
axe.reparentTo(rightHand)
axe.show()
self.hb = HealthBar(1.5, value=Axeman.MAX_HEALTH)
self.hb.reparentTo(self._floater)
self.hb.setValue(self.get_health())
model = loader.loadModel("models/circle")
model.setTransparency(True)
model.reparentTo(self._character)
model.setAlphaScale(0.5)
model.setScale(2)
model.setPos(0, 0, -10)
def basic_attack(self):
total_dmg = Axeman.BASIC_ATK_DMG
swing_sound = loader.loadSfx("sound/Woosh.wav")
if self._atk_buff==1:
total_dmg *= 1.1
elif self._atk_buff==2:
total_dmg *= 1.25
# play animation
sound_interval1 = SoundInterval(
swing_sound,
loop = 1 ,
duration = 0,
volume = 0.7,
startTime = 0
)
seq2 = Sequence(Wait(0.5),sound_interval1, sound_interval1)
#self._character.play("attack")
atk_interval = self._character.actorInterval("attack")
seq = Sequence(atk_interval)
if self._is_moving:
seq.append(Func(self.animate, 2))
seq.start()
seq2.start()
return total_dmg
def special_attack(self):
total_dmg = Axeman.SPECIAL_ATK_DMG
if self._atk_buff==1:
total_dmg *= 1.1
elif self._atk_buff==2:
total_dmg *= 1.25
#self._character.play("special",fromFrame = 10)
atk_interval = self._character.actorInterval("special", startFrame=10)
seq = Sequence(atk_interval)
if self._is_moving:
seq.append(Func(self.animate, 2))
seq.start()
return total_dmg
def apply_def_buff(self):
if not self._is_dead:
health = Character.get_health(self)
if self._def_buff==1:
Character.set_health(self, health*1.1)
Axeman.MAX_HEALTH = Axeman.MAX_HEALTH*1.1
elif self._def_buff==2:
Character.set_health(self, health*1.25)
Axeman.MAX_HEALTH = Axeman.MAX_HEALTH*1.25
def unapply_def_buff(self):
if not self._is_dead:
if self._def_buff==0:
Axeman.MAX_HEALTH = 100
elif Axeman.MAX_HEALTH==140 and self._def_buff==1:
Axeman.MAX_HEALTH = 110
health = Character.get_health(self)
if health > Axeman.MAX_HEALTH:
health = Axeman.MAX_HEALTH
pass
def take_damage(self, health_change):
health = Character.get_health(self)
if health <= health_change and not self._is_dead:
Character.set_health(self, 0)
self.hb.setValue(0)
hurt_interval = self._character.actorInterval("hurt")
death_interval = self._character.actorInterval("die")
seq = Sequence(hurt_interval, death_interval)
seq.append(Wait(2))
seq.append(Func(self.respawn))
seq.start()
self._is_dead = True
else:
Character.set_health(self, health-health_change)
#self.hb.setValue(Character.get_health(self)-health_change)
self.hb.setValue(Character.get_health(self))
self._character.play("hurt")
def animate(self, anim_type):
if anim_type==0:
self._character.loop("idle")
elif anim_type==1:
self._character.loop("walk")
elif anim_type==2:
self._character.loop("run")
elif anim_type==3:
self._character.play("attack")
elif anim_type==4:
self._character.play("special",fromFrame = 10)
elif anim_type==5:
self._character.play("hurt")
elif anim_type==6:
self._character.play("die")
def respawn(self):
self._is_moving=2
self._character.loop("idle")
class Game(PygameGame):
def levelUpInit(self):
self.letterX = 0
self.lvl = 1
self.letterLst = ["%s" % self.lvl, ":", "l", "e", "v", "e", "L"]
self.letterIndex = -1
self.letters = []
self.letterCounter = 0
self.letterNum = 0
self.lvlUp = True
self.letterTimer = 0
GameDrops = pygame.sprite.Group()
def init(self):
self.levelUpInit()
super(Game, self).__init__()
self.s = StartScreen()
self.bgColor = (0, 0, 0)
Enemy.poses()
self.startWall = Wall(0, 360, 400, 360)
self.endWall = Wall(1600, 360, 400, 360)
self.bulletGroup = pygame.sprite.Group()
self.player = Player(50, 340, "Stand", False)
self.players = pygame.sprite.GroupSingle(self.player)
self.enemies = pygame.sprite.Group()
self.gravity = True
self.walls = [
self.startWall,
Slant(400, 360, 800, 300, 800, 360),
Wall(800, 300, 400, 360),
Slant(1200, 300, 1600, 360, 1200, 360), self.endWall
]
self.BackGround = Background("background")
self.jumpingUp = False
self.jumpCounter = 0
self.runCounter = 0
self.dir = "Right"
self.jumpingCounter = 0
self.shooting = False
self.shootCounter = 0
self.falling = None
self.jumpingRight = False
self.jumpingLeft = False
self.enemyRunCounter = 0
self.homingMissles = pygame.sprite.GroupSingle()
self.rotateCount = 1
self.aimMode = False
self.target = Target()
self.rotatedTarget = self.target.rotate(self.rotateCount)
self.targetX, self.targetY = 100, 100
self.healthBar = HealthBar(0, 0, self.width, self.height)
self.homing = False
self.isKilled = False
self.enemyBulletGroup = pygame.sprite.Group()
self.bloodGroup = pygame.sprite.Group()
self.scrollX = 0
self.lockedOn = False
self.missiles = 0
self.spawnCounter, self.spawnTrigger = 0, random.randint(5, 25)
self.health = 160
self.enemiesSpawned = 0
self.enemyLimit = 10
self.enemyNum = 10
self.myfont = pygame.font.SysFont('Comic Sans MS', (30))
self.text = self.myfont.render('Enemies: %s' % self.enemyNum, False,
(0, 0, 0))
self.textW, self.textH = self.text.get_size()
self.enemyLevel = 0
self.gameOver = False
self.jumping = False
self.v = 6.5
self.gameWon = False
self.Flash = False
self.gameOverScreen = Background("Gameover")
self.gameOverText = self.myfont.render('Press X to Restart', False,
(0, 0, 0))
self.gameWonScreen = Background("Gamewon")
pygame.mixer.set_num_channels(2)
pygame.mixer.init()
pygame.mixer.music.load('images/backMusic.ogg')
pygame.mixer.music.play()
self.actived = pygame.mixer.Sound('images/missileActivated.ogg')
self.endMusic = False
self.pause = False
self.pauseImage = pygame.transform.scale(
pygame.image.load('images/pause.png'), (200, 200))
def findY(self, x): #enable running over slopes and hills
for wall in self.walls:
if type(wall).__name__ == "Wall":
if wall.x1 <= x < wall.x1 + wall.x2:
slope = 0
return wall.y1
else:
if wall.x1 <= x < wall.x2:
slope = ((500 - wall.y2) -
(500 - wall.y1)) / (wall.x2 - wall.x1)
y = 500 - ((slope * (x - wall.x1)) + (500 - wall.y1))
if slope < 0:
y = 500 - ((slope * (x - wall.x1)) + (500 - wall.y1))
return y
def checkBounds(self):
x = random.randrange(0, self.width)
if x < self.player.x - 50 or x > self.player.x + 50:
return x
else:
return self.checkBounds()
def spawn(self):
self.spawnCounter += 1
if self.spawnCounter == self.spawnTrigger and self.enemiesSpawned < self.enemyLimit:
x = self.checkBounds() + self.scrollX
for wall in self.walls:
if type(wall).__name__ == "Wall":
if wall.x1 < x < wall.x1 + wall.x2:
slope = ((500 - wall.y2) - (500 - wall.y1)) / (wall.x2)
y = wall.y1
if x > self.player.x + self.scrollX:
self.enemies.add(Enemy(x, y - 20, False, "Right"))
else:
self.enemies.add(Enemy(x, y - 20, True, "Left"))
elif type(wall).__name__ == "Slant":
if wall.x1 < x < wall.x2:
slope = ((500 - wall.y2) -
(500 - wall.y1)) / ((wall.x2) - (wall.x1))
y = 500 - ((slope * (x - wall.x1)) + 140)
if slope < 0:
y = 500 - ((slope * (x - wall.x1)) + 300)
if x > self.player.x + self.scrollX:
self.enemies.add(Enemy(x, y - 20, False, "Right"))
else:
self.enemies.add(Enemy(x, y - 20, True, "Left"))
self.spawnCounter = 0
self.spawnTrigger = random.randint(35, 55)
self.enemiesSpawned += 1
def keyPressed(self, keyCode, modifier):
if keyCode == "START":
self.pause = not self.pause
if not self.gameOver and not self.pause:
if keyCode == "Circle":
self.Flash = True
if keyCode == pygame.K_3:
pass
if keyCode == pygame.K_2 or keyCode == "L1" and self.missiles > 0:
self.aimMode = not self.aimMode
if self.aimMode:
pygame.mixer.music.pause()
self.actived.play()
else:
if not pygame.mixer.get_busy:
pygame.mixer.music.unpause()
if self.aimMode and self.joystickMode:
for e in self.enemies:
if e.rect.collidepoint(self.targetX,
self.targetY) and keyCode == "X":
self.ex, self.ey = self.targetX + self.scrollX, self.targetY
e.lockedOn = True
self.lockedOn = True
self.aimMode = False
pygame.mixer.music.unpause()
#lets character move jump with momentum
else:
if keyCode == pygame.K_UP or keyCode == "X":
self.jumping = True
elif keyCode == pygame.K_SPACE or keyCode == "R2":
self.shooting = True
if self.dir == "Right":
self.bulletGroup.add(Bullet(self.player.x+ self.player.width//4 ,\
self.player.y-self.player.height//6-4, self.dir))
else:
self.bulletGroup.add(Bullet(self.player.x- self.player.width//2 ,\
self.player.y-self.player.height//6-4, self.dir))
elif keyCode == pygame.K_1 or keyCode == "R1" and self.missiles > 0:
#self.coor = self.player.missile()
if self.lockedOn:
self.homingMissles.add(
HomingMissle(self.player.x + self.scrollX,
self.player.y))
self.lockedOn = False
if self.missiles > 0:
self.missiles -= 1
print(self.missiles)
self.homing = True
else:
if keyCode == "X":
self.gameOver = False
self.init()
def isKeyPressed(self, key):
return self._keys.get(key, False)
def moveTarget(self, dir):
if self.aimMode and self.joystickMode:
if dir == "Left":
self.targetX -= 5
elif dir == "Right":
self.targetX += 5
elif dir == "Up":
self.targetY -= 5
elif dir == "Down":
self.targetY += 5
def mouseMotion(self, x, y):
if self.aimMode and not self.joystickMode:
self.targetX, self.targetY = x, y
def mousePressed(self, x, y):
#spawn enemy at mouse xy
if not self.gameOver:
if self.aimMode:
for e in self.enemies:
if e.rect.collidepoint(x, y):
e.lockedOn = True
self.aimMode = False
def followPlayer(self):
for e in self.enemies:
x = e.x
if e.x > self.player.x + self.scrollX:
x = x - 5
else:
x = x + 5
def enemyTimerFired(self):
for enemy in pygame.sprite.groupcollide(self.enemies, self.bulletGroup,
False, True):
enemy.health -= 20
if enemy.health <= 0:
if enemy.lockedOn:
self.homingMissles.empty()
drop = enemy.drop()
if drop != None:
Game.GameDrops.add(drop)
else:
self.bloodGroup.add(Blood(enemy.x, enemy.y))
enemy.kill()
self.enemyNum -= 1
for enemy in self.enemies:
if self.player.zoneRect.colliderect(enemy.rect):
enemy.change(self.scrollX, "attack")
if enemy.shoot():
if enemy.x < self.player.x + self.scrollX:
self.enemyBulletGroup.add(
Fireball(enemy.x, enemy.y - 12, "Right"))
elif enemy.x > self.player.x + self.scrollX:
self.enemyBulletGroup.add(
Fireball(enemy.x, enemy.y - 12, "Left"))
else:
enemy.move(self.scrollX, self.player.x + self.scrollX,
self.walls)
enemy.change(self.scrollX)
self.followPlayer()
for bullet in self.enemyBulletGroup:
bullet.move(self.width, self.scrollX)
def levelUp(self):
if self.lvlUp:
if self.letterNum < 7:
self.letterCounter += 1
if self.letterCounter == 5:
self.letterIndex += 1
self.letterX -= 40
self.letters.append(
Letter(self.letterX, 100,
self.letterLst[self.letterIndex]))
self.letterNum += 1
self.letterCounter = 0
else:
self.letterTimer += 1
if self.letterTimer == 40:
self.lvlUp = False
self.letters = []
self.letterNum = 0
self.letterIndex = -1
self.letterTimer = 0
self.letterX = 0
for l in self.letters:
l.move()
def timerFired(self, dt):
if self.health <= 0:
self.gameOver = True
pygame.mixer.music.stop()
if self.lvl == 3:
self.gameWon = True
if not self.gameOver and not self.gameWon and not self.pause:
self.text = self.myfont.render('Enemies: %s' % self.enemyNum,
False, (0, 0, 0))
self.BackGround.image = self.BackGround.backs[
self.BackGround.change()]
if self.enemyNum == 0:
self.lvl += 1
i = random.randint(self.enemyLimit + 1, self.enemyLimit + 10)
self.enemyNum, self.enemyLimit = i, i
self.enemiesSpawned = 0
self.spawnCounter = 0
self.lvlUp = True
self.letterLst = [
"%s" % self.lvl, ":", "l", "e", "v", "e", "L"
]
self.levelUp()
for enemy in self.enemies:
enemy.updateImage(self.scrollX)
if self.aimMode:
Target.count += 1
if Target.count == 4:
self.rotateCount += 1
Target.count = 0
if self.rotateCount == 5:
self.rotateCount = 1
self.rotatedTarget = self.target.rotate(self.rotateCount)
else:
self.spawn()
for bullet in self.enemyBulletGroup:
if self.player.hitMarker.colliderect(bullet.rect):
self.Flash = True
bullet.kill()
self.healthBar.hit()
self.health -= 10
for p in self.homingMissles:
for e in self.enemies:
if e.lockedOn:
p.move(e.x - 20, e.y + 10, self.scrollX,
self.walls)
if e.missileRect.colliderect(p.missileRect):
self.homing = False
self.homingMissles.empty()
e.kill()
self.enemyNum -= 1
for player in self.players:
for drop in Game.GameDrops:
if player.dropRect.colliderect(drop.missileRect):
if type(drop).__name__ == "HomingMissle":
self.missiles += 1
else:
self.healthBar.regain()
self.health += 10
drop.kill()
if not self.jumping:
y = self.findY(self.player.x + self.scrollX)
if self.player.y != y:
self.player.y = y - 15
else:
self.player.y -= (self.v**2)
self.v -= 1
if self.v <= 0:
self.player.y += (self.v**2)
self.v -= 1
y = self.findY(self.player.x + self.scrollX)
if self.player.y >= y:
self.player.y = y - 15
self.jumping = False
self.v = 6.5
self.enemyTimerFired()
for bullet in self.bulletGroup:
bullet.move(self.width, self.scrollX)
for bullet in self.enemyBulletGroup:
if bullet.y > self.findY(bullet.x):
bullet.kill()
if self.shooting:
self.shootCounter += 1
if self.dir == "Right":
self.player.change("Shoot", self.dir, self.scrollX)
else:
self.player.change("Shoot", self.dir, self.scrollX)
if self.shootCounter == 10:
self.shootCounter = 0
self.shooting = False
else:
#chnage pose to running rightb
if self.isKeyPressed(
pygame.K_RIGHT) or self.moveRight("Right"):
self.dir = "Right"
self.runCounter += 1
if (self.endWall.x1 + self.endWall.x2 -
self.scrollX) > 800 and self.player.x > 100:
self.scrollX += 10
if self.runCounter == 0:
self.player.change("Stand", self.dir, self.scrollX)
else:
if self.runCounter > 5:
self.runCounter = 1
state = "run%s" % self.runCounter
self.player.change(state, self.dir, self.scrollX)
self.player.move(5, "x", self.scrollX)
#change pose to running left
elif self.isKeyPressed(pygame.K_LEFT) or self.moveLeft(
"Left"): #method for switching run image state
self.dir = "Left"
self.runCounter += 1
if (self.startWall.x1 -
self.scrollX) < 0 and self.player.x < 700:
self.scrollX -= 10
if self.runCounter == 0:
self.player.change("Stand", self.dir, self.scrollX)
else:
if self.runCounter > 5:
self.runCounter = 1
state = "run%s" % self.runCounter
self.player.change(state, self.dir, self.scrollX)
self.player.move(-5, "x", self.scrollX)
#change pose to standing left or right
elif not self.isKeyPressed(
pygame.K_LEFT) and self.dir == "Left":
self.player.change("Stand", self.dir, self.scrollX)
elif not self.isKeyPressed(
pygame.K_RIGHT) and self.dir == "Right":
self.player.change("Stand", self.dir, self.scrollX)
elif self.gameOver:
self.gameOverScreen.image = self.gameOverScreen.backs[
self.gameOverScreen.change()]
elif self.gameWon:
self.gameWonScreen.image = self.gameWonScreen.backs[
self.gameWonScreen.change(1)]
# self.player = Player(self.player.x,self.player.y,"fall", False)
def redrawAll(self, screen):
if not self.gameOver and not self.gameWon:
#draw all walls,players, enemies, and bullets
screen.blit(self.BackGround.image, (0 - self.scrollX, 0))
screen.blit(self.BackGround.image, (800 - self.scrollX, 0))
screen.blit(self.BackGround.image, (1600 - self.scrollX, 0))
for wall in self.walls:
wall.draw(screen, self.scrollX)
for drop in Game.GameDrops:
screen.blit(drop.image, (drop.x - self.scrollX, drop.y))
self.player.draw(screen, self.scrollX)
for bullet in self.bulletGroup:
bullet.draw(screen, self.scrollX)
for b in self.enemyBulletGroup:
b.draw(screen, self.scrollX)
for enemy in self.enemies:
screen.blit(enemy.image,
(enemy.x - self.scrollX - enemy.w // 2,
enemy.y - enemy.h // 2))
for blood in self.bloodGroup:
screen.blit(
blood.image,
(blood.x - self.scrollX - blood.w // 2, blood.y + 5))
#self.enemies.draw(screen)
if self.homing:
#print("HOMINGGGGGG")
for h in self.homingMissles:
h.draw(screen, self.scrollX)
self.healthBar.draw(screen, self.missiles)
if self.aimMode:
screen.blit(self.rotatedTarget,
(self.targetX - self.target.width // 2,
self.targetY - self.target.height // 2))
screen.blit(self.text,
(400 - self.textW // 2, 470 - self.textH // 2))
if self.lvlUp:
for l in self.letters:
l.draw(screen)
if self.Flash:
screen.fill((255, 0, 0))
self.Flash = False
if self.pause:
screen.blit(self.pauseImage, (300, 150))
elif self.gameOver:
screen.fill((0, 0, 0))
screen.blit(self.gameOverScreen.image, (0, 0))
screen.blit(self.gameOverText, (300, 400))
elif self.gameWon:
screen.fill((
0,
0,
0,
))
screen.blit(self.gameWonScreen.image, (0, 0))
text = Letter(100, 100, "You Are A God!!!!", False,
'Comic Sans MS')
text.draw(screen)
if not self.endMusic:
pygame.mixer.music.load('images/kanye.ogg')
pygame.mixer.music.play(-1)
self.endMusic = True
@staticmethod
def runGame():
t, s, c = StartScreen(800, 500).run()
Game(800, 500).run(t, c, s)
class TileTest(GameState):
MAX_OFFSET_X = 150
MAX_OFFSET_Y = 75
FACTOR = 10
INDEX_DOWN = 0
INDEX_UP = 1
INDEX_LEFT = 2
INDEX_RIGHT = 3
NUM_ENEMY = 13
WALL_WIDTH = 50
def __init__(self):
Globals.PLAYER_HEALTH = 100
Globals.PLAYER_SCORE = 0
Globals.REMAINING_TIME = 30000
self.tileEngine = TileEngine("test_def.txt", "test_map.txt", 1, 3)
self.camera = Camera(self.tileEngine, pygame.Rect(
0, 0, Globals.WIDTH, Globals.HEIGHT))
self.keyCode = None
self.testPoint = []
self.object_radius = \
self.camera.tileEngine.get_tile_rect().height * 1.5
self.direction = -1
self.has_collided = False
self.enemySprites = pygame.sprite.Group()
self.playerSprites = pygame.sprite.Group()
self.health = HealthBar()
self.score_timer = ScoreTimer()
for x in range(TileTest.NUM_ENEMY):
# fix the positions they are added in and everything else
# should work
self.enemySprites.add(Enemy(Globals.WIDTH, Globals.HEIGHT,
self.camera))
player_x = Globals.WIDTH / 2
player_y = int(Globals.HEIGHT -
self.camera.tileEngine.get_tile_rect().height * 3.5)
self.player = Player(
Globals.WIDTH,
Globals.HEIGHT,
player_x,
player_y,
self.score_timer
)
self.playerSprites.add(self.player)
def render(self):
self.camera.render(Globals.SCREEN)
self.enemySprites.draw(Globals.SCREEN)
self.playerSprites.draw(Globals.SCREEN)
self.health.render(Globals)
self.score_timer.render(Globals)
def update(self, time):
self.player.update(time, self.camera, self.enemySprites)
self.enemySprites.update(time, self.camera)
self.checkCameraPosition()
if pygame.sprite.spritecollideany(self.player, self.enemySprites):
Globals.PLAYER_HEALTH -= .5
def checkCameraPosition(self):
dist_x = self.camera.container.centerx - self.player.rect.centerx
dist_y = self.camera.container.centery - self.player.rect.centery
if abs(dist_x) > TileTest.MAX_OFFSET_X:
diff = abs(dist_x) - TileTest.MAX_OFFSET_X
# player is to the right of center
if dist_x < 0:
pass
# player is to the left of center
else:
diff *= -1
self.camera.move(diff, 0)
self.player.rect.centerx -= diff
for enemy in self.enemySprites:
enemy.rect.centerx -= diff
if abs(dist_y) > TileTest.MAX_OFFSET_Y:
diff = abs(dist_y) - TileTest.MAX_OFFSET_Y
# player is below center
if dist_y < 0:
pass
# player is above center
else:
diff *= -1
self.camera.move(0, diff)
self.player.rect.centery -= diff
for enemy in self.enemySprites:
enemy.rect.centery -= diff
def event(self, event):
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
Globals.STATE = Menu.Menu()
elif event.key == pygame.K_r or event.key == pygame.K_F5:
self.reloadCamera()
else:
self.keyCode = event.key
elif event.type == pygame.KEYUP and event.key == self.keyCode:
self.keyCode = None
if event.type == pygame.KEYDOWN:
for p in self.playerSprites:
p.keyPressed(event.key)
if event.type == pygame.KEYUP:
for p in self.playerSprites:
p.keyReleased(event.key)
def reloadCamera(self):
try:
self.tileEngine = TileEngine("test_def.txt", "test_map.txt", 1, 3)
self.camera.tileEngine = self.tileEngine
print "Reloaded Tile Engine"
except Exception as e:
print "Reload failed: ", e
class GamePlayMain:
def __init__(self, screen, level, number_level, save):
self.save = save
saved_time = self.save[str(number_level)]['last_time_start']
self.game_start_time = time.time(
) if saved_time is None else saved_time
self.number_level = number_level
self.screen = screen
self.level_pre = level
self.hb_gr = pygame.sprite.Group()
self.hb = HealthBar(self.hb_gr, (20, 20), 4)
self.clock_t = pygame.time.Clock()
self.clock = [0]
self.all_tiles = pygame.sprite.Group()
self.background_group = pygame.sprite.Group()
self.player, x_max, y_max = generate_level(
level,
self.all_tiles,
self.clock,
self.background_group,
pos_pl=self.save[str(number_level)]['last_pos'])
self.spites_start()
self.background = ForrestBackgroundMain(self.screen,
self.background_group,
self.clock, x_max)
self.background_front = ForrestBackgroundFront(self.screen,
self.background_group,
self.clock, x_max)
self.ifpause = False
def spites_start(self):
for t in self.all_tiles:
try:
t.drop_down()
except Exception as e:
continue
def terminate(self):
self.save_data()
sys.exit()
pygame.quit()
def save_data(self):
t, pos_pl = self.game_start_time, (self.player.pos_rel_x,
self.player.pos_rel_y)
self.save[str(self.number_level)]['last_pos'] = pos_pl
self.save[str(self.number_level)]['last_time_start'] = t
with open(SAVE_PATH, 'w') as f:
json.dump(self.save, f)
def pygame_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.terminate()
if event.type == pygame.KEYDOWN:
key = event.key
if key == pygame.K_ESCAPE:
pass
def keyboard_events(self):
key = pygame.key.get_pressed()
for i in slugs:
i.stay()
for j in bees:
j.stay()
for z in piranhas:
z.stay()
for u in stars:
u.stay()
if key[pygame.K_ESCAPE]:
print(
pygame.sprite.spritecollide(self.player, self.all_tiles,
False))
if key[pygame.K_LEFT]:
self.player.event_handler(MOVE_LEFT)
elif key[pygame.K_RIGHT]:
self.player.event_handler(MOVE_RIGHT)
elif key[pygame.K_UP]:
jump_music()
self.player.event_handler(MOVE_UP)
self.clock_t.tick(40)
background_music()
elif key[pygame.K_f]:
hurt_music()
self.player.event_handler(ATTACK)
self.clock_t.tick(40)
background_music()
else:
self.player.event_handler(None)
def event_handler(self):
self.pygame_events()
self.keyboard_events()
self.player.render()
[
t.damage_check(self.player) for t in self.all_tiles
if isinstance(t, Enemy)
]
self.hb.red_inner(self.player.hp)
if self.player.hp == 0:
self.running = False
self.camera_events()
def camera_events(self):
self.camera.update(self.player)
for el in self.all_tiles:
self.camera.apply(el)
def drawing(self):
self.screen.fill((255, 255, 255))
self.background_group.draw(self.screen)
self.all_tiles.draw(self.screen)
self.hb_gr.draw(self.screen)
pygame.display.flip()
def rendering(self):
self.running = True
self.passed_level = False
self.camera = Camera(self.background_front)
while self.running:
self.clock[0] = self.clock_t.tick()
self.event_handler()
if any(
isinstance(t, Tiles.House)
for t in pygame.sprite.spritecollide(
self.player, self.all_tiles, False)):
self.running = False
self.passed_level = True
self.save[str(self.number_level)]['last_pos'] = None
self.save[str(self.number_level)]['last_time_start'] = None
with open(SAVE_PATH, 'w') as f:
json.dump(self.save, f)
break
if self.player.game_over:
self.running = False
break
self.drawing()
if self.passed_level:
return True, time.time() - self.game_start_time
else:
game_over = GameOver(self.screen)
result = game_over.rendering()
if result is False:
return False, None
else:
again = GamePlayMain(self.screen, self.level_pre)
return again.rendering()
def pause(self):
Pause(self.screen)
class Swordsman(Character):
ATK_RANGE = 8
BASIC_ATK_DMG = 15
SPECIAL_ATK_DMG = 30
MOVE_SPEED = 10
CHARGE_SPEED = 15
MAX_HEALTH = 100
FOV = 60
def __init__(self, *args):
super(Swordsman, self).__init__(*args)
Character.set_health(self, Swordsman.MAX_HEALTH)
Character.set_speed(self, Swordsman.MOVE_SPEED)
actor = Actor(
"models/swordsman", {
"idle": "models/swordsman-idle",
"walk": "models/swordsman-walk",
"run": "models/swordsman-run",
"hurt": "models/swordsman-hurt",
"die": "models/swordsman-die",
"attack": "models/swordsman-attack"
})
team = Character.get_team(self)
if team == 0:
"""
actor = Actor("models/swordsman_red",
{"idle": "models/swordsman-idle",
"walk": "models/swordsman-walk",
"run": "models/swordsman-run",
"hurt": "models/swordsman-hurt",
"die": "models/swordsman-die",
"attack": "models/swordsman-attack"})
"""
tex = loader.loadTexture("models/textures/swordsman_red.png")
ts = actor.findTextureStage('*')
actor.setTexture(ts, tex, 1)
#ts = actor.findTextureStage('ts')
#actor.setTexture(ts, tex)
elif team == 1:
"""
actor = Actor("models/swordsman_blue",
{"idle": "models/swordsman-idle",
"walk": "models/swordsman-walk",
"run": "models/swordsman-run",
"hurt": "models/swordsman-hurt",
"die": "models/swordsman-die",
"attack": "models/swordsman-attack"})
"""
tex = loader.loadTexture("models/textures/swordsman_blue.png")
ts = actor.findTextureStage('*')
actor.setTexture(ts, tex, 1)
#ts = actor.findTextureStage('ts')
#actor.setTexture(ts, tex)
Character.set_actor(self, actor)
self.hb = HealthBar(1.5, value=Swordsman.MAX_HEALTH)
self.hb.reparentTo(self._floater)
self.hb.setValue(self.get_health())
self.model = loader.loadModel("models/circle")
self.model.setTransparency(True)
self.model.reparentTo(self._character)
self.model.setAlphaScale(0.5)
self.model.setScale(2)
self.model.setPos(0, 0, -10)
def basic_attack(self):
total_dmg = Swordsman.BASIC_ATK_DMG
swing_sound = loader.loadSfx("sound/Swoosh.mp3")
if self._atk_buff == 1:
total_dmg *= 1.1
elif self._atk_buff == 2:
total_dmg *= 1.25
sound_interval = SoundInterval(swing_sound,
loop=2,
duration=0.6,
volume=0.7,
startTime=0)
atk_interval1 = self._character.actorInterval("attack",
startFrame=1,
endFrame=26)
atk_interval2 = self._character.actorInterval("attack",
startFrame=56,
endFrame=80)
seq = Sequence(atk_interval1, atk_interval2)
if self._is_moving:
seq.append(Func(self.animate, 2))
seq2 = Sequence(Wait(0.5), sound_interval, sound_interval)
seq.start()
seq2.start()
return total_dmg
def special_attack(self):
total_dmg = Swordsman.SPECIAL_ATK_DMG
swing_sound = loader.loadSfx("sound/Swoosh.mp3")
if self._atk_buff == 1:
total_dmg *= 1.1
elif self._atk_buff == 2:
total_dmg *= 1.25
sound_interval = SoundInterval(swing_sound,
loop=2,
duration=0.8,
volume=0.7,
startTime=0)
atk_interval1 = self._character.actorInterval("attack",
startFrame=1,
endFrame=13)
atk_interval2 = self._character.actorInterval("attack",
startFrame=38,
endFrame=80)
seq = Sequence(atk_interval1, atk_interval2)
if self._is_moving:
seq.append(Func(self.animate, 2))
seq2 = Sequence(Wait(0.5), sound_interval, sound_interval)
seq.start()
seq2.start()
return total_dmg
def take_damage(self, health_change):
health = Character.get_health(self)
if health < health_change and not self._is_dead:
Character.set_health(self, 0)
self.hb.setValue(0)
hurt_interval = self._character.actorInterval("hurt")
death_interval = self._character.actorInterval("die")
seq = Sequence(hurt_interval, death_interval)
seq.append(Wait(2))
# add Func interval to place the character at a new location
seq.append(Func(self.respawn))
seq.start()
self._is_dead = True
#self._is_moving=2
else:
Character.set_health(self, health - health_change)
#self.hb.setValue(Character.get_health(self)-health_change)
self.hb.setValue(Character.get_health(self))
self._character.play("hurt")
def apply_def_buff(self):
if not self._is_dead:
health = Character.get_health(self)
if self._def_buff == 1:
Character.set_health(self, health * 1.1)
Swordsman.MAX_HEALTH = Swordsman.MAX_HEALTH * 1.1
elif self._def_buff == 2:
Character.set_health(self, health * 1.25)
Swordsman.MAX_HEALTH = Swordsman.MAX_HEALTH * 1.25
def unapply_def_buff(self):
if not self._is_dead:
if self._def_buff == 0:
Swordsman.MAX_HEALTH = 100
elif Swordsman.MAX_HEALTH == 125 and self._def_buff == 1:
Swordsman.MAX_HEALTH = 110
health = Character.get_health(self)
if health > Swordsman.MAX_HEALTH:
health = Swordsman.MAX_HEALTH
def animate(self, anim_type):
if anim_type == 0:
self._character.loop("idle")
elif anim_type == 1:
self._character.loop("walk")
elif anim_type == 2:
self._character.loop("run")
elif anim_type == 3:
atk_interval1 = self._character.actorInterval("attack",
startFrame=1,
endFrame=26)
atk_interval2 = self._character.actorInterval("attack",
startFrame=56,
endFrame=80)
seq = Sequence(atk_interval1, atk_interval2)
seq.start()
elif anim_type == 4:
atk_interval1 = self._character.actorInterval("attack",
startFrame=1,
endFrame=13)
atk_interval2 = self._character.actorInterval("attack",
startFrame=38,
endFrame=80)
seq = Sequence(atk_interval1, atk_interval2)
seq.start()
elif anim_type == 5:
self._character.play("hurt")
elif anim_type == 6:
self._character.play("die")
def respawn(self):
self._is_moving = 2
self._character.loop("idle")
def init(self):
self.levelUpInit()
super(Game, self).__init__()
self.s = StartScreen()
self.bgColor = (0, 0, 0)
Enemy.poses()
self.startWall = Wall(0, 360, 400, 360)
self.endWall = Wall(1600, 360, 400, 360)
self.bulletGroup = pygame.sprite.Group()
self.player = Player(50, 340, "Stand", False)
self.players = pygame.sprite.GroupSingle(self.player)
self.enemies = pygame.sprite.Group()
self.gravity = True
self.walls = [
self.startWall,
Slant(400, 360, 800, 300, 800, 360),
Wall(800, 300, 400, 360),
Slant(1200, 300, 1600, 360, 1200, 360), self.endWall
]
self.BackGround = Background("background")
self.jumpingUp = False
self.jumpCounter = 0
self.runCounter = 0
self.dir = "Right"
self.jumpingCounter = 0
self.shooting = False
self.shootCounter = 0
self.falling = None
self.jumpingRight = False
self.jumpingLeft = False
self.enemyRunCounter = 0
self.homingMissles = pygame.sprite.GroupSingle()
self.rotateCount = 1
self.aimMode = False
self.target = Target()
self.rotatedTarget = self.target.rotate(self.rotateCount)
self.targetX, self.targetY = 100, 100
self.healthBar = HealthBar(0, 0, self.width, self.height)
self.homing = False
self.isKilled = False
self.enemyBulletGroup = pygame.sprite.Group()
self.bloodGroup = pygame.sprite.Group()
self.scrollX = 0
self.lockedOn = False
self.missiles = 0
self.spawnCounter, self.spawnTrigger = 0, random.randint(5, 25)
self.health = 160
self.enemiesSpawned = 0
self.enemyLimit = 10
self.enemyNum = 10
self.myfont = pygame.font.SysFont('Comic Sans MS', (30))
self.text = self.myfont.render('Enemies: %s' % self.enemyNum, False,
(0, 0, 0))
self.textW, self.textH = self.text.get_size()
self.enemyLevel = 0
self.gameOver = False
self.jumping = False
self.v = 6.5
self.gameWon = False
self.Flash = False
self.gameOverScreen = Background("Gameover")
self.gameOverText = self.myfont.render('Press X to Restart', False,
(0, 0, 0))
self.gameWonScreen = Background("Gamewon")
pygame.mixer.set_num_channels(2)
pygame.mixer.init()
pygame.mixer.music.load('images/backMusic.ogg')
pygame.mixer.music.play()
self.actived = pygame.mixer.Sound('images/missileActivated.ogg')
self.endMusic = False
self.pause = False
self.pauseImage = pygame.transform.scale(
pygame.image.load('images/pause.png'), (200, 200))
class Npc():
def __init__(self, controlPointId, id, anchorx, anchory, anchorz, render,
team):
self.id = id
self.anchorx = anchorx
self.anchory = anchory
self.anchorz = anchorz
self.controlPointId = controlPointId
self.target = None
self.isMoving = False
self.health = 200
self.isCurrentUser = False
self.damage = 8
self.attackTimer = 0
self._is_dead = False
self._team = team
self.render = render
'''Initializing NPC actors'''
self.npc = Actor(
"models/priest", {
"walk": "models/priest-walk",
"attack": "models/priest-attack",
"hurt": "models/priest-hit",
"die": "models/priest-die"
})
if self._team == 0:
self.npcTex = loader.loadTexture("models/tex/guard_red.png")
else:
self.npcTex = loader.loadTexture("models/tex/guard_blue.png")
self.npc.setTexture(self.npcTex)
self.npc.setScale(0.5, 0.5, 0.5)
self.npc.clearColor()
self.npc.clearColorScale()
self.npc.setColor(255, 0, 0, 0)
self.npc.setColorScale(255, 0, 0, 0)
self.npc.reparentTo(self.render)
self.npc.setPos(anchorx, anchory, anchorz)
self.AIchar = AICharacter("npc" + str(self.id), self.npc, 100, 0.05, 5)
self.AIbehaviors = self.AIchar.getAiBehaviors()
self.hb = HealthBar(1.5, value=self.health)
#self._floater = NodePath(PandaNode("char_info"))
#self._floater.reparentTo(self.npc)
self.hb.setPos(0, 0, 11.9)
self.hb.reparentTo(self.npc)
#self.hb.reparentTo(self.npc)
def renderBlue(self, AIworld):
if not self._is_dead:
self.AIbehaviors.removeAi("pursue")
self.npc.detachNode()
print "Started delete procedure for npc ",
print self.id
self.npc.delete()
self.npc = Actor(
"models/priest", {
"walk": "models/priest-walk",
"attack": "models/priest-attack",
"hurt": "models/priest-hit",
"die": "models/priest-die"
})
self.npcTex = loader.loadTexture("models/tex/guard_blue.png")
self.npc.setTexture(self.npcTex)
self.npc.setScale(0.5, 0.5, 0.5)
self.npc.clearColor()
self.npc.clearColorScale()
self.npc.setColor(255, 0, 0, 0)
self.npc.setColorScale(255, 0, 0, 0)
self.npc.reparentTo(self.render)
self.npc.setPos(self.anchorx, self.anchory, self.anchorz)
AIworld.removeAiChar("npc" + str(self.id))
self.AIchar = AICharacter("npc" + str(self.id), self.npc, 100, 0.05, 5)
self.AIbehaviors = self.AIchar.getAiBehaviors()
AIworld.addAiChar(self.AIchar)
self.hb = HealthBar(1.5, value=self.health)
self.hb.setPos(0, 0, 18.1)
self.hb.reparentTo(self.npc)
#self.hb.reparentTo(self.npc)
def renderRed(self, AIworld):
if not self._is_dead:
self.AIbehaviors.removeAi("pursue")
self.npc.detachNode()
self.npc.delete()
self.npc = Actor(
"models/priest", {
"walk": "models/priest-walk",
"attack": "models/priest-attack",
"hurt": "models/priest-hit",
"die": "models/priest-die"
})
self.npcTex = loader.loadTexture("models/tex/guard_red.png")
self.npc.setTexture(self.npcTex)
self.npc.setScale(0.5, 0.5, 0.5)
self.npc.clearColor()
self.npc.clearColorScale()
self.npc.setColor(255, 0, 0, 0)
self.npc.setColorScale(255, 0, 0, 0)
self.npc.reparentTo(self.render)
self.npc.setPos(self.anchorx, self.anchory, self.anchorz)
AIworld.removeAiChar("npc" + str(self.id))
self.AIchar = AICharacter("npc" + str(self.id), self.npc, 100, 0.05, 5)
self.AIbehaviors = self.AIchar.getAiBehaviors()
AIworld.addAiChar(self.AIchar)
AIworld.update()
self.hb = HealthBar(1.5, value=self.health)
self.hb.setPos(0, 0, 8.1)
self.hb.reparentTo(self.npc)
def switchTeam(self, AIworld):
print self.id,
print " from team ",
print self._team,
print " getting deleted."
if self._team == 0:
self._team = 1
self.renderBlue(AIworld)
else:
self._team = 0
self.renderRed(AIworld)
if self.isCurrentUser:
main.freeDeadNpc(self.id)
self.target = None
self.isMoving = False
self.health = 200
self.isCurrentUser = False
self.damage = 8
self.attackTimer = 0
self._is_dead = False
def set_health(self, health):
self.health = health
def take_damage(self, health_change):
health = self.health
if health <= health_change and not self._is_dead:
self.killNpc()
else:
health = health - health_change
self.set_health(health)
self.hb.setValue(self.health)
self.npc.play("hurt")
def killNpc(self):
self.set_health(0)
self.hb.setValue(0)
self.AIbehaviors.removeAi("pursue")
hurt_interval = self.npc.actorInterval("hurt")
death_interval = self.npc.actorInterval("die")
seq = Sequence(hurt_interval, death_interval)
seq.start()
self.npc.pose("die", 45)
self._is_dead = True
self.npc.detachNode()
if self.isCurrentUser:
main.freeDeadNpc(self.id)
#main.cManager.sendRequest(Constants.CMSG_NPCDEATH, [self.id])
print Constants.CMSG_NPCDEATH,
print " + ",
print self.id
def chaseTarget(self, target, status=False):
if (not self.isMoving):
self.target = target
self.AIbehaviors.pursue(self.target)
self.npc.loop("walk")
self.isMoving = True
self.isCurrentUser = status
def stopChase(self):
#self.AIbehaviors.pauseAi("pursue")
if not self._is_dead:
self.AIbehaviors.removeAi("pursue")
p1 = LerpHprInterval(self.npc, 4, Point3(180, 0, 0))
p2 = LerpPosInterval(
self.npc, 4, Point3(self.anchorx, self.anchory, self.anchorz))
animInterval = self.npc.actorInterval("walk", loop=1, duration=4)
p2.start()
p1.start()
animInterval.start()
self.isMoving = False
self.target = None
self.isCurrentUser = False
def givNPCDistance(self, charachter):
x = self.npc.getX()
y = self.npc.getY()
z = self.npc.getZ()
minDist = math.sqrt((charachter.getX() - x) * (charachter.getX() - x) +
(charachter.getY() - y) * (charachter.getY() - y) +
(charachter.getZ() - z) * (charachter.getZ() - z))
return minDist
def checkNpcIsAlive(self):
if (self.health > 0):
return True
else:
return False
def shouldAttack(self, currentTime, cManager):
if not self._is_dead:
if self.isMoving:
if self.attackTimer > 0:
self.attackTimer = self.attackTimer - currentTime
#print self.attackTimer
if self.AIbehaviors.behaviorStatus("pursue") == "done":
#self.npc.stop("walk")
#print self.npc.getAnimControl("walk")
if self.attackTimer <= 0:
if self.npc.getAnimControl("walk").isPlaying():
self.npc.stop("walk")
if not self.npc.getAnimControl("attack").isPlaying():
#self.npc.loop("attack")
self.npc.play("attack")
self.attackTimer = 2
#myInterval = self.npc.actorInterval("attack")
#seq = Sequence(myInterval)
#seq.append(Wait(3))
#seq.start()
if self.isCurrentUser:
cManager.sendRequest(Constants.CMSG_NPCATTACK,
[self.id, self.damage])
if self.AIbehaviors.behaviorStatus("pursue") == "active":
if self.npc.getAnimControl("attack").isPlaying():
self.npc.stop("attack")
if not self.npc.getAnimControl("walk").isPlaying():
self.npc.loop("walk")
class Axeman(Character):
BASIC_ATK_DMG = 12
SPECIAL_ATK_DMG = 40
MAX_HEALTH = 120
ATK_RANGE = 3
MOVE_SPEED = 8
FOV = 45
def __init__(self, *args):
super(Axeman, self).__init__(*args)
Character.set_health(self, Axeman.MAX_HEALTH)
actor = Actor("models/axeman", {"idle": "models/axeman-idle",
"walk": "models/axeman-walk",
"run": "models/axeman-run" ,
"hurt": "models/axeman-hurt",
"die": "models/axeman-die",
"attack": "models/axeman-swing",
"special":"models/axeman-special-attack"})
Character.set_speed(self, Axeman.MOVE_SPEED)
# loda texture based on team
team = Character.get_team(self)
if team == 0:
tex = loader.loadTexture("models/textures/axeman_red.png")
ts = actor.findTextureStage("*")
actor.setTexture(ts, tex, 1)
elif team == 1:
tex = loader.loadTexture("models/textures/axeman_blue.png")
ts = actor.findTextureStage('*')
actor.setTexture(ts, tex, 1)
Character.set_actor(self, actor)
#attach axe
rightHand = self._character.exposeJoint(None, 'modelRoot', 'hand_ctrl_r')
axe = loader.loadModel("models/axe")
axe_tex = loader.loadTexture("models/textures/axe.png")
axe.setTexture(axe_tex, 1)
axe.setPos(-3.0, 0.6, -0.2)
axe.setHpr(0, -90, -90)
axe.setScale(10)
axe.reparentTo(rightHand)
axe.show()
self.hb = HealthBar(1.5, value=Axeman.MAX_HEALTH)
self.hb.reparentTo(self._character)
model = loader.loadModel("models/circle")
model.setTransparency(True)
model.reparentTo(self._character)
model.setAlphaScale(0.5)
model.setScale(2)
model.setPos(0, 0, -10)
def basic_attack(self):
total_dmg = Axeman.BASIC_ATK_DMG
swing_sound = loader.loadSfx("sound/Woosh.wav")
if self._atk_buff==1:
total_dmg *= 1.1
elif self._atk_buff==2:
total_dmg *= 1.25
# play animation
sound_interval1 = SoundInterval(
swing_sound,
loop = 1 ,
duration = 0,
volume = 0.7,
startTime = 0
)
seq2 = Sequence(Wait(0.5),sound_interval1, sound_interval1)
#self._character.play("attack")
atk_interval = self._character.actorInterval("attack")
seq = Sequence(atk_interval)
if self._is_moving:
seq.append(Func(self.loop_run))
seq.start()
seq2.start()
return total_dmg
def special_attack(self):
total_dmg = Axeman.SPECIAL_ATK_DMG
if self._atk_buff==1:
total_dmg *= 1.1
elif self._atk_buff==2:
total_dmg *= 1.25
#self._character.play("special",fromFrame = 10)
atk_interval = self._character.actorInterval("special", startFrame=10)
seq = Sequence(atk_interval)
if self._is_moving:
seq.append(Func(self.loop_run))
seq.start()
return total_dmg
def loop_run(self):
self._character.loop("run")
def apply_def_buff(self):
if not self._is_dead:
health = Character.get_health(self)
if self._def_buff==1:
Character.set_health(self, health*1.1)
Axeman.MAX_HEALTH = Axeman.MAX_HEALTH*1.1
elif self._def_buff==2:
Character.set_health(self, health*1.25)
Axeman.MAX_HEALTH = Axeman.MAX_HEALTH*1.25
def unapply_def_buff(self):
if not self._is_dead:
if self._def_buff==0:
Axeman.MAX_HEALTH = 100
elif Axeman.MAX_HEALTH==140 and self._def_buff==1:
Axeman.MAX_HEALTH = 110
health = Character.get_health(self)
if health > Axeman.MAX_HEALTH:
health = Axeman.MAX_HEALTH
pass
def take_damage(self, health_change):
health = Character.get_health(self)
if health <= health_change and not self._is_dead:
Character.set_health(self, 0)
self.hb.setValue(0)
hurt_interval = self._character.actorInterval("hurt")
death_interval = self._character.actorInterval("die")
seq = Sequence(hurt_interval, death_interval)
seq.start()
self._is_dead = True
else:
Character.set_health(self, health-health_change)
self.hb.setValue(Character.get_health(self)-health_change)
self._character.play("hurt")
def animate(self, anim_type):
if anim_type==0:
self._character.loop("idle")
elif anim_type==1:
self._character.loop("walk")
elif anim_type==2:
self._character.loop("run")
elif anim_type==3:
self._character.play("attack")
elif anim_type==4:
self._character.play("special",fromFrame = 10)
elif anim_type==5:
self._character.play("hurt")
elif anim_type==6:
self._character.play("die")
def __init__(self, map_path):
super(CustomLevel, self).__init__(CustomLevel.DEF_NAME,
map_path,
music_path=CustomLevel.MUSIC_PATH)
Globals.Globals.HEALTH_BAR = HealthBar()
