def add_items():
""" Initialize all items to be added to the model"""
# create all instances of goombas
model.items.append(Goomba(model, 700, 300, -0.1, 0))
model.items.append(Goomba(model, 800, 300, -0.1, 0))
model.items.append(Goomba(model, 1000, 300, -0.1, 0))
model.items.append(Goomba(model, 1300, 300, -0.1, 0))
model.items.append(Goomba(model, 1500, 300, -0.1, 0))
model.items.append(Goomba(model, 1700, 300, -0.1, 0))
model.items.append(Goomba(model, 2800, 300, -0.1, 0))
model.items.append(Goomba(model, 3000, 300, -0.1, 0))
# create all instances of pipes
model.items.append(Pipe(model, 800, 425, height=125))
model.items.append(Pipe(model, 2000, 425, height=125))
# create all instances of bricks in the air
model.items.append(Air_Bricks(model, 550, 450))
model.items.append(Air_Bricks(model, 1000, 450))
model.items.append(Air_Bricks(model, 1400, 450))
model.items.append(Air_Bricks(model, 2600, 450))
# create the flag and castle
model.items.append(Flag(model, length - 275, 250))
model.items.append(Castle(model, length - 200, 350))
# add clouds to display
for n in range(1, length, 400):
model.items.append(Cloud(x=n, y=random.randint(50, 250)))
def __init__(self, screen, angle, x, y, sizey, team, flags, strength,
play=True, defense=False):
super().__init__()
if team == "green":
file1, file2, fileFlag, fileBall = greenCannon
elif team == "blue":
file1, file2, fileFlag, fileBall = blueCannon
coords = np.array([x, y], dtype=float)
self.troops = []
for i in range(sizey):
""" x displacement from center of Battery based on count
shiftx increases with count with a period of sizey, creating
a row of soldiers with a length of sizey
"""
shifty = C_GAPY * ((i % sizey) - sizey // 2)
shiftx = 0
self.troops.append(Cannon(screen, angle, shiftx, shifty, strength,
file1, file2, fileBall, team,
coords, defense))
self.flag = Flag(screen, (x, y), angle, fileFlag, play)
flags.append(self.flag)
# 0,1=click,release to show buttons, 2,3=click,release to select
self.showOrders = 0
# self.bayonetButton = Button(screen, "Bayonets")
self.healthDisp = Button(screen, str(self.health))
self.play = play
self.team = team
self.oldUnits = []
# used to id object for testing, not meant to be seen/used
self.id = file1
def generate_related_flags(self):
"""
Generates a list of Flag objects, sorted by exported dataset create time, associated with this user.
"""
flags = self.manager.get_flag_dataobj_names_by_user(self.id)
self.flags = [Flag(self.dashboard, flag) for flag in flags]
self.flags.sort(key=lambda item: item.exported)
def enter():
global player
global objectList
global backGround
global flag
global enemyList
global music
music = load_music('sound\\stage.mp3')
music.set_volume(60)
music.repeat_play()
backGround = BackGround(1)
game_world.add_object(backGround, 0)
for i in range(10):
for k in range(20):
if tile_type[i][k] is 3:
crushBlockList.append(CrushBlock((mapFirst + image_sizeW * k, mapTop - i * image_sizeH)))
elif tile_type[i][k] is 4:
lebberList.append(Lebber((mapFirst + image_sizeW * k, mapTop - i * image_sizeH), tile_type[i][k]))
elif tile_type[i][k] is 5:
lebberList.append(Lebber((mapFirst + image_sizeW * k, mapTop - i * image_sizeH), tile_type[i][k]))
elif tile_type[i][k] is 6:
lebberList.append(Lebber((mapFirst + image_sizeW * k, mapTop - i * image_sizeH), tile_type[i][k]))
elif tile_type[i][k] is 7:
player = Ohdam((mapFirst + image_sizeW * k, mapTop - i * image_sizeH))
elif tile_type[i][k] is 8:
enemyList.append(Monster1((mapFirst + image_sizeW * k, mapTop - i * image_sizeH)))
elif tile_type[i][k] is 9:
flag = Flag((mapFirst + image_sizeW * k, mapTop - i * image_sizeH))
elif tile_type[i][k] is 0:
pass
else:
flourBlockList.append(
FlourBlock((mapFirst + image_sizeW * k, mapTop - i * image_sizeH), tile_type[i][k]))
game_world.add_object(flag, 5)
game_world.add_objects(lebberList, 1);
game_world.add_objects(flourBlockList, 3);
game_world.add_objects(crushBlockList, 4);
game_world.add_objects(enemyList, 2);
game_world.add_object(player, 6)
for i in range(0, 3):
objectList.append(Apple((32 + 64 * 6 + i * 64, 608)))
for i in range(0, 3):
objectList.append(Apple((32 + 64 * 6 + i * 64, 480)))
for i in range(0, 3):
objectList.append(Apple((32 + 64 * 6 + i * 64, 352)))
for i in range(0, 3):
objectList.append(Apple((32 + 64 * 13 + i * 64, 480)))
for i in range(0, 3):
objectList.append(Apple((32 + 64 * 13 + i * 64, 352)))
for i in range(0, 3):
objectList.append(Apple((32 + 64 * 14 + i * 64, 608)))
for i in range(0, 15):
objectList.append(Apple((32 + 64 * 4 + i * 64, 160)))
game_world.add_objects(objectList, 7);
pass
def createExceptionhandler():
global excHandler,excFile,queues
errorQueueFileIO = queue.Queue(20)
excFile = fileio.FileIO("error_log.txt",errorQueueFileIO,Flag(True))
queues["error"] = queue.Queue(40)
excHandler = exceptionhandler.ExceptionHandler(queues["error"],errorQueueFileIO)
basicio.BasicIO.setErrorLog(queues["error"])
processing.DataHandler.setErrorLog(queues["error"])
distributor.Distributor.setErrorLog(queues["error"])
dbproxy.DataBaseWorker.setErrorLog(queues["error"])
fileio.FileIO.setErrorLog(queues["error"])
excHandler.start()
excFile.start()
def generate_related_flags(self):
"""
Generates a list of Flag objects, sorted by exported dataset create time, created during the period specified.
If no period is specified, all flags are displayed. If only a start date is specified, only those flags created
between then and the current time are displayed. If only an end date is specified, only those flags created
up to but not including the end date are displayed. Note that any invalid flags are separated out into a
separate list for special display.
"""
flag_dataobj_names = self.manager\
.get_dataobj_names_created_between(paths.FLAGS_PATH, self.start_date, self.end_date)
candidate_flags = [Flag(self.dashboard, flag_dataobj_name) for flag_dataobj_name in flag_dataobj_names]
self.flags = [item for item in candidate_flags if item.valid]
self.invalid_flags = list(set(candidate_flags) - set(self.flags))
self.flags.sort(key=lambda f: f.exported)
def make_level(level_num, max_e, total_e, diff):
x = y = 0
global bricks_group, sprite_group, lvl_w, lvl_h, enemies, \
friends, max_enemies, total_enemies, spavned_enemies, enemy_spavner_group,\
camera
enemy_spavner_group = []
bullets_group = []
timer.timer = 0
max_enemies = max_e
total_enemies = total_e
if diff == 1:
max_e += 2
total_enemies += 5
if diff == 2:
max_e += 4
total_enemies += 10
spavned_enemies = 0
bricks_group = []
sprite_group = []
enemies = friends = 0
lvl_h = len(levels[level_num]) * 40
for row in levels[level_num]:
lvl_w = len(row) * 40
for col in row:
if col == '0':
b1 = Blocks(x, y, 'images/blocks/brick.png', 1)
bricks_group.append(b1)
sprite_group.append(b1)
if col == '1':
b1 = Blocks(x, y, 'images/blocks/experimentalbrick.png',
1000000)
bricks_group.append(b1)
sprite_group.append(b1)
if col == 'e':
enemy_spavner_group.append([x, y])
if col == 'f':
sprite_group.append(Friend(x, y))
friends += 1
if col == 'p':
sprite_group = [Player(x, y)] + sprite_group
friends += 1
if col == 'b':
sprite_group.append(Flag(x, y))
x += 40
y += 40
x = 0
camera = Camera(camera_func, lvl_w, lvl_h)
def choose_flag(self):
"""Randomly choose which flag to play the game with."""
self.flag = Flag({
1:"ace",
2:"alt-lesbian",
3:"bi",
4:"intersex",
5:"l-lesbian",
6:"nb",
7:"pan",
8:"poc",
9:"pride",
10:"trans",
11:"gqueer"
}[random.randint(1, 10)])
def __init__(self,
screen,
angle,
x,
y,
sizex,
sizey,
team,
flags,
strength,
play=True,
defense=False):
super().__init__()
if team == "green":
fil1, fil2, fil3, fileFlag = greenImages
elif team == "blue":
fil1, fil2, fil3, fileFlag = blueImages
coords = np.array([x, y], dtype=float)
self.troops = []
# self.maxSize = sizex * sizey
# add infantry to company
for i in range(sizex * sizey):
""" x, y displacement from center of Company based on count
shiftx increases with count with a period of sizex, creating
a row of soldiers with a length of sizex
shifty increases when count increases by sizex, starting
a new row of soldiers every sizex soldiers
"""
shifty = I_GAPY * ((i % sizey) - sizey // 2)
shiftx = I_GAPX * ((i // sizey) - sizex // 2)
self.troops.append(
Infantry(screen, angle, shiftx, shifty, strength, team, fil1,
fil2, fil3, coords, play, defense))
self.flag = Flag(screen, (x, y), angle, fileFlag, play)
flags.append(self.flag)
# 0,1=click,release to show buttons, 2,3=click,release to select
self.showOrders = 0
self.bayonetButton = Button(screen, "Bayonets")
self.carreButton = Button(screen, "Carre")
self.lineButton = Button(screen, "Line")
self.healthDisp = Button(screen, str(self.health))
self.play = play
self.team = team
self.formation = "Line"
self.oldUnits = []
# used to id object for testing, not meant to be seen/used
self.id = fil1
def parse_flag_chunk(chunk: list, colors_dict: dict, names: dict) -> Flag:
name = re.match(r'[A-Z]*_*[A-Z]*', chunk[0])[0]
chunk.pop(0)
try:
name = names[name]
except Exception:
pass
# scan for the background elements
background = re.split(
r'(colored_emblem|texture_emblem|textured_emblem)\s*=\s*{',
''.join(chunk))[0]
background = '\n'.join(background.split('\t'))
# parsing pattern
pattern = re.findall(r'pattern\s*=\s*"?.*"?', background)
pattern = re.findall(r'[A-z0-9]*[.]tga', pattern[0])[0]
# parsing background colors
colors = re.findall(r'color[0-9]\s*=\s*"?.*"?(?=\t)?', background)
colors = [
colors_dict[color.split('=')[-1].replace('"', '').replace(' ', '')]
for color in colors
]
# make flag object
flag = Flag(name, pattern, colors, size=SIZE)
# scan for emblems and add them to the flag object
defaults = {'colors': colors}
emblems = []
chunk = '\n'.join(chunk).replace('\t', '\n').replace(' ', '\n')
chunk = re.split(
r'(colored_emblem|texture_emblem|textured_emblem)\s*=\s*{',
''.join(chunk))[1:]
while not chunk == []:
chunk = ''.join(chunk)
emblems = parse_emblem(
re.split(
r'(colored_emblem|texture_emblem|textured_emblem)\s*=\s*{',
chunk)[0], colors_dict, defaults)
chunk = re.split(r'(colored_emblem|texture_emblem)\s*=\s*{', chunk)[1:]
flag.set_emblems(emblems)
return flag
def __init__(self):
pyxel.init(240, 240, caption='Bourne Again', fps=30)
pyxel.mouse(True)
pyxel.load('stuff.pyxres')
self.seemsg = ''
self.seemsg_iter = ''
self.seemsg_out = ''
self.player = Player(30, 120)
self.beam_angle = None
self.inputed_angle = None
self.beam_start_time = 0
#self.wll_index = 0
self.targets = {
'A': Target(200, 120, 'Target A feels lonely'),
'B': Target(1, 20, 'Fortune awaits Target B'),
'C': Target(120, 199, 'Target C is in the mood for shawarma')
}
self.walls = [Solid(150, 120), Solid(100, 45), Solid(24, 200)]
self.flag = Flag(60, 24)
self.powerup = Powerup(80, 120)
self.upgraded = False
self.blocked_functions = ['up', 'down', 'left']
self.locked = False
self.has_won = False
self.raycast_distance = 0
self.raycast_has_collided = False
pyxel.playm(1, loop=True)
pyxel.run(self.update, self.draw)
def enter():
global boy, ground, background, spikeList, Hp_Bar, Monster_Bear_List, Monster_Mage_List, ChestList, CHicken,\
GUI, FlatFormList, FLAG
background = Background()
boy = Boy(background)
Hp_Bar = HP_BAR()
ground = [Ground(i, background) for i in range(len(Ground.groundList))]
Monster_Bear_List = [
Monster_bear(i, background) for i in range(len(Monster_bear.posList))
]
Monster_Mage_List = [
Monster_mage(i) for i in range(len(Monster_mage.posList))
]
spikeList = [Spike(i, background) for i in range(len(Spike.spikeList))]
ChestList = [Chest(i, background) for i in range(len(Chest.chestList))]
GUI = Gui()
FlatFormList = [
Flatform(i, background) for i in range(len(Flatform.flatFormList))
]
FLAG = Flag(background)
game_world.add_object(background, 0)
for i in range(len(ground)):
game_world.add_object(ground[i], 0)
game_world.add_object(boy, 2)
game_world.add_object(Hp_Bar, 1)
for i in range(len(Monster_Bear_List)):
game_world.add_object(Monster_Bear_List[i], 1)
for i in range(len(Monster_Mage_List)):
game_world.add_object(Monster_Mage_List[i], 1)
for i in range(len(ChestList)):
game_world.add_object(ChestList[i], 1)
for i in range(len(spikeList)):
game_world.add_object(spikeList[i], 1)
game_world.add_object(GUI, 1)
for i in range(len(FlatFormList)):
game_world.add_object((FlatFormList[i]), 1)
game_world.add_object(FLAG, 1)
background.set_center_object(boy)
boy.set_background(background)
def __init__(self, _engine):
super(Map, self).__init__()
if not Map.tiles:
Map.tiles = loadImages('data/gfx/tiles/', alpha=True)
self._engine = _engine
self._level = self._engine.getLevel()
self._above = []
self._workshops = pygame.sprite.Group()
self.flags = pygame.sprite.Group()
self.tanks = pygame.sprite.Group()
self.explosions = pygame.sprite.Group()
self.missiles = pygame.sprite.Group()
self._holdpos = (False, False)
self._pos = [0, 0]
self._w, self._h = len(self._level[0]), len(self._level)
self._mw, self._mh = self._w * 32, self._h * 32
self._background = pygame.Surface((self._mw, self._mh))
self._debugbackground = pygame.Surface((self._mw, self._mh))
self._debugbackground.fill((1, 5, 4))
self._debugbackground.set_colorkey((1, 5, 4))
self._debugbackground.set_alpha(96)
self.debug = pygame.Surface((self._mw, self._mh))
self.debug.fill((1, 5, 4))
self.debug.set_alpha(96)
self.debug.set_colorkey((1, 5, 4))
self.screenUpdated()
spawn1, spawn2 = None, None
for r, row in enumerate(self._level):
for c, (cell, mask) in enumerate(row):
_, _, x, y = self.tiles[str(cell)].get_rect()
self._background.blit(self.tiles[str(cell)],
((c + 1) * 32 - x, (r + 1) * 32 - y))
pygame.draw.rect(self._debugbackground, (0, 0, 0),
(c * 32, r * 32, 32, 32), 1)
if mask & FIELD_SPAWN1:
self._engine.players[0]['spawn'] = spawn1 = (c, r)
if mask & FIELD_SPAWN2:
self._engine.players[1]['spawn'] = spawn2 = (c, r)
if mask & FIELD_FLAG1:
self._engine.players[0]['flag'] = flag = Flag(
_engine, self, 0, (c * 32 + 16, r * 32 + 16))
self.flags.add(flag)
if mask & FIELD_FLAG2:
self._engine.players[1]['flag'] = flag = Flag(
_engine, self, 1, (c * 32 + 16, r * 32 + 16))
self.flags.add(flag)
if mask & FIELD_WORKSHOP1:
self._engine.players[0]['workshop'] = workshop = Workshop(
(c * 32 + 16, r * 32 + 16))
self._workshops.add(workshop)
if mask & FIELD_WORKSHOP2:
self._engine.players[1]['workshop'] = workshop = Workshop(
(c * 32 + 16, r * 32 + 16))
self._workshops.add(workshop)
if str(cell) + 'a' in self.tiles:
self._above.append((str(cell) + 'a', ((c + 1) * 32 - x,
(r + 1) * 32 - y)))
spawn1 = neighbours(
spawn1, lambda (x, y): not self.getGridField(
(x, y))[1] & FIELD_BLOCKED, TANKS)
spawn2 = neighbours(
spawn2, lambda (x, y): not self.getGridField(
(x, y))[1] & FIELD_BLOCKED, TANKS)
random.shuffle(spawn1)
random.shuffle(spawn2)
for t in xrange(TANKS):
x, y = spawn1[t]
_engine.players[0]['tanks'].append(
Tank(_engine, self, 0, (x * 32 + 16, y * 32 + 16)))
for t in xrange(TANKS):
x, y = spawn2[t]
_engine.players[1]['tanks'].append(
Tank(_engine, self, 1, (x * 32 + 16, y * 32 + 16)))
self.tanks.add(_engine.players[0]['tanks'])
self.tanks.add(_engine.players[1]['tanks'])
self.surface = self._background.copy()
def __init__(self, country):
self.flag = Flag(country)
import numpy as np from flag import Flag import forms as formas import matriz as matriz santa_lucia = Flag(1200, 675, (255, 210, 0)) santa_lucia.drawTriangle([(600, 10), (915, 665), (285, 665)], (255, 255, 255)) #PREENCHIMENTO santa_lucia.fillPolygon((380, 511), (255, 255, 255)) santa_lucia.drawTriangle([(600, 100), (865, 665), (335, 665)], (0, 0, 0)) #PREENCHIMENTO santa_lucia.fillPolygon((650, 250), (0, 0, 0)) santa_lucia.drawTriangle([(600, 337), (915, 665), (285, 665)], (0, 210, 255)) #PREENCHIMENTO santa_lucia.fillPolygon((650, 500), (0, 210, 255)) santa_lucia.fillPolygon((325, 645), (0, 210, 255)) santa_lucia.fillPolygon((875, 645), (0, 210, 255)) santa_lucia.scale(1, 2) santa_lucia.translation(20, 20) santa_lucia.rotate(15) santa_lucia.showFlag()
def init_map(engine, player, gravity):
"""
Loads up all the assets for the game map and
background sprites. Updates actors to hold world data. Does an inital render
of all game objects.
param - engine: The engine being used for this game instance
param - player: The player being used for this game instance
param - enemy_list: A list of enemey objects that are in this game instance.
"""
league.Settings.tile_size = 16
league.Settings.fill_color = (0, 0, 60)
# league.Settings.tile_scale = 1.7
sprites = league.Spritesheet('./assets/tileset-collapsed.png',
league.Settings.tile_size, 14)
level1 = league.Tilemap('./assets/level1.lvl', sprites, layer=2)
world_size = (level1.wide * league.Settings.tile_size,
level1.high * league.Settings.tile_size)
# initialize camera
cam = CameraUpdates(player, world_size)
engine.objects.append(cam)
engine.drawables = cam # allow camera to override draw()
# add in background and level1
index = 0
while index < world_size[0]:
full_background = Background('./assets/skyline-a.png',
x=index,
layer=0)
background = Background('./assets/buildings-bg.png', x=index, layer=1)
engine.drawables.add(full_background)
engine.drawables.add(background)
index += league.Settings.width
engine.drawables.add(level1.passable.sprites())
# Gravity must be appended first
engine.objects.append(gravity)
player.world_size = world_size
player.blocks.add(level1.impassable)
engine.collisions[player] = []
engine.objects.append(player)
engine.drawables.add(player)
place_random_items(engine, world_size, player)
flag = Flag(world_size[0] - (league.Settings.tile_size * 10),
world_size[1])
engine.collisions[player].append((flag, flag.win))
engine.objects.append(flag)
engine.drawables.add(flag)
# add background music with map creation
### MUSIC IS BROKEN WON' REPEAT
# pygame.mixer.music.load('assets/Blazer Rail.wav')
# pygame.mixer.music.play(-1, 0.0)
for enemy in engine.enemy_list:
enemy.world_size = world_size
enemy.rect = enemy.image.get_rect()
enemy.blocks.add(level1.impassable)
engine.objects.append(enemy)
engine.drawables.add(enemy)
engine.collisions[player].append((enemy, player.take_dmg))
def createFlags():
global flags
for process,processCode in Processes.getAll():
flags[process] = Flag(False)
def __init__(self):
self.tparams = OrderedDict()
self.flag_training = Flag(False)
def load_world_11(self):
data = load_pygame("worlds/1-1/W11.tmx")
self.map_size = (data.width, data.height)
self.sky = pygame.Surface((screen_width, screen_height))
self.sky.fill((92, 148, 252))
self.map = [[0] * data.height for i in range(data.width)]
# Sets the different layers so mario does not interact with all items on the screen
layer_num = 0
for layer in data.visible_layers:
for y in range(data.height):
for x in range(data.width):
image = data.get_tile_image(x, y, layer_num)
if image is not None:
tile_id = data.get_tile_gid(x, y, layer_num)
if layer.name == 'Foreground':
if tile_id == 22:
image = (
image, # 1
data.get_tile_image(0, 15, layer_num), # 2
data.get_tile_image(1, 15, layer_num), # 3
data.get_tile_image(2, 15,
layer_num) # activated
)
self.map[x][y] = Platform(x * data.tileheight,
y * data.tilewidth,
image, tile_id)
self.obj.append(self.map[x][y])
elif layer.name == 'Background':
self.map[x][y] = BGObject(x * data.tileheight,
y * data.tilewidth,
image)
self.obj_bg.append(self.map[x][y])
layer_num += 1
# Specific positons of the world object ======================================================================
self.spawn_tube(28, 10)
self.spawn_tube(37, 9)
self.spawn_tube(46, 8)
self.spawn_tube(55, 8)
self.spawn_tube(163, 10)
self.spawn_tube(179, 10)
# Mobs
self.mobs.append(Goombas(736, 352, False))
self.mobs.append(Goombas(1295, 352, True))
self.mobs.append(Goombas(1632, 352, False))
self.mobs.append(Goombas(1672, 352, False))
self.mobs.append(Goombas(5570, 352, False))
self.mobs.append(Goombas(5620, 352, False))
self.map[21][8].bonus = 'mushroom'
self.map[78][8].bonus = 'mushroom'
self.map[109][4].bonus = 'mushroom'
self.flag = Flag(6336, 48)
def register_ntstatus(cls, code, name, descr):
if code in cls.ALL_STATUS:
return # Use the first def
cls.ALL_STATUS[code] = (code, name, descr)
return Flag(name, code)
def set_question(self, question, answer):
self.question = question
self.answer = answer
self.flag = Flag(answer)
def add_flag(self, x, y, owner):
image = self.images[owner]
position = (x, y)
flag = Flag(position, image, self.game_map.map_corners)
self.flags.append(flag)
class Capture:
BOARD_WIDTH = 400.0
BOARD_HEIGHT = 400.0
FLAGS = [
Flag(0, Flag.CONTACT_DISTANCE, Flag.CONTACT_DISTANCE),
Flag(1, BOARD_WIDTH - Flag.CONTACT_DISTANCE,
BOARD_HEIGHT - Flag.CONTACT_DISTANCE)
]
WAIT_TIME = 0.05
N_TURNS_IN_JAIL = 100 # 5 Seconds
MOVE_DIST = 5
def __init__(self):
self.teams = [[], []]
self.flags = list(Capture.FLAGS)
self.jail = []
self.curr_team = 0
self.started = False
self.creator = None
def __str__(self):
return 'Game with players:', str(players)
def add_player(self, player):
if not self.started:
player.init_side(self.curr_team, Capture.BOARD_WIDTH,
Capture.BOARD_HEIGHT, Capture.MOVE_DIST,
Capture.WAIT_TIME, Capture.N_TURNS_IN_JAIL,
len(self.teams[self.curr_team]) == 0)
self.teams[self.curr_team].append(player)
self.curr_team = int(not self.curr_team)
else:
error_obj = {
'msg': 'You cannot join the game. It has already started.\n',
'code': 1
}
player.conn.sendall('error ' + json.dumps(error_obj))
return not self.started
def start(self):
self._init_positions()
self._send_to_all('start\n')
start_new_thread(self.main_loop, ())
self.started = True
print 'New Game Started'
# Winner should be a JSON object
def game_over(self, team):
winner = {'winner': team}
self._send_to_all('over {}\n'.format(json.dumps(winner)))
self.__init__()
def main_loop(self):
while len(self.teams[0]) + len(self.teams[1]) > 0:
free_players = set(self.teams[0] + self.teams[1]) - set(self.jail)
# Update position of all players
for player in free_players:
player.move(Capture.BOARD_WIDTH, Capture.BOARD_HEIGHT)
# Check for a winner
if player.flag and player.on_own_side(Capture.BOARD_WIDTH,
Capture.BOARD_HEIGHT):
print 'Game over'
self.game_over(player.team)
sys.exit(0)
# Check contact/visiblitly with other players / flags
for player in free_players:
contact_list = player.set_player_visibility(
set(self.teams[0] + self.teams[1]) - set([player]) -
set(self.jail))
flag_list = player.set_flag_visibility(self.flags)
# Deal with players in contact with other players / flags
if contact_list and not player.on_own_side(
Capture.BOARD_WIDTH, Capture.BOARD_HEIGHT):
player.go_to_jail()
self.jail.append(player)
# Return flag if player was carrying it
if player.flag:
self.flags.append(player.flag)
player.flag = None
# Pickup flag
elif flag_list:
player.caught_flag(flag_list[0])
self.flags.remove(flag_list[0])
try:
# Send data to player
player.alert()
except:
# If connection disrupted, remove player from game
self.teams[player.team].remove(player)
# If no players left, reset the game and end thread
if len(self.teams[0]) + len(self.teams[1]) == 0:
self.__init__()
print 'Game reset'
sys.exit(1)
# For all players in jail, countdown until they can leave
for player in self.jail:
if player.turn_in_jail():
player.pos = [
Capture.BOARD_WIDTH / 2,
player.team * Capture.BOARD_HEIGHT
]
self.jail.remove(player)
# Pause for set time
time.sleep(Capture.WAIT_TIME)
# If all players have quit the game
self.__init__()
print 'Game reset'
sys.exit(0)
# Msg should already be formatted as 'cmd[ {JSON}]'
def _send_to_all(self, msg):
for team in self.teams:
for player in team:
player.conn.sendall(msg)
def _init_positions(self):
for i, team in enumerate(self.teams):
n_players = len(team)
for j, player in enumerate(team):
x = (j + 0.5) * 1.0 / n_players * Capture.BOARD_WIDTH
y = i * Capture.BOARD_HEIGHT + (
1 - 2 * i) * Player.CONTACT_DISTANCE
player.pos = [x, y]
"""
menuitem_test.py
A simple tester program for menu items.
"""
from turtle import *
from menuitem import MenuItem
from flag import Flag
INDENT = 30
START_Y = 100
ITEM_SPACE = 30
menuClick = Flag()
def changePenColor(c):
"""Changes the system turtle’s color to c."""
menuClick.value(True)
color(c)
def createMenu(callback):
"""Displays 6 menu items to respond to the given callback function."""
x = -(window_width() / 2) + INDENT
y = START_Y
colors = ("red", "green", "blue", "yellow", "purple", "black")
shape = "circle"
for color in colors:
MenuItem(x, y, shape, color, callback)
y -= ITEM_SPACE
import sys
from map import Map
from flag import Flag
from game import Scene
from bullet import Bullet
from player import Player
from enemy_tank import EnemyTank
from explosion import Explosion
from moveable_object import MoveableObject
from bonus import Bonus
from game_object import GameObject
app = QApplication(sys.argv)
map = Map()
flag = Flag()
scene = Scene()
player = Player()
bullet = Bullet(player)
@pytest.fixture
def test_map_init():
assert type(map) == Map
def test_map_init_level():
assert len(map.objects) > 0
assert len(map.all_enemys) > 0
def __init__(self, level=0):
self.objects = []
self.all_enemys = []
self.__init_level__(level)
self.__init_borders__(WIDTH, HEIGHT)
self.objects.append(Flag())
def run_game():
radio = pygame.mixer
radio.init()
pygame.init()
settings = Settings()
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption("Mario")
clips = [
radio.Sound('sounds/bg_music.wav'),
radio.Sound('sounds/block_bump.wav'),
radio.Sound('sounds/brick_break.wav'),
radio.Sound('sounds/coin.wav'),
radio.Sound('sounds/death.wav'),
radio.Sound('sounds/extra_life.wav'),
radio.Sound('sounds/fireball.wav'),
radio.Sound('sounds/jump.wav'),
radio.Sound('sounds/kill.wav'),
radio.Sound('sounds/pipe.wav'),
radio.Sound('sounds/power_spawn.wav'),
radio.Sound('sounds/powerup.wav'),
radio.Sound('sounds/stage_clear.wav'),
radio.Sound('sounds/star.wav')
]
pipes = Group()
secret_pipes = Group()
bricks = Group()
secret_bricks = Group()
upgrades = Group()
enemies = Group()
poles = Group()
fireballs = Group()
flags = Group()
ground = Group() # +
stats = Stats()
for i in range(6, 8):
pipe = Pipe(screen, settings, i)
secret_pipes.add(pipe)
# Create and initialize flag and pole before storing in group
flag = Flag(screen, settings, stats)
flags.add(flag)
pole = Pole(screen, settings)
poles.add(pole)
mario = Mario(screen, settings, pipes, bricks, upgrades, stats, enemies,
poles, radio, clips, fireballs, secret_bricks, secret_pipes,
ground)
lvl_map = None
level = Level(screen, settings, pipes, lvl_map, bricks, upgrades, enemies,
flags, poles)
display = Display(screen, stats)
clips[0].play(-1)
while True:
# Checks if Mario is in the main level and sets the map, generate the bricks, pipes, flags, and pole
# Does this only once
if stats.activate_main_lvl:
lvl_map = Map(screen, settings, bricks, pipes, mario, enemies,
ground, upgrades, stats, secret_bricks)
lvl_map.build_brick()
# generate pipes and flag/pole
for i in range(0, 6):
pipe = Pipe(screen, settings, i)
pipes.add(pipe)
flag = Flag(screen, settings, stats)
flags.add(flag)
pole = Pole(screen, settings)
poles.add(pole)
stats.activate_main_lvl = False
# Checks if Mario has activated the secret level and sets the map, clears all of the main level
# Does this only once
if stats.activate_secret:
# Clears everything belonging to main level to prevent lag
pipes.empty()
bricks.empty()
enemies.empty()
poles.empty()
flags.empty()
lvl_map = Map(screen, settings, bricks, pipes, mario, enemies,
ground, upgrades, stats, secret_bricks)
lvl_map.build_brick()
stats.activate_secret = False
stats.main_level = False
if stats.game_active:
gf.check_events(mario, stats, clips, fireballs)
# If the player gets near the right side, shift the world left (-x)
if mario.rect.right >= 600 and stats.main_level:
diff = mario.rect.right - 600
mario.rect.right = 600
level.shifting_world(-diff)
# If the player gets near the left side, shift the world right (+x)
# if mario.rect.left <= 100:
# diff = 100 - mario.rect.left
# mario.rect.left = 100
# level.shifting_world(diff)
gf.update_screen(screen, mario, settings, level, pipes, display,
stats, bricks, upgrades, enemies, flags, poles,
radio, clips, fireballs, secret_bricks,
secret_pipes)
pygame.display.flip()
def create_flag(settings, screen, flags):
flag = Flag(screen, settings.flag_positions[settings.current_level])
flag.x = flag.pos[0]
flag.y = flag.pos[1]
flags.add(flag)
def run():
# Initialization
pygame.init()
settings = Settings()
state = Game_State()
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption("Super Mario Bros")
bg_color = settings.bg_color
stats = Game_Stats(screen, settings)
clock = pygame.time.Clock()
mario = Mario(screen, settings, stats)
pygame.mixer.music.load("Sounds/overworld.mp3")
pygame.mixer.music.play(-1)
# Groups
map_group = Group()
block_group = Group()
floor_group = Group()
pipe_group = Group()
enemy_group = Group()
powerup_group = Group()
fireball_group = Group()
dead_group = Group()
map.generate_map(screen, settings, map_group, floor_group, pipe_group,
block_group, enemy_group)
f = Flag(screen, settings, 198 * settings.block_width,
13 * settings.block_height)
f.add(map_group)
pipesprites = pipe_group.sprites()
timer = 0
death_counter = 0
# Game Loop
while state.running:
settings.reset_holders()
clock.tick(settings.fps)
# handle mario death
if mario.is_dead and death_counter <= 240:
# draw black screen
if death_counter == 60:
screen.fill(settings.bg_color)
stats.lives -= 1
if stats.lives < 0:
stats.init_base_values()
#display game over
game_over_label = Text(None, settings.TEXT_SIZE,
"Game Over", settings.WHITE, 0, 0)
game_over_label.rect.center = (settings.screen_width / 2,
settings.screen_height / 2)
game_over_label.draw(screen)
else:
# display level
lvl_str = "World " + str(stats.world) + "-" + str(
stats.level_num)
level_label = Text(None, settings.TEXT_SIZE, lvl_str,
settings.WHITE, 0, 0)
level_label.rect.center = (settings.screen_width / 2,
settings.screen_height / 2)
level_label.draw(screen)
pygame.display.flip()
death_counter += 1
print(death_counter)
elif mario.is_dead and death_counter > 240:
# reset
death_counter = 0
mario.kill()
mario = Mario(screen, settings, stats)
map_group = Group()
block_group = Group()
floor_group = Group()
pipe_group = Group()
enemy_group = Group()
powerup_group = Group()
fireball_group = Group()
dead_group = Group()
pygame.mixer.music.play(-1)
map.generate_map(screen, settings, map_group, floor_group,
pipe_group, block_group, enemy_group)
f = Flag(screen, settings, 198 * settings.block_width,
13 * settings.block_height)
f.add(map_group)
stats.new_level()
# victory -> change level -> use death_counter to reset
if mario.has_won and death_counter <= 300:
# draw black screen
if death_counter == 100:
stats.level_num += 1
screen.fill(settings.bg_color)
# display level
lvl_str = "World " + str(stats.world) + "-" + str(
stats.level_num)
level_label = Text(None, settings.TEXT_SIZE, lvl_str,
settings.WHITE, 0, 0)
level_label.rect.center = (settings.screen_width / 2,
settings.screen_height / 2)
level_label.draw(screen)
coming_soon = Text(None, settings.TEXT_SIZE, "Coming Soon",
settings.WHITE, 0, 0)
coming_soon.rect.center = (settings.screen_width / 2,
(settings.screen_height / 2) +
settings.SPACER)
coming_soon.draw(screen)
pygame.display.flip()
death_counter += 1
print(death_counter)
elif mario.has_won and death_counter > 300:
# reset game
death_counter = 0
mario.kill()
mario = Mario(screen, settings, stats)
map_group = Group()
block_group = Group()
floor_group = Group()
pipe_group = Group()
enemy_group = Group()
powerup_group = Group()
fireball_group = Group()
dead_group = Group()
pygame.mixer.music.load("Sounds/overworld.mp3")
pygame.mixer.music.play(-1)
map.generate_map(screen, settings, map_group, floor_group,
pipe_group, block_group, enemy_group)
f = Flag(screen, settings, 198 * settings.block_width,
13 * settings.block_height)
f.add(map_group)
stats.new_level()
# Game Play
gf.check_events(state, mario, screen, settings, fireball_group,
map_group)
# Update here
if not mario.is_dead and not mario.has_won:
if timer < settings.fps:
timer += 1
else:
timer = 0
stats.decrement_time()
gf.update(screen, settings, mario, map_group, floor_group,
pipe_group, block_group, enemy_group, powerup_group,
fireball_group, dead_group, f)
if stats.did_time_runout():
mario.dead()
if stats.time == 100:
pygame.mixer.Sound('Sounds/time_warning.wav').play()
# update game values
stats.add_score(settings.score_holder)
stats.add_coin(settings.coin_holder)
if settings.one_up:
stats.lives += 1
settings.one_up = False
# Display here
stats.update()
gf.update_screen(screen, settings, stats, mario, map_group,
floor_group, pipe_group, block_group, enemy_group,
powerup_group, fireball_group, dead_group, f)
# stats.draw()
pygame.quit()
sys.exit()
def main():
selectableTanks = []
allTanks = []
for o in gameConsts.obstacles:
gameObjects.append(Obstacle((o['x'], o['y']), o['size']))
# after tanks puts them on top
for p in gameConsts.players:
gameObjects.append(
Base(p['color'], (p['base']['x'], p['base']['y']),
p['base']['size']))
for p in gameConsts.players:
tankNum = 1 # TODO: replace with dictionary index?
for t in p['tanks']:
tank = Tank(color=p['color'],
position=(
t['position']['x'],
t['position']['y'],
),
number=tankNum,
addToGameObject=addToGameObject)
gameObjects.append(tank)
tankNum = tankNum + 1
allTanks.append(tank)
if p['human']:
selectableTanks.append(tank)
# append flags after tanks so they are on top
for p in gameConsts.players:
gameObjects.append(
Flag(p['color'], (p['base']['x'], p['base']['y']),
gameConsts.FLAG_SIZE))
allAIPlayers = []
for p in gameConsts.players:
if not p['human']:
allAIPlayers.append(AI(p['color'], gameObjects))
clock = pg.time.Clock()
done = False
scoreboardNextTick = 0
aiNextTick = 0
while not done:
clock.tick(gameConsts.FPS)
currentTick = pg.time.get_ticks()
for event in pg.event.get():
if event.type == pg.QUIT:
done = True
if event.type == pg.MOUSEBUTTONDOWN:
pos = pg.mouse.get_pos()
for t in selectedTanks:
t.setDestination(pos)
elif event.type == pg.KEYDOWN:
if event.key == pg.K_SPACE:
for t in selectedTanks:
t.fire()
if event.key == pg.K_1: # TODO: map K_1 to index of selectableTank array
selectTank(selectableTanks[0])
if event.key == pg.K_2:
selectTank(selectableTanks[1])
if event.key == pg.K_3:
selectTank(selectableTanks[2])
# screen.fill(gameConsts.BACKGROUND_COLOR) # TODO: replace with grass
for x in range(0, gameConsts.MAP_WIDTH, gameConsts.BACKGROUND_SIZE):
for y in range(0, gameConsts.MAP_WIDTH,
gameConsts.BACKGROUND_SIZE):
screen.blit(bg, (x, y))
if (currentTick > aiNextTick):
aiNextTick = currentTick + gameConsts.AI_UPDATE_TIMEOUT
for ai in allAIPlayers:
ai.control()
scoreboard.update()
for obj1 in gameObjects:
for obj2 in gameObjects:
if obj1 is obj2: continue
if not (obj1.top > obj2.bottom or obj1.right < obj2.left
or obj1.bottom < obj2.top or obj1.left > obj2.right):
handleHit(obj1, obj2, gameObjects)
if (obj1.markedForTermination):
gameObjects.remove(obj1)
del obj1
continue
if (isinstance(obj1, Tank)):
checkWalls(obj1)
if obj1.respawn:
obj1.checkRespawn(pg.time.get_ticks())
continue
if (isinstance(obj1, Flag)):
if obj1.pickedUp and obj1.pickedUpBy.respawn:
obj1.pickedUpBy.setFlag(None)
obj1.dropped()
obj1.update()
obj1.getSprite().draw(screen)
if (currentTick > scoreboardNextTick):
scoreboardNextTick = currentTick + gameConsts.ONE_SECOND
for t in allTanks:
if (isinstance(t.flag, Flag)):
scoreboard.updateScore(t.color,
gameConsts.POINTS_CARRYING_FLAG)
pg.display.flip()
