arcade/main.py

import arcade
from random import randint

SCREEN_WIDTH = 1920
SCREEN_HEIGHT = 1280
SCREEN_FULL = True
TILE_WIDTH = 64
TILE_HEIGHT = 32

class Engine:
  def __init__(self,player_sprite,wall_list):
    self.player = player_sprite
    self.dynamic = arcade.SpriteList()
    self.dynamic.append(self.player)
    self.walls = wall_list
  def add_list(self,sprite_list):
    for sprite in sprite_list:
      self.dynamic.append(sprite)
  def can_move(self,obj,vec):
    new_pos = (obj.center_x + vec[0]*TILE_WIDTH//2,obj.center_y + vec[1]*TILE_HEIGHT//2)
    for wall in self.walls:
      if wall.position == new_pos:
        return False
    return True
  def update(self,delta_time):
    pass
  def draw(self):
    dr = arcade.SpriteList()
    for wall in self.walls:
      for obj in self.dynamic:
        if wall.position in [
          (obj.center_x-TILE_WIDTH//2,obj.center_y-TILE_HEIGHT//2),
          (obj.center_x+TILE_WIDTH//2,obj.center_y-TILE_HEIGHT//2),
          (obj.center_x,obj.center_y-TILE_HEIGHT)]:
          if not obj in dr:
            dr.append(obj)
      dr.append(wall)
    for obj in self.dynamic:
      if not obj in dr:
        dr.append(obj)
    dr.draw()

def to_iso(tile_list):
  for tile in tile_list:
    col = tile.center_x//TILE_WIDTH
    row = tile.center_y//TILE_HEIGHT
    tile.center_x = tile.center_x - TILE_WIDTH//2 * (col-row)
    tile.center_y = tile.center_y - TILE_HEIGHT//2 * (col+row)
  return tile_list

class Player(arcade.Sprite):
  def __init__(self,sprite,lookLeft=True,control=False):
    super().__init__()
    self.texture = sprite.texture
    self.lookLeft = lookLeft
    self.center_x = sprite.center_x
    self.center_y = sprite.center_y
    self.move_timer = 0
  def update(self,delta_time):
    self.move_timer += delta_time
    if self.move_timer >= 1:
      self.move_timer = 0
      way = randint(0,3)
      if way == 0:
        self.move(1,1,delta_time)
      elif way == 1:
        self.move(1,-1,delta_time)
      elif way == 2:
        self.move(-1,-1,delta_time)
      elif way == 3:
        self.move(-1,1,delta_time)
    super().update()
    
  def move(self,dx,dy,dt=1):
    self.lookLeft = False if self.change_x > 0 else True
    self.center_x = self.center_x + dx*TILE_WIDTH//2
    self.center_y = self.center_y + dy*TILE_HEIGHT//2
    if dx > 0 and self.lookLeft:
      self.texture = self.texture.flip_left_right()
      self.lookLeft = False
    elif dx < 0 and not self.lookLeft:
      self.texture = self.texture.flip_left_right()
      self.lookLeft = True

class MainView(arcade.View):
  def __init__(self):
    super().__init__()
    self.background_color = (100,100,200)
    self.move = (0,0)
    self.tilemap = arcade.load_tilemap('./assets/level1.tmx',scaling=1)
    self.flor = self.tilemap.sprite_lists["flor"]
    self.flor = to_iso(self.flor)
    self.walls = self.tilemap.sprite_lists["walls"]
    self.walls = to_iso(self.walls)
    objects = self.tilemap.sprite_lists["objects"]
    objects = to_iso(objects)
    self.enemys = arcade.SpriteList()
    for obj in objects:
      self.enemys.append(Player(obj))

    self.camera = arcade.Camera2D()
    objects = self.tilemap.sprite_lists["player"]
    objects = to_iso(objects)
    self.player = Player(objects[0],control=True)
    
    self.engine = Engine(self.player,self.walls)
    self.engine.add_list(self.enemys)
  def on_draw(self):
    self.clear()
    self.camera.use()
    self.flor.draw()
    self.engine.draw()
    #self.enemys.draw()
    
  def on_update(self,delta_time):
    self.camera.position = (self.player.center_x,self.player.center_y)
    self.engine.update(delta_time)
    #self.enemys.update(delta_time)
  def on_mouse_press(self,x,y,but,mod):
    world_point = self.camera.unproject((x,y))
    tile_col = world_point.x/TILE_WIDTH
    tile_row = world_point.y/TILE_HEIGHT
    sheet = arcade.load_spritesheet('./assets/tiles/64x64.png')
    textures = sheet.get_texture_grid((64,64),16,184)
    self.walls.append(
      arcade.Sprite(
        textures[165],
        center_x=world_point.x - world_point.x%(TILE_WIDTH//2),
        center_y=world_point.y - world_point.y%(TILE_HEIGHT//2)
      )
    )
  def on_key_press(self,key,mod):
    if key == arcade.key.W and self.engine.can_move(self.player,(1,1)):
      self.player.move(1,1)
    elif key == arcade.key.A and self.engine.can_move(self.player,(-1,1)):
      self.player.move(-1,1)
    elif key == arcade.key.S and self.engine.can_move(self.player,(-1,-1)):
      self.player.move(-1,-1)
    elif key == arcade.key.D and self.engine.can_move(self.player,(1,-1)):
      self.player.move(1,-1)


if __name__ == '__main__':
  window = arcade.Window(
    SCREEN_WIDTH,
    SCREEN_HEIGHT,
    'Isometric game',
    fullscreen=SCREEN_FULL)
  view = MainView()
  window.show_view(view)
  arcade.run()