def start_loop(self):
"""Loop for start screen"""
selected = False
background = Background(START_BG, [0, 0])
top_score = Hud(10, 350, 200, 40, "TOP SCORE")
def launch_game():
nonlocal selected
selected = True
self.game_loop()
while not selected:
for event in pygame.event.get():
if event.type == pygame.QUIT:
selected = True
top_score.prop = self.scores.top_score
self.clock.tick(20)
pygame.mouse.set_visible(True)
self.screen.blit(background.image, background.rect)
large_text = pygame.font.Font('freesansbold.ttf', 80)
text_surf, text_rect = text_objects("OMEGA!", large_text,
(210, 208, 224))
text_rect.center = ((self.screen_width / 2),
(self.screen_height / 2.75))
self.screen.blit(text_surf, text_rect)
top_score.update(dest=self.screen)
button('PLAY', ((self.screen_width / 2) - 50), 240, 100, 40,
((37, 31, 71), (108, 100, 153), (210, 208, 224)),
self.screen, launch_game)
def main():
hud = Hud()
# ser = serial.Serial(port = '/dev/ttyUSB0',
# baudrate = 9600,
# parity = serial.PARITY_NONE,
# stopbits = serial.STOPBITS_ONE,
# bytesize = serial.EIGHTBITS,
# timeout = 1)
logger = 0
kv = {}
stringKV = {}
firstPass = True
while True:
# wrapping this all in a try-catch should handle file-opening/-closing timeline nicely
# i.e. catch TclError(possibly tclError): close file
#
# var parsing and file writing will need to be wrapped in classes
sleep(0.5)
#kv = RT.randomKV()
#print kv
try:
#inLine = ser.readline()
inLine = RT.randomKVLine()
if inLine[0] == '@':
newKV = parseLineToKV(inLine)
newStringKV = parseLineToStringKV(inLine)
if firstPass:
keys = sorted(newStringKV.keys())
logger = Logger(keys)
firstPass = False
if newKV != kv:
kv = newKV
stringKV = newStringKV
hud.updateHud(kv)
hud.update_idletasks()
hud.update()
logger.logKV(stringKV)
print strfkv(stringKV)
except TclError: #possibly tclError
print "HUD was closed"
logger.close()
break
except err:
print err
break
class Game():
def __init__(self, _parent=None):
self.parent = _parent
# Containers
self.game_objects = {}
self.game_doors = {}
self.game_objects_np = render.attachNewNode("Game_Objects")
self.game_doors_np = render.attachNewNode("Player_Doors")
self.game_doors_np.setPos(0, 0, 0)
self.game_counter_node = None
self.game_collector_nodes = []
self.redDudesCount = 0
self.blueDudesCount = 0
# Physics world
self.physics_world = None
self.builder = Builder(self)
# level lights
self.directLight = None
# Dude class
self.dude = None
self.spawnPoints = self.builder.spawnPoints
# HUD
self.hud = Hud()
# Lightshow
self.elapsed = 0.0
def start(self, levelID, winCondition=25):
self.winCondition = winCondition
self.loadLevel("assets/level{}".format(levelID))
self.loadLights()
# player
self.loadPlayer("default")
self.loadDude()
# Timer
taskMgr.add(self.update, "Game_Update_Task", 0)
self.hud.show()
# start the Lightshow
taskMgr.add(self.discoLightTask, "the lightshow")
def stop(self):
self.player.stop()
self.dude.stop()
self.builder.cleanup()
self.physics_world = None
render.clearLight()
self.directLight = None
self.hud.hide()
taskMgr.remove("the lightshow")
def update(self, task):
if self.game_counter_node is None:
return
ghost = self.game_counter_node.node()
for node in ghost.getOverlappingNodes():
if "red" in node.name:
self.redDudesCount += 1
self.physics_world.removeRigidBody(self.dude.dudes[node.name].node())
self.dude.dudes[node.name].removeNode()
self.hud.update(self.redDudesCount, self.blueDudesCount)
del self.dude.dudes[node.name]
break
elif "blue" in node.name:
self.blueDudesCount += 1
self.physics_world.removeRigidBody(self.dude.dudes[node.name].node())
self.dude.dudes[node.name].removeNode()
self.hud.update(self.redDudesCount, self.blueDudesCount)
del self.dude.dudes[node.name]
break
if self.redDudesCount > self.blueDudesCount:
base.messenger.send("lostGame")
return Task.done
elif self.blueDudesCount >= self.winCondition:
base.messenger.send("wonGame")
return Task.done
for collectorGhostNP in self.game_collector_nodes:
collectorGhost = collectorGhostNP.node()
for node in collectorGhost.getOverlappingNodes():
if "red" in node.name:
self.physics_world.removeRigidBody(self.dude.dudes[node.name].node())
self.dude.dudes[node.name].removeNode()
self.hud.update(self.redDudesCount, self.blueDudesCount)
del self.dude.dudes[node.name]
return Task.cont
def setPhysicsWorld(self, _physicsworld):
self.physics_world = _physicsworld
#### LOADERS ####
def loadLevel(self, _filename):
self.builder.parseEggFile(_filename)
def loadLights(self):
# Set a simple light
dlight = DirectionalLight('DirectLight')
dlnp = render.attachNewNode(dlight)
dlnp.setHpr(-30, 0, 0)
render.setLight(dlnp)
self.directLight = dlnp
self.discoLights = []
p1 = PointLight("PointLight1")
p1.setColor(VBase4(1, 0, 0, 1))
p1.setAttenuation((0.08, 0, 0.05))
p1np = render.attachNewNode(p1)
p1np.setPos(0, -5, 0)
render.setLight(p1np)
self.discoLights.append(p1)
p2 = PointLight("PointLight2")
p2.setColor(VBase4(0, 1, 0, 1))
p2.setAttenuation((0.08, 0, 0.05))
p2np = render.attachNewNode(p2)
p2np.setPos(5, -5, 0)
render.setLight(p2np)
self.discoLights.append(p2)
p3 = PointLight("PointLight3")
p3.setColor(VBase4(0, 0, 1, 1))
p3.setAttenuation((0.08, 0, 0.05))
p3np = render.attachNewNode(p3)
p3np.setPos(-5, -5, 0)
render.setLight(p3np)
self.discoLights.append(p3)
p4 = PointLight("PointLight4")
p4.setColor(VBase4(0, 0, 1, 1))
p4.setAttenuation((0.08, 0, 0.05))
p4np = render.attachNewNode(p4)
p4np.setPos(-5, -5, 5)
render.setLight(p4np)
self.discoLights.append(p4)
p5 = PointLight("PointLight1")
p5.setColor(VBase4(0, 0, 1, 1))
p5.setAttenuation((0.08, 0, 0.05))
p5np = render.attachNewNode(p5)
p5np.setPos(0, -5, 5)
render.setLight(p5np)
self.discoLights.append(p5)
p6 = PointLight("PointLight1")
p6.setColor(VBase4(0, 0, 1, 1))
p6.setAttenuation((0.08, 0, 0.05))
p6np = render.attachNewNode(p6)
p6np.setPos(5, -5, 5)
render.setLight(p6np)
self.discoLights.append(p6)
def discoLightTask(self, task):
self.elapsed += globalClock.getDt()
if self.elapsed > 0.75:
for light in self.discoLights:
newcolor = choice(
[VBase4(0, 0, 1, 1),
VBase4(0, 1, 0, 1),
VBase4(1, 0, 0, 1),
VBase4(0, 1, 1, 1),
VBase4(1, 0, 1, 1),
VBase4(1, 1, 0, 1),]
)
light.setColor(newcolor)
self.elapsed = 0.0
return task.cont
def loadPlayer(self, _name):
self.player = Player(self)
self.player.start()
def loadDude(self):
self.dude = Dude(self)
self.dude.start()
def run():
pygame.init()
random.seed()
display_size = 800, 600
viewport_size = display_size[0], 600
black = 0, 0, 0
red = 255, 70, 70
green = 70, 255, 70
blue = 70, 70, 255
white = 255, 255, 255
l_green = 50, 255, 0
screen = pygame.display.set_mode(display_size)
screen.fill(black)
clock = Clock(readonly=False)
dbman = DBManager()
dbman.import_db("./db")
gfxman = GfxManager()
gfxman.import_gfx(dbman.get(), "./gfx")
stagemanager = StageManager()
stagemanager.import_stages("./stages")
stages = stagemanager.get()
groupmanager = GroupManager()
g_draw = groupmanager.add("draw", "OrderedUpdates")
g_ship = groupmanager.add("ship")
g_enemies = groupmanager.add("enemies")
g_enemy_projectiles = groupmanager.add("enemy_projectiles")
g_player_projectiles = groupmanager.add("player_projectiles")
g_beams = groupmanager.add("beams")
g_explosions = groupmanager.add("explosions")
g_shields = groupmanager.add("shields")
g_bonuses = groupmanager.add("bonuses")
hud = Hud(viewport_size)
g_enemies.add(Obstacle((60, 30)))
g_enemies.add(MovingObstacle((160, 80)))
g_bonuses.add(RechargeBonus((300, 200)))
g_bonuses.add(SuperShieldBonus((500, 300)))
g_bonuses.add(ShieldUpgradeBonus((500, 500)))
g_bonuses.add(ShieldUpgradeBonus((300, 500)))
ship = ref(PlayerShip((175, viewport_size[1] - 60), g_ship))
hud.setup_connections(ship())
back = SpaceBackground(viewport_size)
for stage_name in sorted(stages.keys()):
stage_clock = 0
while True:
for spawn_time in stages[stage_name]["spawn"]:
if spawn_time <= stage_clock:
while stages[stage_name]["spawn"][spawn_time]:
spawn = stages[stage_name]["spawn"][spawn_time].pop()
pos = spawn["x"], spawn["y"]
object_cls = eval(spawn["object_cls_name"])
if spawn["object_base_cls_name"]:
if spawn["object_base_cls_name"] == "Projectile":
if not spawn.has_key("object_params"):
raise ValueError, "Params for projectile '%s' in stage %s \
not set" % (
spawn["object_cls_name"],
stage_name,
)
if not spawn["object_params"].has_key("dir"):
raise ValueError, "Invalid 'dir' for projectile '%s' in \
stage %s" % (
spawn["object_cls_name"],
stage_name,
)
if not spawn["object_params"].has_key("collision_group"):
raise ValueError, "Invalid 'collision_group' for projectile \
'%s' in stage %s" % (
spawn["object_cls_name"],
stage_name,
)
params = spawn["object_params"]
dir = params["dir"]
g_coll = groupmanager.get(params["collision_group"])
object = object_cls(pos, dir, g_coll)
elif spawn["object_base_cls_name"] == "Bonus":
pass
else:
raise ValueError, "Invalid value '%s' for attrubite \
'object_base_cls_name' in stage %s" % (
spawn["object_base_cls_name"],
stage_name,
)
else:
object = object_cls(pos)
if spawn["bonus_cls_name"]:
if isinstance(object, BonusHolder):
object.set_bonus(spawn["bonus_cls_name"], spawn["bonus_params"])
else:
raise ValueError, "Instances of %s can not hold bonuses." % object.__class__.__name__
if spawn["mover_cls_name"]:
mover_cls = eval("mover.%s" % spawn["mover_cls_name"])
m = mover_cls(pos, object.max_speed, spawn["mover_params"])
object.set_mover(m)
for g in spawn["groups"]:
if g == "enemies":
g_enemies.add(object)
elif g == "explosions":
g_explosions.add(object)
elif g == "enemy_projectiles":
g_enemy_projectiles.add(object)
elif g == "player_projectiles":
g_player_projectiles.add(object)
# time management
clock.tick(40)
# clock.tick( float(sys.argv[1]) )
stage_clock += clock.get_time()
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
sys.exit()
elif event.key == pygame.K_s:
if ship():
ship().next_weapon()
elif event.key == pygame.K_a:
if ship():
ship().previous_weapon()
elif event.key == pygame.K_x:
if ship():
ship().activate_shield(True)
elif event.type == pygame.KEYUP:
if event.key == pygame.K_UP:
if ship():
ship().fly_up(False)
elif event.key == pygame.K_x:
if ship():
ship().activate_shield(False)
pressed_keys = pygame.key.get_pressed()
if pressed_keys[pygame.K_UP]:
if ship():
ship().fly_up(True)
if pressed_keys[pygame.K_DOWN]:
if ship():
ship().fly_down(viewport_size[1])
if pressed_keys[pygame.K_LEFT]:
if ship():
ship().fly_left()
if pressed_keys[pygame.K_RIGHT]:
if ship():
ship().fly_right(viewport_size[0])
if pressed_keys[pygame.K_z]:
if ship():
ship().shoot()
back.clear(screen, clear_bg)
back.update()
back.draw(screen)
# temp
# if ship():
# ship().damage(1)
#
g_draw.clear(screen, clear_bg)
hud.clear(screen, clear_bg)
g_draw.update()
hud.update()
g_draw.draw(screen)
hud.draw(screen)
pygame.display.flip()
class World:
# This is the __init__
# its important.
def __init__(self, app, screen):
# tock started out random, but now is an important variable.
# It is a frames count, used for periodic updates on certain
# frames.
self.p_max_health = 5
self.won = False
self.won_msg = "WINNER!"
self.particle_ban = False
self.wait_stop_count = -1 # -1 means do not count
self.wait_stop_max = 120 # wait this many frames after decay
# before showing menu
self.tock = 0
self.stage_e_bullet_odds = 15
self.mouse_rect = None
self.temp_rect = None
self.app = app
self.screen = screen
self.app.music_name = "intro.ogg"
# self.app.continue_music()
if self.app.settings['music']:
# self.app.music_loaded = self.app.music_name
# pygame.mixer.music.load(self.app.resource_find(
# self.music_name))
# pygame.mixer.music.play() # plays once PLUS repeats param
pass
left_border = 50
right_border = 50
w, h = screen.get_size()
self.world_rect = pygame.Rect(left_border, 0,
w-right_border-left_border, h)
self.bg = BackgroundManager(self.world_rect)
# Yay spritegroups! They make the world go round, and iterate.
# Basically each visible game object resides in its own special
# spritegroup & then all one needs to do is go through these &
# call functions & stuff.
# It makes sense in here *points to brain*
self.p_swarm = Swarm(self.world_rect)
self.particles = Swarm(self.world_rect)
self.explosion_images = self.app.load_seq('ex-medium')
self.shield_hit_images = self.app.load_seq('shield_hit-tiny')
self.damage_images = self.app.load_seq('ex-tiny')
# Load player sprite as image list.
self.p_unit_images = self.app.load_seq('pship')
# self.p_unit_images = []
# self.p_unit_images.append(self.load_file('pship.png'))
# self.p_unit_images.append(self.load_file('pship1.png'))
# self.p_unit_images.append(self.load_file('pship2.png'))
# self.p_unit_images.append(self.load_file('pship3.png'))
# Load enemy ship image.
self.e_ship_image = self.load_file('eship.png')
if self.app.settings['sounds']:
self.p_shoot_sound = self.app.load_file('p-weapon0.wav',
file_type='sound')
self.p_shoot_sound.set_volume(.3)
self.e_ex_sound = self.app.load_file('e-ex.wav',
file_type='sound')
self.p_ex_sound = self.app.load_file('p-ex.wav',
file_type='sound')
self.e_damage_sound = self.app.load_file('e-damage.wav',
file_type='sound')
self.e_shield_sound = self.app.load_file('e-shield.wav',
file_type='sound')
self.p_shield_sound = self.app.load_file('p-shield.wav',
file_type='sound')
self.p_damage_sound = self.app.load_file('p-damage.wav',
file_type='sound')
print("loaded sounds...")
self.menus = None
self.tock = 0
self.lagcount = 0
self.leftkeydown = 0
self.rightkeydown = 0
# self.enemylist = [] # list of dirty rects
self.swarm = Swarm(self.world_rect,
shoot_odds=self.stage_e_bullet_odds)
self.stage = Stage(self.swarm, self.p_swarm)
self.p_shot_image = self.load_file('p-laser.png')
self.e_shot_image = self.load_file('e-laser.png')
self.p_bullet_swarm = Swarm(self.world_rect)
self.e_bullet_swarm = Swarm(self.world_rect)
# self.bullet_width = 10
self.hud_rect = pygame.Rect(0, 0, 5, 150)
self.hud = Hud()
self.hud.generate_blip('player.score', 100,
fg_color=(255,243,207),
text_color=(192,180,180),
caption="SCORE")
self.hud.generate_blip('player.health', self.p_max_health,
fg_color=(0,255,42),
text_color=(192,180,180),
caption="SHIELD")
self.statcounter = self.hud.get_blip('player.score')
def load_file(self, name):
return self.app.load_file(name)
def on_exit(self):
print("on_exit...")
# Clears all the variables
def clear_vars(self):
# print("clear_vars: world_rect: " + str(self.world_rect))
self.p_start_x = self.world_rect.width / 2
self.p_start_y = self.world_rect.height - 60
self.bend_y = float(self.p_start_y)
# print("clear_vars: p_start_y: " + str(self.p_start_y))
self.bend_rate = 0.02
self.leftkeydown = 0
self.rightkeydown = 0
if self.p_unit is not None:
self.hud.set_blip_value('player.health', self.p_unit.health)
else:
print("WARNING: clear_vars failed to set bar since no" +
" player unit exists")
self.statcounter.set_val(0)
self.stage.set_stage_number(-1) # hax
self.stage_e_bullet_odds = 100
self.swarm.empty()
self.p_bullet_swarm.empty()
self.p_swarm.empty()
self.particles.empty()
self.e_bullet_swarm.empty()
# Define function to draw player ship on X, Y plane
def draw_player_units(self):
self.p_swarm.draw(self.screen)
# Define function to move the enemy ship
def emove(self):
self.swarm.draw(self.screen) # use spritegroup draw method
# Draws all the enemys you ask it
def generate_enemies(self):
print("generating enemies...")
# Some recursive loops:
xmin = self.world_rect.left
xmax = self.world_rect.right
ymin = self.world_rect.top
stage_data = self.stage.get_data()
self.e_ship_image = self.app.load_file(stage_data['e']+".png")
enemy_width, enemy_height = self.e_ship_image.get_size()
enemy_spacing_x = 15
enemy_spacing_y = 10
init_enemy_speed = 3
angle = -90 # cartesian
self.app.music_name = stage_data['music']
# if self.app.music_name == 'intro.ogg':
# self.app.continue_music() # force song change
e_max_health = stage_data['e_h']
for enemycol in range(stage_data['x_e_count']):
# Now for the rows
for enemyrow in range(stage_data['y_e_count']):
# Make a new enemy object:
new_enemy = Entity(self.app,
'eship', [self.e_ship_image],
init_enemy_speed, angle,
self.swarm, e_max_health,
self.explosion_images, self.particles,
ai_enable=True,
value=stage_data['e_h'],
ex_sound=self.e_ex_sound)
new_enemy.set_xy(
xmin +
enemycol * (enemy_width +
enemy_spacing_x),
ymin +
enemyrow * (enemy_height +
enemy_spacing_y) - 150
)
new_enemy.set_range(
xmin +
enemycol * (enemy_width +
enemy_spacing_x),
xmax -
(stage_data['x_e_count'] - enemycol) *
(enemy_height +
enemy_spacing_x)
)
# Now add the temp enemy to the array and we're good to
# go
self.swarm.add(new_enemy)
# So I'm trying out having the program check for collisions, instead
# of the enemy objects i think i might switch to the objects, but
# still keep this function just hand the computing to the object
def test_collision(self):
part_speed = 1
part_angle = -90
part_health = 1
e_hit = pygame.sprite.groupcollide(self.swarm,
self.p_bullet_swarm,
0, 0)
for sprite, bullets in e_hit.items():
# print("removed " + str(bullet)
for bullet in bullets:
was_alive = sprite.get_is_alive()
prev_health = sprite.health
if sprite.get_is_alive():
sprite.set_hit(1)
damage = prev_health - sprite.health
poof = self.shield_hit_images
temper_sound = self.e_shield_sound
if damage > 0:
poof = self.damage_images
temper_sound = self.e_damage_sound
if not was_alive:
break
point = pygame.sprite.collide_mask(sprite,
bullet)
if ((point is not None) and
(not self.particle_ban)):
particle = Entity(self.app, 'particle',
poof,
part_speed,
part_angle, self.particles,
part_health,
None,
None,
anim_done_remove=True,
temper_sound=temper_sound)
particle.temper = 1 # start particle death
x1, y1 = sprite.get_pos() # top left
x = x1 + point[0] - particle.rect.width / 2
y = y1 + point[1] - particle.rect.height / 2
particle.set_xy(x, y)
self.particles.add(particle)
if not sprite.get_is_alive():
points = sprite.take_value() # only once & if health 0
if points > 0:
self.statcounter.add_value(points)
self.p_bullet_swarm.remove(bullets)
p_hit = pygame.sprite.groupcollide(self.p_swarm,
self.e_bullet_swarm,
0, 0)
for sprite, bullets in p_hit.items():
for bullet in bullets:
was_alive = sprite.get_is_alive()
prev_health = sprite.health
if sprite.get_is_alive():
sprite.set_hit(1)
damage = prev_health - sprite.health
poof = self.shield_hit_images
temper_sound = self.p_shield_sound
if damage > 0:
poof = self.damage_images
temper_sound = self.p_damage_sound
self.hud.set_blip_value('player.health',
self.p_unit.health)
# New in pygame 1.8.0:
point = pygame.sprite.collide_mask(sprite, bullet)
if not was_alive:
break
if (point is not None) and (not self.particle_ban):
particle = Entity(self.app, 'particle',
poof,
part_speed,
part_angle, self.particles,
part_health,
None,
None,
anim_done_remove=True,
temper_sound=temper_sound)
particle.temper = 1 # start particle death
x1, y1 = sprite.get_pos() # top left
x = x1 + point[0] - particle.rect.width / 2
y = y1 + point[1] - particle.rect.height / 2
particle.set_xy(x, y)
self.particles.add(particle)
# if pygame.sprite.spritecollideany(self.p_unit,
# self.e_bullet_swarm):
# self.p_unit.set_hit(1)
# self.hud.set_blip_value('player.health',
# self.p_unit.health)
# if there are no enemys left, go to the next stage
def check_done(self):
if not self.swarm:
if self.stage.is_last_stage():
if not self.won:
self.won = True # TODO: make ending screen
# self.app.music_name = 'victory.ogg'
# if self.app.music_name == 'intro.ogg':
# self.app.continue_music() # force song change
self.app.music_name = None # stop repeating
self.app.check_music() # apply None to loop
self.app.queue_music('victory.ogg', 1)
if not self.won:
self.stage.next_stage()
if self.stage_e_bullet_odds > 15:
self.stage_e_bullet_odds -= 15
self.generate_enemies()
# checks to see if we can expand the ranges of the bots so its nice
# and.... umm... nice.
def check_rows(self):
if self.tock % 20 == 0:
# simple sorting algorithm to find the highest values
xmin = self.world_rect.left
xmax = self.world_rect.right
highest = xmin
lowest = xmax
for enemy in self.swarm:
if enemy.get_range()[1] > highest:
highest = enemy.get_range()[1]
if enemy.get_range()[0] < lowest:
lowest = enemy.get_range()[0]
highest = xmax - highest
lowest = lowest - xmin
if highest != 0 or lowest != 0:
# makes things |--| this much more efficient
for enemy in self.swarm:
erange = enemy.get_range()
enemy.set_range(erange[0]-lowest,
erange[1]+highest)
# major hack just to get this thing playable..... sorry
def again(self):
if self.hud.get_blip_value('player.health') <= 0:
self.particle_ban = True
if self.p_unit.get_is_decayed():
self.particle_ban = True
# also wait for particles to finish for prettier ending
if len(self.particles) < 1:
if self.wait_stop_count < 0:
print("player unit decayed, counting down to menu")
self.wait_stop_count = 0
# return False
if self.wait_stop_count >= 0:
self.wait_stop_count += 1
if self.wait_stop_count > self.wait_stop_max:
return False
if self.won:
if self.wait_stop_count < 0:
print("won game, counting down to menu")
self.wait_stop_count = 0
return True
# this is called if the player initiates shooting
def pshoot(self):
# sx = self.p_unit.rect.centerx -
# self.p_shot_image.rect.width / 2
# sy = self.p_unit.rect.top +
# self.p_shot_image.rect.height * .75
if self.p_unit.get_is_alive():
self.p_unit.shoot(self.p_shot_image,
self.p_bullet_swarm)
# self.p_unit.shoot_from(self.p_shot_image,
# self.p_bullet_swarm,
# sx, sy, self.p_unit.angle)
def draw_bullets(self):
self.p_bullet_swarm.draw(self.screen)
self.e_bullet_swarm.draw(self.screen)
def draw_hud(self):
if self.tock % 5 == 0:
self.hud.update()
self.hud.draw(self.screen)
# Goes through all the objects and makes each of them move as
# necessary
def tick(self):
self.bend_y += self.bend_rate
bend_max = 5.0
if self.bend_rate < 0.0:
self.bend_rate -= .02
else:
self.bend_rate += .02
if ((self.bend_y > self.p_start_y + bend_max) or
(self.bend_y < self.p_start_y)):
if self.bend_rate < 0.0:
self.bend_rate = .02
self.bend_y = float(self.p_start_y)
else:
self.bend_rate = -.02
self.bend_y = float(self.p_start_y) + bend_max
self.p_unit.set_xy(self.p_unit.get_pos()[0],
int(self.bend_y+.5))
self.p_bullet_swarm.update()
self.swarm.update()
self.e_bullet_swarm.update()
######################
# Here are a bunch of metafunctions.
# I break it up so its really easy to add new features,
# like if we ant a counter? add something to check() and draw().
# All of these are called once per frame.
def check(self):
self.check_done()
self.test_collision()
self.check_rows()
self.bg.update()
if self.p_unit.get_is_alive():
self.swarm.shoot(self.e_shot_image, self.e_bullet_swarm)
self.p_unit.update()
for particle in self.particles:
particle.update()
def draw(self):
self.screen.fill(self.bg.bg_color)
# if self.world_rect is not None:
# self.screen.fill((64, 64, 64), self.world_rect)
self.bg.draw(self.screen)
self.draw_bullets()
self.draw_player_units()
self.emove()
self.particles.draw(self.screen)
self.draw_hud()
# if self.p_unit is not None:
# if self.p_unit.rect is not None:
# self.screen.fill((128, 128, 128), self.p_unit.rect)
# if self.mouse_rect is not None:
# self.screen.fill((255, 255, 255), self.mouse_rect)
# if self.temp_rect is not None:
# self.screen.fill((128, 0, 0), self.temp_rect)
# does just what it sounds like.....
def clear_screen(self):
self.screen.fill(self.bg.bg_color)
# pygame.display.flip()
# for debugging info mostly
def dispvars(self):
print("The Enemy SpriteGroup size is:" +
str(len(self.swarm.sprites())))
print("The Player Bullet Array size is:" +
str(len(self.p_bullet_swarm.sprites())))
print("The Enemy Bullet Array size is:" +
str(len(self.e_bullet_swarm.sprites())))
# does lots and lots of stuff, it really needs to be cleaned up
def process_events(self, events):
# print("input: self.p_unit.rect: " + str(self.p_unit.rect))
xmin = self.world_rect.left
xmax = self.world_rect.right
smooth_scroll_var1 = 10
smooth_scroll_var2 = 2
pygame.event.pump() # redraw Window so OS knows not frozen
self.app.check_music()
pause_menu_strings = ["RESUME", "ABOUT", "HELP", "EXIT"]
if self.won:
pause_menu_strings.insert(0, self.won_msg)
for event in events:
if event.type == QUIT:
self.on_exit()
sys.exit(0)
if event.type == pygame.MOUSEMOTION:
pygame.event.get()
prev_pos = self.p_unit.get_pos()
tempx = (pygame.mouse.get_pos()[0] -
self.p_unit.rect.width / 2)
# *Just to make sure we don't get the ship way out:
if tempx + self.p_unit.rect.width > xmax:
# if its outside the world,
# just stick it as far as possible
self.p_unit.set_xy(xmax - self.p_unit.rect.width,
prev_pos[1])
elif tempx < xmin:
self.p_unit.set_xy(xmin, prev_pos[1])
elif abs(tempx-self.p_start_x) > \
smooth_scroll_var1:
# smooth scrolling if the mouse gets far
# from the ship
self.p_unit.set_xy(
prev_pos[0] +
(tempx-prev_pos[0]) /
smooth_scroll_var2,
prev_pos[1])
else:
# if it gets down to this point,
# we've passed all sanity checks so just move it
self.p_unit.set_xy(tempx, prev_pos[1])
elif event.type == pygame.MOUSEBUTTONDOWN:
self.pshoot()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
self.menus.show_dialog(pause_menu_strings)
if event.key == pygame.K_p:
self.menus.show_dialog(pause_menu_strings)
if event.key == pygame.K_ESCAPE:
self.menus.show_dialog(pause_menu_strings)
# keyboard controls
if event.key == pygame.K_LEFT:
self.leftkeydown = 1
if event.key == pygame.K_RIGHT:
self.rightkeydown = 1
if event.key == pygame.K_SPACE:
self.pshoot()
elif event.type == pygame.KEYUP:
if event.key == pygame.K_LEFT:
self.leftkeydown = 0
if event.key == pygame.K_RIGHT:
self.rightkeydown = 0
elif event.type == pygame.USEREVENT:
if event.code == pygame.USEREVENT_DROPFILE:
print("Tried to open file on MacOS (this should" +
" never happen:")
print(" " + str(event))
else: # should be event.code 0
self.app.continue_music()
print("music queue ended in game:")
if event.code != 0:
print("unknown USEREVENT event.code: " +
str(event.code))
if self.leftkeydown:
self.p_unit.move_one(-1, self.world_rect)
if self.rightkeydown:
self.p_unit.move_one(1, self.world_rect)
pygame.event.clear()
####################################################################
def start(self, menus):
self.won = False
self.particle_ban = False
self.wait_stop_count = -1 # -1 means do not count down to menu
self.menus = menus
p_speed = 10
self.p_unit = Entity(self.app, 'pship', self.p_unit_images,
p_speed, 90.0,
self.p_swarm, self.p_max_health,
self.explosion_images,
self.particles,
ex_sound = self.p_ex_sound)
self.p_unit.shoot_sound = self.p_shoot_sound
print("Clearing vars...")
self.clear_vars() # does reset player unit (p_unit) position
self.p_swarm.add(self.p_unit)
self.p_unit.set_xy(self.p_start_x, self.p_start_y)
print("Starting main event loop...")
self.loop()
# Yeah see this one does all of the work
def loop(self):
# Start loop
REFRESH_TIME = self.app.get_fps() * 3
while (not self.menus.get_bool('exit')) and (self.again()):
# Refresh screen periodically
if self.tock >= REFRESH_TIME:
# self.clear_screen()
self.tock = 0
self.tock += 1
# Check everythign and see if changes need to be made
self.check()
# Draw bullets
self.draw()
# Move everything
self.tick()
# Initiate input function
self.process_events(pygame.event.get())
# applies the smart screen updating
pygame.display.update()
# TODO: ? pygame.display.update(self.enemylist)
# self.enemylist = []
# Pauses and waits
timeittook = self.app.clock.tick(self.app.get_fps())
class GameScreen(Events):
"""docstring for GameScreen"""
def __init__(self, window):
super(GameScreen, self).__init__()
self.window = window
self.camera = Camera(window)
self.player = player.Player()
self.proj_viewer = ProjectileViewer(self.send_center)
self.controls = {}
self.controls_old = {}
self.map = Map('blank')
#self.player.spawn(100, 100)
self.time = 0
self.moves = moves(1024)
self.index = [0]
self.head = [0]
#other players
self.players = {}
self.specs = {}
#crosshair
self.cross = CrossHair()
self.isSpec = True
self.hud = Hud()
self.gs_view = GameStateViewer(self.players, self.hud.update_prop,
self.hud.set_score)
def update(self, dt):
dt = int(dt * 1000000) / 1000000.
if self.controls['esc'] and not self.controls_old['esc']:
self.send_message('menu_transition_+', (GameMenu, self.isSpec))
if self.controls['rdy'] and not self.controls_old['rdy']:
if not self.isSpec:
self.ready_up()
if self.controls['chat'] and not self.controls_old['chat']:
self.send_message('menu_transition_+',
(ChatScreen, self.window))
self.update_keys()
self.on_update(dt)
def update_physics(self, dt, state=False, input=False):
playergen = (player.rect for player in self.players.itervalues())
mapgen = (rect for rect in self.map.quad_tree.retrieve([],
self.player.rect))
rectgen = chain(playergen, mapgen)
self.player.update(dt, rectgen, state, input)
return self.player.state
def update_state_only(self, state):
self.player.state.update(0, state)
def update_keys(self):
for key_, value in self.controls.items():
self.controls_old[key_] = value
def from_server(self, data):
typ, data = data
if typ == proto.playerUpdate:
ind, time, s_state, inpt, weaponinfo = data
smove = move(time, inpt, s_state)
if ind == self.player.id:
correct_client(self.update_physics, smove, self.moves,
self.head, self.index[0],
self.update_state_only)
self.player.weapons.from_server(weaponinfo)
else:
#try:
self.players[ind].client_update(s_state)
self.players[ind].input = inpt
#except KeyError:
# pass
elif typ == proto.projectile:
self.proj_viewer.process_proj(data)
elif typ == proto.newPlayer:
gs, data = data
if gs == proto.goesSpec:
ind, name, colstring = data
new = player.Player()
new.name = name
new.id = ind
new.set_color(colstring)
self.specs[ind] = new
#if there are existing players on the server
elif gs == proto.wantsJoin:
ind, name, state, time, colstring = data
new = player.Player()
new.name = name
new.state = state
new.time = time
new.id = ind
new.set_color(colstring)
new.rect.update_color(new.color)
self.players[ind] = new
print 'new player: %s' % name
self.gs_view.to_team(ind)
elif typ == proto.disconnect:
ind = data
if ind in self.players:
self.gs_view.leave(ind)
del self.players[ind]
elif ind in self.specs:
del self.specs[ind]
elif typ == proto.stateUpdate:
gametime, data = data
gs, ind = data
self.gs_view.set_time(gametime)
if gs == proto.wantsJoin:
if ind == self.player.id:
self.send_message('menu_transition_-')
self.player.state.isDead = False
self.trans_to_game()
else:
self.players[ind] = self.specs[ind]
del self.specs[ind]
self.gs_view.to_team(ind)
elif gs == proto.goesSpec:
if ind == self.player.id and self.isSpec:
pass
elif ind == self.player.id and not self.isSpec:
self.send_message('menu_transition_-')
self.trans_to_spec()
else:
self.specs[ind] = self.players[ind]
self.gs_view.leave(ind)
del self.players[ind]
elif gs == proto.isDead:
ind, killer, weapon = ind
if ind == self.player.id:
self.player.die()
else:
self.players[ind].die()
self.gs_view.score(ind, killer, weapon)
elif gs == proto.spawns:
ind, pos = ind
if ind == self.player.id:
self.player.spawn(*pos)
else:
self.players[ind].spawn(*pos, other=True)
elif gs == proto.isReady:
ind, name = ind
self.gs_view.is_ready(ind, name)
elif gs == proto.countDown:
self.player.freeze()
elif gs == proto.inProgress:
self.gs_view.start_game()
elif gs == proto.warmUp:
self.gs_view.to_warmup()
elif typ == proto.mapUpdate:
ind, itemid, gt, spawn = data
self.gs_view.set_time(gt)
if ind == self.player.id:
if isinstance(self.map.items[itemid], Triangle):
st = self.map.items[itemid].keystr
if not st in self.player.weapons.weapons:
self.player.weapons.pickup(st)
else:
self.player.weapons.apply(st, self.player)
self.map.serverupdate(itemid, spawn)
elif typ == proto.chat:
ind, msg = data
if ind == self.player.id:
name = self.player.name
color = self.player.color
elif ind in self.players:
name = self.players[ind].name
color = self.players[ind].color
else:
name = self.specs[ind].name
color = self.specs[ind].color
#chatdata = ' '.join((name + ':', '\t', msg))
chatdata = (name, color, msg)
self.hud.update_prop(chat=chatdata)
def send_to_client(self, dt):
temp_input = proto.Input()
self.time += int(dt * 1000000)
temp_input.CopyFrom(self.player.input)
c_move = move(self.time, temp_input, self.player.state.copy())
try:
self.moves[self.index[0]] = c_move
except IndexError:
self.moves.append(c_move)
self.moves.advance(self.index)
self.send_message('input', (self.player.input, self.time))
def spec_send(self, dt):
self.send_message('input', (proto.Input(), self.time))
def draw(self):
self.on_draw()
def on_connect(self, msg):
ind, mapname, name = msg
self.player.get_id(ind, name)
self.map = Map(mapname)
print 'connected with id: ' + str(self.player.id)
#self.send_message('input', (self.player.input, 1337))
self.gs_view.init_self(ind)
self.trans_to_spec()
def try_join(self):
msg = proto.Message()
msg.type = proto.stateUpdate
plr = proto.Player()
plr.id = self.player.id
msg.player.CopyFrom(plr)
if self.isSpec:
msg.gameState = proto.wantsJoin
else:
msg.gameState = proto.goesSpec
self.send_message('other', msg)
def ready_up(self):
msg = proto.Message()
msg.type = proto.stateUpdate
plr = proto.Player()
plr.id = self.player.id
msg.player.CopyFrom(plr)
msg.gameState = proto.isReady
self.send_message('other', msg)
def send_chat(self, chatmsg):
msg = proto.Message()
msg.type = proto.chat
plr = proto.Player()
plr.id = self.player.id
plr.chat = chatmsg
msg.player.CopyFrom(plr)
self.send_message('other', msg)
def on_update(self, dt):
pass
def on_draw(self):
pass
def idle_update(self, dt):
self.send_to_client(dt)
self.gs_view.update(dt)
self.hud.update(dt)
def trans_to_spec(self):
self.on_update = self.spec_update
self.on_draw = self.spec_draw
self.isSpec = True
self.player.state.hook_hud(self.hud.update_prop)
self.hud.init_spec()
def trans_to_game(self):
self.on_update = self.game_update
self.on_draw = self.game_draw
self.isSpec = False
self.player.weapons.hook_hud(self.hud.update_prop)
self.player.state.hook_hud(self.hud.update_prop)
self.gs_view.add_self(self.player)
self.hud.init_player(self.players)
def game_update(self, dt):
self.update_physics(dt)
self.camera.update(dt, self.player.state)
self.send_to_client(dt)
self.proj_viewer.update(dt)
self.gs_view.update(dt)
self.hud.update(dt)
def game_draw(self):
self.camera.set_camera()
for plr in self.players.itervalues():
plr.draw()
self.player.draw()
self.proj_viewer.draw()
self.map.draw()
self.camera.set_static()
self.hud.draw()
self.cross.draw(*self.camera.mpos)
def spec_update(self, dt):
self.player.specupdate(dt)
self.camera.update(dt, self.player.state)
#self.send_to_client(dt)
self.spec_send(dt)
self.proj_viewer.update(dt)
self.gs_view.update(dt)
self.hud.update(dt)
def spec_draw(self):
self.camera.set_camera()
for plr in self.players.itervalues():
plr.draw()
self.proj_viewer.draw()
self.map.draw()
self.camera.set_static()
self.hud.draw()
def send_center(self, ind):
if ind == self.player.id:
pl = self.player
return pl.rect.center, (pl.input.mx, pl.input.my)
else:
pl = self.players[ind]
return pl.rect.center, (pl.input.mx, pl.input.my)
def playGame(character1, character2):
pygame.init()
pygame.mixer.init()
pygame.mixer.music.load("Sound/07 - The Raising Fighting Spirit.ogg") #Background music "The Rising Fighting Spirit":http://downloads.khinsider.com/game-soundtracks/album/naruto-original-soundtrack-1
pygame.mixer.music.play(-1)
displaysurf = pygame.display.set_mode((WIDTH, HEIGHT))
clock = pygame.time.Clock()
player1=Character(PLAYER1_CONTROLS, IMAGES[character1], SOUNDS[character1], PLAYER1_POSITION)
player2=Character(PLAYER2_CONTROLS, IMAGES[character2], SOUNDS[character2], PLAYER2_POSITION)
HUD1_IMAGES=HUD_IMAGES.copy()
HUD1_IMAGES["icon"]=IMAGES[character1]["icon"]
HUD2_IMAGES=HUD_IMAGES.copy()
HUD2_IMAGES["icon"]=IMAGES[character2]["icon"]
player1_hud=Hud(HUD1_IMAGES, LEFT_HUD_POSITION)
player2_hud=Hud(HUD2_IMAGES, RIGHT_HUD_POSITION)
player2_hud.flip()
background=load_image("Background/training_background.png") #http://spritedatabase.net/game/1889
background=pygame.transform.scale(background, (WIDTH, HEIGHT))
player1_wins=load_image("Background/player1wins.png") #Used the folowing website to generate the win signs: http://www.dafont.com/ninja-naruto.font
player2_wins=load_image("Background/player2wins.png")
pygame.display.set_caption('Pybrawl')
game_over=False
while True: # main game loop
displaysurf.blit(background, (0,0))
clock.tick(FPS)
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
elif event.type == KEYDOWN and event.key == K_RETURN and game_over:
return
if player1.health==0:
game_over=True
pygame.mixer.music.stop()
displaysurf.blit(player2_wins, (172, 200))
if player2.health==0:
game_over=True
pygame.mixer.music.stop()
displaysurf.blit(player1_wins, (172, 200))
keys_status=pygame.key.get_pressed()
if game_over:
keys_status=[False for i in keys_status]
player1.update(keys_status)
player2.update(keys_status)
collide(player1, player2)
keep_inside(player1)
keep_inside(player2)
if player1.rect.centerx < player2.rect.centerx:
player1.direction="right"
player2.direction="left"
else:
player1.direction="left"
player2.direction="right"
player1_hud.update(player1.health/player1.max_health,
player1.mana/player1.max_mana)
player2_hud.update(player2.health/player2.max_health,
player2.mana/player2.max_mana)
player1.draw(displaysurf)
player2.draw(displaysurf)
player1_hud.draw(displaysurf)
player2_hud.draw(displaysurf)
pygame.display.update()
class GameScreen(Events):
"""docstring for GameScreen"""
def __init__(self, window, input_handler):
super(GameScreen, self).__init__()
self.window = window
self.input_handler = input_handler
self.camera = Camera(window)
self.render = Render(self.camera, self.window)
sc_batch = self.render.scene_batch
st_batch = self.render.static_batch
self.player = player.Player(renderhook=self.render.playerhook)
self.proj_viewer = ProjectileViewer(
self.send_center, batch=sc_batch, scale=self.render.scale,
rndhook=self.render.attack)
self.controls = {}
self.controls_old = {}
self.map = Map('blank')
#self.player.spawn(100, 100)
self.time = 0
self.moves = moves(1024)
self.index = [0]
self.head = [0]
#other players
self.players = {}
self.specs = {}
#crosshair
self.cross = CrossHair(batch=st_batch)
self.isSpec = 0.5
self.hud = Hud(batch=st_batch, window=self.window)
self.gs_view = GameStateViewer(self.players, self.hud.update_prop,
self.hud.set_score)
self.frozen = False
self.rest_time = 0
def update(self, dt):
dt = int(dt * 1000000.) / 1000000.
if self.controls['esc'] and not self.controls_old['esc']:
self.send_message('menu_transition_+', (GameMenu, self.isSpec))
if self.controls['rdy'] and not self.controls_old['rdy']:
if not self.isSpec:
self.ready_up()
self.render.move_ahead()
if self.controls['chat'] and not self.controls_old['chat']:
self.send_message('menu_transition_+',
(ChatScreen, None))
self.update_keys()
for plr in self.players.itervalues():
mapgen = [rect for rect in self.map.quad_tree.retrieve([],
plr.rect)]
plr.predict(dt, mapgen)
self.on_update(dt)
def update_physics(self, dt, state=False, input=False):
self.player.update(dt, self.get_rect(), state, input)
return self.player.state.copy()
def update_state_only(self, state):
self.player.state.update_hp(state)
def update_keys(self):
for key_, value in self.controls.items():
self.controls_old[key_] = value
def from_server(self, data):
typ, data = data
if typ == proto.playerUpdate:
ind, time, s_state, inpt, weaponinfo = data
smove = move(time, inpt, s_state)
if ind == self.player.id:
correct_client(self.update_physics, smove, self.moves,
self.head, self.index[0],
self.update_state_only)
self.player.weapons.from_server(weaponinfo)
else:
self.players[ind].client_update(s_state)
self.players[ind].input = inpt
if ind == self.isSpec:
self.camera.mpos_from_aim(vec2(inpt.mx, inpt.my))
self.players[ind].weapons.from_server(weaponinfo)
self.render.weapon_check(ind, weaponinfo)
elif typ == proto.projectile:
self.proj_viewer.process_proj(data)
elif typ == proto.newPlayer:
gs, data = data
if gs == proto.goesSpec:
ind, name, colstring = data
new = player.Player(renderhook=self.render.playerhook, id=ind)
new.name = name
new.id = ind
new.set_color(colstring)
new.rect.update_color(new.color)
self.specs[ind] = new
#if there are existing players on the server
elif gs == proto.wantsJoin:
ind, name, state, time, colstring = data
new = player.Player(renderhook=self.render.playerhook, id=ind)
new.name = name
new.state = state
new.time = time
new.id = ind
new.set_color(colstring)
new.rect.update_color(new.color)
self.players[ind] = new
new.add_to_view()
print 'new player: %s' % name
self.gs_view.to_team(ind)
elif typ == proto.disconnect:
ind = data
if ind in self.players:
if ind == self.isSpec:
self.cancel_follow()
self.gs_view.leave(ind)
self.players[ind].remove_from_view()
del self.players[ind]
self.set_playergen()
elif ind in self.specs:
del self.specs[ind]
elif typ == proto.stateUpdate:
gametime, data = data
gs, ind = data
self.gs_view.set_time(gametime)
if gs == proto.wantsJoin:
if ind == self.player.id:
self.send_message('menu_transition_-')
self.player.state.isDead = False
if self.isSpec > 0.5:
self.players[self.isSpec].state.unhook()
self.players[self.isSpec].weapons.unhook()
self.trans_to_game()
else:
self.players[ind] = self.specs[ind]
del self.specs[ind]
self.gs_view.to_team(ind)
self.players[ind].add_to_view()
elif gs == proto.goesSpec:
if ind == self.player.id and self.isSpec:
pass
elif ind == self.player.id and not self.isSpec:
self.send_message('menu_transition_-')
self.gs_view.leave(self.player.id)
self.trans_to_spec()
else:
self.specs[ind] = self.players[ind]
self.gs_view.leave(ind)
if ind == self.isSpec:
self.cancel_follow()
del self.players[ind]
self.specs[ind].remove_from_view()
self.set_playergen()
elif gs == proto.isDead:
ind, killer, weapon = ind
if ind == self.player.id:
self.player.die()
else:
self.players[ind].die()
self.gs_view.score(ind, killer, weapon)
elif gs == proto.spawns:
ind, pos = ind
if ind == self.player.id:
self.player.spawn(*pos)
else:
self.players[ind].spawn(*pos, other=True)
elif gs == proto.isReady:
ind, name = ind
self.gs_view.is_ready(ind, name)
elif gs == proto.countDown:
self.player.freeze()
self.gs_view.count_down()
elif gs == proto.inProgress:
self.gs_view.start_game()
elif gs == proto.warmUp:
self.frozen = False
self.gs_view.to_warmup()
elif gs == proto.gameOver:
self.frozen = True
self.gs_view.show_score()
elif gs == proto.overTime:
self.hud.update_prop(text='Overtime!')
elif typ == proto.mapUpdate:
ind, itemid, gt, spawn = data
self.gs_view.set_time(gt)
if ind == self.player.id:
if isinstance(self.map.items[itemid], Triangle):
st = self.map.items[itemid].keystr
if not st in self.player.weapons.weapons:
self.player.weapons.pickup(st)
else:
if not isinstance(self.map.items[itemid], Ammo):
self.player.weapons.apply(st, self.player)
else:
self.player.weapons.predict_ammo(st)
elif ind in self.players:
if isinstance(self.map.items[itemid], Triangle):
st = self.map.items[itemid].keystr
if not st in self.players[ind].weapons.weapons:
self.players[ind].weapons.pickup(st)
else:
if not isinstance(self.map.items[itemid], Ammo):
try:
pl = self.players[ind]
pl.weapons.apply(st, pl)
except TypeError:
pass
else:
self.players[ind].weapons.predict_ammo(st)
self.map.serverupdate(itemid, spawn)
elif typ == proto.chat:
ind, msg = data
if ind == self.player.id:
name = self.player.name
color = self.player.color
elif ind in self.players:
name = self.players[ind].name
color = self.players[ind].color
else:
name = self.specs[ind].name
color = self.specs[ind].color
#chatdata = ' '.join((name + ':', '\t', msg))
chatdata = (name, color, msg)
self.hud.update_prop(chat=chatdata)
def send_to_client(self, dt):
temp_input = proto.Input()
self.time += int(dt * 1000000.)
temp_input.CopyFrom(self.player.input)
c_move = move(self.time, temp_input, self.player.state.copy())
try:
self.moves[self.index[0]] = c_move
except IndexError:
self.moves.append(c_move)
self.moves.advance(self.index)
self.send_message('input', (self.player.input, self.time))
def spec_send(self, dt):
self.rest_time += dt
if self.rest_time >= timestep * 6:
self.time += int(timestep * 1000000.)
self.rest_time = 0
self.send_message('input', (proto.Input(), self.time))
def draw(self):
self.render.draw()
def on_connect(self, msg):
ind, mapname, name, gs = msg
self.player.get_id(ind, name)
batch = pyglet.graphics.Batch()
self.map = Map(mapname, batch=batch, renderhook=self.render.maphook)
self.render.maphook(self.map, add=True)
print 'connected with id: ' + str(self.player.id)
#self.send_message('input', (self.player.input, 1337))
self.gs_view.init_self(ind, gs)
self.trans_to_spec()
def try_join(self):
msg = proto.Message()
msg.type = proto.stateUpdate
plr = proto.Player()
plr.id = self.player.id
msg.player.CopyFrom(plr)
if self.isSpec:
msg.gameState = proto.wantsJoin
else:
msg.gameState = proto.goesSpec
self.send_message('other', msg)
def ready_up(self):
msg = proto.Message()
msg.type = proto.stateUpdate
plr = proto.Player()
plr.id = self.player.id
msg.player.CopyFrom(plr)
msg.gameState = proto.isReady
self.send_message('other', msg)
def send_chat(self, chatmsg):
msg = proto.Message()
msg.type = proto.chat
plr = proto.Player()
plr.id = self.player.id
plr.chat = chatmsg
msg.player.CopyFrom(plr)
self.send_message('other', msg)
def on_update(self, dt):
pass
def on_draw(self):
pass
def idle_update(self, dt):
self.rest_time += dt
if not self.isSpec:
while self.rest_time >= timestep:
if not self.frozen:
self.update_physics(timestep)
self.send_to_client(timestep)
self.rest_time -= timestep
#interpolate missing time
state = self.player.state.copy()
self.player.predict_step(self.rest_time, self.get_rect(),
state, self.player.input)
else:
self.spec_send(dt)
self.render.update(dt)
self.gs_view.update(dt)
self.proj_viewer.update(dt)
self.hud.update(dt)
def trans_to_spec(self):
self.on_update = self.spec_update
self.isSpec = 0.5
self.player.state.hook_hud(self.hud.update_prop)
self.hud.init_spec()
self.gs_view.scorehook(self.gs_view.a.score, self.gs_view.b.score)
self.player.remove_from_view()
self.cross.remove()
self.ready_cycle = False
self.set_playergen()
self.window.set_mouse_visible(True)
self.window.set_exclusive_mouse(False)
def trans_to_game(self):
self.player.add_to_view()
self.isSpec = False
self.player.weapons.hook_hud(self.hud.update_prop)
#self.player.state.hook_hud(self.hud.update_prop)
self.hud.init_player(self.players)
self.gs_view.add_self(self.player)
self.cross.add(self.render.static_batch)
self.on_update = self.game_update
self.register_mouse()
self.window.set_mouse_visible(False)
self.window.set_exclusive_mouse(True)
self.cancel_drag()
self.rest_time = 0
def game_update(self, dt):
self.rest_time += dt
while self.rest_time >= timestep:
if not self.frozen:
self.update_physics(timestep)
self.send_to_client(timestep)
self.rest_time -= timestep
#interpolate missing time
state = self.player.state.copy()
self.player.predict_step(self.rest_time, self.get_rect(),
state, self.player.input)
#state.id = self.player.id
#state.mpos = vec2(self.player.input.mx, self.player.input.my)
#state.color = self.player.color
#self.render.playerhook(state, update=True)
self.render.update(dt)
self.camera.update(dt, self.player.state)
self.proj_viewer.update(dt)
self.gs_view.update(dt)
self.hud.update(dt)
self.cross.update(*self.camera.mpos)
def spec_update(self, dt):
if self.player.input.att and self.ready_cycle:
try:
self.ready_cycle = False
if self.isSpec > 0.5:
self.players[self.isSpec].state.unhook()
self.players[self.isSpec].weapons.unhook()
self.isSpec = self.playergen.next()
id = self.isSpec
self.players[id].state.hook_hud(self.hud.update_prop)
self.players[id].weapons.hook_hud(self.hud.update_prop)
self.unregister_mouse()
self.cross.add(self.render.static_batch)
self.hud.init_pers_hud()
self.cancel_drag()
except StopIteration:
self.cancel_follow()
if not self.player.input.att:
self.ready_cycle = True
if self.isSpec > 0.5:
self.camera.update(dt, self.players[self.isSpec].state)
self.cross.update(*self.camera.interpolate_mpos())
else:
self.player.specupdate(dt)
self.camera.update(dt, self.player.state)
self.render.update(dt)
self.spec_send(dt)
self.proj_viewer.update(dt)
self.gs_view.update(dt)
self.hud.update(dt)
def send_center(self, ind):
if ind == self.player.id:
pl = self.player
return pl.rect.center, (pl.input.mx, pl.input.my)
else:
pl = self.players[ind]
return pl.rect.center, (pl.input.mx, pl.input.my)
def register_mouse(self):
self.input_handler.register(self.camera.receive_m_pos, 'mouse_cam')
self.window.set_mouse_visible(True)
self.window.set_exclusive_mouse(False)
def unregister_mouse(self):
try:
self.input_handler.unregister(self.camera.receive_m_pos)
self.window.set_mouse_visible(False)
self.window.set_exclusive_mouse(True)
except KeyError:
pass
def set_playergen(self):
self.playergen = iter(self.players.keys())
def cancel_follow(self):
ind = self.isSpec
if ind > 0.5:
self.player.state.pos = vec2(*self.players[ind].state.pos)
self.isSpec = 0.5
self.set_playergen()
self.register_mouse()
self.cross.remove()
self.hud.init_spec()
@self.window.event
def on_mouse_drag(x, y, dx, dy, buttons, mods):
if buttons == 4:
self.player.state.pos -= vec2(dx, dy) * 2
self.dragevent = on_mouse_drag
def cancel_drag(self):
try:
self.window.remove_handler('on_mouse_drag', self.dragevent)
except AttributeError:
pass
def get_rect(self):
playerlist = [player.rect for player in self.players.itervalues()
if not player.state.isDead]
maplist = [rect for rect in self.map.quad_tree.retrieve([],
self.player.rect)]
return playerlist + maplist
class World (object):
def __init__(self):
super(World, self).__init__()
self.frames = 1
# this is normal difficulty by default
# easy would prolly be .7ish and hard.. 1.3 or so?
self.difficulty = 0.7
self.spawnFreq = 10
self.scrollPosition = 0
self.scrollSpeed = 3
self.endPosition = FRAMES_UNTIL_BOSS * self.scrollSpeed
self.startScreen = True
self.helpScreen = False
self.difficultyScreen = False
self.bossMode = False
self.gameOver = False
self.winScreen = False
self.score = 0
self.call_popcorn = 0
self.boss_music=False
self.holdingLeftMouseButton = False
#for keeping track of for the win screen!
self.numEnemiesAppeared = 0
self.numEnemiesDestroyed = 0
self.numViruses = 0
self.numWorms = 0
self.numPopUps = 0
self.playerGroup = pygame.sprite.GroupSingle()
self.enemies = pygame.sprite.Group()
self.pickups = pygame.sprite.Group()
self.bullets = pygame.sprite.Group()
self.mines = pygame.sprite.Group()
self.backgrounds = pygame.sprite.Group()
self.spawnBkg()
# sprite groups listed in draw order (lowest sprite get drawn first)
self.spriteGroups = [self.backgrounds, self.mines, self.pickups, self.bullets, self.enemies, self.playerGroup]
self.hud = Hud()
def spawnWorld(self):
self.StartScreen = False
playerPos = (PLAY_WIDTH / 2, SCREEN_HEIGHT - 50)
pygame.mouse.set_pos(playerPos)
self.player = Player(self, playerPos)
self.playerGroup.add(self.player)
pygame.mixer.music.load("data/music/Main.mp3")
pygame.mixer.music.play()
self.hud.createHudElements()
self.frames = 1
self.scrollPosition = 0
self.scrollSpeed = 3
def spawnBkg(self):
bkg = Bkg()
self.backgrounds.add(bkg)
def spawnCtrl(self):
ctrl = Ctrl()
self.pickups.add(ctrl)
def spawnAlt(self):
alt = Alt()
self.pickups.add(alt)
def spawnDel(self):
d = Del()
self.pickups.add(d)
def spawnVirus(self, position):
self.numEnemiesAppeared += 1
enemy = Virus(position)
self.enemies.add(enemy)
def spawnDoubleVirus(self, position):
self.numEnemiesAppeared += 1
enemy = DoubleVirus(self, position)
self.enemies.add(enemy)
def spawnTripleVirus(self):
self.numEnemiesAppeared += 1
enemy = TripleVirus(self)
self.enemies.add(enemy)
def spawnWorm(self):
self.numEnemiesAppeared += 1
position1 = random.randint(195,PLAY_WIDTH-50)
position2 = 10
position = position1, position2
enemy = Worm(position,'head')
self.enemies.add(enemy)
for i in range(random.randint(1,5)):
position1 -= 32
position = position1, position2
enemy = Worm(position,'body')
self.enemies.add(enemy)
position1 -= 32
position = position1, position2
enemy = Worm(position,'tail')
self.enemies.add(enemy)
def spawnPopup(self):
self.numEnemiesAppeared += 1
enemy = Popup()
while len(pygame.sprite.spritecollide(enemy, self.playerGroup, False)) > 0:
enemy = Popup()
self.enemies.add(enemy)
def spawnBoss(self):
self.boss_music=True
self.numEnemiesAppeared += 1
pygame.mixer.music.load("data/music/Boss.mp3")
pygame.mixer.music.play(-1)
self.boss = Boss((PLAY_WIDTH / 2, -200))
self.enemies.add(self.boss)
for tentacle in self.boss.tentacles:
for link in tentacle.links:
self.enemies.add(link)
def spawnSafe(self):
safe = SafeMode()
self.pickups.add(safe)
def leftMouseButtonDown(self):
self.holdingLeftMouseButton = True
self.player.shoot(self.bullets)
def leftMouseButtonUp(self):
self.holdingLeftMouseButton = False
def rightMouseButtonDown(self):
self.player.quarantine(self.mines)
sound = pygame.mixer.Sound("data/sounds/minedeploy.wav")
sound.set_volume(.25)
sound.play()
def enemy_popcorn(self):
if len(self.enemy_list)==1:
self.call_popcorn=0
else:
self.enemy_list[1].takeHit(self.enemy_list[1].health)
self.enemy_list.remove(self.enemy_list[1])
def destroy_all_enemies(self):
self.enemy_list=[0]
if self.player.destroyAllEnemies:
self.player.after_destroy_all()
sound = pygame.mixer.Sound("data/sounds/destroyall.wav")
sound.play()
for enemy in self.enemies:
if enemy.typeofenemy == 'boss' or enemy.typeofenemy == 'link':
enemy.takeHit(1)
else:
if enemy.typeofenemy is 'virus':
self.numViruses += 1
if enemy.typeofenemy is 'worm':
self.numWorms += 1
if enemy.typeofenemy is 'pop up window':
self.numPopUps += 1
self.numEnemiesDestroyed += 1
self.enemy_list.insert(1,enemy)
#enemy.takeHit(enemy.health)
self.call_popcorn=self.frames
def update(self):
if self.holdingLeftMouseButton:
if self.frames % 5 == 0:
self.player.shoot(self.bullets)
for group in self.spriteGroups:
group.update()
self.hud.update(self)
# Test player-enemy collisions
for enemy in pygame.sprite.spritecollide(self.player, self.enemies, False):
if not enemy.dead and not enemy.animName == 'spawn':
if not enemy.typeofenemy == 'boss':
enemy.takeHit(enemy.health)
if not self.player.invincible:
self.player.decrease_life()
self.score -= 100
if enemy.dead:
if enemy.typeofenemy is 'virus':
self.numViruses += 1
self.numEnemiesDestroyed += 1
if enemy.typeofenemy is 'worm':
self.numWorms += 1
self.numEnemiesDestroyed += 1
if enemy.typeofenemy is 'pop up window':
self.numPopUps += 1
self.numEnemiesDestroyed += 1
# Test player-pickup collisions
for pickup in pygame.sprite.spritecollide(self.player, self.pickups, False):
pickup.on_collision(self.player)
sound = pygame.mixer.Sound("data/sounds/keypickup.wav")
sound.play()
# Test enemy-playerBullet collisions
for enemy, bullets in pygame.sprite.groupcollide(self.enemies, self.bullets, False, False).items():
for bullet in bullets:
enemy.collideWithBullet(bullet)
if enemy.dead:
self.player.increase_powerup(5)
if enemy.typeofenemy == "worm":
self.numWorms += 1
self.numEnemiesDestroyed += 1
self.score += 25
elif enemy.typeofenemy == "virus":
self.numViruses += 1
self.numEnemiesDestroyed += 1
self.score += 10
elif enemy.typeofenemy == "popup":
self.numEnemiesDestroyed += 1
self.numPopUps += 1
self.score += 15
# Test enemy-mine collisions
for mine in self.mines:
if mine.exploding:
for enemy in pygame.sprite.spritecollide(mine, self.enemies, False):
enemy.takeHit(1)
if enemy.dead:
if enemy.typeofenemy is 'virus':
self.numViruses += 1
self.numEnemiesDestroyed += 1
if enemy.typeofenemy is 'worm':
self.numWorms += 1
self.numEnemiesDestroyed += 1
if enemy.typeofenemy is 'pop up window':
self.numPopUps += 1
self.numEnemiesDestroyed += 1
# Check enemies offscreen, popups doing damage
for enemy in self.enemies:
if enemy.rect.top > SCREEN_HEIGHT and not enemy.typeofenemy == 'link':
enemy.kill()
self.score -= 10
self.player.decrease_health(1)
sound = pygame.mixer.Sound("data/sounds/CPUload.wav")
sound.play()
if enemy.typeofenemy == "popup":
if enemy.frame % 20 == 0:
self.score -= 1
# Check bullets offscreen
for bullet in self.bullets:
if bullet.rect.bottom < 0:
bullet.kill()
# Check backgrounds offscreen
for bkg in self.backgrounds:
if bkg.rect.top > SCREEN_HEIGHT:
bkg.kill()
if self.frames % 360 == 0:
self.spawnBkg()
if self.spawnFreq is not 1:
if self.frames % (500) == 0:
if self.spawnFreq <= 1:
self.spawnFreq = 1
elif self.spawnFreq > 1:
self.spawnFreq -= self.difficulty
# Spawn more enemies
baseSpawnRate = (self.spawnFreq * 5 + random.randint(1, 5))
#print self.difficulty, baseSpawnRate, self.spawnFreq
if not self.bossMode:
if self.frames % baseSpawnRate < 1:
seed = random.randint(1, 10)
if(seed < 7):
self.spawnVirus(0)
elif(seed < 10):
self.spawnDoubleVirus(0)
else:
self.spawnTripleVirus()
if self.frames % (baseSpawnRate * random.randint(3, 6)) < 1:
self.spawnWorm()
if self.frames % (baseSpawnRate * random.randint(2, 5)) < 1:
self.spawnPopup()
if self.frames % (baseSpawnRate * random.randint(18, 21)) < 1:
self.player.destroyAllEnemies = True
if self.frames % (baseSpawnRate * random.randint(1, 4)) < 1:
self.spawnCtrl()
if self.frames % (baseSpawnRate * random.randint(5, 8)) < 1:
self.spawnAlt()
if self.frames % (baseSpawnRate * random.randint(9, 12)) < 1:
self.spawnDel()
if self.frames % (baseSpawnRate * random.randint(4, 7)) < 1:
self.spawnSafe()
# Check if main music has ended, and loop music should start
if not pygame.mixer.music.get_busy():
if not self.boss_music:
pygame.mixer.music.load("data/music/Mainloop.mp3")
pygame.mixer.music.play(-1)
elif self.frames == FRAMES_UNTIL_BOSS + MUSIC_LENGTH_BOSS:
pygame.mixer.music.load("data/music/Bossloop.mp3")
pygame.mixer.music.play(-1)
#Check for calling enemy_popcorn
if self.call_popcorn != 0 and self.call_popcorn<self.frames-10:
self.enemy_popcorn()
# Check gameover
if self.player.lives == 0:
self.gameOver = True
pygame.mixer.music.stop()
# Check win screen!
if self.bossMode and self.boss.dead and self.boss.anim.done:
if not self.winScreen:
self.numEnemiesDestroyed += 1
self.winScreen = True
# Scroll level
self.scrollPosition += self.scrollSpeed
self.scrollPosition = min(self.scrollPosition, self.endPosition)
if self.scrollPosition == self.endPosition and not self.bossMode:
self.bossMode = True
self.spawnBoss()
self.frames += 1
def draw(self, screen):
for group in self.spriteGroups:
for sprite in group:
sprite.draw(screen)
self.hud.draw(screen, PLAY_WIDTH)
class Game_Client2:
def __init__(self, width, height, gui, stack):
self.logger = logging.getLogger('Client')
hdlr = logging.FileHandler('tankwarz_client.log')
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
hdlr.setFormatter(formatter)
self.logger.addHandler(hdlr)
self.logger.setLevel(logging.INFO)
self.running = False
self.started = False
self.connected = False
self.alive = True
self.tank = None
self.switch_sound = pyglet.media.load("res/sounds/switch28.wav",
streaming=False)
self.bg_sound = pyglet.media.load("res/music/bgmusic2.wav",
streaming=True)
self.bg_loop = pyglet.media.SourceGroup(self.bg_sound.audio_format,
None)
self.bg_loop.loop = True
self.bg_loop.queue(self.bg_sound)
self.bg_player = pyglet.media.Player()
self.bg_player.volume = 0.05
self.bg_player.queue(self.bg_loop)
self.game_map = None
self.minimap = None
self.hud = None
self.camera = None
self.cl_id = int(time.time())
self.CLIENT_ID = int(time.time())
self.gui = gui
self.stack = stack
self._client = legume.Client()
self._client.OnMessage += self.message_handler
self._client.OnConnectRequestAccepted += self.on_connect_accepted
self._client.OnConnectRequestRejected += self.on_connect_rejected
self._client.OnError += self.on_connection_error
self._client.OnDisconnect += self.on_disconnect
self.update_timer = time.time()
self.time_label = pyglet.text.HTMLLabel(
'<font face="Arial" size="50" color="white"><b>00:00</b></font>',
x=Game.WIDTH // 2,
y=Game.HEIGHT - 12,
anchor_x='center',
anchor_y='center',
batch=hud_batch)
self.score = 0
create_walls()
pyglet.clock.schedule_interval(self.update, 1.0 / 60)
def on_connect_accepted(self, sender, args):
self.connected = True
self.logger.info("Connection Accepted")
if not self.started:
self.logger.info("Creating New Tank")
cl = ClientStart()
cl.client_id.value = self.CLIENT_ID
self._client.send_reliable_message(cl)
message = TankCreate()
message.id.value = self.cl_id
x = random.randint(660, 2230)
y = random.randint(350, 2500)
message.pos_x.value = x
message.pos_y.value = y
message.rot.value = 0
message.l_vel_x.value = 0
message.l_vel_y.value = 0
message.a_vel.value = 0
color_value = random.randint(1, 5)
message.color.value = color_value
message.client_id.value = self.CLIENT_ID
self._client.send_reliable_message(message)
self.started = True
def on_connect_rejected(self, args):
self.logger.info("Connection Rejected")
def on_disconnect(self, sender, args):
self.logger.info("You have been disconnected")
def on_connection_error(self, sender, error_message):
self.logger.error(error_message)
self.logger.info("Attempting to reconnect")
self.connect(host)
def start_game(self):
self.logger.info("STARTGAME")
self.tank = tanks[self.cl_id]
self.hud = Hud()
self.camera = Camera()
self.camera.init_gl(Game.WIDTH, Game.HEIGHT)
self.on_resize = self.camera.on_resize
self.bg_player.play()
self.running = True
self.gui.remove(self.stack)
def update_camera_player(self):
self.camera.left = self.tank.sprite.position[0] - 640
self.camera.right = self.camera.left + self.camera.width
self.camera.bottom = self.tank.sprite.position[1] - 350
self.camera.top = self.camera.bottom + self.camera.height
if self.camera.left < 0:
self.camera.left = 0
self.camera.right = self.camera.left + Game.WIDTH
elif self.camera.right > global_vars.full_width:
self.camera.right = global_vars.full_width
self.camera.left = self.camera.right - Game.WIDTH
if self.camera.bottom < 0:
self.camera.bottom = 0
self.camera.top = Game.HEIGHT
elif self.camera.top > global_vars.full_height:
self.camera.top = global_vars.full_height
self.camera.bottom = self.camera.top - Game.HEIGHT
def switch1(self):
if self.tank.ammo_type == Projectile.Ammo_Type.AP:
self.switch_sound.play()
self.tank.ammo_type = Projectile.Ammo_Type.REGULAR
self.hud.bullet1_overlay.color = (40, 40, 40, 200)
self.hud.bullet1_sprite.opacity = 255
self.hud.bullet1_text.color = (255, 255, 255, 255)
self.hud.bullet1_ammo.color = (255, 255, 255, 255)
self.hud.bullet2_overlay.color = (40, 40, 40, 100)
self.hud.bullet2_sprite.opacity = 100
self.hud.bullet2_text.color = (255, 255, 255, 100)
self.hud.bullet2_ammo.color = (255, 255, 255, 100)
msg = TankSwitchAmmo()
msg.id.value = self.tank.idn
msg.ammo_type.value = self.tank.ammo_type
self.send_reliable_message_safely(msg)
def switch2(self):
if self.tank.ammo_type == Projectile.Ammo_Type.REGULAR:
self.switch_sound.play()
self.tank.ammo_type = Projectile.Ammo_Type.AP
self.hud.bullet1_overlay.color = (40, 40, 40, 100)
self.hud.bullet1_sprite.opacity = 100
self.hud.bullet1_text.color = (255, 255, 255, 100)
self.hud.bullet1_ammo.color = (255, 255, 255, 100)
self.hud.bullet2_overlay.color = (40, 40, 40, 200)
self.hud.bullet2_sprite.opacity = 255
self.hud.bullet2_text.color = (255, 255, 255, 255)
self.hud.bullet2_ammo.color = (255, 255, 255, 255)
msg = TankSwitchAmmo()
msg.id.value = self.tank.idn
msg.ammo_type.value = self.tank.ammo_type
self.send_reliable_message_safely(msg)
def rotate_left_turret(self):
self.tank.rotateTurret(Direction.LEFT)
msg = TankCommand()
msg.id.value = self.cl_id
msg.command.value = Tank.Command.TURRET_ROTATE_LEFT
self.send_message_safely(msg)
def rotate_right_turret(self):
self.tank.rotateTurret(Direction.RIGHT)
msg = TankCommand()
msg.id.value = self.cl_id
msg.command.value = Tank.Command.TURRET_ROTATE_RIGHT
self.send_message_safely(msg)
def stop_rotate_turret(self):
self.tank.stopRotateTurret()
msg = TankCommand()
msg.id.value = self.cl_id
msg.command.value = Tank.Command.STOP_ROTATING_TURRET
self.send_message_safely(msg)
def move_forward(self):
self.tank.move(Direction.FORWARD)
msg = TankCommand()
msg.id.value = self.cl_id
msg.command.value = Tank.Command.MOVE_FORWARD
self.send_message_safely(msg)
def move_backward(self):
self.tank.move(Direction.BACKWARD)
msg = TankCommand()
msg.id.value = self.cl_id
msg.command.value = Tank.Command.MOVE_BACKWARD
self.send_message_safely(msg)
def stop(self):
self.tank.stop()
msg = TankCommand()
msg.id.value = self.cl_id
msg.command.value = Tank.Command.STOP_MOVING
self.send_message_safely(msg)
def rotate_right(self):
self.tank.rotate(Direction.RIGHT)
msg = TankCommand()
msg.id.value = self.cl_id
msg.command.value = Tank.Command.ROTATE_RIGHT
self.send_message_safely(msg)
def rotate_left(self):
self.tank.rotate(Direction.LEFT)
msg = TankCommand()
msg.id.value = self.cl_id
msg.command.value = Tank.Command.ROTATE_LEFT
self.send_message_safely(msg)
def stop_rotate(self):
self.tank.stopRotating()
msg = TankCommand()
msg.id.value = self.cl_id
msg.command.value = Tank.Command.STOP_ROTATING
self.send_message_safely(msg)
def fire(self):
if self.tank.isReloading:
return
self.tank.reloading = True
msg = TankFire()
msg.id.value = self.cl_id
msg.projectile_id.value = int(time.time())
self.tank.fire(msg.projectile_id.value)
self.send_message_safely(msg)
if self.tank.ammo_type == Projectile.Ammo_Type.REGULAR and self.tank.ammo1 <= 0 or self.tank.ammo_type == Projectile.Ammo_Type.AP and self.tank.ammo2 <= 0:
return
Tank.firing_sound.play()
Tank.reloading_sound.play()
self.hud.update(self.tank.ammo1, self.tank.ammo2)
def send_message_safely(self, msg):
try:
self._client.send_message(msg)
except legume.exceptions.ClientError:
self.connected = False
if self._client.connected:
self._client.send_message(msg)
def send_reliable_message_safely(self, msg):
try:
self._client.send_message(msg)
except legume.exceptions.ClientError:
self.connected = False
if self._client.connected:
self._client.send_reliable_message(msg)
def update(self, dt):
dtt = 1.0 / 60.0
space.step(dtt)
for tank in tanks.values():
tank.update(dtt)
for p in projectiles.values():
p.update(dtt)
def message_handler(self, sender, message):
if legume.messages.message_factory.is_a(message, 'TankCreate'):
if tanks.get(message.id.value) is None:
tanks[message.id.value] = Tank.create_from_message(message)
if message.id.value == self.cl_id:
self.logger.info("Creating self")
self.start_game()
else:
tanks[message.id.value].update_from_message(message)
elif legume.messages.message_factory.is_a(message, 'TankUpdate'):
if tanks.get(message.id.value) is None:
tanks[message.id.value] = Tank.create_from_message(message)
if message.id.value == self.cl_id:
self.logger.info("Creating self")
self.start_game()
else:
tanks[message.id.value].update_from_message(message)
elif legume.messages.message_factory.is_a(message, 'GameOver'):
if message.winner_id.value == self.CLIENT_ID:
game_over_bg = glooey.Background()
game_over_bg.image = pyglet.image.load(
"res/PNG/GUI/overlay.png")
game_over_bg.custom_alignment = 'fill'
self.gui.add(game_over_bg)
game_over_vbox = glooey.VBox()
game_over_vbox.custom_alignment = 'center'
game_over_label = TitleLabel("You Win!")
score_label = SubtitleLabel("Your score is %d" %
message.score.value)
score_label.custom_font_size = 10
ex_button = Exit_Button()
game_over_vbox.add(game_over_label)
game_over_vbox.add(score_label)
game_over_vbox.add(ex_button)
self.gui.add(game_over_vbox)
else:
game_over_bg = glooey.Background()
game_over_bg.image = pyglet.image.load(
"res/PNG/GUI/overlay.png")
game_over_bg.custom_alignment = 'fill'
self.gui.add(game_over_bg)
game_over_vbox = glooey.VBox()
game_over_vbox.custom_alignment = 'center'
game_over_label = TitleLabel("You Lose")
ex_button = Exit_Button()
game_over_vbox.add(game_over_label)
game_over_vbox.add(ex_button)
self.gui.add(game_over_vbox)
elif legume.messages.message_factory.is_a(message, 'UpdateTime'):
time = message.time.value
self.time_label.text = '<font face="Arial" size="50" color="white"><b>%s</b></font>' % (
time)
elif legume.messages.message_factory.is_a(message, 'TankFireClient'):
tank = tanks[message.id.value]
if tank.idn != self.tank.idn:
tank.fire(message.projectile_id.value)
elif legume.messages.message_factory.is_a(message, 'TankSwitchAmmo'):
tank = tanks[message.id.value]
tank.ammo_type = message.ammo_type.value
elif legume.messages.message_factory.is_a(message, 'TankHit'):
tank = tanks[message.id.value]
projectile = projectiles.get(message.projectile_id.value)
if projectile is not None:
tank.hit(projectile.damage)
if tank.idn == self.tank.idn and not self.tank.alive and not self.tank.destroyed:
self.tank.destroyed = True
game_over_bg = glooey.Background()
game_over_bg.image = pyglet.image.load(
"res/PNG/GUI/overlay.png")
game_over_bg.custom_alignment = 'fill'
self.gui.add(game_over_bg)
game_over_vbox = glooey.VBox()
game_over_vbox.alignment = 'center'
game_over_label = TitleLabel("You have been eliminated")
retry_button = PlayAgain_Button()
ex_button = Exit_Button()
def on_click(widget):
self.gui.remove(game_over_bg)
self.gui.remove(game_over_vbox)
self.gui.add(stack)
self._client.disconnect()
self.cl_id = random.randint(1, 100000)
self.started = False
self.running = False
retry_button.on_click = on_click
game_over_vbox.add(game_over_label)
game_over_vbox.add(retry_button)
game_over_vbox.add(ex_button)
self.gui.add(game_over_vbox)
projectile.destroy()
projectiles.pop(projectile.idn)
elif legume.messages.message_factory.is_a(message,
'ProjectileDestroy'):
projectile = projectiles.get(message.projectile_id.value)
if projectile is not None:
projectile.destroy()
projectiles.pop(projectile.idn)
elif legume.messages.message_factory.is_a(message, 'ProjectileCreate'):
if projectiles.get(message.id.value) is None:
projectiles[message.id.value] = Projectile.create_from_message(
message)
else:
projectiles[message.id.value].update_from_message(message)
elif legume.messages.message_factory.is_a(message, 'ProjectileUpdate'):
if projectiles.get(message.id.value) is None:
projectiles[message.id.value] = Projectile.create_from_message(
message)
else:
projectiles[message.id.value].update_from_message(message)
elif legume.messages.message_factory.is_a(message, 'MapCreate'):
l = message.l.value
w = message.w.value
seed_a = message.seed_a.value
seed_b = message.seed_b.value
self.game_map = Game_Map.generate_map(l, w, seed_a, seed_b)
self.minimap = Minimap(self.game_map, self.cl_id)
else:
self.logger.info('Message: %s' % message)
def connect(self, host='localhost'):
self._client.connect((host, PORT))
def send_update(self):
if self.tank is not None:
self.client.send_message_safely(self.tank.get_message())
for projectile in projectiles.values():
self.client.send_message_safely(projectile.get_message())
def go(self, args):
try:
if time.time() > self.update_timer + UPDATE_RATE:
self.update_timer = time.time()
self._client.update()
except:
self.running = False
class Character(Sprite):
"""Representing a character(toon) with its movements, skills,
sound effects and hud.
attributes -- dictionary that holds the attribute of each character
skill_names -- dictionary that holds the skills of each cahracter
"""
attributes = {"itachi": ATTRIBUTES[0], "sasuke": ATTRIBUTES[1],
"suigetsu": ATTRIBUTES[1], "naruto": ATTRIBUTES[0],
"jiraiya": ATTRIBUTES[0]}
skill_names = {"itachi": {"throw": "throw_shuriken",
"special_1": "amaterasu",
"special_2": "katon_goukakyuu"},
"sasuke": {"throw": "throw_lightning",
"special_1": "katon_gouryuuka",
"special_2": "chidori"},
"suigetsu": {"throw": "throw_explosive_note",
"special_1": "suirou",
"special_2": "kubikiri_shuriken"},
"naruto": {"throw": "rasengan",
"special_1": "rasen_shuriken",
"special_2": "kyuubi"},
"jiraiya": {"throw": "throw_kunai",
"special_1": "rasengan_original",
"special_2": "katon_endan"}}
def __init__(self, player, character_name, position=Vec2D(0, 0)):
"""Initialize all member variables of character.
damage -- numeric value, the amount of harm dealt through normal_attack
lock -- bool varible, says if the character is currently casting an
ability or motion
action -- string, the action currently being excecuted by the character
"""
pygame.sprite.Sprite.__init__(self)
self.name = character_name
self.damage = 100
self.attribute = self.attributes[self.name]
self.lock = True
self.action = "introduction"
self.enemy_position = pygame.Rect(0, 0, 0, 0)
if not isinstance(position, Vec2D):
self.position = Vec2D(position)
else:
self.position = position
if player == 1:
self.controls = P1_CONTROLS
self.direction = "Right"
elif player == 2:
self.controls = P2_CONTROLS
self.direction = "Left"
else:
raise SystemExit("player argument should be either 1 or 2")
self.movements = {}
for action in get_all_movements(self.name):
self.movements[action] = Movement(self.name, action)
self.skills = SkillManager()
self.hud = Hud(player, self.name)
self.sound_effects = SoundManager(self.name)
self.update({})
def update(self, input_list):
"""Update the current character action, movement, position,
sound effect and hud.
Character.update(): return None
"""
self.update_action(input_list)
self.movements[self.action].update(pygame.time.get_ticks())
self.image, self.rect = self.movements[self.action].get_image()
self._adjust_direction()
self._adjust_position()
if (self.direction == "Left" and self.action in
["take_damage", "normal_attack"]):
self.position -= self.movements[self.action].force
else:
self.position += self.movements[self.action].force
self.rect.topleft = self.position
if self.lock:
if self.movements[self.action].done:
self.movements[self.action].reset()
self.lock = False
if self.action in self.skill_names[self.name]:
skill = Skill(self)
self.skills.add(skill)
self.hud.mana.value -= skill.mana_cost
self.sound_effects.stop()
self.sound_effects[self.action].play()
self.hud.update()
def update_action(self, input_list):
"""Update character's action given an input list.
If a skill is to be cast check the mana bar if it holds enought mana
and play the corresponding sound effect.
Character.update_action(input_list): return None
"""
action_taken = False
if not self.lock:
if input_list[self.controls[0]]:
self.action = "move_left"
action_taken = True
if input_list[self.controls[1]]:
self.action = "move_right"
action_taken = True
if input_list[self.controls[2]]:
self.action = "jump"
self.lock = True
action_taken = True
if (input_list[self.controls[3]] and
self.hud.mana.value >= Skill.mana_costs["throw"]):
self.action = "throw"
self.lock = True
action_taken = True
if input_list[self.controls[4]]:
self.action = "normal_attack"
self.lock = True
action_taken = True
if (input_list[self.controls[5]] and
self.hud.mana.value >= Skill.mana_costs["special_1"]):
self.action = "special_1"
self.lock = True
action_taken = True
if (input_list[self.controls[6]] and
self.hud.mana.value >= Skill.mana_costs["special_2"]):
self.action = "special_2"
self.lock = True
action_taken = True
if not action_taken:
self.action = "stance"
def draw(self, surface):
"""Draw the hud and the character image onto the passed surface.
Call the draw methods of Hud and Sprite.
Character.draw(surface): return None
"""
self.hud.draw(surface)
super(Character, self).draw(surface)
def _adjust_position(self):
"""Adjust the character position so the bottom side of its rect is at
FLOOR_HEIGHT position.
Character._adjust_position(): return None
Should not be called manually.
"""
if (self.action != "jump" or
self.movements[self.action].current_frame == 0):
self.position.y = (DEFAULT_SCREEN_SIZE[1] - FLOOR_HEIGHT -
self.rect.height)
if self.position.x < 0:
self.position.x = 0
elif self.position.x > DEFAULT_SCREEN_SIZE[0] - self.rect.width:
self.position.x = DEFAULT_SCREEN_SIZE[0] - self.rect.width
elif (self.position.y > (DEFAULT_SCREEN_SIZE[1] - FLOOR_HEIGHT -
self.rect.height)):
self.position.y = (DEFAULT_SCREEN_SIZE[1] - FLOOR_HEIGHT -
self.rect.height)
def _adjust_direction(self):
"""Adjust the character direction so it faces the opponent. This does
not hold when the character is moving left or right.
Character._adjust_direction(): return None
Should not be called manually.
"""
if (self.direction == "Left" and
self.action not in ["move_left", "move_right"]):
self.image = pygame.transform.flip(self.image, True, False)
