def __init__( self, screen, unitname, spritesheet ):
self.spritesheet = spritesheet
self.unit_ss = Spritesheet( spritesheet )
self.unit_sprite = (0, 0, 40, 40)
self.unit_image = self.unit_ss.image_at( self.unit_sprite )
self.move_tile_ss = Spritesheet('spritesheets/move_tile.bmp')
self.move_tile_image = self.move_tile_ss.image_at((0, 0, 40, 40))
self.screen = screen
self.unitname = unitname
self.frame = 0
self.pos_x = 0
self.pos_y = 0
self.distance_x = 0
self.distance_y = 0
self.move_x = 0
self.move_y = 0
self.speed = 10
self.unit_location = (self.pos_x, self.pos_y)
self.state = 'idle'
self.pressed_z = 0
def __init__(self, screen):
ss = Spritesheet('spritesheets/cursor.bmp')
self.screen = screen
self.pos_x = 0
self.pos_y = 0
self.location = (self.pos_x,self.pos_y)
self.image = ss.image_at((0, 0, 40, 40))
def __init__(self, screen):
grass = Spritesheet('tiles/grass/grass.bmp')
water = Spritesheet('tiles/water/water.bmp')
self.grass = grass.image_at((0, 0, 40, 40))
self.water = water.image_at((0, 0, 40, 40))
self.tile = screen
self.screen = screen
self.mapdata = [line.strip() for line in open("maps/map0.txt", "r")]
self.pos_x = 0
self.pos_y = 0
self.location = (self.pos_x, self.pos_y)
def __init__(self):
super().__init__()
self.state = 2
sprite_sheet = Spritesheet("art/crosshair.png")
self.states = []
image = sprite_sheet.get_image(0, 0, 30, 30)
self.states.append(image)
image = sprite_sheet.get_image(0, 30, 30, 30)
self.states.append(image)
image = sprite_sheet.get_image(0, 60, 30, 30)
self.states.append(image)
self.image = self.states[self.state]
self.rect = self.image.get_rect()
def __init__(self, x, y):
pygame.sprite.Sprite.__init__(self)
ss = Spritesheet(bullet_image)
self.bullet_images = ss.images_at([\
(275, 69, 20, 10)\
], -1)
self.bullets = []
for bullet in self.bullet_images:
self.bullets.append(pygame.transform.rotate(bullet, 90))
self.idx = 0
self.image = self.bullets[self.idx]
self.last_idx = len(self.bullets) - 1
self.rect = self.image.get_rect()
self.rect.midbottom = (x, y)
self.speed = 4
self.frames_count = 0
self.animate_each_frame = 10
def load_frames(self):
my_spritesheet = Spritesheet('poppy_sheet.png')
#pygame.image.load('MY_IMAGE_NAME.png').convert()
self.idle_frames_left = [
my_spritesheet.parse_sprite("poppy_idle1.png"),
my_spritesheet.parse_sprite("poppy_idle2.png")
]
self.walking_frames_left = [
my_spritesheet.parse_sprite("poppywalk1.png"),
my_spritesheet.parse_sprite("poppywalk2.png"),
my_spritesheet.parse_sprite("poppywalk3.png"),
my_spritesheet.parse_sprite("poppywalk4.png"),
my_spritesheet.parse_sprite("poppywalk5.png"),
my_spritesheet.parse_sprite("poppywalk6.png"),
my_spritesheet.parse_sprite("poppywalk7.png"),
my_spritesheet.parse_sprite("poppywalk8.png")
]
self.idle_frames_right = []
for frame in self.idle_frames_left:
self.idle_frames_right.append(
pygame.transform.flip(frame, True, False))
self.walking_frames_right = []
for frame in self.walking_frames_left:
self.walking_frames_right.append(
pygame.transform.flip(frame, True, False))
def on_init(self):
self._running = True
pygame.init()
pygame.font.init()
self.font = pygame.font.Font(None, 20)
self.TILE_HEIGHT = 32
self.TILE_WIDTH = 32
self.MESSAGE_BOX_WIDTH = 400
self.size = self.weight, self.height = self.gameMap.xSize * self.TILE_WIDTH + self.MESSAGE_BOX_WIDTH, \
self.gameMap.ySize * self.TILE_HEIGHT
self.msgBoxLeft = self.gameMap.xSize * self.TILE_WIDTH
self.output = self
self.screen = pygame.display.set_mode(
self.size, pygame.HWSURFACE | pygame.DOUBLEBUF)
# msgBaseDelaySecs = self.msgBaseDelaySecs;
# Default spritesheet assets
self.sprites = Spritesheet(
"assets/fantasy-tileset-8cols-26rows-32x32pixels.png")
self.spritesPlural = Spritesheet(
"assets/fantasy-tileset-8cols-26rows-32x32pixels-shadow.png")
self.enemySprites = Spritesheet(
"assets/fantasy-tileset-8cols-26rows-32x32pixels-red.png")
output = self.output
self.gameTime = 0
output.log("Game begins!")
self.dead = []
output.dump()
# time.sleep(2 * msgBaseDelaySecs);
# Position armies
iX = 0
iY = 2
for oItemA in self.aAttackers:
oItemA.x = iX
oItemA.y = iY
iX += 1
if (iX == self.gameMap.xSize):
iX = 0
iY += 1
def load_data(self):
"""Adding music & fx"""
root_folder = path.dirname(__file__)
img_folder = path.join(root_folder, "data", "img")
music_folder = path.join(root_folder, "data", "music")
fx_folder = path.join(root_folder, "data", "fx")
sprites = Spritesheet(path.join(img_folder, "spritesheet_x2.png"))
# IMAGES
self.item_images = {}
for item_name in ITEMS:
sprite_at = ITEMS[item_name]['SPRITE_AT']
self.item_images[item_name] = sprites.image_at(
sprite_at[0], sprite_at[1], TILESIZE, 2, KEY_COLOR)
self.player_img = sprites.image_at(PLAYER_SPRITE_AT[0],
PLAYER_SPRITE_AT[1], TILESIZE, 2,
KEY_COLOR)
self.bee_img = sprites.image_at(BEE_SPRITE_AT[0], BEE_SPRITE_AT[1],
TILESIZE, 2, KEY_COLOR)
self.bee_nest_img = sprites.image_at(BEE_NEST_SPRITE_AT[0],
BEE_NEST_SPRITE_AT[1], TILESIZE,
2, KEY_COLOR)
self.top_wall_img = sprites.image_at(TOP_WALL_SPRITE_AT[0],
TOP_WALL_SPRITE_AT[1], TILESIZE,
2, KEY_COLOR)
self.front_wall_img = sprites.image_at(FRONT_WALL_SPRITE_AT[0],
FRONT_WALL_SPRITE_AT[1],
TILESIZE, 2, KEY_COLOR)
# SOUND
# Using arrays to add some variance
pygame.mixer.music.load(path.join(music_folder, BG_MUSIC))
self.basic_gun_fx = []
for fx in BASIC_GUN_FX:
pewpew = pygame.mixer.Sound(path.join(fx_folder, fx))
pewpew.set_volume(0.1)
self.basic_gun_fx.append(pewpew)
self.critter_death_fx = []
for fx in CRITTER_DEAD_FX:
self.critter_death_fx.append(
pygame.mixer.Sound(path.join(fx_folder, fx)))
self.item_fx = {}
for fx in ITEMS:
self.item_fx[fx] = pygame.mixer.Sound(
path.join(fx_folder, ITEMS[fx]['FX']))
def __init__(self, x, y):
pygame.sprite.Sprite.__init__(self)
ss = Spritesheet(shoot_image)
self.bullets = ss.images_at([\
(107, 272, 14, 14), \
(126, 272, 15, 14), \
(145, 273, 15, 13), \
(165, 271, 14, 15), \
(184, 272, 14, 14), \
(201, 273, 16 ,14), \
(221, 273, 15, 13), \
(240, 271, 14, 15), \
], -1)
self.image = self.bullets[0]
self.idx = 0
self.rect = self.image.get_rect()
self.rect.center = (x, y)
self.speed = 5
self.frames_count = 0
self.animate_each_frame = 10
def load_frames(self):
bullet_spritesheet = Spritesheet('images/bullet/player/bullet.png')
e_bullet_spritesheet = Spritesheet('images/bullet/enemy/bullet.png')
self.bullet_frames = [
bullet_spritesheet.parse_sprite('bullet1.png'),
bullet_spritesheet.parse_sprite('bullet2.png'),
bullet_spritesheet.parse_sprite('bullet3.png'),
bullet_spritesheet.parse_sprite('bullet4.png'),
bullet_spritesheet.parse_sprite('bullet5.png'),
bullet_spritesheet.parse_sprite('bullet6.png'),
]
self.enemy_bullet_frames = [
e_bullet_spritesheet.parse_sprite('bullet1.png'),
e_bullet_spritesheet.parse_sprite('bullet2.png'),
e_bullet_spritesheet.parse_sprite('bullet3.png')
]
def __init__(self, settings, screen, button):
self.screen = screen
self.screen_rect = screen.get_rect()
self.theSettings = Settings
self.button = button
ss = Spritesheet('images/space_invaders_spritesheet.png')
# Load in alien images
self.image = ss.image_at((65, 512, 64, 64))
self.image2 = ss.image_at((65, 704, 64, 64))
self.image3 = ss.image_at((65, 896, 64, 64))
self.image4 = ss.image_at((65, 0, 64, 64))
self.rect = self.image.get_rect()
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
screen.fill(settings.bg_color)
def __init__(self):
pygame.init()
self.window = pygame.display.set_mode((WIDTH, HEIGHT))
self.running = True
victory_spritesheet = Spritesheet('sudoku_winner_spritesheet.png')
border_sprites = Spritesheet('borders.png')
VictoryAnimation.images = victory_spritesheet.imgsat(
VictoryAnimation.img_rects, -1)
self.border_images = border_sprites.imgsat(border_img_locs, -1)
self.grid = [[0 for i in range(9)] for j in range(9)]
self.grid_finished = [[0 for i in range(9)] for j in range(9)]
# self.grid = test_board_2
# self.grid_finished = test_board_2_finished
self.selected = None
self.mouse_pos = None
self.mouse_click = None
self.finished = False
self.cell_changed = False
self.show_victory = False
self.status = ''
self.incorrect_cells = []
self.locked_cells = []
self.state = "playing"
self.playing_buttons = []
self.menu_buttons = []
self.end_buttons = []
self.victory = VictoryAnimation(victory_pos)
self.font = pygame.font.SysFont('arial', int(cell_size / 2))
self.load()
class Player(pygame.sprite.Sprite):
def __init__(self):
pygame.sprite.Sprite.__init__(self)
self.image = Spritesheet('spritesheet.png').parse_sprite('chick.png')
self.rect = self.image.get_rect()
self.LEFT_KEY, self.RIGHT_KEY, self.FACING_LEFT = False, False, False
self.is_jumping, self.on_ground = False, False
self.gravity, self.friction = .35, -.12
self.position, self.velocity = pygame.math.Vector2(
0, 0), pygame.math.Vector2(0, 0)
self.acceleration = pygame.math.Vector2(0, self.gravity)
def draw(self, display):
display.blit(self.image, (self.rect.x, self.rect.y))
def update(self, dt):
self.horizontal_movement(dt)
self.vertical_movement(dt)
def horizontal_movement(self, dt):
self.acceleration.x = 0
if self.LEFT_KEY:
self.acceleration.x -= .3
elif self.RIGHT_KEY:
self.acceleration.x += .3
self.acceleration.x += self.velocity.x * self.friction
self.velocity.x += self.acceleration.x * dt
self.limit_velocity(4)
self.position.x += self.velocity.x * dt + (self.acceleration.x *
.5) * (dt * dt)
self.rect.x = self.position.x
def vertical_movement(self, dt):
self.velocity.y += self.acceleration.y * dt
if self.velocity.y > 7: self.velocity.y = 7
self.position.y += self.velocity.y * dt + (self.acceleration.y *
.5) * (dt * dt)
if self.position.y > 128:
self.on_ground = True
self.velocity.y = 0
self.position.y = 128
self.rect.bottom = self.position.y
def limit_velocity(self, max_vel):
min(-max_vel, max(self.velocity.x, max_vel))
if abs(self.velocity.x) < .01: self.velocity.x = 0
def jump(self):
if self.on_ground:
self.is_jumping = True
self.velocity.y -= 8
self.on_ground = False
def __init__(self, game, pos_x, pos_y):
self.game = game
groups = game.all_sprites, game.character_sprites
pg.sprite.Sprite.__init__(self, groups)
self.pos = vec2(pos_x, pos_y)
self.health = 100
self.moving_out_counter = 0
self.moving_out_wait_start_time = None
self.moved_out = False
self._idle_sprites = []
self._hit_sprites = []
self._angry_sprites = []
self._spritesheet_file = 'assets/moose.png'
self._spritesheet = Spritesheet(self._spritesheet_file)
self._load_default_sprite()
self._load_sprites()
self.rect = self.image.get_rect(topleft=self.pos)
self.state = CharacterState.IDLE
self._animation_counter = 0
self._animation_index = 0
self._hit_animation_counter = 0
self._angry_animation_counter = 0
def get_unscaled_portal_sprites():
portalsheet = Spritesheet('images/portals.png')
portal_images_unscaled = [
portalsheet.get_image(x=364, y=7, w=177, h=176),
portalsheet.get_image(x=553, y=14, w=163, h=163),
portalsheet.get_image(x=7, y=222, w=161, h=159),
portalsheet.get_image(x=193, y=220, w=155, h=158),
portalsheet.get_image(x=373, y=222, w=159, h=158),
portalsheet.get_image(x=553, y=220, w=163, h=163)
]
return portal_images_unscaled
def __init__(self):
SceneBase.__init__(self)
self.scrabble = Scrabble(True)
self.board = Board('imgs/board.jpg', [0, 0])
self.letter_ss = Spritesheet('imgs/letters.jpg')
self.player_tiles = []
self.game_tiles = []
self.selected_tile = None
self.offset_x = 0
self.offset_y = 0
for i, letter in enumerate(self.scrabble.get_rack()):
self.player_tiles.append(
Tile(letter, self.letter_ss, PLAYER_TILE_POSITIONS[i]))
class Tilemap(object):
def __init__(self, levelfile, spritesheetfile):
self.Level = Level()
self.Level.load_file(levelfile)
self.Spritesheet = Spritesheet(spritesheetfile)
def get_tilesize(self):
return self.Level.tilesize
def get_tile(self, x, y):
t = self.Level.get_tuple(x, y, "tile")
if t != None and t[0] != -1:
return self.Spritesheet.image_at(t)
return None
def __init__(self, ai_settings, screen):
"""Initialize the ship, and set its starting position."""
super(Ship, self).__init__()
self.screen = screen
self.ai_settings = ai_settings
ss = Spritesheet('images/space_invaders_spritesheet.png')
# Load the ship image, and get its rect.
self.image = ss.image_at((0, 192, 64, 64))
self.rect = self.image.get_rect()
self.screen_rect = screen.get_rect()
# Start each new ship at the bottom center of the screen.
self.rect.centerx = self.screen_rect.centerx
self.rect.bottom = self.screen_rect.bottom
# Store a decimal value for the ship's center.
self.center = float(self.rect.centerx)
# Movement flags.
self.moving_right = False
self.moving_left = False
def __init__(self, ai_settings, screen):
#initialize the alien and set its starting position
super(Alien, self).__init__()
self.screen = screen
self.ai_settings = ai_settings
self.image = Spritesheet('images/spritesheet.png')
self.images = []
self.index = 0
self.images.append(
self.image.image_at((640, 0, 64, 64), colorkey=(0, 0, 0, 1)))
self.images.append(
self.image.image_at((704, 0, 64, 64), colorkey=(0, 0, 0, 1)))
self.image = self.images[self.index]
self.score = 10
#load the alien image and set its rect attribute
self.rect = self.image.get_rect()
#start each new alien near the top left of the screen
self.rect.x = self.rect.width
self.rect.y = self.rect.height
#store the alien's exact position
self.x = float(self.rect.x)
def load_data(self):
"""Let's create more sensible data structures for each group"""
root_folder = path.dirname(__file__)
img_folder = path.join(root_folder, "data", "img")
music_folder = path.join(root_folder, "data", "music")
fx_folder = path.join(root_folder, "data", "fx")
sprites = Spritesheet(path.join(img_folder, "spritesheet_x2.png"))
# IMAGES & SOUND
self.images = {}
self.fx = {}
for item in ITEMS:
sprite_at = ITEMS[item]['SPRITE']
self.images[item] = sprites.image_at(sprite_at[0], sprite_at[1],
TILESIZE, 2, KEY_COLOR)
fx = pygame.mixer.Sound(
path.join(fx_folder, ITEMS[item]['FX_PICKUP']))
fx.set_volume(0.1)
self.fx[item] = fx
for mob in MOBS:
sprite_at = MOBS[mob]['SPRITE']
self.images[mob] = sprites.image_at(sprite_at[0], sprite_at[1],
TILESIZE, 2, KEY_COLOR)
fx = pygame.mixer.Sound(path.join(fx_folder,
MOBS[mob]['FX_DEATH']))
fx.set_volume(0.1)
self.fx[mob] = fx
for nest in NESTS:
sprite_at = NESTS[nest]['SPRITE']
self.images[nest] = sprites.image_at(sprite_at[0], sprite_at[1],
TILESIZE, 2, KEY_COLOR)
fx = pygame.mixer.Sound(
path.join(fx_folder, NESTS[nest]['FX_DEATH']))
fx.set_volume(0.1)
self.fx[nest] = fx
for weapon in WEAPONS:
fx = pygame.mixer.Sound(path.join(fx_folder,
WEAPONS[weapon]['FX']))
fx.set_volume(0.1)
self.fx[weapon] = fx
self.tiles = {}
for wall in WALLS:
for orientation in ['TOP', 'FRONT']:
sprite_at = WALLS[wall][orientation]
self.tiles[f"{wall}_{orientation}"] = sprites.image_at(
sprite_at[0], sprite_at[1], TILESIZE, 2, KEY_COLOR)
# MUSIC
pygame.mixer.music.load(path.join(music_folder, BG_MUSIC))
def load_data(self):
"""Loads pertinent data for the game"""
# Map initialization
self.map = TiledMap(r'../assets/stage_1.tmx')
self.map_image = self.map.make_map()
map_rect = self.map_image.get_rect()
# Sprite initialization
pacman_sprites = Spritesheet(r'../assets/sprites.png')
self.open_mouth = pacman_sprites.get_sprite(0, 0, TILESIZE, TILESIZE)
pellet_sprites = Spritesheet(r'../assets/small_pellet.png')
self.pellet_sprite = pellet_sprites.get_sprite(0, 0, TILESIZE, TILESIZE)
def get_fruit_sprites():
spritesheet = Spritesheet('images/spritesheet.png')
fruit_images = [
spritesheet.get_image(x=(24 * 0), y=(24 * 5), w=24,
h=24), # cherries
spritesheet.get_image(x=(24 * 1), y=(24 * 5), w=24,
h=24), # strawberry
spritesheet.get_image(x=(24 * 2), y=(24 * 5), w=24,
h=24), # orange
spritesheet.get_image(x=(24 * 3), y=(24 * 5), w=24, h=24), # ?????
spritesheet.get_image(x=(24 * 4), y=(24 * 5), w=24, h=24), # apple
spritesheet.get_image(x=(24 * 5), y=(24 * 5), w=24,
h=24), # grapes
]
return fruit_images
def update( self, cursor_x, cursor_y ):
self.unit_ss = Spritesheet( self.spritesheet )
if self.state == 'idle':
self._animate('idle')
if self.pressed_z and self.pos_x == cursor_x and self.pos_y == cursor_y:
self.state = 'selected'
self.pressed_z = 0
elif self.state == 'selected':
self._animate('selected')
if self.pressed_z:
self.state = 'moving'
elif self.state == 'moving':
self._animate('moving')
self._move( cursor_x, cursor_y )
self.pressed_z = 0
self.unit_location = (self.pos_x,self.pos_y)
self.unit_image = self.unit_ss.image_at( self.unit_sprite )
def __init__(self, arg):
pygame.init()
self.opt = Setting()
self.name_map = arg.name_map
self.screen = pygame.display.set_mode((self.opt.WIDTH + self.opt.TILE_SIZE*15,self.opt.HEIGHT + self.opt.TILE_SIZE*3))
self.set_grill_surface()
pygame.display.set_caption(self.opt.TITLE)
self.path = os.path.dirname(__file__)
self.path_img = os.path.join(self.path, ".." , "src", "img")
self.images = Spritesheet(self)
self.path_maps = os.path.join(self.path, ".." , "src", "maps", self.name_map + self.opt.LUA_FORMAT)
self.create = not os.path.exists(self.path_maps)
self.builder = Builder(self)
self.clock = pygame.time.Clock()
self.converter = Converter(self)
self.map = Map(self)
self.selector = Selector(self)
self.toolbar = Toolbar(self)
self.loop()
pygame.quit()
class Tileset(object):
def __init__(self, tileset, assetdir):
self._imageCache = {}
self.tileset = tileset
self.tile_count = self.tileset.tile_count
self.usecache = True
fp = os.path.join(assetdir, tileset.image.source)
self._spriteSheet = Spritesheet(fp)
def image_at_index(self, index):
rawIndex = index - 1
# assumes using tileset w/h
w = self.tileset.max_tile_size.width
h = self.tileset.max_tile_size.height
y = math.floor(rawIndex / self.tileset.columns) * h
x = (rawIndex % self.tileset.columns) * w
return self.image_at([x, y, w, h])
def image_at(self, rectangle, colorkey=None):
return self._spriteSheet.image_at(rectangle)
def load_data(self):
root_folder = path.dirname(__file__)
sprites = Spritesheet(
path.join(root_folder, "data", "img", "spritesheet.png"))
self.player_img = sprites.image_at(
PLAYER_SPRITE_AT[0], PLAYER_SPRITE_AT[1], TILESIZE, 1, KEY)
self.bee_img = sprites.image_at(
BEE_SPRITE_AT[0], BEE_SPRITE_AT[1], TILESIZE, 1, KEY)
self.top_wall_img = sprites.image_at(
TOP_WALL_SPRITE_AT[0], TOP_WALL_SPRITE_AT[1], TILESIZE, 1, KEY)
self.front_wall_img = sprites.image_at(
FRONT_WALL_SPRITE_AT[0], FRONT_WALL_SPRITE_AT[1], TILESIZE, 1, KEY)
class Floor(pg.sprite.Sprite):
"""Class for the floor in levels
Attributes:
pos_x: x position on the map
pos_y: y position on the map
"""
def __init__(self, pos_x, pos_y):
"""Constructs a new floor class
Args:
pos_x: x position on the map
pos_y: y position on the map
"""
super().__init__()
self.sprite_sheet = Spritesheet("floor.png")
self.image = choice(self.sprite_sheet.load_strip((0, 0, 50, 50), 4))
self.rect = self.image.get_rect()
self.rect.x = pos_x
self.rect.y = pos_y
class tree(object):
def __init__(self, tree, x, y):
self.tree = tree
self.get = Spritesheet(tree)
self.image = self.get.get_spritte()
self.rect = self.image[0].get_rect()
self.rect.x = x
self.rect.y = y
self.vel = pygame.math.Vector2(0, 0)
self.acceleration = pygame.math.Vector2(0, .1)
self.on_ground = False
self.drop = False
self.col = False
def draw(self, win):
if not self.col and not self.drop:
win.blit(self.image[random.randint(1, 10)],
(self.rect.x, self.rect.y))
elif self.col or self.drop:
self.rect.x = random.randint(100, 1700)
self.rect.y = 40
self.col = False
def update(self, dt, plat):
self.checkCollisionspy(plat)
def checkCollisionspy(self, platform):
if not self.on_ground:
self.rect.bottom += 4
if self.rect.y >= 1000:
self.col = True
def get_hits(self, players):
hits = []
for player in players:
if self.rect.colliderect(player):
hits.append(player)
return hits
def create_animations(self,
sheet_name,
agrandissement=192 / 19,
w_normal=True):
setattr(self, sheet_name + "_sheet",
Spritesheet(self.dir + sheet_name + "-sheet.png"))
setattr(self, sheet_name + "_right_sprites", [])
setattr(self, sheet_name + "_left_sprites", [])
for i in range(getattr(self, sheet_name + "_sheet").get_nb_sprites()):
sprite, duration = getattr(
self,
sheet_name + "_sheet").parse_sprites(f"{sheet_name}{i}.png")
w, h = sprite.get_width(), sprite.get_height()
if w_normal:
size = round(sprite.get_width() * agrandissement)
size2 = round(h * size / w)
else:
size2 = round(sprite.get_height() * agrandissement)
size = round(w * size2 / h)
sprite = pygame.transform.scale(sprite, (size, size2))
getattr(self,
sheet_name + "_right_sprites").append([sprite, duration])
getattr(self, sheet_name + "_left_sprites").append(
[pygame.transform.flip(sprite, True, False), duration])
def load_data(self):
"""Lets add an image for bee's nests"""
root_folder = path.dirname(__file__)
sprites = Spritesheet(
path.join(root_folder, "data", "img", "spritesheet_x2.png"))
self.player_img = sprites.image_at(PLAYER_SPRITE_AT[0],
PLAYER_SPRITE_AT[1], TILESIZE, 2,
KEY)
self.bee_img = sprites.image_at(BEE_SPRITE_AT[0], BEE_SPRITE_AT[1],
TILESIZE, 2, KEY)
self.bee_nest_img = sprites.image_at(BEE_NEST_SPRITE_AT[0],
BEE_NEST_SPRITE_AT[1], TILESIZE,
2, KEY)
self.top_wall_img = sprites.image_at(TOP_WALL_SPRITE_AT[0],
TOP_WALL_SPRITE_AT[1], TILESIZE,
2, KEY)
self.front_wall_img = sprites.image_at(FRONT_WALL_SPRITE_AT[0],
FRONT_WALL_SPRITE_AT[1],
TILESIZE, 2, KEY)
def test_multi(self):
ss = Spritesheet(self.TILES)
[wall, floor] = ss.images_at([self.WALL, self.FLOOR])
def test_init(self):
ss = Spritesheet(self.TILES)
floor = ss.image_at(self.FLOOR, -1)
def __init__(self):
super().__init__()
self.change_x = 0
self.change_y = 0
self.current_level = None
self.weapon_list = []
self.current_weapon = 0
self.weapon = None
self.speed = 5
self.face = 'R'
self.frame = 0
self.firing = False
self.max_health = 100
self.health = 100
self.arm_state = 3
self.webcounter = 0
self.crouched = False
self.try_stand = False
pistol = weapons.Pistol()
self.weapon_list.append(pistol)
self.weapon = self.weapon_list[self.current_weapon]
self.arm_images = []
sprite_sheet = Spritesheet("art/shootman_arms.png")
image = sprite_sheet.get_image(0, 0, 65, 72)
self.arm_images.append(image)
image = sprite_sheet.get_image(65, 0, 65, 72)
self.arm_images.append(image)
image = sprite_sheet.get_image(130, 0, 65, 72)
self.arm_images.append(image)
image = sprite_sheet.get_image(195, 0, 65, 72)
self.arm_images.append(image)
image = sprite_sheet.get_image(260, 0, 65, 72)
self.arm_images.append(image)
image = sprite_sheet.get_image(325, 0, 65, 72)
self.arm_images.append(image)
image = sprite_sheet.get_image(390, 0, 65, 72)
self.arm_images.append(image)
sprite_sheet = Spritesheet("art/shootman_sheet.png")
self.walking_frames_r = []
image = sprite_sheet.get_image(10, 0, 50, 85)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(75, 0, 50, 85)
for x in range(7):
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(140, 0, 50, 85)
for x in range(7):
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(205, 0, 50, 85)
for x in range(7):
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(140, 0, 50, 85)
for x in range(7):
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(270, 0, 50, 85)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(335, 0, 50, 85)
self.walking_frames_r.append(image)
self.image = self.walking_frames_r[self.frame]
self.crouched_frames_r = []
image = sprite_sheet.get_image(10, 95, 50, 75)
self.crouched_frames_r.append(image)
image = sprite_sheet.get_image(75, 95, 50, 75)
for x in range(7):
self.crouched_frames_r.append(image)
image = sprite_sheet.get_image(140, 95, 50, 75)
for x in range(7):
self.crouched_frames_r.append(image)
image = sprite_sheet.get_image(205, 95, 50, 75)
for x in range(7):
self.crouched_frames_r.append(image)
image = sprite_sheet.get_image(140, 95, 50, 75)
for x in range(7):
self.crouched_frames_r.append(image)
image = sprite_sheet.get_image(10, 95, 50, 75)
self.crouched_frames_r.append(image)
self.rect = self.image.get_rect()
self.rect.x = 120
self.rect.y = 520
def __init__(self, levelfile, spritesheetfile):
self.Level = Level()
self.Level.load_file(levelfile)
self.Spritesheet = Spritesheet(spritesheetfile)
def __init__(self):
super().__init__()
self.health = 30
self.speed = 1
self.change_x = 0
self.change_y = 1
self.frame = 0
self.dead = False
self.death_sound = assets.spider_death_sound
self.shoot_timer = 5
self.alt_shoot_timer = 20
self.fire_sound = assets.web_shoot_sound
self.altfire_sound = assets.blob_shoot_sound
self.walking_frames = []
self.death_frames = []
sprite_sheet = Spritesheet("art/spider_sheet.png")
image = sprite_sheet.get_image(0, 0, 90, 45)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
image = sprite_sheet.get_image(90, 0, 90, 45)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
image = sprite_sheet.get_image(0, 0, 90, 45)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
image = sprite_sheet.get_image(180, 0, 90, 45)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
sprite_sheet = Spritesheet("art/spider_death_sheet.png")
image = sprite_sheet.get_image(0, 0, 105, 90)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
image = sprite_sheet.get_image(105, 0, 105, 90)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
image = sprite_sheet.get_image(210, 0, 105, 90)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
self.image = self.walking_frames[self.frame]
self.rect = self.image.get_rect()
def __init__(self, x, y, current_room):
super().__init__((x - 7), (y - 7), current_room, colors.green, 15, 15)
self.speed = 2
self.coins_collected = 0
self.lifetime_coins = 0
self.target_coin = None
self.max_age = 2000
self.max_hunger = 300
self.change_x = 0
self.change_y = 0
self.age = 0
self.ticks_without_food = 0
self.food_type = coin.Coin
self.pit = None
self.frame = 0
self.walking_frames_r = []
self.walking_frames_l = []
self.walking_frames_d = []
self.walking_frames_u = []
sprite_sheet = Spritesheet("art/goblin_spritesheet.png")
# Load all the right facing images into a list
image = sprite_sheet.get_image(0, 0, 15, 15)
self.walking_frames_d.append(image)
self.walking_frames_d.append(image)
self.walking_frames_d.append(image)
image = sprite_sheet.get_image(16, 0, 15, 15)
self.walking_frames_d.append(image)
self.walking_frames_d.append(image)
self.walking_frames_d.append(image)
image = sprite_sheet.get_image(0, 0, 15, 15)
self.walking_frames_d.append(image)
self.walking_frames_d.append(image)
self.walking_frames_d.append(image)
image = sprite_sheet.get_image(32, 0, 15, 15)
self.walking_frames_d.append(image)
self.walking_frames_d.append(image)
self.walking_frames_d.append(image)
image = sprite_sheet.get_image(0, 16, 15, 15)
self.walking_frames_u.append(image)
self.walking_frames_u.append(image)
self.walking_frames_u.append(image)
image = sprite_sheet.get_image(16, 16, 15, 15)
self.walking_frames_u.append(image)
self.walking_frames_u.append(image)
self.walking_frames_u.append(image)
image = sprite_sheet.get_image(0, 16, 15, 15)
self.walking_frames_u.append(image)
self.walking_frames_u.append(image)
self.walking_frames_u.append(image)
image = sprite_sheet.get_image(32, 16, 15, 15)
self.walking_frames_u.append(image)
self.walking_frames_u.append(image)
self.walking_frames_u.append(image)
image = sprite_sheet.get_image(0, 32, 15, 15)
self.walking_frames_r.append(image)
self.walking_frames_r.append(image)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(16, 32, 15, 15)
self.walking_frames_r.append(image)
self.walking_frames_r.append(image)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(0, 32, 15, 15)
self.walking_frames_r.append(image)
self.walking_frames_r.append(image)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(32, 32, 15, 15)
self.walking_frames_r.append(image)
self.walking_frames_r.append(image)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(0, 32, 15, 15)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
self.walking_frames_l.append(image)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(16, 32, 15, 15)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
self.walking_frames_l.append(image)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(0, 32, 15, 15)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
self.walking_frames_l.append(image)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(32, 32, 15, 15)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
self.walking_frames_l.append(image)
self.walking_frames_l.append(image)
self.face = 'R'
self.image = self.walking_frames_d[self.frame]
def __init__(self, width, height, fullimage, starting_position=(0, 0)):
Spritesheet.__init__(self, width, height, fullimage, starting_position)
self.current_x = 0
self.current_y = 0
def __init__(self, width, height):
"""
Configure display-wide settings and one-time
setup work here.
"""
BaseDisplay.__init__(self, width, height)
# There are other fonts available, but they are not
# the same on every computer. You can read more about
# fonts at http://www.pygame.org/docs/ref/font.html
self.font_size = 12
self.font = pygame.font.SysFont("Courier New",self.font_size)
# Colors are specified as a triple of integers from 0 to 255.
# The values are how much red, green, and blue to use in the color.
# Check out http://www.colorpicker.com/ if you want to try out
# colors and find their RGB values. Be sure to use the `R`, `G`,
# `B` values at the bottom, not the H, S, B values at the top.
self.player_color = (0, 255, 0)
self.opponent_color = (255, 0, 0)
self.missile_color = (0, 255, 255)
self.npc_color = (255, 255, 0)
self.wall_color = (255, 255, 255)
self.text_color = (255, 255, 255)
self.background_color = (0, 0, 0)
buttonF = 'code camp buttons.png'
sheet = Spritesheet(buttonF)
self.tourneyB = sheet.image_at(pygame.Rect(5,5,200,97),(255,255,255))
self.singleB = sheet.image_at(pygame.Rect(5,134,200,97),(255,255,255))
self.dualB = sheet.image_at(pygame.Rect(5,264,200,97),(255,255,255))
self.demoB = sheet.image_at(pygame.Rect(5,394,200,97),(255,255,255))
# self.logo = pygame.image.load("display\imgs\game pngs '\code camp logo-01")
self.filenames = ["code camp kirby-01.png", "code camp kirby-02.png", "code camp link-01-01.png", "code camp link-02-01.png", "code camp mario-01.png","code camp mario-04.png", "code camp mario-02.png","code camp mario-03.png"]
self.imgs = []
self.filename2 = ["code camp castle small.png", "forest background code camp small.png", "haunted house code camp small.png"]
self.arena = []
self.filenames2 = ["code camp logo-01.png"]
self.logo = []
for f in self.filenames:
f = os.path.join('display','imgs',f)
self.imgs.append(pygame.image.load(f))
for a in self.filename2:
a = os.path.join("display","imgs",a)
self.arena.append(pygame.image.load(a))
for l in self.filenames2:
l = os.path.join("display", "imgs", l)
self.logo.append(pygame.image.load(l))
# playerStates {'walk':['walk','walkdown','walkleft','walkup','walkright'],'throw':['throw','throwdown','throwleft','throwup','throwright'], 'death':['death'],'victory':['victory'],'hp':['victory']}
# filename = os.path.join('display', 'imgs', 'Link Sprites with coordinates.png')
# self.image = pygame.image.load(filename)
# self.rect = self.obj_to_rect(obj)
# self.image = pygame.image.load(filename)
# ss = Spritesheet(filename)
# for s in playerStates:
# if len(s) == 1:
# for d in s:
# if len()
# playerStates {'walk':['walkdown','walkleft','walkup','walkright'],'throw':['throwdown','throwleft','throwup','throwright'], 'death':['death'],'victory':['victory'],'hp':['victory']}
# self.image = pygame.image.load(filename)
# self.rect = self.obj_to_rect(obj)
# self.image = pygame.image.load(filename)
return
def __init__(self):
super().__init__()
self.health = 80
self.speed = 0.1
self.change_x = 0
self.change_y = 1
self.frame = 0
self.dead = False
self.death_sound = assets.spider_death_sound
self.shoot_timer = 60
self.alt_shoot_timer = 10
self.fire_sound = assets.missile_fire
self.walking_frames = []
self.death_frames = []
sprite_sheet = Spritesheet("art/robot_sheet.png")
image = sprite_sheet.get_image(0, 0, 45, 47)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
image = sprite_sheet.get_image(45, 0, 45, 47)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
image = sprite_sheet.get_image(0, 0, 45, 47)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
image = sprite_sheet.get_image(135, 0, 45, 47)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
self.walking_frames.append(image)
sprite_sheet = Spritesheet("art/robot_death_sheet.png")
image = sprite_sheet.get_image(0, 0, 50, 60)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
image = sprite_sheet.get_image(50, 0, 50, 60)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
image = sprite_sheet.get_image(100, 0, 50, 60)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
image = sprite_sheet.get_image(150, 0, 50, 60)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
image = sprite_sheet.get_image(200, 0, 50, 60)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
image = sprite_sheet.get_image(250, 0, 50, 60)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
image = sprite_sheet.get_image(300, 0, 50, 60)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
image = sprite_sheet.get_image(350, 0, 50, 60)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
self.death_frames.append(image)
self.image = self.walking_frames[self.frame]
self.rect = self.image.get_rect()
def test_strips(self):
ss = Spritesheet(self.TILES)
result = ss.load_strip((0, 0, self.STEP, self.STEP), 8)
assert len(result) == 8
def __init__(self, image, width, height, coordinates):
pygame.sprite.Sprite.__init__(self)
sheet = Spritesheet(image)
self.image = sheet.get_image(coordinates)
self.image = pygame.transform.scale(self.image, (width, height))
self.rect = self.image.get_rect()
[["no"], ["bo"], ["ro"], ["ro"], ["no"]],
[["no"], ["is"], ["wo"], ["no"], ["no"]],
[["no"], ["no"], ["no"], ["no"], ["fo"]]]
states = [deepcopy(state)]
nrow = len(state)
ncol = len(state[0])
# Create the window
screen = pg.display.set_mode((ncol * 90, nrow * 90))
pg.display.set_caption('')
# Import images
images = Spritesheet("spritesheet.png")
test = pg.transform.scale(images.get_sprite(0 * 24, 57 * 24, 24, 24), (90, 90))
baba = pg.transform.scale(images.get_sprite(1 * 24, 0 * 24, 24, 24), (90, 90))
baba_text = pg.transform.scale(images.get_sprite(6 * 24, 27 * 24, 24, 24),
(90, 90))
flag = pg.transform.scale(images.get_sprite(6 * 24, 21 * 24, 24, 24), (90, 90))
flag_text = pg.transform.scale(images.get_sprite(1 * 24, 30 * 24, 24, 24),
(90, 90))
is_text = pg.transform.scale(images.get_sprite(18 * 24, 30 * 24, 24, 24),
(90, 90))
you_text = pg.transform.scale(images.get_sprite(20 * 24, 42 * 24, 24, 24),
(90, 90))
win_text = pg.transform.scale(images.get_sprite(17 * 24, 42 * 24, 24, 24),
(90, 90))
wall = pg.transform.scale(images.get_sprite(0 * 24, 57 * 24, 24, 24), (90, 90))
def __init__(self, x, y, current_room):
super().__init__((x - 10), (y - 10), current_room, colors.red, 20, 20)
self.target_goblin = None
self.speed = 3
self.goblins_eaten = 0
self.lifetime_goblins_eaten = 0
self.change_x = 0
self.change_y = 0
self.age = 0
self.ticks_without_food = 0
self.food_type = goblin.Goblin
self.home_hut = None
self.frame = 0
self.killing = 'No'
self.walking_frames_r = []
self.walking_frames_l = []
self.kill_frames_r = []
self.kill_frames_l = []
sprite_sheet = Spritesheet("art/ogre_spritesheet.png")
# Load all the right facing images into a list
image = sprite_sheet.get_image(0, 0, 20, 20)
self.walking_frames_r.append(image)
self.walking_frames_r.append(image)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(21, 0, 20, 20)
self.walking_frames_r.append(image)
self.walking_frames_r.append(image)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(0, 0, 20, 20)
self.walking_frames_r.append(image)
self.walking_frames_r.append(image)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(42, 0, 20, 20)
self.walking_frames_r.append(image)
self.walking_frames_r.append(image)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(0, 0, 20, 20)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
self.walking_frames_l.append(image)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(21, 0, 20, 20)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
self.walking_frames_l.append(image)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(0, 0, 20, 20)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
self.walking_frames_l.append(image)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(42, 0, 20, 20)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
self.walking_frames_l.append(image)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(21, 42, 20, 20)
self.kill_frames_r.append(image)
self.kill_frames_r.append(image)
self.kill_frames_r.append(image)
image = sprite_sheet.get_image(42, 42, 20, 20)
self.kill_frames_r.append(image)
self.kill_frames_r.append(image)
self.kill_frames_r.append(image)
self.kill_frames_r.append(image)
self.kill_frames_r.append(image)
self.kill_frames_r.append(image)
image = sprite_sheet.get_image(21, 42, 20, 20)
image = pygame.transform.flip(image, True, False)
self.kill_frames_l.append(image)
self.kill_frames_l.append(image)
self.kill_frames_l.append(image)
image = sprite_sheet.get_image(42, 42, 20, 20)
image = pygame.transform.flip(image, True, False)
self.kill_frames_l.append(image)
self.kill_frames_l.append(image)
self.kill_frames_l.append(image)
self.kill_frames_l.append(image)
self.kill_frames_l.append(image)
self.kill_frames_l.append(image)
self.face = 'R'
self.image = self.walking_frames_r[self.frame]
class Unit(object):
def __init__( self, screen, unitname, spritesheet ):
self.spritesheet = spritesheet
self.unit_ss = Spritesheet( spritesheet )
self.unit_sprite = (0, 0, 40, 40)
self.unit_image = self.unit_ss.image_at( self.unit_sprite )
self.move_tile_ss = Spritesheet('spritesheets/move_tile.bmp')
self.move_tile_image = self.move_tile_ss.image_at((0, 0, 40, 40))
self.screen = screen
self.unitname = unitname
self.frame = 0
self.pos_x = 0
self.pos_y = 0
self.distance_x = 0
self.distance_y = 0
self.move_x = 0
self.move_y = 0
self.speed = 10
self.unit_location = (self.pos_x, self.pos_y)
self.state = 'idle'
self.pressed_z = 0
def get_data( self, unit, data ):
self.i = 0
self.char = ''
self.value = 0
self.path = "units/" + unit + "/" + unit + ".txt"
self.tiledata = [ line.strip() for line in open( self.path, "r") ]
if data == 'move_range':
self.char = self.tiledata[1][13]
self.value = int( self.char )
return self.value
def _move_diamond( self ):
self.coordinates = []
self.radius = self.get_data( self.unitname, 'move_range' )
self.y = 0
self.x = 0
self.x_limit = 0
self.x0 = self.pos_x
self.y0 = self.pos_y + self.radius*40
while self.y <= self.radius*2:
while self.x <= self.x_limit:
self.coordinates.append( ( self.x0 - self.x*40, self.y0 - self.y*40 ) )
if self.y >= 0:
self.coordinates.append( ( self.x0 + self.x*40, self.y0 - self.y*40 ) )
self.x += 1
self.x = 0
if self.y < self.radius:
self.x_limit += 1
elif self.y >= self.radius:
self.x_limit -= 1
self.y += 1
return self.coordinates
self.coordinates = []
def update( self, cursor_x, cursor_y ):
self.unit_ss = Spritesheet( self.spritesheet )
if self.state == 'idle':
self._animate('idle')
if self.pressed_z and self.pos_x == cursor_x and self.pos_y == cursor_y:
self.state = 'selected'
self.pressed_z = 0
elif self.state == 'selected':
self._animate('selected')
if self.pressed_z:
self.state = 'moving'
elif self.state == 'moving':
self._animate('moving')
self._move( cursor_x, cursor_y )
self.pressed_z = 0
self.unit_location = (self.pos_x,self.pos_y)
self.unit_image = self.unit_ss.image_at( self.unit_sprite )
def draw( self ):
self.i = 0
self.coordinates = self._move_diamond()
while self.state == 'selected' and self.i < len(self.coordinates):
self.screen.blit(self.move_tile_image, self.coordinates[self.i])
self.i += 1
self.screen.blit(self.unit_image, self.unit_location)
def action( self ):
self.pressed_z = 1
def _move( self, cursor_x, cursor_y ):
self.distance_x = cursor_x - self.pos_x
self.distance_y = cursor_y - self.pos_y
if self.distance_x == 0 and self.distance_y == 0:
self.state = 'idle'
if self.distance_x != 0:
if self.distance_x > 0:
self.pos_x += self.speed
elif self.distance_x < 0:
self.pos_x -= self.speed
if self.distance_y != 0:
if self.distance_y > 0:
self.pos_y += self.speed
elif self.distance_y < 0:
self.pos_y -= self.speed
def _animate( self, state ):
if state == 'idle':
if self.frame == 0:
self.frame += 1
else:
self.frame = 0
if state == 'selected' or state == 'moving':
if self.frame < 5:
self.frame += 1
else:
self.frame = 2
self.unit_sprite = ( self.frame*40, 0, 40, 40 )
