def run_pygame_collide(args):
"""Test if spritecollide works without pygame.init() called
Rect(left, top, width, height) -> Rect
"""
logg = logging.getLogger(f"c.{__name__}.run_pygame_collide")
logg.info(f"Start run_pygame_collide")
c_rect = Rect(10, 20, 40, 80)
logg.debug(f"c_rect {c_rect}")
car = Sprite()
car.rect = c_rect
logg.debug(f"car {car}")
segments = []
for i in range(5):
new_seg = Sprite()
s_rect = Rect(i * 30, i * 50, 40, 80)
new_seg.rect = s_rect
segments.append(new_seg)
mmap = Group()
for seg in segments:
mmap.add(seg)
logg.debug(f"mmap {mmap}")
hits = spritecollide(car, mmap, dokill=False)
for segment in hits:
# logg.debug(f"hit segment with id {segment.s_id}")
# logg.debug(f"hit segment {segment}")
logg.debug(f"hit segment with rect {segment.rect}")
def start(self):
self.entity.add_component(Sprite())
self.entity.get_component(Sprite()).set_sprite(
self.data.sokoban_spritesheet.get_image(994, 988, 92, 108))
self.entity.get_component(Sprite()).show_rect = True
self.entity.transform.position = (300, 300)
self.entities_manager.add(self.entity)
def start_resultmode(result, money):
global all_sprites, resultmode_fon, resultmode_money_group, resultmode_score_group, resultmode_total_group
global resultmode_menu_button, resultmode_return_button, resultmode_bonus, finish
pygame.mixer.music.stop()
finish.play()
all_sprites = Group()
resultmode_fon = Sprite()
resultmode_fon.image = pygame.image.load(
'data/Images/game_over_stuff/gameover.png')
resultmode_fon.rect = resultmode_fon.image.get_rect()
resultmode_fon.rect.x = 182
resultmode_fon.rect.y = 50
all_sprites.add(resultmode_fon)
resultmode_menu_button = Sprite()
resultmode_menu_button.image = pygame.image.load(
'data/Images/game_over_stuff/menu button.png')
resultmode_menu_button.rect = resultmode_menu_button.image.get_rect()
resultmode_menu_button.rect.x = 182 + 45
resultmode_menu_button.rect.y = 470
all_sprites.add(resultmode_menu_button)
resultmode_return_button = Sprite()
resultmode_return_button.image = pygame.image.load(
'data/Images/game_over_stuff/return button.png')
resultmode_return_button.rect = resultmode_return_button.image.get_rect()
resultmode_return_button.rect.x = 400
resultmode_return_button.rect.y = 470
all_sprites.add(resultmode_return_button)
all_sprites.draw(main_screen)
resultmode_score_group = Group()
transform_number(result, resultmode_score_group, (175 + 182, 205))
resultmode_score_group.draw(main_screen)
resultmode_money_group = Group()
x = transform_number(
str(money) + '+', resultmode_money_group, (150 + 182, 290))
resultmode_money_group.draw(main_screen)
bonus = int(result * 0.02)
resultmode_bonus = Group()
transform_number(bonus, resultmode_bonus, (x, 290))
resultmode_bonus.draw(main_screen)
resultmode_total_group = Group()
transform_number(money + bonus, resultmode_total_group, (150 + 182, 395))
resultmode_total_group.draw(main_screen)
pygame.display.flip()
if data['high score'] < result:
data['high score'] = result
data['money'] += money + bonus
def render_center_info(board_render):
center_info_surface = Surface((250, 250))
match = board_render.match
group = LayeredUpdates()
# Background
info_rect = Rect(0, 0, 250, 250)
info_rect.center = board_render.surface.get_rect().center
pygame.draw.rect(center_info_surface, (0, 0, 0), info_rect)
current_path = os.path.dirname(os.path.realpath(__file__))
font_path = os.path.join(
current_path, "..", "..", "resources", "fonts", "SourceSans3-Semibold.ttf"
)
font = Font(font_path, 30)
large_font = Font(font_path, 42)
# Round Title
round_text = "{} {}".format("East" if match.east_prevalent else "South", match.round_number)
round_surface = font.render(round_text, True, (255, 255, 255))
round_sprite = Sprite()
round_sprite.image = round_surface
round_sprite.rect = round_surface.get_rect()
round_sprite.rect.center = info_rect.center
round_sprite.rect.y -= (round_surface.get_rect().height // 2)
round_sprite.layer = 1
group.add(round_sprite)
# Tiles Left in Wall
tile_count_surface = large_font.render(str(len(match.current_board.wall)), True, (255, 255, 255))
wall_remaining_sprite = Sprite()
wall_remaining_sprite.image = tile_count_surface
wall_remaining_sprite.rect = tile_count_surface.get_rect()
wall_remaining_sprite.rect.center = info_rect.center
wall_remaining_sprite.rect.y += (tile_count_surface.get_rect().height // 3)
wall_remaining_sprite.layer = 1
group.add(wall_remaining_sprite)
# Wind Markers
create_wind_markers(match, info_rect, group)
# Turn Marker
create_turn_marker(match, info_rect, group)
# Riichi Markers
create_riichi_markers(match, info_rect, group)
background_sprite = Sprite()
background_sprite.rect = info_rect
background_sprite.image = center_info_surface
background_sprite.layer = 0
group.add(background_sprite)
return group
def start(self):
self.play_button.add_component(Button())
self.play_button.transform.position = WINDOW_CENTER
self.play_button.get_component(
Button()).scene_manager = self.scene_manager
self.play_button.get_component(Button()).show_rect = False
self.play_button.add_component(Sprite())
self.play_button.get_component(Sprite()).set_default_image(
self.green_sheet.get_image(0, 0, 190, 49))
self.play_button.add_component(Text())
self.play_button.get_component(
Text()).font = self.data.kenny_future_narrow_font
self.play_button.get_component(Text()).text = 'PLAY'
self.entities_manager.add(self.play_button)
def select(self):
self.selected = True
select = Sprite()
select.image = pygame.image.load("images/Selected.png").convert_alpha()
select.rect = self.rect
select._layer = 5
self.add(select)
def mark(self):
self.marked = True
mark = Sprite()
mark.image = pygame.image.load("images/Mark.png").convert_alpha()
mark.rect = self.rect
mark._layer = 4
self.add(mark)
def sprite(self, rect):
action_sprite = Sprite()
action_sprite.pygame.image.load("../images/" +
self.__class__.__name__ +
".png").convert()
action_sprite.rect = rect
return action_sprite
def __init__(self, bullets: Group):
super().__init__()
self.bullets = bullets
# Load images
img = image.load('images/player03.png').convert_alpha()
self.imagesN = []
self.imagesL = []
self.imagesR = []
for i in range(4):
self.imagesN.append(img.subsurface((64 * i, 192, 64, 96)))
for i in range(4):
imgL = img.subsurface((64 * i, 288, 64, 96))
imgR = transform.flip(imgL, True, False)
self.imagesL.append(imgL)
self.imagesR.append(imgR)
self.image = self.imagesN[0]
self.rect = self.image.get_rect()
self.slow_effect0 = image.load('images/sloweffect.png').convert_alpha()
self.slow_effect = self.slow_effect0
self.slow_rect = self.slow_effect.get_rect()
self.slow_rect.center = self.rect.center
self.shoot1_img = img.subsurface((384, 0, 64, 64))
self.hit_box = Sprite()
self.hit_box.rect = Rect(0, 0, 4, 4)
self.reborn()
def __init__(self,
manager: UIManager,
x_pos: int,
y_pos: int,
color: Tuple[int, int, int],
width: int,
height: int,
text='Test Button',
disable=False,
font_size=15,
padding=PADDING):
Group.__init__(self)
UIComponent.__init__(self, manager)
self.color = color
self.x_pos = x_pos
self.y_pos = y_pos
self.width = width
self.height = height
self.text = text
self.disable = disable
self.font_size = font_size
self.padding = padding
self.color = color
self.button = Sprite()
self.button.image = Surface([width, height])
self.button.image.fill(color)
render_inline_text(self.button.image, self.text, self.font_size,
(0, 0, 0))
self.button.rect = self.button.image.get_rect()
self.button.rect.topleft = (x_pos, y_pos)
self.add(self.button)
def create_turn_marker(board, parent_rect, group):
MARKER_OFFSET = 20
MARKER_WIDTH = 5
current_turn = board.current_board.current_turn
if current_turn % 2 == 0:
marker_size = (parent_rect.width - MARKER_OFFSET, MARKER_WIDTH)
else:
marker_size = (MARKER_WIDTH, parent_rect.width - MARKER_OFFSET)
marker_size_half = (marker_size[0] / 2, marker_size[1] / 2)
parent_half_width = parent_rect.width / 2
parent_half_height = parent_rect.height / 2
SEAT_OFFSETS = [
(0, parent_half_height - marker_size_half[1]),
(parent_half_width - marker_size_half[0], 0),
(0, -parent_half_height + marker_size_half[1]),
(-parent_half_width + marker_size_half[0], 0),
]
turn_marker_surface = Surface(marker_size)
turn_marker_surface.fill((255, 255, 255))
sprite = Sprite()
sprite.rect = turn_marker_surface.get_rect()
sprite.image = turn_marker_surface
sprite.rect.center = parent_rect.center
sprite.rect.x += SEAT_OFFSETS[current_turn][0]
sprite.rect.y += SEAT_OFFSETS[current_turn][1]
sprite.layer = 2
group.add(sprite)
def __init__(self, image, x, y, game):
self.name = "Dingo"
self.init_image = image_util.load_image("dingo.png")
self.init_x = x
self.init_y = y
image = image_util.load_image("dingo.png")
attack_image = image_util.load_image("dingo_attack.png")
unselected_images = image_util.load_sliced_sprites(32, 32, "dingo_unselected.png")
rect = image.get_rect()
rect.left = 5
rect.top = 5
rect.width = rect.width-10
rect.height = rect.height-10
speed = 3
attack_length = 250
attack_delay = 200
Player.__init__(self, game, x, y, image, attack_image, unselected_images, rect, speed, attack_length, attack_delay)
self.left_offset = 5
self.top_offset = 5
self.rect.width = 32 - self.left_offset * 2
self.rect.height = self.rect.width
self.attack_sprite = Sprite()
self.attack_sprite.rect = image.get_rect()
#self.attack_sprite.rect.width += 10
#self.attack_sprite.rect.height += 10
self.canDriveCar = False
def __init__(self, tile, camera, wx=0, wy=0, color=Color(255, 255, 255)):
self.size = TileService.size
GameObject.__init__(self, self.size, self.size, wx, wy)
sprite = Sprite()
sprite.image = TileService.getTile(tile, color)
sprite.rect = (wx, wy, self.size, self.size)
self.addSprites(sprite, camera)
def place_unit(self, name, pos, team_id=-1):
prefab = self.mod_loader.entities[name]
if 'buildable' not in prefab['tags']:
print(f'Trying to place non placeable: {name=}, {team_id=}')
return
spr = Sprite()
rect = Rect((0, 0), prefab['size'])
rect.center = pos
spr.rect = rect
if pygame.sprite.spritecollideany(spr, self.sprites):
print(f'Trying to place on occupied area: {name=}, {team_id=}')
return
pl = self.get_player(team_id)
if not pl.has_enough(prefab['cost']):
print(f'Trying to place without resources: {name=}, {team_id=}')
return
cls = self.mod_loader.bases[prefab['base']]
u = cls(self, name, pos[0], pos[1], team_id)
self.sprites.add(u)
self.buildings.add(u)
pl.spend(prefab['cost'])
self.send([Game.ClientCommands.CREATE, u.name, u.unit_id, team_id, u.get_update_args()])
def start(self):
self.player.transform.position = (400, 400)
self.player.transform.width = 100
self.player.transform.height = 100
self.player.add_component(Sprite())
self.player.get_component(Sprite()).set_image(
self.sokoban_spritesheet.get_image(994, 988, 92, 108))
self.player.get_component(Sprite()).image.set_colorkey(BLACK)
self.player.add_component(Movement())
self.wall2.gameObject.tag = 'wall 2'
self.wall2.transform.position = (0, 0)
self.wall2.add_component(Collider())
self.wall2.transform.width = 64
self.wall2.transform.height = 64
self.entities_manager.add(self.player)
self.entities_manager.add(self.wall2)
def _detect_fall(self):
# check if player should fall off ledge
falling_dummy = Sprite()
falling_dummy.rect = self.rect
falling_dummy.rect.bottom += 1
#print(f"falling_dummy's bottom {falling_dummy.rect.bottom}")
return len(
pygame.sprite.spritecollide(falling_dummy,
self.environment.platforms,
False)) == 0
def __init__(self, manager):
State.__init__(self, manager)
self.sprite = Sprite()
self.sprite.image = Surface((0, 0))
self.sprite.rect = Rect(0, 0, 1, options.height)
self.sprite.mask = Mask((1, options.height))
self.sprite.mask.fill()
self.STATE_NUMBER = manager.DEACTIVATED
def prep_lives(self):
for x in range(self.stats.lives_left):
temp = ImageRect(self.screen, "pac_man_right_1", 18, 18)
life = Sprite()
life.image = temp.image
temp.rect.x = x * 18
temp.rect.bottom = self.screen_rect.bottom - 1
life.rect = temp.rect
self.lives.add(life)
def test_collide_hit_rect_with_rect(self) -> None:
player = make_player()
pos = player.pos
x = pos.x
y = pos.y
wall_sprite = Sprite([self.groups.walls])
wall_sprite.rect = Rect(x, y, 30, 30)
self.assertTrue(collide_hit_rect_with_rect(player, wall_sprite))
def clean_up():
'''
Deletes all blocks that were created.
@postcondition: No more objects of BLOCK_TYPE exist in memory.
'''
global blocks, block_buffer
blocks = get_empty_block_array()
block_buffer = GroupSingle(Sprite())
block_buffer.sprite.rect = Rect(0, 0, 0, 0)
_blocks_to_check.clear()
_blocks_to_clear.clear()
def __init__(self, pos, *groups):
super().__init__(*groups)
spr = SpriteSheet("res/CreyMan.png")
self.rect = Rect(pos[0], pos[1], 32, 32)
self.idle_sprites = [
scale(spr.clip_sprite(16, 16, 16, 16), (32, 32)),
scale(spr.clip_sprite(32, 16, 16, 16), (32, 32)),
scale(spr.clip_sprite(48, 16, 16, 16), (32, 32)),
scale(spr.clip_sprite(64, 16, 16, 16), (32, 32))
]
self.run_sprites = [
scale(spr.clip_sprite(16, 32, 16, 16), (32, 32)),
scale(spr.clip_sprite(32, 32, 16, 16), (32, 32)),
scale(spr.clip_sprite(48, 32, 16, 16), (32, 32)),
scale(spr.clip_sprite(48, 32, 16, 16), (32, 32)),
scale(spr.clip_sprite(32, 32, 16, 16), (32, 32)),
scale(spr.clip_sprite(16, 32, 16, 16), (32, 32))
]
self.grab_item_idle_sprite = [
scale(spr.clip_sprite(80, 16, 16, 16), (32, 32)),
scale(spr.clip_sprite(96, 16, 16, 16), (32, 32)),
scale(spr.clip_sprite(112, 16, 16, 16), (32, 32)),
scale(spr.clip_sprite(128, 16, 16, 16), (32, 32))
]
self.grab_item_run_sprites = [
scale(spr.clip_sprite(304, 16, 16, 16), (32, 32)),
scale(spr.clip_sprite(320, 16, 16, 16), (32, 32)),
scale(spr.clip_sprite(336, 16, 16, 16), (32, 32)),
scale(spr.clip_sprite(336, 16, 16, 16), (32, 32)),
scale(spr.clip_sprite(320, 16, 16, 16), (32, 32)),
scale(spr.clip_sprite(304, 16, 16, 16), (32, 32))
]
self.hitbox = Sprite()
self.hitbox.rect = Rect(self.rect.x + 8, self.rect.y + 16, 14, 16)
self.pos_x = [True, True]
self.pos_y = [True, True]
self.sprite_change = 0
self.current_sprites = self.idle_sprites
self.flipped = False
self.item_grab = False
self.item = None
self.parar = 3
self.image = self.idle_sprites[0]
def create_grid(self, layer_id, group):
layer_level = self.mapa_atual["layers"][layer_id]
index_item = -1
for celula in layer_level["grid"]:
index_item += 1
if celula == '0':
continue
y = index_item // layer_level["gridCellsY"]
x = index_item % layer_level["gridCellsX"]
celula_bloco = Sprite(group)
celula_bloco.image = scale(
self.tilemap_level.clip_sprite(0, 0, 16, 16), (32, 32))
celula_bloco.rect = Rect(x * 32, y * 32, 32, 32)
def create_wind_markers(match, parent_rect, group):
current_path = os.path.dirname(os.path.realpath(__file__))
font_path = os.path.join(
current_path, "..", "..", "resources", "fonts", "SourceSans3-Semibold.ttf"
)
font = Font(font_path, 40)
MARKER_SIZE = (40, 40)
MARKER_SIZE_HALF = (MARKER_SIZE[0] / 2, MARKER_SIZE[1] / 2)
MARKER_OFFSET = 40
parent_half_width = parent_rect.width / 2
parent_half_height = parent_rect.height / 2
SEAT_OFFSETS = [
(0, parent_half_height - MARKER_SIZE_HALF[1] - MARKER_OFFSET),
(parent_half_width - MARKER_SIZE_HALF[0] - MARKER_OFFSET, 0),
(0, -parent_half_height + MARKER_SIZE_HALF[1] + MARKER_OFFSET),
(-parent_half_width + MARKER_SIZE_HALF[0] + MARKER_OFFSET, 0),
]
WIND_ORDERS = [
["E", "S", "W", "N"],
["N", "E", "S", "W"],
["W", "N", "E", "S"],
["S", "W", "N", "E"],
]
current_east_seat = match.current_board.current_dealer
wind_order = WIND_ORDERS[current_east_seat]
for i in range(4):
wind = wind_order[i]
background_surface = Surface(MARKER_SIZE)
if i == current_east_seat:
background_color = (255, 0, 0)
else:
background_color = (100, 100, 100)
background_surface.fill(background_color)
font_surface = font.render(wind, True, (255, 255, 255))
font_width, font_height = font.size(wind)
background_surface.blit(
font_surface,
((MARKER_SIZE[0] - font_width) / 2, (MARKER_SIZE[1] - font_height) / 2),
)
sprite = Sprite()
sprite.rect = background_surface.get_rect()
sprite.image = background_surface
sprite.rect.center = parent_rect.center
sprite.rect.x += SEAT_OFFSETS[i][0]
sprite.rect.y += SEAT_OFFSETS[i][1]
sprite.layer = 2
group.add(sprite)
def test_y_wall_collisions(self) -> None:
player = make_player()
hit_rect = player.motion.hit_rect
wall_sprite = Sprite([self.groups.walls])
x = player.pos.x
y = player.pos.x + hit_rect.height / 2 + 1
wall_sprite.rect = Rect(x, y, 30, 30)
self.assertFalse(collide_hit_rect_with_rect(player, wall_sprite))
player.motion.vel.y = 10
player.update()
self.assertFalse(collide_hit_rect_with_rect(player, wall_sprite))
self.assertEqual(player.motion.vel.y, 0)
def __init__(self, game, x, y, image, attack_image, unselected_images,
rect, speed, attack_length, attack_delay):
super(Player, self).__init__(image, (x * tile_size, y * tile_size),
game)
self.isInTree = False
self.car = None
self.screen = game.screen
self.rect = self.image.get_rect()
self.speed = 1
self.screen = game.screen
self.attack_image = attack_image
self.rect = rect
self.rect.left = self.x
self.rect.top = self.y
self.speed = speed
self.unselected_images = unselected_images
self.last_unselected_change = time.get_ticks()
self.unselected_change_delay = 250
self.unselected_image = 0
self.current_image = self.unselected_images[self.unselected_image]
self.attack_length = attack_length
self.attack_delay = attack_delay
self.attack_end = 0
self.attack_start = 0
self.attacking = False
self.isInCar = False
self.inUse = False
self.game.player_group.add(self)
if self.game.current_map is not None:
self.game.current_map.num_animals += 1
self.left_offset = 5
self.top_offset = 5
self.rect.width = TILE_SIZE - (self.left_offset * 2)
self.rect.height = self.rect.width
self.attack_sprite = Sprite()
self.attack_sprite.rect = image.get_rect()
def start_menumode():
global fon, menumode_start_btn, menumode_info_btn, menumode_shop_btn, jar, all_sprites, process_mode, menumode_money_sprites
global menumode_high_score_sprites, background_music_playing
process_mode = 'menu'
fon = pygame.transform.scale(
pygame.image.load('data/images/menu/main_menu.png'), (width, height))
main_screen.blit(fon, (0, 0))
menumode_start_btn = StartButton()
menumode_info_btn = InfoButton()
menumode_shop_btn = ShopButton()
jar = MenuJar()
all_sprites = Group()
all_sprites.add(menumode_start_btn)
all_sprites.add(menumode_info_btn)
all_sprites.add(menumode_shop_btn)
all_sprites.add(jar)
menumode_money_sprites = Group()
transform_number(data['money'], menumode_money_sprites, (90, 20))
menumode_money_sprites.draw(main_screen)
menumode_high_score_sprites = Group()
x = 1000 - 25 * (len(str(data['high score'])) + 1)
transform_number(data['high score'], menumode_high_score_sprites, (x, 20))
menumode_high_score_sprites.draw(main_screen)
high_score = Sprite()
high_score.image = pygame.image.load('data/Images/menu/high_score.png')
high_score.mask = pygame.mask.from_surface(high_score.image)
high_score.rect = high_score.image.get_rect()
high_score.mask = pygame.mask.from_surface(high_score.image)
high_score.rect.x = 760 - 25 * (len(str(data['high score'])) - 1)
high_score.rect.y = 20
all_sprites.add(high_score)
all_sprites.draw(main_screen)
pygame.display.flip()
if not background_music_playing:
pygame.mixer.music.load('data/Music/Background.mp3')
pygame.mixer.music.play(-1)
background_music_playing = True
def __init__(self, screen):
self.screen = screen
self.map_screen = self.screen.subsurface(0, 0, MAP_WIDTH, MAP_HEIGHT)
#pygame.display.set_icon(pygame.image.load(os.path.join("images", "ui","icon.png")))
self.loaded_maps = {}
self.current_map = None
pygame.mouse.set_visible(1);
self.hasKey = False
self.animalsFreed = False
self.soundUtil = SoundUtil()
self.soundUtil.sound_on = True
self.pauseMenu = PauseScreen(self)
self.cursor = Sprite()
self.cursor.rect = Rect(0,0,1,1)
self.hud = Hud(self)
self.player_group = Group()
self.player = Taz(image_util.load_image("tasmanian.png"), 1, 1, self)
self.player.inUse = True
self.player.current_image = self.player.image
self.hud.set_player(self.player)
self.last_rendered_achievement = 0
self.achievement_countdown = 0
self.clock = pygame.time.Clock()
self.achievements_done = []
self.pressed = []
for key in pygame.key.get_pressed():
self.pressed.append( True )
self.loadLevel("jail.txt")
self.isGameOver = False
self.returnToMainMenu = False
def run_game():
""" The main function"""
# Initialize the game and create a screen object.
os.environ['SDL_VIDEO_CENTERED'] = '1'
pygame.init()
settings = Settings()
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption('Houtou Project')
screen_sprite = Sprite()
screen_sprite.rect = screen.get_rect()
keys = Keys()
# Create the player with her bullet group.
player = Player(screen)
# Create the list of enemies.
enemies = []
# Load the enemies.
enemy_repo = EnemyRepo(screen)
bullets_list = []
# Initialize the clock.
clock = Clock()
ticks = 0
# Start the main loop.
while True:
gf.check_events(player, keys)
gf.check_ticks(ticks, enemies, enemy_repo)
# Update the player and the enemies.
player.update()
for enemy in enemies.copy():
if enemy.update(player):
enemies.remove(enemy)
enemy.check_ticks(player)
# Update the bullets.
bullets_list = gf.get_bullets_list(player, enemies)
gf.update_bullets(screen_sprite, bullets_list)
# Update the screen.
gf.update_screen(screen, settings, player, enemies, bullets_list)
clock.tick(settings.fps)
ticks += 1
def create_riichi_markers(match, parent_rect, group):
MARKER_OFFSET = 60
MARKER_Y_OFFSET = 10
MARKER_WIDTH = 15
i = -1
for player in match.players:
i += 1
if not player.riichi_declared:
continue
if i % 2 == 0:
marker_size = (parent_rect.width - MARKER_OFFSET, MARKER_WIDTH)
else:
marker_size = (MARKER_WIDTH, parent_rect.width - MARKER_OFFSET)
marker_size_half = (marker_size[0] / 2, marker_size[1] / 2)
parent_half_width = parent_rect.width / 2
parent_half_height = parent_rect.height / 2
SEAT_OFFSETS = [
(0, parent_half_height - marker_size_half[1] - MARKER_Y_OFFSET),
(parent_half_width - marker_size_half[0] - MARKER_Y_OFFSET, 0),
(0, -parent_half_height + marker_size_half[1] + MARKER_Y_OFFSET),
(-parent_half_width + marker_size_half[0] + MARKER_Y_OFFSET, 0),
]
riichi_marker_surface = Surface(marker_size)
marker_rect = riichi_marker_surface.get_rect()
riichi_marker_surface.fill((255, 255, 255))
pygame.draw.circle(
riichi_marker_surface,
(255, 0, 0),
(marker_rect.width / 2, marker_rect.height / 2),
5,
)
sprite = Sprite()
sprite.rect = marker_rect
sprite.image = riichi_marker_surface
sprite.rect.center = parent_rect.center
sprite.rect.x += SEAT_OFFSETS[i][0]
sprite.rect.y += SEAT_OFFSETS[i][1]
sprite.layer = 2
group.add(sprite)
def __init__(self, tile, camera, wx=0, wy=0, color=Color(255,255,255)):
self.size = TileService.size
GameObject.__init__(self, self.size, self.size, wx, wy)
sprite = Sprite()
sprite.image = TileService.getTile(tile, color)
sprite.rect = (
wx,
wy,
self.size,
self.size
)
self.addSprites(sprite, camera)
Keyboard.on(Keyboard.keymap['TICK'], self.passTurn, CHARACTER_INPUT_GROUP)
Keyboard.on(Keyboard.keymap['MOVE_UP'], partial(self.moveCharacter,0,-1*self.size), CHARACTER_INPUT_GROUP);
Keyboard.on(Keyboard.keymap['MOVE_RIGHT'], partial(self.moveCharacter,1*self.size,0), CHARACTER_INPUT_GROUP);
Keyboard.on(Keyboard.keymap['MOVE_LEFT'], partial(self.moveCharacter,-1*self.size,0), CHARACTER_INPUT_GROUP);
Keyboard.on(Keyboard.keymap['MOVE_DOWN'], partial(self.moveCharacter,0,1*self.size), CHARACTER_INPUT_GROUP);
Keyboard.on(Keyboard.keymap['MOVE_UP_RIGHT'], partial(self.moveCharacter,1*self.size,-1*self.size), CHARACTER_INPUT_GROUP);
Keyboard.on(Keyboard.keymap['MOVE_UP_LEFT'], partial(self.moveCharacter,-1*self.size,-1*self.size), CHARACTER_INPUT_GROUP);
Keyboard.on(Keyboard.keymap['MOVE_DOWN_RIGHT'], partial(self.moveCharacter,1*self.size,1*self.size), CHARACTER_INPUT_GROUP);
Keyboard.on(Keyboard.keymap['MOVE_DOWN_LEFT'], partial(self.moveCharacter,-1*self.size,1*self.size), CHARACTER_INPUT_GROUP);
