def start_next_stage(self):
# Se generan las posiciones al azar de los enemigos en "enemies_bucket"
enemies_sd = GameConfig.get_enemies(self.stage)
enemies_bucket = []
for (enemy_type, enemy_quantity) in enemies_sd:
for x in range(0, enemy_quantity):
enemies_bucket.append(enemy_type)
random.shuffle(enemies_bucket)
total_enemies = len(enemies_bucket)
#Se calculan los objetos especiales
items_sd = GameConfig.get_items(self.stage)
items_bucket = []
for (item_type, item_quantity) in items_sd:
for x in range(0, item_quantity):
items_bucket.append(item_type)
while len(items_bucket) < total_enemies:
items_bucket.append(0)
random.shuffle(items_bucket)
# Creando los sprites de los enemigos
great_rect = None
enemy_shoots = pygame.sprite.RenderPlain()
enemies = pygame.sprite.RenderPlain()
x = -1
for etype in enemies_bucket:
x += 1
start_position = self.get_start_position_for_enemy(x, total_enemies)
enemy = Enemy((etype - 1), items_bucket[x], start_position, enemy_shoots)
enemy.add(enemies)
if great_rect is None:
great_rect = enemy.get_rect().copy()
else:
great_rect.union_ip(enemy.get_rect())
enemy_box = EnemyBox(great_rect, GameConfig.get_move(self.stage))
for e in enemies:
e.set_enemy_box(enemy_box)
# Se generan los prisioneros
prisoners = pygame.sprite.RenderPlain()
nprisoners = GameConfig.get_prisoners(self.stage)
screen = pygame.display.get_surface()
gap = (screen.get_width() - (self.PRISONER_SPRITE_WIDTH * nprisoners)) / (nprisoners + 1)
for p in range(0, nprisoners):
start_position = (self.PRISONER_SPRITE_WIDTH * p) + (gap * (p + 1)), 3
prisoner = Prisoner(start_position)
prisoner.add(prisoners)
# Comienza el juego!
pygame.time.set_timer(USEREVENT+2, 0) # Ready screen
pygame.time.set_timer(USEREVENT+1, 1000) # Game's time
return enemies, prisoners, enemy_shoots, enemy_box
def show_rules_stage(self):
self.render_menu_basics()
self.render_title("Rules", 2)
options = pygame.sprite.RenderPlain()
option = self.place_button_in_screen("back", 60, 120)
option.add(options)
fontsubtitle = pygame.font.Font(None, 40)
#Enemigos
text = fontsubtitle.render("Enemies", 1, (180, 180, 180))
self.background.blit(text, (180, 150))
font = pygame.font.Font(None, 32)
y_offset = 200
index = 0
for e in GameConfig.get_enemy_types():
image = Enemy.get_image(index)
self.background.blit(image, (180, y_offset))
data = font.render(str(e['score']) + " pts", 1, self.subtitle_font_color)
self.background.blit(data, (250, y_offset + 20))
y_offset += 80
index += 1
#Friends
text = fontsubtitle.render("Friends", 1, (180, 180, 180))
self.background.blit(text, (500, 150))
image = Prisoner.get_image()
self.background.blit(image, (500, 200))
text = GameConfig.get_text('prisoner')
y_offset = 200
for line in text:
data = font.render(line, 1, self.subtitle_font_color)
self.background.blit(data, (550, y_offset))
y_offset += 30
image = SpecialItem.get_image('extra_life')
self.background.blit(image, (430, 420))
data = font.render("Extra life", 1, self.subtitle_font_color)
self.background.blit(data, (470, 420))
image = SpecialItem.get_image('invincible')
self.background.blit(image, (570, 420))
data = font.render("Invincible", 1, self.subtitle_font_color)
self.background.blit(data, (610, 420))
image = SpecialItem.get_image('super_shoot')
self.background.blit(image, (500, 470))
data = font.render("Super shoot", 1, self.subtitle_font_color)
self.background.blit(data, (540, 470))
return options
def kill_enemy(self):
self.time_to_shoot = -1
self.time_to_death = 25
data = GameConfig.get_others('fire')
(sprite_x, sprite_y) = data[0]
(width, heigth) = data[1]
self.image = SpriteManager.load(sprite_x, sprite_y, width, heigth)
def set_sprite(self, typesprite, time=None):
if time is not None:
self.time_to_back2normal = time
data = GameConfig.get_player(typesprite)
(sprite_x, sprite_y) = data[0]
(width, height) = data[1]
#Loads sprite
self.image = SpriteManager.load(sprite_x, sprite_y, width, height)
def show_main_stage(self):
self.render_menu_basics()
options = pygame.sprite.RenderPlain()
xcoord = 120
ycoord = 120
menu_items = GameConfig.get_ordered_menu_items()
for index in menu_items:
option = self.place_button_in_screen(index, xcoord, ycoord)
option.add(options)
xcoord += 150
return options
def __init__(self, index, xpos, ypos):
pygame.sprite.Sprite.__init__(self)
self.type_id = index
data = GameConfig.get_menu_items(index)
(sprite_x, sprite_y) = data[0]
(width, height) = data[1]
#Loads sprite
self.image, self.rect = SpriteManager.load_all(sprite_x, sprite_y, width, height)
self.rect.topleft = xpos, ypos
def __init__(self, coord):
shoot_xcoord = coord[0]
shoot_ycoord = coord[1]
pygame.sprite.Sprite.__init__(self)
data = GameConfig.get_others('enemy_shoot')
(sprite_x, sprite_y) = data[0]
(width, height) = data[1]
self.image, self.rect = SpriteManager.load_all(sprite_x, sprite_y, width, height)
self.rect.topleft = (shoot_xcoord + 30), shoot_ycoord + 30
self.move = 10
def refresh_background(self):
wdata = GameConfig.get_wallpaper(self.stage)
backgrounds = pygame.image.load("backgrounds.data")
(x, y) = wdata[1]
(width, height) = wdata[2]
rect = pygame.Rect((x, y, width, height))
self.background = pygame.Surface(rect.size)
self.background.blit(backgrounds, (0, 0), rect)
screen = pygame.display.get_surface()
font = pygame.font.Font(None, 22)
text = font.render(wdata[0], 1, (40, 40, 40))
self.background.blit(text, (screen.get_width() - (5 + text.get_width()), 3))
def __init__(self, shoot_xcoord, shoottype):
pygame.sprite.Sprite.__init__(self)
data = GameConfig.get_others(shoottype)
(sprite_x, sprite_y) = data[0]
(width, height) = data[1]
self.image, self.rect = SpriteManager.load_all(sprite_x, sprite_y, width, height)
if shoottype == 'shoot':
# Ojos, disparo normal, velocidad normal
self.rect.topleft = (shoot_xcoord + 30), 530
self.move = -10
elif shoottype == 'super_shoot':
self.rect.topleft = (shoot_xcoord + 10), 530
self.move = -15
def __init__(self, etype, drop_item, start_position, enemy_shoots):
self.enemy_shoots = enemy_shoots
self.drop_item = drop_item
self.time_to_death = -1
pygame.sprite.Sprite.__init__(self)
self.image = self.get_image(etype)
self.rect = self.image.get_rect()
self.data = GameConfig.get_enemy_type(etype)
self.rect.topleft = start_position
self.enemy_box = None
self.time_to_shoot = None
self.reset_time_to_shoot()
def show_about_stage(self):
self.render_menu_basics()
self.render_title("About this game", 2)
options = pygame.sprite.RenderPlain()
option = self.place_button_in_screen("back", 60, 120)
option.add(options)
y_offset = 160
font = pygame.font.Font(None, 32)
text = GameConfig.get_text('about')
for line in text:
data = font.render(line, 1, self.subtitle_font_color)
self.background.blit(data, (155, y_offset))
y_offset += 30
return options
def __init__(self, conffile):
pygame.init()
self.config = GameConfig(conffile)
self.clock = pygame.time.Clock()
self.layer_manager = LayerManager(self.config, self.clock)
self.story_manager = StoryManager(self, self.layer_manager)
self.collision_manager = CollisionManager(self.layer_manager)
#list pour le joueur et monstre
self.perso = None
self.monstres = []
self.layer_manager.set_map(self, self.config.get_start_map())
self.layer_manager.new_layer('player', tmx.SpriteLayer)
self.layer_manager.new_layer('npcs', tmx.SpriteLayer)
self.layer_manager.new_layer('monster', tmx.SpriteLayer)
self.FPS = 30
self.clocks = {"playerHud": 0}
self.userInput = None
def template_Run(self, n, svr_do_sync, user_do_sync):
assert svr_do_sync == user_do_sync
k = MockKeyboard()
k.inputs = [1]*30+[0]*100
r = NullRenderer()
conf = GameConfig()
conf.player_size = n
conf.frames_per_sec = 32767
conf.game_length = 0.05
conf.post_game_time = 0
conf.do_sync = svr_do_sync
conf.sync_timeout = 0.1
conf.sync_rate = 100
conf.buffer_size = 64
# Try to avoid clients dying at the end of handshake.
test_tries = 40
status = 0
for i in range(0, test_tries):
s = UDPSocket()
s.Open()
s.Bind(('', 0))
svraddr = s.sock.getsockname()
ps = []
qs = []
clients = []
# Try only once here. In case of server failure and client success,
# we must re-run the test as a whole.
server_tries = 1
server_timeout = 0.5
client_tries = 1
# Send only once. To keep tests short, games run only briefly.
# If the resend happens after the game is ended, the test fails.
client_resend = 1
client_timeout = 0.5
user_conf = GameConfig()
user_conf.do_sync = user_do_sync
user_conf.sync_timeout = conf.sync_timeout * n
for i in range(0, n):
q = multiprocessing.Queue()
c = UDPClient()
p = multiprocessing.Process(target=\
UDPServerTestPickleJar_Run,
args=(client_tries, client_resend, client_timeout,
c, svraddr, r, k, user_conf, q))
p.start()
ps.append(p)
qs.append(q)
svr = UDPServer()
svr.buffer_time = 0
try:
status = svr.Run(s, False, conf, server_tries, server_timeout)
except Exception as ex:
logger.exception(ex)
status = 100 # Error in the server, stop the test
results = []
for i in range(0, n):
results.append(qs[i].get())
ps[i].join()
s.Close()
self.assertTrue(status != 100)
if status == 0:
break
self.assertTrue(status == 0)
for i in range(0, n):
self.assertTrue(results[i])
class Game(object):
def __init__(self, conffile):
pygame.init()
self.config = GameConfig(conffile)
self.clock = pygame.time.Clock()
self.layer_manager = LayerManager(self.config, self.clock)
self.story_manager = StoryManager(self, self.layer_manager)
self.collision_manager = CollisionManager(self.layer_manager)
#list pour le joueur et monstre
self.perso = None
self.monstres = []
self.layer_manager.set_map(self, self.config.get_start_map())
self.layer_manager.new_layer('player', tmx.SpriteLayer)
self.layer_manager.new_layer('npcs', tmx.SpriteLayer)
self.layer_manager.new_layer('monster', tmx.SpriteLayer)
self.FPS = 30
self.clocks = {"playerHud": 0}
self.userInput = None
def start(self):
#Trouve l'emplacement du héro
source = self.layer_manager['boundaries'].find_source("start")
self.layer_manager.set_focus(source.px, source.py, True)
self.perso = self.charge_player()
self.collision_manager.set_player(self.perso)
self.perso.definir_position(source.px, source.py)
self.monstres = self.charge_monstres()
self.userInput = userInput.Keyboard(self)
epe = weapon.Weapon(self.layer_manager, self.perso, 'clavier', 20, 50, 10)
self.perso.ajoute_outils(epe, self.layer_manager)
#hub
self.createHuds()
self.story_manager.read_stories(self.config.get_start_map())
self.mainloop()
def mainloop(self):
while True:
dt = self.clock.tick(self.FPS)
quitter = EventManager.update(self)
if quitter:
return
if not self.story_manager.blocking:
self.userInput.updateKey(dt)
for key, value in self.clocks.iteritems():
if value >= 0:
if value == 0:
if key == "playerHud":
self.hideHud(key)
pass
else:
self.clocks[key] = value - 1
#Récupère les collisions
self.collision_manager.tmx_stackCollisionEvents()
#stack les collision de monstre
self.collision_manager.player_stackEvents()
self.collision_manager.monster_stackEvents()
#gère les évenement crée par le joureur
self.collision_manager.player_manageCollisionEvents()
#Gère les colisions selon leur nature
self.collision_manager.tmx_manageCollisionEvents()
self.collision_manager.monster_manageCollisionEvents()
if self.perso.alive():
self.layer_manager.update(self.story_manager.blocking)
else:
self.story_manager.display_speech(["GAME OVER"], "bottom")
self.story_manager.set_unblockable(False)
self.layer_manager.draw()
pygame.display.update()
#pygame.display.flip()
#factory pour monstre
def charge_monstres(self):
monstres = []
try:
for cell in self.layer_manager['pnjs'].find('monstre'):
monster_layer = []
if "visible" not in cell.properties or cell.properties['visible']:
monster_layer = self.layer_manager['monster']
m = monster.Monster(cell.name,
os.path.join(self.config.get_sprite_dir(),
"sprite-Ennemi.png"),
(cell.px, cell.py), monster_layer)
m.definir_position(cell.px, cell.py)
monstres.append(m)
except KeyError:
pass
return monstres
def charge_player(self):
return player.Player("player",
os.path.join(self.config.get_sprite_dir(),
"sprite-Hero.png"),
(0, 0), self.layer_manager['player'])
def do_trigger(self, trigger):
self.story_manager.read_story(trigger)
def effectuer_transition(self, limite):
if not isinstance(limite, tmx.Object):
pass
try:
if limite.properties['barree']:
clef_requise = limite.properties['clef']
if not clef_requise in self.perso.tools:
self.story_manager.display_speech([u"La porte est barrée... Il serait certainement possible de", u"l'ouvrir si tu avais une clé."], "top")
return
except KeyError:
# la porte n'est probablement pas barrée...
pass
self.deleteHuds()
source_name = self.layer_manager.get_current_filename()
if 'destination' in limite.properties:
self.layer_manager.set_map(self, limite.properties['destination'])
if 'dest_transition' in limite.properties:
source = \
self.layer_manager['boundaries'].find_source(limite.properties['dest_transition'])
else:
source = \
self.layer_manager['boundaries'].find_source(source_name)
self.createHuds()
self.perso.definir_position(source.px, source.py)
self.charge_monstres()
self.layer_manager.set_focus(source.px, source.py, True)
self.story_manager.read_stories(limite.properties['destination'])
def createHuds(self):
hud = playerHud.PlayerHud("playerHud",
self.perso,
self.layer_manager)
self.layer_manager.add_layer(hud.name, hud)
def showHud(self, name):
layer = self.layer_manager[name]
layer.setVisible(True)
def hideHud(self, name):
layer = self.layer_manager[name]
layer.setVisible(False)
def deleteHuds(self):
if "playerHud" in self.layer_manager.layers:
layer = self.layer_manager["playerHud"]
self.layer_manager.remove(layer)
def addClockSec(self, name, second):
self.clocks[name] += second * self.FPS
def test_ne_1(self):
conf = GameConfig()
conf.game_length = 413
conf2 = GameConfig()
conf2.game_length = 32
self.assertTrue(conf != conf2)
def test_SerializeAndDeserialize(self):
conf = GameConfig()
conf.player_size = 5
conf.game_length = 40
conf.frames_per_sec = 130
conf.screen_width = 1024
conf.screen_height = 756
conf.buffer_region = 89
conf.ball_wall_offset_x = 9357
conf.ball_wall_offset_y = 932
conf.paddle_width = 32
conf.paddle_height = 50
conf.ball_vel = 3
conf.ball_size = 100
conf.rounds = 8
conf.buffer_delay = 1
conf.player_id = 2
# Ignore the event type bytes.
b = conf.Serialize()[4:]
test = GameConfig()
test.Deserialize(b)
self.assertTrue(conf == test, msg='{0} != {1}'.format(conf, test))
parser.add_argument('--port', type=int, default=8090, help='The port.')
parser.add_argument('-i', '--interpolate', action='store_true',
default=False, help='Enable interpolation')
parser.add_argument('-b', '--buffersize', type=int, default=64,
help='Number of records to keep.')
parser.add_argument('--tries', type=int, default=60,
help='The number of attempts to connect to the server.')
parser.add_argument('--resend', type=int, default=9,
help='The number of duplicate messages to send during handshake.')
parser.add_argument('--timeout', type=int, default=10,
help='The time allowed for each connection and handshake.')
parser.add_argument('--nosync', default=False, action='store_true',
help='Allow server to measure latency and clock.')
parser.add_argument('--synctimeout', type=int, default=3,
help='The timeout for RecvSync.')
args = parser.parse_args()
conf = GameConfig()
conf.do_interpolate = args.interpolate
conf.buffer_size = args.buffersize
conf.do_sync = not args.nosync
conf.sync_timeout = args.synctimeout
c = UDPClient()
from renderer import Renderer
r = Renderer()
# For now, nothing in server's conf affects renderer.
r.Init()
conf.ApplyRenderer(r)
if not c.Run((args.ip, args.port), r, r, conf, args.tries, args.resend,
args.timeout):
print('Timed out.')
def get_image(etype):
data = GameConfig.get_enemy_type(etype)
(sprite_x, sprite_y) = data['image'][0]
(width, height) = data['image'][1]
return SpriteManager.load(sprite_x, sprite_y, width, height)
def test_Apply(self):
conf = GameConfig()
conf.frames_per_sec = 120
conf.game_length = 60
conf.rounds = 2
conf.screen_width = 1024
conf.screen_height = 756
conf.paddle_width = 32
conf.paddle_height = 50
conf.ball_size = 100
conf.player_id = 2
conf.cool_down = 5
e = UDPGameEngine()
conf.Apply(e)
self.assertTrue(e.player_id == conf.player_id)
self.assertTrue(e.key_cool_down_time == conf.cool_down)
s = e.state
self.assertTrue(s.frames_per_sec == conf.frames_per_sec)
self.assertTrue(s.game_length == conf.game_length)
self.assertTrue(s.rounds == conf.rounds)
self.assertTrue(s.rotation_length == conf.frames_per_sec * 10)
self.assertTrue(s.round_length == conf.frames_per_sec * 30)
self.assertTrue(s.screen.half_width == conf.screen_width // 2)
self.assertTrue(s.screen.half_height == conf.screen_height // 2)
self.assertTrue(s.paddle_left.half_width == conf.paddle_width // 2)
self.assertTrue(s.paddle_right.half_height == \
conf.paddle_height // 2)
self.assertTrue(s.ball.half_width == conf.ball_size // 2)
'''
For testing.
'''
self.renderer.Render(s, s, 0, 0)
time.sleep(5)
def PrintStats(self):
pass
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser(description='The triplepong game \
engine. Use the command line interface for testing.')
parser.add_argument('-i', '--interpolate', action='store_true',
default=False, help='Turn on renderer interpolation.')
args = parser.parse_args()
e = UDPGameEngine()
e.is_client = True
e.is_server = False
conf = GameConfig()
conf.do_interpolate = args.interpolate
conf.Apply(e)
from renderer import Renderer
r = Renderer()
r.Init()
conf.ApplyRenderer(r)
e.renderer = r
e.keyboard = r
e.PlayAs(e.state, e, 0)
def test_eq_3(self):
conf = GameConfig()
conf.game_length = 51
conf2 = GameConfig()
conf2.game_length = 51
self.assertTrue(conf == conf2)
