def __init__(self):
super().__init__()
self.background = urwid.AttrMap(urwid.SolidFill(' '), 'bg')
self.player = Player(Config.ARENA_WIDTH, Config.ARENA_HEIGHT)
self.entities = [
Entity(Config.ARENA_WIDTH, Config.ARENA_HEIGHT)
for _ in range(Config.ENEMIES)
]
self.loop = urwid.MainLoop(self.__get_screen(),
palette=Config.PALLETE,
unhandled_input=self.handle_input)
def create_player(self,
player_id: str,
spaceship_id: str,
player_config: PlayerConfig,
status_x=15,
status_y=15):
status = PlayerStatus(screen=self.screen,
x=status_x,
y=status_y,
color=player_config.bullet_color)
return Player(player_id=player_id,
spaceship_id=spaceship_id,
player_config=player_config,
player_status=status)
def play():
player = Player()
os.system('cls')
print('Select complexity:')
options = [
f'{name} (freedom: {int(complexity * 100)}%)'
for name, complexity in complexities
]
area = Area(120, 20, complexities[select_option(options)][1], player)
while player.area is not None:
area.draw()
act(area)
if player.won:
print("You won")
else:
print("Game over")
def main():
# Set window size
windowSize = [600, 600]
# Create variable keep_going
keep_going = True
# Create pygame Clock class instance
timer = pygame.time.Clock()
# Create display
screen = pygame.display.set_mode(windowSize)
# Create instances of local classes
sound = Sound()
sound.playMusic(sound.soundtrack)
object = Object(screen, windowSize[0] // 2, windowSize[1] // 2, "#e00000")
player = Player(2, screen, windowSize[0] // 2, windowSize[1] // 2)
background = Background(screen, -windowSize[0], -windowSize[1])
# Play soundtrack in sound class
sound.playMusic(sound.soundtrack)
# Game loop
while keep_going:
# Fill screen with blue
screen.fill("#4287f5")
# Update entities
background.update()
player.update()
object.update()
# Flip display
pygame.display.flip()
# Check if quit
for event in pygame.event.get():
if event.type == pygame.QUIT:
# Set keep_going to false
keep_going = False
# Call tick method in timer instance
timer.tick(720)
def __init__(self):
pygame.init()
pygame.display.set_caption("Bomberman")
self.BLOCKS_DESTRUCTIBLE = 100
self.ENEMIES = 10
self.appear = 0
self.display = pygame.display.set_mode(c.WINDOW)
self.clock = pygame.time.Clock()
self.player = Player()
self.block_positions = []
self.gr_player = Group()
self.gr_enemies = Group()
self.gr_block = Group()
self.gr_block_destructible = Group()
self.gr_bomb = Group()
self.gr_bomb_collide = Group()
self.start()
def __init__(self):
self.window = Window()
self.hud = Hud(self.window.screen, self.window.size)
self.statistics = Statistic()
self.clock = pygame.time.Clock()
pygame.key.set_repeat(40, 30)
self.size = [80, 80]
self.player = Player(self.size, "entities/bb.png")
self.enemies_buffer = 15
self.knifeAnimation = load_image('entities/attack/a0.png'), load_image('entities/attack/a1.png'),load_image('entities/attack/a2.png'),\
load_image('entities/attack/a3.png'), load_image('entities/attack/a4.png'),load_image('entities/attack/a5.png'),\
load_image('entities/attack/a6.png'), load_image('entities/attack/a7.png'),load_image('entities/attack/a8.png'),\
load_image('entities/attack/a9.png'), load_image('entities/attack/a10.png'),load_image('entities/attack/a11.png'),\
load_image('entities/attack/a12.png'), load_image('entities/attack/a13.png'),load_image('entities/attack/a14.png')
self.entities = pygame.sprite.Group()
self.enemies = pygame.sprite.Group()
self.bullets = pygame.sprite.Group()
self.entities.add(self.player)
self.old_time = pygame.time.get_ticks()
self.new_time = pygame.time.get_ticks()
def __init__(self, singlemulti, level_number, parent=None):
QGraphicsScene.__init__(self, parent)
self.key_notifier = KeyNotifier()
self.key_notifier.key_signal.connect(self.do_key_press)
self.key_notifier.start()
self.numberOfPlayer = singlemulti
self.level_numberrr = level_number
# Postavljanje pozadine
self.set_background()
#Postavljanje Glavnog igraca
if (self.numberOfPlayer == 1):
self.player = Player()
self.player.setPos(400, 525)
self.addItem(self.player)
self.flag_playerOneDead = False
elif (self.numberOfPlayer == 2):
self.player = Player()
self.player.setPos(400, 525)
self.addItem(self.player)
self.flag_playerOneDead = False
self.player2 = Player2()
self.player2.setPos(100, 525)
self.addItem(self.player2)
self.flag_playerTwoDead = False
# Postavljanje neprijatelja
self.enemies = []
self.enemies.append(Enemy())
self.enemies[0].setPos(100, 50)
for i in range(0, 55):
self.enemies.append(Enemy())
if i == 11:
self.enemies[i].setPos(self.enemies[0].x(),
self.enemies[0].y() + 60)
continue
if i == 22:
self.enemies[i].setPos(self.enemies[11].x(),
self.enemies[11].y() + 60)
continue
if i == 33:
self.enemies[i].setPos(self.enemies[22].x(),
self.enemies[22].y() + 60)
continue
if i == 44:
self.enemies[i].setPos(self.enemies[33].x(),
self.enemies[33].y() + 60)
continue
self.enemies[i].setPos(self.enemies[i - 1].x() + 60,
self.enemies[i - 1].y())
for i in range(0, 55):
self.addItem(self.enemies[i])
# Pomeranje neprijatelja
self.moveEnemy = MoveEnemy()
self.moveEnemy.calc_done.connect(self.move_enemy)
self.moveEnemy.start()
# Pucanje igraca
self.shootLaser = PlayerShoot()
self.shootLaser.calc_done.connect(self.move_laser_up)
self.shootLaser.collision_detected.connect(
self.player_laser_enemy_collide)
self.shootLaser.start()
self.playerOneCanShoot = True
self.playerTwoCanShoot = True
# Pucanje protivnika
self.enemyShoot = EnemyShoot()
self.enemyShoot.can_shoot.connect(self.enemy_shoot_laser)
self.enemyShoot.move_down.connect(self.move_enemy_laser)
self.enemyShoot.collision_detected.connect(self.enemy_hit_player)
self.enemyShoot.collision_detected_with_shield.connect(
self.enemy_laser_shield_collide)
#self.enemyShoot.next_level.connect(self.next_level)
if self.numberOfPlayer == 1:
self.enemyShoot.add_player(self.player)
else:
self.enemyShoot.add_player(self.player)
self.enemyShoot.add_player(self.player2)
self.enemyShoot.start()
for i in range(0, 55):
self.moveEnemy.add_enemy(self.enemies[i])
self.shootLaser.add_enemy(self.enemies[i])
self.enemyShoot.add_enemy(self.enemies[i])
#Dodavanje stitova
self.shields = []
self.shields.append(Shield())
self.shields[0].setPos(50, 350)
self.shields.append(Shield())
self.shields[1].setPos(375, 350)
self.shields.append(Shield())
self.shields[2].setPos(700, 350)
for i in range(0, 3):
self.addItem(self.shields[i])
self.enemyShoot.add_shield(self.shields[i])
self.view = QGraphicsView(self)
self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.show()
self.view.setFixedSize(WINDOW_WIDTH, WINDOW_HEIGHT)
self.setSceneRect(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT)
self.initUI(self.numberOfPlayer, self.level_numberrr)
def add_player(id_):
Entities.players.append(
Player(id_, Entities.colors[id_], Constants.map_width_screen / 2,
Constants.map_height_screen / 2))
from states.HaliteStates import HaliteStates
from persistence.Files import Files
from entities.Player import Player
file = "2018-07-28 18:39:14.334851_1"
state = HaliteStates()
persistence = Files("/home/fstuck/repros/hunger-games/haliteChallenge/data/")
p = Player(4)
'''
playerList =[]
playerList.append(Player(3))
playerList.append(Player(4))
playerList.append(Player(6))
playerList.append(Player(60))
state.addPlayer(playerList)
'''
persistence.file = file
#persistence.saveStateRandom(state)
stateBot = persistence.accessFile(file)
n = 0
def get_players():
players = Player("Sebbe")
players1 = Player('Linus')
players2 = Player('Fredrik')
return [players, players1, players2]
from KeyHandler import KeyHandler
from InteractionHandler import InteractionHandler
from terrain.Terrain import *
from Utils import *
"""
Testing Assets:
"""
pygame.init()
screen = pygame.display.set_mode((600, 600), RESIZABLE)
pygame.display.set_caption("Game")
player = Player(0, 0, 0)
interactionHandler = InteractionHandler(player)
keyHandler = KeyHandler(player)
entityHandler = EntityHandler(player)
entityHandler.add_entity(Rock(100, 100, 0))
entityHandler.add_entity(LittleRock(100, 200, 0))
entityHandler.add_entity(Rick(100, 0, 0))
tileHandler = TileHandler()
chunkHandler = ChunkHandler()
def tick():
# interaction handler for player interaction
def main():
sdl2.ext.init()
# Create the window
window = sdl2.ext.Window("Foo", size=(960, 640))
window.show()
# Create the spirte factory and the sprite for the player
factory = sdl2.ext.SpriteFactory(sdl2.ext.SOFTWARE)
# Create the worl and spriterenderer system
world = sdl2.ext.World()
spriterenderer = SoftwareRenderer(window)
movement = MovementSystem(0, 0, 960, 640)
playerMovement = PlayerMovementSystem()
collision = CollisionSystem()
battleSystem = BattleSystem()
# Add all systems to the world
world.add_system(playerMovement)
world.add_system(collision)
world.add_system(movement)
world.add_system(spriterenderer)
world.add_system(battleSystem)
# Test map generation
grid = mapGen.buildMap(world, factory, 4)
grid.build(world, factory)
enemyTile = random.choice(grid.tiles)
enemy = Enemy(world, factory, enemyTile.position.x, enemyTile.position.y)
# Pick random location for player
playerTile = random.choice(grid.tiles)
player = Player(world, factory, playerTile.position.x, playerTile.position.y)
player_speed = 1
battleSystem.player = player
playerMovement.player = player
playerMovement.grid = grid
gridSystem = GridSystem(960, 640, player)
world.add_system(gridSystem)
# Colliders for said items
collision.player = player
collision.grid = grid
# Main event loop
running = True
key_down = False
while(running):
events = sdl2.ext.get_events()
for event in events:
# Hittin' dat X button doe
if event.type == sdl2.SDL_QUIT:
running = False
break
if event.type == sdl2.SDL_KEYUP:
key_down = False
# Movement
if event.type == sdl2.SDL_KEYDOWN:
d = None
if(not key_down):
if event.key.keysym.sym == sdl2.SDLK_UP:
d = Direction.NORTH
key_down = True
elif event.key.keysym.sym == sdl2.SDLK_e:
print("I'm attacking with", player.get_damage(), "!")
key_down = True
elif event.key.keysym.sym == sdl2.SDLK_f:
print("Consuming")
player.consume()
print("Player health now at,", player.playerdata.health)
elif event.key.keysym.sym == sdl2.SDLK_DOWN:
d = Direction.SOUTH
key_down = True
elif event.key.keysym.sym == sdl2.SDLK_LEFT:
d = Direction.EAST
key_down = True
elif event.key.keysym.sym == sdl2.SDLK_RIGHT:
d = Direction.WEST
key_down = True
if d != None:
collision.player_dir = d
enemy.random_move(grid)
playerMovement.walk(d)
sdl2.SDL_Delay(10)
world.process()
return 0
turn = 0
while True:
# TURN START
# Update the map for the new turn and get the latest version
game_map = game.update_map()
# map game data to states and entities
allPlayers = game_map.all_players()
playerList = []
shipList = []
planetList = []
playerString = ""
for p in allPlayers:
playerList.append(Player(p.id))
playerString += str(p.id) + " : "
for s in game_map.get_player(p.id).all_ships():
shipList.append(s)
for p in game_map.all_planets():
planetList.append(p)
logging.info(playerString)
states.addPlayer(playerList)
states.addPlanets(planetList)
states.addShips(shipList)
# Here we define the set of commands to be sent to the Halite engine at the end of the turn
command_queue = []
# For every ship that I control
for ship in game_map.get_me().all_ships():
def add_player(self, name, color, type_of_player):
self.__check_for_too_many_players()
self.__check_if_color_is_already_been_used(color)
self.players.append(Player(name, color, type_of_player))
