def test_01_load_save_simple(self):
""" test loading and saving a level"""
selector = selector_fake.SelectorFake()
loaded_level = level.Level(selector)
loaded_level.load("../test/test_samples/level/simple/", state.LevelState.Instantiated)
self.assertIsNotNone(loaded_level)
self.assertIsNotNone(loaded_level.values.gates)
self.assertEqual(len(loaded_level.values.gates), 4)
self.assertIsNotNone(loaded_level.values.rooms)
self.assertEqual(len(loaded_level.values.rooms), 3)
output = "/tmp/test_01_load_save_simple"
self.remake_dest(output)
_dump = loaded_level.save(output)
reloaded_level = level.Level(selector)
reloaded_level.load(output, state.LevelState.Instantiated)
self.assertIsNotNone(reloaded_level)
self.assertIsNotNone(reloaded_level.values.gates)
self.assertEqual(len(reloaded_level.values.gates), 4)
self.assertIsNotNone(reloaded_level.values.rooms)
self.assertEqual(len(reloaded_level.values.rooms), 3)
async def xp(ctx, member: discord.Member = None):
allowance = not_allowed(ctx, xp.name, bot)
if allowance[0]:
await bot.say(f'acess denied,channel for ={xp.name} is {allowance[1]}')
return
if member == None:
lev = level.Level(ctx=ctx)
else:
lev = level.Level(member=member)
try:
lev.get_level()
except:
await bot.say('need to bet once at least!!')
return
if member == None:
embed = discord.Embed(
title=f'{ctx.message.author} has level {lev.level}',
description=f'XP = {lev.xp}',
colour=discord.Colour.dark_orange())
else:
embed = discord.Embed(title=f'{member} has level {lev.level}',
description=f'XP = {lev.xp}',
colour=discord.Colour.dark_orange())
embed.add_field(name='MULTIPLIER', value=f'mult -->{lev.mult}')
await bot.say(embed=embed)
def do_main(no_intro=0, the_level=0):
global flags
print("hello from zanthor do_main")
pygame.mixer.pre_init(22050, -16, 2, 1024)
pygame.init()
pygame.font.init()
#pygame.display.set_caption("The Wrath of ZANTHOR") #It's powered by steam!")
pygame.display.set_caption(
"The Wrath of ZANTHOR! It's powered by steam! h key for help")
#flags = FULLSCREEN
print flags
print(SW, SH)
screen = pygame.display.set_mode((SW, SH), flags)
# Map the back button to the escape key.
if android:
android.map_key(android.KEYCODE_BACK, pygame.K_ESCAPE)
print("initialising joystick module")
pygame.joystick.init()
joystics = []
num_joys = pygame.joystick.get_count()
print "initialising joys", num_joys
for x in range(num_joys):
print "x joy is:", x
j = pygame.joystick.Joystick(x)
j.init()
joystics.append(j)
print "initialising joys: done."
game = Game()
game.should_restore_stats = True
game.backup_upgradable_amounts = None
game.backup_castle_stats = None
# the intro is not done first.
#game.run(states.Title(game),screen)
if no_intro == 0:
game.run(intro.Intro(game), screen)
elif no_intro == 1:
#game.run(level.Level(game, 0,100),screen)
game.run(menu.Menu(game), screen)
elif no_intro == 3:
# we load the level number from the levels defined in menu.
n = menu.data[no_intro][4]
perc = menu.data[no_intro][5]
music = menu.data[no_intro][7]
game.run(level.Level(game, n, perc, music), screen)
else:
game.run(level.Level(game, no_intro, 100, None), screen)
def startGame(self):
s = shelve.open(Menu.LEVEL_FILE)
try:
data = s["level_01"]
l = level.Level()
l.gameObjects = data
except:
l = level.Level()
l.generateMap()
s.close()
Game.curGame.loadScene(l)
def test_update_3(self):
""" Test update with velocity """
modobj = sprite.ModelObject(self.model)
level.Level(mapsize=(1000, 1000),
screen=SCREEN).add(modobj, (100, 100))
modobj.velocity = [1, 1]
modobj.update()
self.assertEquals(modobj.maprect.center, (101, 101))
self.assertEquals(modobj.maprect.topleft, (90, 90))
self.assertEquals(modobj.rect.topleft, (90, 90))
modobj.update()
self.assertEquals(modobj.maprect.center, (102, 102))
self.assertEquals(modobj.maprect.topleft, (91, 91))
self.assertEquals(modobj.rect.topleft, (91, 91))
modobj.velocity = [0, -1]
modobj.update()
self.assertEquals(modobj.maprect.topleft, (91, 90))
self.assertEquals(modobj.rect.topleft, (91, 90))
modobj.velocity = [-1, 0]
modobj.update()
self.assertEquals(modobj.maprect.topleft, (90, 90))
self.assertEquals(modobj.rect.topleft, (90, 90))
modobj.velocity = [-1, -1]
modobj.update()
self.assertEquals(modobj.maprect.topleft, (89, 89))
self.assertEquals(modobj.rect.topleft, (89, 89))
modobj.update()
self.assertEquals(modobj.maprect.topleft, (88, 88))
self.assertEquals(modobj.rect.topleft, (88, 88))
def test_update_4(self):
""" Test update with angular velocity """
modobj = sprite.ModelObject(self.model)
level.Level(screen=SCREEN).add(modobj, (11, 11))
modobj.angular_velocity = 1
modobj.update()
self.assertEquals(modobj.angle, 1)
self.assertEquals(modobj.maprect.topleft, (0, 0))
self.assertEquals(modobj.rect.topleft, (0, 0))
self.assertEquals(modobj.rect.center, (11, 11))
modobj.update()
self.assertEquals(modobj.angle, 2)
self.assertEquals(modobj.maprect.topleft, (0, 0))
self.assertEquals(modobj.rect.topleft, (0, 0))
self.assertEquals(modobj.rect.center, (11, 11))
modobj.angular_velocity = 90
modobj.update()
self.assertEquals(modobj.angle, 92)
self.assertEquals(modobj.maprect.topleft, (0, 0))
self.assertEquals(modobj.rect.topleft, (0, 0))
self.assertEquals(modobj.rect.center, (11, 11))
modobj.angular_velocity = 43
modobj.update()
self.assertEquals(modobj.angle, 135)
self.assertEquals(modobj.maprect.topleft, (0, 0))
self.assertEquals(modobj.rect.topleft, (-5, -5))
self.assertEquals(modobj.rect.center, (11, 11))
modobj.angular_velocity = 45
modobj.update()
self.assertEquals(modobj.angle, 180)
self.assertEquals(modobj.maprect.topleft, (0, 0))
self.assertEquals(modobj.rect.topleft, (0, 0))
self.assertEquals(modobj.rect.center, (11, 11))
def __init__(self, curLevel): """Initialize""" """Load level info""" self.level = level.Level(curLevel) """Set the window Size""" self.width = self.level.width self.height = self.level.height """Set block size""" self.BLOCK_SIZE = self.level.blockSize """Initialize PyGame""" pygame.init() """Create the Screen""" self.screen = pygame.display.set_mode((self.width, self.height)) self.background = None self.layout = None self.sprites_block = None self.character = None self.sprites_character = None self.sprites_pellet = None self.sprites_spellet = None self.npc = None self.sprites_npc = None
def CreateNewLevel(self, name, numrows, numcols, author):
# Lanza fuera la excepción Exception
newlevel = level.Level(name, numrows, numcols, author)
if not self.__CheckName(name):
self.__levels.append(newlevel)
return True
return False
def test_scroll(self):
modobj = sprite.ModelObject(self.model)
level.Level(screen=SCREEN).add(modobj, (11, 11))
modobj.scroll((10, 10))
self.assertEquals(modobj.maprect.topleft, (0, 0))
self.assertEquals(modobj.maprect.center, (11, 11))
self.assertEquals(modobj.rect.topleft, (10, 10))
self.assertEquals(modobj.rect.center, (21, 21))
def runGameHost():
window = py.display.set_mode((600, 600))
white_screen_col = py.Color(255, 255, 255)
fps_controller = py.time.Clock()
lvl = l.Level('map1.png', 20, (50, 50))
clientPlayer = player.Base_Player(300, 300, py.Color(255, 0, 150), window,
0)
hostPlayer = player.Base_Player(350, 350, py.Color(0, 255, 0), window, 1)
connections, names = net.get_connections()
for i in connections:
i.send(bytes("START", 'utf-8'))
play = True
frame = 0
while play:
py.draw.rect(window, white_screen_col, (0, 0, 600, 600))
lvl.draw(window)
hostPlayer.draw()
clientPlayer.draw()
py.display.update()
for event in py.event.get():
if event.type == QUIT:
py.quit()
play = False
return
player_input = player.Player_Input.generate(1)
hostPlayer.apply_movement(player_input, lvl)
data, addr = connections[0].socket.recvfrom(
1024) # buffer size is 1024 bytes
try:
clientMovement = pickle.loads(data)
clientPlayer.apply_movement(clientMovement, lvl)
except:
print("Nothing works")
toSend = []
toSend.append(player.copy.copy(hostPlayer.current_position))
toSend.append(player.copy.copy(clientPlayer.current_position))
toSendData = player.pickle.dumps(toSend)
connections[0].socket.sendto(toSendData,
(connections[0].IP, connections[0].port))
frame += 1
if frame % 30 == 0:
print(frame)
fps_controller.tick(30)
def update(self):
pressedkeys = pygame.key.get_pressed()
for e in pygame.event.get():
if e.type == pygame.KEYDOWN:
if e.key == pygame.K_ESCAPE:
sys.exit()
if e.key == pygame.K_k:
self.die()
if e.key == pygame.K_r:
self.prevlifeframe = 0
self.prevlifeindex = 0
self.prevlives = []
self.currentlife = [
replay.InputState(pygame.key.get_pressed())
]
self.player.respawn()
for ent in self.level.entities:
ent.reset()
elif e.type == pygame.QUIT:
sys.exit()
elif e.type == pygame.USEREVENT + 2: #level win
#TODO cleaner level changing, at the very least an array of levels...
if self.level_count > 0:
sys.exit()
else:
self.level = level.Level("../assets/lvl/level1.lvl")
self.prevlifeframe = 0
self.prevlifeindex = 0
self.prevlives = []
self.currentlife = [
replay.InputState(pygame.key.get_pressed())
]
self.camera.bounds = self.level.map_surface.get_rect()
self.player.spawn_x = self.level.spawn_x
self.player.spawn_y = self.level.spawn_y
self.player.respawn()
self.level_count += 1
#store current life's state.
if pressedkeys != self.currentlife[-1].keys:
self.currentlife.append(replay.InputState(pressedkeys))
else:
self.currentlife[-1].frames += 1
for life in self.prevlives:
life.replay_step(self.level.colliders)
for ent in self.level.entities:
ent.update()
self.player.update(pressedkeys, self.level.colliders)
self.camera.center_at(self.player.rect)
self.camera.update()
#call death code only if current player dies. Replays will simply stop working and disappear.
if self.player.dead:
self.die()
def nextlevel(self):
"""Play the next level"""
self.board.clear()
title = ('level ' + str(self.levelnum + 1) + '/' + str(self.numlevels))
# play it
self.level = level.Level(self.game, self, title,
self.alllevels[self.levelnum])
# if here, we completed the level
self.levelnum += 1
def test_update_1(self):
""" Test update with no animation update, no angular velocity, no
velocity """
modobj = sprite.ModelObject(self.model)
level.Level(screen=SCREEN).add(modobj, (11, 11))
modobj.update()
self.assertEquals(modobj.image, modobj.animation_view.frame)
self.assertEquals(modobj.maprect.topleft, (0, 0))
self.assertEquals(modobj.rect.topleft, (0, 0))
def __init__(self, caption):
self.screen = pg.display.get_surface()
self.clock = pg.time.Clock()
self.fps = 60.0
self.keys = pg.key.get_pressed()
self.done = False
self.caption = caption
self.level = level.Level()
self.player = self.level.player
async def pot(ctx, amount):
allowance = not_allowed(ctx, pot.name, bot)
if allowance[0]:
await bot.say(f'acess denied,channel for ={pot.name} is {allowance[1]}'
)
return
if amount == 't':
jackpot = game.jackpot(0, ctx)
jackpot.time_delta()
await bot.say(f'{round(40-jackpot.delta)} seconds left')
return
lev = level.Level(ctx)
check = utils.Check(ctx)
embed = check.embed
balance = check.balance()
amount = utils.Check.amount(amount, balance)
if utils.Check.broke(amount, balance):
await check.display(amount, balance, bot)
return
else:
jackpot = game.jackpot(amount, ctx)
jackpot.join(amount, ctx.message.channel.id)
log = statistics.bet_log(ctx)
log.update_count()
chances = jackpot.chances()
if jackpot.time_delta():
winner = jackpot.get_winner()
jackpot.update(winner, ctx)
chance = [i for i in chances if winner[0][0] in i]
await bot.say('AND THE WINNER IS.....')
for i in range(0, 5):
await bot.say('*drum rolls*')
await asyncio.sleep(1)
await bot.say(f'@{winner[0][0]} won with {chance[0][0]*100}%')
lev.get_level()
lev.evaluate(amount)
else:
vals = jackpot.get_stake_and_size()
embed.add_field(name='POT SIZE', value=f'{vals[0]}/4')
embed.add_field(name='POT STAKE', value=f'{vals[1]}')
display = ''
for i in chances:
display += f'User: {i[1]} \nChance: {i[0]*100}% \n'
embed.add_field(name='CHANCES', value=display + '\n')
await bot.say(embed=embed)
lev.get_level()
lev.evaluate(amount)
def test_01_load_invalid_level(self):
""" test loading an invalid level"""
selector = selector_fake.SelectorFake()
loaded_level = level.Level(selector)
has_error = False
try:
loaded_level.load("../test/test_samples/level/invalid/", state.LevelState.Instantiated)
except jsonschema.exceptions.ValidationError:
has_error = True
self.assertTrue(has_error)
def goToNextLevel(self):
import pickle, shelve, menu
s = shelve.open(menu.Menu.LEVEL_FILE)
self.level += 1
try:
data = s["level_0" + str(self.__level)]
l = level.Level()
l.gameObjects = data
except:
l = level.Level()
l.generateMap()
l.player = self
s.close()
Game.curGame.loadScene(l)
def test_03_structure_personalization(self):
"""Test the instantiation algo using a fake selector"""
selector = selector_fake.SelectorFake()
loaded_level = level.Level(selector)
loaded_level.load("../test/test_samples/level/simple_1r_0b_instantiated/", state.LevelState.Instantiated)
self.assertIsNotNone(loaded_level)
loaded_level.structure_personalization()
output = "/tmp/test_03_structure_personalization"
self.remake_dest(output)
loaded_level.save(output)
def __init__(self,game,value):
self.game = game
self.cur = 0
self.options = [
("Play < $l >",level.Level(self.game,None)),
("High Scores",HighScores(self.game,None)),
("Help",Help(self.game,None)),
("Quit",engine.Quit(self.game,None)),
]
def check_level(directory, filename):
""" Get level, check it loads and return it"""
if directory == '':
print("Error, expected directory. See --help for info.")
sys.exit(1)
if not filename in os.listdir(directory):
print("Error, expected directory with ", filename,
"file. See --help for info.")
sys.exit(1)
return level.Level(directory + "/" + filename,
selector_regular.SelectorRegular())
def __init__(self):
self.level = level.Level(0, 0)
self.player = player.Player()
self.player.pos = 100, 100
self.rescue_sound = pyglet.media.load("sounds/rescue.wav", streaming=False)
self.rescued_mans = {}
self.fade_amount = 1.0
self.state = FADE_IN
fade_image = pyglet.image.load("images/fade.png")
self.fade_images = pyglet.image.ImageGrid(fade_image, 1, 38)
def __init__(self, ctrl):
super(PlayScene, self).__init__(ctrl)
self.player = player.Player(self.ctrl, self)
self.bg_color = (100, 128, 64)
w, h = self.ctrl.screen.get_size()
self.camera = camera.Camera(self.player.rect, w, h)
self.level = level.Level('data/map.tmx')
self.entities = []
self.objects = self.level.generate_objects(self.ctrl)
self.enemies = enemies.EnemyCtrl(self.ctrl, self)
def main():
""" your app starts here
"""
pygame.init()
screen = pygame.display.set_mode(settings.DISPLAY_SIZE)
while 1:
level1 = level.Level(screen)
level1.run()
def __init__(self):
pg.init()
self.screensize = (480, 480)
self.screen = pg.display.set_mode(self.screensize)
self.screenrect = self.screen.get_rect()
self.clock = pg.time.Clock()
self.fps = 60
self.done = False
self.level = level.Level(self.screen)
self.player = player.Player(self.screenrect.center)
def initGame(): filename = os.path.join(os.getcwd(), "map.png") print "Trying to open " + filename tileset = loadTileset(filename, TILE_SIZE, TILE_SIZE) Game.level = level.Level(Game.screen, tileset) print "Tileset loaded" if loadLevel() == False: return False filename = os.path.join(os.getcwd(), "player.png") print "Trying to open " + filename loadPlayer(filename) return True
def __init__(self):
self.saveManager = saveManager.SaveManager()
if input("Load level? y/n \n> ") == "y":
self.level = self.saveManager.loadLevel(
int(input("Enter level id:\n> ")))
else:
self.level = level.Level()
self.level.width = int(input("Enter width:\n> "))
self.level.height = int(input("Enter height:\n> "))
self.camera = camera.Camera()
self.renderer = renderer.Renderer(self.camera,
self.level,
editorMode=True)
self.running = True
self.mouseDown = False
self.mouseX = 0
self.mouseY = 0
self.absMouseX = 0
self.absMouseY = 0
self.clicked = False
self.keysDown = {
"esc": False,
"w": False,
"a": False,
"s": False,
"d": False,
"q": False,
"e": False,
"z": False,
"x": False,
"ctrl": False
}
self.keysPressed = {
"esc": False,
"w": False,
"a": False,
"s": False,
"d": False,
"q": False,
"e": False,
"z": False,
"x": False,
"ctrl": False
}
self.currentTime = time.clock()
self.timePassed = 0
self.gridLock = 4
self.mode = MODE_WALLS
self.idSelected = 0
pygame.font.init()
self.uiFont = pygame.font.SysFont("Arial", 30)
self.mainLoop()
def event(self, e):
if e.type is USEREVENT and e.action == 'down':
self.cur = (self.cur + 1) % len(self.items)
self.repaint()
elif e.type is USEREVENT and e.action == 'up':
self.cur = (self.cur - 1 + len(self.items)) % len(self.items)
self.repaint()
elif e.type is USEREVENT and e.action == 'left':
self.game.lcur = (self.game.lcur - 1 + len(self.levels)) % len(
self.levels)
self.cur = 1
self.repaint()
elif e.type is USEREVENT and e.action == 'right':
self.game.lcur = (self.game.lcur + 1) % len(self.levels)
self.cur = 1
self.repaint()
elif e.type is USEREVENT and e.action == 'exit':
return engine.Quit(self.game)
elif e.type is USEREVENT and (e.action == 'menu'
or e.action == 'jump'):
text, value = self.items[self.cur]
if value == 'start':
self.game.init_play()
self.game.lcur = 0
import level
l = level.Level(self.game, None, self)
return Transition(self.game, l)
elif value == 'play':
self.game.init_play()
import level
l = level.Level(self.game, None, self)
return Transition(self.game, l)
elif value == 'quit':
return engine.Quit(self.game)
elif value == 'credits':
return Transition(self.game, Credits(self.game, self))
elif value == 'help':
return Transition(self.game, Help(self.game, self))
elif e.type is KEYDOWN and e.key == K_d:
self.debug_mode()
def __init__(self):
self.timer = pygame.time.Clock()
self.display = pygame.display.get_surface()
self.level_manager = state.StateMachine(self, level.Level())
self.player = player.Player()
Game.player = self.player
self.hud_manager = state.StateMachine(
self, hud.Hud(self, self.player, self.timer))
self.background = pygame.image.load(
"data/images/city.png").convert_alpha()
surface_manager.add(self.player)
self.music = pygame.mixer.Sound("data/sound/game.wav")
self.music.play(loops=-1)
def appStarted(self):
self.setSize(640, 480)
self.player = creature.Player(self, 10, 2, 2)
self.levels = []
self.levels.append(level.Level(self, self.player))
self.currentLevel = 0
self.turns = 0
self.addMode(StartMode(name="start"))
self.addMode(GameMode(name="game"))
self.addMode(Inventory(name="inv"))
self.addMode(Win(name="win"))
self.addMode(Lose(name="lose"))
self.setActiveMode('start')
def ImportLevelFromFile(self, filename):
# Lanza fuera la excepción Exception
newlevel = level.Level("", 0, 0)
from xml.dom import minidom
xmldoc = minidom.parse(filename)
levels = xmldoc.getElementsByTagName('level')
if len(levels) != 1:
raise Exception('Needed just one <level> tag in file.')
newlevel.fromXML(levels[0])
if not self.__CheckName(newlevel.getName()):
self.__levels.append(newlevel)
return True
return False
