def create_cliff(self):
self.cliffs = BatchNode()
self.add(self.cliffs)
for i, _ in enumerate(self.obstacle_map.cells):
if not self.obstacle_map.cells[i][0].tile:
self.cliffs.add(
Cliff(self.obstacle_map.cells[i][0].center,
self.obstacle_map))
def __init__( self, director, dificuldade ):
super( GameLayer, self ).__init__()
self.director = director
self.tabuleiro = []
self.offsetX = director.get_window_size()[0]/3
self.offsetY = director.get_window_size()[1]/8
lado = 45
self.lado = lado
self.dificuldade = dificuldade
self.cpu = False
self.prolog = Prolog()
self.prolog.consult("reversi.pl")
self.tabMatriz = list(self.prolog.query("novotab(X)"))[0]['X']
self.matriz = deepcopy(self.tabMatriz)
pyglet.font.add_directory('.')
self.jogadorAtivo = Label("Jogador: Player1", font_name = 'Blood Of Dracula', font_size = 22,
x = 20, y = 350)
self.add(self.jogadorAtivo)
self.dif = Label("Dificuldade: " + self.dificuldade, font_name = 'Blood Of Dracula', font_size = 16,
x = 20, y = 300)
self.add(self.dif)
self.p = list(self.prolog.query("winner(" + str(self.tabMatriz) + ", P0, P1, P2)"))[0]
self.p1 = Label("P1: " + str(self.p['P1']) + self.dificuldade, font_name = 'Bloodsuckers', font_size = 26,
x = 20, y = 200)
self.p2 = Label("P1: " + str(self.p['P2']) + self.dificuldade, font_name = 'Bloodsuckers', font_size = 26,
x = 20, y = 150)
self.add(self.p1)
self.add(self.p2)
#Batch que vai segurar todos os pecas
self.spriteBatch = BatchNode()
self.add(self.spriteBatch)
size = 8*self.lado
for i in range(8):
l = []
for j in range(8):
peca = Peca(self.tabMatriz[i][j], (j*lado + lado/2, size - (i*lado + lado/2)))
l.append(peca)
self.spriteBatch.add(peca)
self.tabuleiro.append(l)
self.spriteBatch.add(Sprite("tabuleiro.png",
(self.tabuleiro[4][4].position[0] - lado/2, self.tabuleiro[4][4].position[1] + lado/2)
, 0, 1, 32), 0)
self.spriteBatch.position = (self.offsetX, self.offsetY)
self.spriteBatch.scale = 1.0
self.hud = GameHud()
self.add(self.hud)
self.schedule(self.gameLoop)
def __init__(self, main_scene):
self.bullets = BatchNode()
self.walls = BatchNode()
self.objects = BatchNode()
self.backgrounds = BatchNode()
self.tanks = BatchNode()
# self.decorations = BatchNode()
#main_scene = get_main_scene_layer()
self.main_scene = main_scene
self.main_scene.add(self.backgrounds, z=0)
self.main_scene.add(self.bullets, z=1)
# self.main_scene.add(self.decorations)
self.main_scene.add(self.walls)
self.main_scene.add(self.objects)
self.main_scene.add(self.tanks)
self.globalPanel = cocos.layer.Layer()
self.main_scene.add(self.globalPanel, z=1)
def __init__(self, director):
super(Tabuleiro, self).__init__()
self.director = director
self.tabuleiro = []
self.offsetX = 100
self.offsetY = 100
lado = 32
#montagem da matriz inicial
self.tabMatriz = []
for i in range(8):
linha = []
for j in range(8):
linha.append(0)
self.tabMatriz.append(linha)
self.tabMatriz[3][3] = 1
self.tabMatriz[3][4] = 2
self.tabMatriz[4][3] = 2
self.tabMatriz[4][4] = 1
###################################
#Batch que vai segurar todos os pecas
self.spriteBatch = BatchNode()
self.add(self.spriteBatch)
for i in range(8):
l = []
for j in range(8):
if (self.tabMatriz[i][j] == 0):
peca = Peca("vazio.png",
(i * lado + lado / 2, j * lado + lado / 2))
elif (self.tabMatriz[i][j] == 1):
peca = Peca("preto.png",
(i * lado + lado / 2, j * lado + lado / 2))
elif (self.tabMatriz[i][j] == 2):
peca = Peca("branco.png",
(i * lado + lado / 2, j * lado + lado / 2))
l.append(peca)
self.spriteBatch.add(peca)
self.tabuleiro.append(l)
self.spriteBatch.position = (self.offsetX, self.offsetY)
self.teste = Sprite("grossini.png", (300, 200))
self.spriteBatch.add(self.teste)
self.hud = GameHud()
self.add(self.hud)
for i in self.tabMatriz:
print(i)
def __init__(self, minimap, w, h, size=10):
super().__init__(0, 0, 0, 100, w * size, h * size)
self.batch = BatchNode()
for (i, j) in minimap:
tmp = minimap[(i, j)]
if tmp is not -1:
img = 'grid/' + str(tmp) + '.png'
pos = i * size, j * size
spr = Sprite(image=img, position=pos)
spr.scale_x, spr.scale_y = size / spr.width, size / spr.height
spr.image_anchor = (0, 0)
self.batch.add(spr)
self.add(self.batch)
self.frame = ColorLayer(0, 0, 100, 100, min(w * 10, 160),
min(h * 10, 90))
self.add(self.frame)
def __init__(self, R):
super(GameScene, self).__init__()
self.R = R
self.batch = BatchNode()
self.collisionManager = CollisionModel.CollisionManagerBruteForce()
#Main Background
mainBack = Sprite(R._BACKGROUND[4])
mainBack.position = (director._window_virtual_width / 2,
director._window_virtual_height / 2)
self.add(mainBack)
#Parallax-BackGround
self.add(
ParallaxBackground((0, 0, 800, 600),
[R._BACKGROUND[1], R._BACKGROUND[1]], 16, 10))
self.add(
ParallaxBackground((0, 0, 800, 600),
[R._BACKGROUND[2], R._BACKGROUND[2]], 4, 10))
self.add(
ParallaxBackground((0, 0, 800, 600),
[R._BACKGROUND[3], R._BACKGROUND[3]], 2, 10))
#Add Player
self.PLAYER = Player()
self.ENEMY = Enemy()
self.HUD = HUD()
#set Data
self.PLAYER.set(self)
self.ENEMY.set(self)
self.HUD.set(self)
#Add layers
self.add(self.PLAYER)
self.add(self.ENEMY)
self.add(self.HUD)
#Adding Batch to Layer
self.add(self.batch)
def __init__(self, *args):
super().__init__()
self.hud = args[0]
self.obstacle_map = args[1]
self.objects_map = args[2]
self.tileset = args[3]
self.create_mario()
self.create_cliff()
self.create_flag()
self.enemies = BatchNode()
self.add(self.enemies)
self.enemy_objs = self.objects_map.match(label="enemy")
self.exist_enemy_index = []
width, height = director.get_window_size()
self.cm = CollisionManagerGrid(0, width, 0, height, 20, 20)
stats.reset_current_game()
Sound.play("mario")
def __init__(self, battle_mech):
super(MechSprite, self).__init__()
self.battle_mech = battle_mech
mech_img = pyglet.resource.image(self.battle_mech.getImagePath())
mech_img_grid = pyglet.image.ImageGrid(mech_img, 1, 6)
self.static = True
img_static = Sprite(mech_img_grid[0])
self.width = img_static.width
self.height = img_static.height
# TODO: setup the non square friendly/enemy indicators based on team of current player's turn
if battle_mech.player.is_bot:
indicator = Sprite(Resources.enemy_indicator_img)
else:
indicator = Sprite(Resources.friendly_indicator_img)
indicator.visible = False
indicator.position = 0, -img_static.height // 2 + indicator.height // 2 + 1
self.indicator = indicator
self.add(indicator, z=0)
shadow = Sprite(MechSprite.shadow_img_grid[battle_mech.getSize() - 1])
shadow_rect = shadow.get_rect()
shadow_rect.bottomleft = (self.battle_mech.col * Board.TILE_SIZE), \
(self.battle_mech.row * Board.TILE_SIZE)
shadow.position = shadow_rect.center
self.shadow = shadow
rect = img_static.get_rect()
rect.bottomleft = (self.battle_mech.col * Board.TILE_SIZE) - (img_static.width//2 - shadow.width//2), \
(self.battle_mech.row * Board.TILE_SIZE)
self.position = rect.center
self.node = BatchNode()
self.add(self.node, z=2)
img_static.y = Board.TILE_SIZE//4
self.node.add(img_static)
self.img_static = img_static
img_ct = Sprite(mech_img_grid[1])
img_ct.y = Board.TILE_SIZE//4
self.img_ct = img_ct
img_ll = Sprite(mech_img_grid[4])
img_ll.y = Board.TILE_SIZE//4
self.img_ll = img_ll
img_rl = Sprite(mech_img_grid[5])
img_rl.y = Board.TILE_SIZE//4
self.img_rl = img_rl
img_la = Sprite(mech_img_grid[2])
img_la.y = Board.TILE_SIZE//4
self.img_la = img_la
img_ra = Sprite(mech_img_grid[3])
img_ra.y = Board.TILE_SIZE//4
self.img_ra = img_ra
# testing the stats stuff
self.stats = BatchNode()
self.updateStatsIndicators()
def __init__(self, image):
self.image = image
self.batch = BatchNode()
self.create_background()
def __init__(self):
super(Board, self).__init__()
Board.BOARD = self
self.boardMap = {}
self.cellMap = {}
# add basic ground
ground_img = Resources.ground_img
node = BatchNode()
self.add(node, z=0)
for row in range(self.numRows):
for col in range(self.numCols):
cell = Cell(ground_img)
rect = cell.get_rect()
rect.bottomleft = col * 32, row * 32
cell.position = rect.center
node.add(cell, z=0)
self.cellMap[(col, row)] = cell
# add buildings
buildings_tex = Resources.buildings_tex
# test 3x2 Building at 1,4
self.boardMap[(1, 4)] = {self.KEY_TYPE: self.TYPE_BUILDING,
self.KEY_COLUMNS: 3,
self.KEY_ROWS: 2,
self.KEY_LEVEL: 1,
self.KEY_ELEVATION: 0,
self.KEY_IMAGES: buildings_tex[(0, 0):(3, 3)]}
self.boardMap[(2, 4)] = {self.KEY_REF: (1, 4)}
self.boardMap[(3, 4)] = {self.KEY_REF: (1, 4)}
self.boardMap[(1, 5)] = {self.KEY_REF: (1, 4)}
self.boardMap[(2, 5)] = {self.KEY_REF: (1, 4)}
self.boardMap[(3, 5)] = {self.KEY_REF: (1, 4)}
# test 2x2 Building at 5,4
self.boardMap[(5, 4)] = {self.KEY_TYPE: self.TYPE_BUILDING,
self.KEY_COLUMNS: 2,
self.KEY_ROWS: 2,
self.KEY_LEVEL: 1,
self.KEY_ELEVATION: 0,
self.KEY_IMAGES: buildings_tex[(3, 0):(7, 2)]}
self.boardMap[(6, 4)] = {self.KEY_REF: (5, 4)}
self.boardMap[(5, 5)] = {self.KEY_REF: (5, 4)}
self.boardMap[(6, 5)] = {self.KEY_REF: (5, 4)}
# test 2x2 Building at 10,6
self.boardMap[(10, 6)] = {self.KEY_TYPE: self.TYPE_BUILDING,
self.KEY_COLUMNS: 2,
self.KEY_ROWS: 2,
self.KEY_LEVEL: 1,
self.KEY_ELEVATION: 0,
self.KEY_IMAGES: buildings_tex[(3, 2):(7, 4)]}
self.boardMap[(11, 6)] = {self.KEY_REF: (10, 6)}
self.boardMap[(10, 7)] = {self.KEY_REF: (10, 6)}
self.boardMap[(11, 7)] = {self.KEY_REF: (10, 6)}
# test 3x2 Building at 10,2
self.boardMap[(10, 2)] = {self.KEY_TYPE: self.TYPE_BUILDING,
self.KEY_COLUMNS: 3,
self.KEY_ROWS: 2,
self.KEY_LEVEL: 1,
self.KEY_ELEVATION: 0,
self.KEY_IMAGES: buildings_tex[(3, 5):(7, 8)]}
self.boardMap[(11, 2)] = {self.KEY_REF: (10, 2)}
self.boardMap[(12, 2)] = {self.KEY_REF: (10, 2)}
self.boardMap[(10, 3)] = {self.KEY_REF: (10, 2)}
self.boardMap[(11, 3)] = {self.KEY_REF: (10, 2)}
self.boardMap[(12, 3)] = {self.KEY_REF: (10, 2)}
# test 2x2x2 Building at 12,12
self.boardMap[(12, 12)] = {self.KEY_TYPE: self.TYPE_BUILDING,
self.KEY_COLUMNS: 2,
self.KEY_ROWS: 2,
self.KEY_LEVEL: 2,
self.KEY_ELEVATION: 0,
self.KEY_IMAGES: buildings_tex[(3, 10):(8, 12)]}
self.boardMap[(13, 12)] = {self.KEY_REF: (12, 12)}
self.boardMap[(12, 13)] = {self.KEY_REF: (12, 12)}
self.boardMap[(13, 13)] = {self.KEY_REF: (12, 12)}
# test 3x3 Building at 15,10
self.boardMap[(15, 10)] = {self.KEY_TYPE: self.TYPE_BUILDING,
self.KEY_COLUMNS: 3,
self.KEY_ROWS: 3,
self.KEY_LEVEL: 1,
self.KEY_ELEVATION: 0,
self.KEY_IMAGES: buildings_tex[(7, 10):(13, 13)]}
self.boardMap[(16, 10)] = {self.KEY_REF: (15, 10)}
self.boardMap[(17, 10)] = {self.KEY_REF: (15, 10)}
self.boardMap[(15, 11)] = {self.KEY_REF: (15, 10)}
self.boardMap[(16, 11)] = {self.KEY_REF: (15, 10)}
self.boardMap[(17, 11)] = {self.KEY_REF: (15, 10)}
self.boardMap[(15, 12)] = {self.KEY_REF: (15, 10)}
self.boardMap[(16, 12)] = {self.KEY_REF: (15, 10)}
self.boardMap[(17, 12)] = {self.KEY_REF: (15, 10)}
# test 5x2 Building at 3,14
self.boardMap[(3, 14)] = {self.KEY_TYPE: self.TYPE_BUILDING,
self.KEY_COLUMNS: 5,
self.KEY_ROWS: 2,
self.KEY_LEVEL: 0,
self.KEY_ELEVATION: 0,
self.KEY_IMAGES: buildings_tex[(9, 0):(11, 5)]}
self.boardMap[(4, 14)] = {self.KEY_REF: (3, 14)}
self.boardMap[(5, 14)] = {self.KEY_REF: (3, 14)}
self.boardMap[(6, 14)] = {self.KEY_REF: (3, 14)}
self.boardMap[(7, 14)] = {self.KEY_REF: (3, 14)}
self.boardMap[(3, 15)] = {self.KEY_REF: (3, 14)}
self.boardMap[(4, 15)] = {self.KEY_REF: (3, 14)}
self.boardMap[(5, 15)] = {self.KEY_REF: (3, 14)}
self.boardMap[(6, 15)] = {self.KEY_REF: (3, 14)}
self.boardMap[(7, 15)] = {self.KEY_REF: (3, 14)}
for col, row in self.boardMap:
loc = (col, row)
cell_data = self.boardMap[loc]
cell_images = cell_data.get(self.KEY_IMAGES)
if cell_images is not None:
cell_level = cell_data[self.KEY_LEVEL]
cell_z = (self.numCols - row - cell_level) * 10
cell_batch = BatchNode()
cell_batch.position = col * self.TILE_SIZE, row * self.TILE_SIZE
self.add(cell_batch, z=cell_z)
cell_cols = cell_data[self.KEY_COLUMNS]
cell_rows = cell_data[self.KEY_ROWS]
for this_row in range(cell_rows + cell_level):
for this_col in range(cell_cols):
cell_index = this_col + (this_row * cell_cols)
cell_sprite = Sprite(cell_images[cell_index])
cell_rect = cell_sprite.get_rect()
cell_rect.bottomleft = this_col * self.TILE_SIZE, this_row * self.TILE_SIZE
cell_sprite.position = cell_rect.center
cell_batch.add(cell_sprite)
def __init__(self):
"""
label:
players:
grass:
projectiles:
controllers:
robots:
castle:
"""
super().__init__()
width, height = game_board["size"]
self.label = Label("debug")
self.label.position = 100, 100
# players...
self.players = [
#Actor(item_types["player1"], (500, 100), self.label),
Actor(item_types["player2"], (100, 600)),
#Actor(item_types["player3"], (250, 600)),
#Actor(item_types["player4"], (900, 600)),
]
last_player_id = 0
# controllers...
self.controllers = [Player(p) for p in self.players]
for controller in self.controllers:
controller.id = last_player_id
last_player_id += 1
# grass...
grass_distance = 50
x_margin, y_margin, width, height = (width // 2, grass_distance, width,
height -
game_board["castle_depth"])
self.grass = [[
Actor(item_types["grass" + str(randint(1, 3))], (x, y))
for x in range(-x_margin, width + x_margin, grass_distance)
] for y in range(-y_margin, height, grass_distance)]
# projectiles...
self.projectiles = []
# robots...
self.robots = [
Actor(item_types["robot1"], (200, 700)),
Actor(item_types["robot1"], (800, 400)),
Actor(item_types["robot1"], (300, 500)),
Actor(item_types["robot1"], (600, 600)),
Actor(item_types["robot2"], (500, 800)),
Actor(item_types["robot3"], (800, 900)),
]
# castle...
self.castle = Actor(item_types["castle1"], (500, 1000))
# add to game layer...
# create grass in batches to speed up game
from cocos.batch import BatchNode
for grass_batch in self.grass:
batch = BatchNode()
for grass in grass_batch:
grass.alpha = 0.8
batch.add(grass)
self.add(batch, -grass_batch[0].coord.y)
self.add(self.label)
for robot in self.robots:
self.add(robot, -robot.coord.y)
for player in self.players:
self.add(player, -player.coord.y)
for controller in self.controllers:
self.add(controller)
self.add(self.castle, -self.castle.coord.y)
print("Game Layer Children" + str(len(self.children)))
self.do(CollisionAction())
def updatePlayerUnitStats(self, battle_unit):
if self.unit_display is not None:
self.unit_display.kill()
self.unit_name.kill()
self.unit_variant.kill()
self.unit_stats.kill()
self.unit_values.kill()
if battle_unit is None:
# Hide player unit stats at bottom left
self.unit_display = None
self.unit_name = None
self.unit_variant = None
self.unit_stats = None
self.unit_values = None
return
size = director.get_window_size()
width = size[0]
height = size[1]
self.unit_display = BatchNode()
self.unit_display.position = 0, 0
mech_img_grid = pyglet.image.ImageGrid(
pyglet.resource.image(battle_unit.getImagePath()), 1, 6)
mech_img_static = mech_img_grid[0]
pitch = -(mech_img_static.width * len('RGBA'))
img_data = mech_img_static.get_image_data()
# testing with masking only a portion of the image
damage_height = int(
mech_img_static.height) # int(mech_img_static.height * 0.67)
data = img_data.get_region(0, 0, mech_img_static.width,
damage_height).get_data('RGBA', pitch)
mask = Image.frombytes('RGBA', (mech_img_static.width, damage_height),
data)
# the first image is the color that the stamp will be
img1 = Image.new('RGBA', mask.size, color=(0, 0, 0, 255))
# second image is the background
img2 = Image.new('RGBA', mask.size, color=(225, 225, 225, 200))
img1 = img1.convert('RGBA')
# apply mask to background image
img = Image.composite(img1, img2, mask)
raw_image = img.tobytes()
img_x = mask.size[0]
img_y = mask.size[1]
pyg_img = pyglet.image.ImageData(img_x,
img_y,
'RGBA',
raw_image,
pitch=-img_x * len('RGBA'))
mech_sprite = Sprite(pyg_img)
mech_sprite.position = Board.TILE_SIZE // 2 + mech_sprite.width // 2, \
Board.TILE_SIZE + mech_sprite.height // 2
self.unit_display.add(mech_sprite)
self.add(self.unit_display)
# Show unit name above the image
self.unit_name = floaters.TextFloater(battle_unit.getName(),
font_name='TranscendsGames',
font_size=Board.TILE_SIZE // 2,
anchor_x='left',
anchor_y='bottom')
self.unit_name.position = Board.TILE_SIZE // 2, mech_sprite.get_rect(
).topleft[1]
self.add(self.unit_name)
# Show unit variant below the image
self.unit_variant = floaters.TextFloater(
battle_unit.getVariant().upper(),
font_name='TranscendsGames',
font_size=Board.TILE_SIZE // 3,
anchor_x='left',
anchor_y='top')
self.unit_variant.position = Board.TILE_SIZE // 2, Board.TILE_SIZE - 4
self.add(self.unit_variant)
# Show armor, structure, heat stats next to the image (top)
self.unit_stats = UnitStats(battle_unit)
stats_pos = mech_sprite.get_rect().topright
self.unit_stats.position = 4 + stats_pos[0], stats_pos[
1] - self.unit_stats.height
self.add(self.unit_stats)
# Show move and attack numbers next to the image (bottom)
values = "MV %i ATK %i/%i/%i" % (battle_unit.getTurnMove(),
battle_unit.short,
battle_unit.medium, battle_unit.long)
self.unit_values = floaters.TextFloater(values,
font_name='TranscendsGames',
font_size=Board.TILE_SIZE // 4,
anchor_x='left',
anchor_y='bottom')
values_pos = mech_sprite.get_rect().bottomright
self.unit_values.position = 4 + values_pos[0], values_pos[1] - 2
self.add(self.unit_values)
# pr.print_stats()
benchmark(1)
import sys
sys.path.extend(['/home/andrei/Python/tanks'])
sys.path.extend(['/home/andrei/Python/tanks/assets'])
import numpy as np
from cocos import director
from cocos import scene
from cocos.batch import BatchNode
from cocos import sprite
from objects.Tank import Tank
director.director.init(width=2048, height=960, resizable=True, autoscale=False)
layer = BatchNode()
c = sprite.Sprite('gil-brazo2.png')
c.position = (12, 11)
layer.add(c)
layer.add(c)
layer.get_children()
t = tanks_list[3]
tanks_list.index(t)
tanks_list = layer.get_children()
tanks = np.array(list(map(lambda obj: obj.position, tanks_list)))
dist_sq = np.sum((tanks[:, np.newaxis] - tanks[np.newaxis, :])**2, axis=-1)
K = 3
nearest_sorted = np.argsort(dist_sq, axis=1)[:, :K + 1]