def __init__(self, screen):
sprite_sheet = pygame.image.load('enemy_sprite_sheet.png')
self.screen = screen
#Create the player's characters
self.player_characters = []
for i in range(5):
character = sprite.Sprite('characters/syclich.txt', sprite_sheet, screen, False)
self.player_characters.append(character)
#Set player characters in position
player_back_row_x = 50
player_back_row_y = 300
player_rise = 200
player_run = 50
for i in range(2):
self.player_characters[i].rect.x = player_back_row_x + i*player_run
self.player_characters[i].rect.y = player_back_row_y - i*player_rise
player_front_row_x = 200
player_front_row_y = 500
for i in range(2,5):
self.player_characters[i].rect.x = player_front_row_x + (i-2)*player_run
self.player_characters[i].rect.y = player_front_row_y - (i-2)*player_rise
#Create enemy characters
self.enemy_characters = []
for i in range(5):
character = sprite.Sprite('characters/lobo.txt', sprite_sheet, screen, True)
self.enemy_characters.append(character)
#Select first enemy character
self.selected_index = 0
self.enemy_characters[self.selected_index].selected = True
#Set enemy characters in position
enemy_back_row_x = 950
enemy_back_row_y = 300
enemy_rise = 200
enemy_run = -50
for i in range(2):
self.enemy_characters[i].rect.x = enemy_back_row_x + i*enemy_run
self.enemy_characters[i].rect.y = enemy_back_row_y - i*enemy_rise
enemy_front_row_x = 800
enemy_front_row_y = 500
for i in range(2,5):
self.enemy_characters[i].rect.x = enemy_front_row_x + (i-2)*enemy_run
self.enemy_characters[i].rect.y = enemy_front_row_y - (i-2)*enemy_rise
#Variables to keep track of animation
self.animating = False
self.animation_phase = 0
self.animation_countdown = 0
self.target_coords = (0,0)
self.target = None
self.animation_list = []
def __init__(self):
self._hp_logo = sprite.Sprite()
self._hp_logo.load("graphics/menu/hp_logo.bmp")
self._hp_logo.set_color_key()
self._tps_logo = sprite.Sprite()
self._tps_logo.load("graphics/menu/tps_logo.bmp")
self._tps_logo.set_color_key()
self._tps_logo_bkg = sprite.Sprite()
self._tps_logo_bkg.load("graphics/menu/tps_logo_bkg.bmp")
def __init__(self, loc, name):
## Unique object ID
self.id = constants.globalId
constants.globalId += 1
## Name of object, used to look up the sprite.
self.name = name
## Faction of object, for use in reacting to collisions
self.faction = name
## Location of the object
self.loc = loc
## Current velocity of the object
self.vel = Vector2D(0, 0)
## True if gravity should be applied during the update cycle.
self.isGravityOn = True
## Acceleration due to gravity, added to self.vel each update cycle.
self.gravity = defaultGravity.copy()
## Maximum velocity in X and Y directions (handled separately)
self.maxVel = defaultMaxVel.copy()
## Controls if we limit self.vel to be less than self.maxVel
self.shouldApplyVelocityCap = True
## Direction object is facing (1: right, -1: left)
self.facing = 1
## Sprite for animations and bounding polygons
self.sprite = sprite.Sprite(name, self, self.loc)
## List of collisions received since the last update cycle.
self.collisions = []
## Damage to do to other objects on contact.
self.touchDamage = 0
## Damage that can be sustained before discorporating
self.health = constants.BIGNUM
## Current state for movement logic
self.state = objectstate.ObjectState(self)
def load(self, location):
f = open(location, 'rb')
self.g_width = struct.unpack('<h', f.read(2))[0]
self.g_height = struct.unpack('<h', f.read(2))[0]
self.sprite_bank = []
bank_end = False
while not bank_end:
sprite_name = f.read(32).replace('\0', '')
if sprite_name == '-'*32:
bank_end = True
continue
if sprite_name != '':
self.sprite_bank += [sprite.Sprite('SPRITES\\compiled\\%s.sprite' % sprite_name)]
# f.seek(16388, 0)
self.grid = []
for tile_index in range(self.g_width*self.g_height):
data = f.read(2)
tile_pointer = struct.unpack('<h', data)[0]
if tile_pointer < len(self.sprite_bank):
self.grid += [tile_pointer]
else:
self.grid += [-1]
f.close()
def __init__(self,
ID,
x,
y,
points,
colour1=(200, 200, 200),
colour2=(255, 255, 255)):
self.scale_factor = [6, 3] #[0] = width, [1] = height
width = 4
height = 56
bar_outline = sprite.Sprite(universal_var.main_sprite, x, y,
width * self.scale_factor[0],
height * self.scale_factor[1],
[(universal_var.main_sprite,
[universal_var.misc_images['bar']], 1)])
super().__init__(ID, x, y, [bar_outline], None, False, width, height)
self.display_layer = 5
self.points = points
self.original_points = points
self.energy_rect_width = width #rect refers to energy bar that's coloured
self.energy_rect_height = height
self.colour1 = colour1
self.colour2 = colour2
self.all_timers.add_ID('time_till_increment', 2)
self.all_timers.add_ID('play_sound', 3)
def __init__(self, gridLoc, terrain, orientation, subType=None):
## Location in gridspace
self.gridLoc = gridLoc
## Location in realspace
self.loc = gridLoc.toRealspace()
## There are currently 20 different block orientations, most of which
# have a square collision polygon.
self.orientation = orientation
## TerrainInfo instance to let the block know what it looks like.
self.terrain = terrain
imagePath = os.path.join('terrain', self.terrain.zone,
self.terrain.region, 'blocks')
## To allow blocks to be animated, we use Sprites for drawing them.
self.sprite = sprite.Sprite(imagePath, self, self.loc, False)
self.sprite.setAnimation(self.orientation, False)
## Purely graphical variation on the block.
self.subType = subType
if self.subType is None:
anim = self.sprite.getCurrentAnimationObject()
self.subType = random.choice(range(0, len(anim.frames) + 1))
## Bounding rect
self.rect = self.sprite.getBounds(self.loc)
def EntityLoop():
global Players, name
deleteItems = []
for item in Items:
image = sprite.Player(screen, (0, 0, 0), 50, item.x - scrollX + 25,
item.y - scrollY + 25, True, 0, item.degrees)
image.image = itemImages[itemIDs[item.ID]]
image.update()
item.degrees += 1
if round(player.x) > image.x - 50 and round(player.x) < image.x + 50:
if round(player.y) > image.y - 50 and round(
player.y) < image.y + 50:
item.pickUp()
deleteItems.append(item)
for item in deleteItems:
DeleteItemAsync(item)
Items.remove(item)
for Player in Players:
if Player.name != name:
image = sprite.Sprite(screen, (0, 0, 0), 50, Player.x - scrollX,
Player.y - scrollY)
image.updateImage()
sprite.text(str(Player.name),
Player.x - scrollX - ((len(Player.name) * 20) / 2),
Player.y - scrollY - 40)
def __init__(self, x, y, direction="right"):
width = 86
height = 175
gate_open = [
universal_var.prop_images['gate_1'],
universal_var.prop_images['gate_2'],
universal_var.prop_images['gate_3'],
universal_var.prop_images['gate_4'],
universal_var.misc_images['blank']
]
gate_close = gate_open[::-1]
gate_sprite = sprite.Sprite(
universal_var.main_sprite, x, y, width, height,
[('gate_open', gate_open, 22), ('gate_close', gate_close, 22),
('gate_idle', [universal_var.prop_images['gate_1']], 22)])
super().__init__("gate", x, y, [gate_sprite], None, True, width,
height)
self.x = x
self.y = y
self.transition_collbox = camera.Transition_box('gate_tbox',
x + 30,
y,
direction=direction)
self.play_gate_sound = True
def move(self):
"""
Method for bullet movement. The movement distance is calculated by the elapsed time since the last call
and the speed as defined at instance creation.
:returns:
"""
time_delta = self._timer.get_delta()
vector_delta = time_delta * self._speed
self._position = project_point(self._position[0], self._position[1],
self._direction, vector_delta)
self._rect = pygame.Rect(self._position[0] - self._image_size[0] / 2,
self._position[1] - self._image_size[1] / 2,
self._image_size[0], self._image_size[1])
if self._param_dict["has_trail"]:
self._trail = sprite.Sprite(
self._trail_image.extract_by_height(vector_delta + 2))
#Projekt the center of the trail sprite so it is right behind the rocket
new_center = project_point(
self._rect.center[0], self._rect.center[1],
self._shift_direction,
floor(self._original_size_y / 2) + floor(vector_delta / 2))
self._trail.rotate(self._direction)
self._trail.set_center(new_center[0], new_center[1])
def __init__(self):
self._mapx = 0;
self._mapy = 0;
self._portals = None;
self._background = sprite.Sprite();
self._background.load("graphics/rooms/courtyard.bmp");
def __init__(self):
self._mapx = 572
self._mapy = 5742
self._portals = portals.Portal()
self._background = sprite.Sprite()
self._background.load("graphics/rooms/hallways.bmp")
def __init__( s, screen, level, teams ):
cfg = loader.cfgloader.get( level )
s.screen = screen
s.level = level
s.map = map.Map( cfg['map'] )
s.teams = teams
s.cursorSprite = sprite.Sprite( "cursor.sprite" )
s.cursorSprite.setAnim( "normal" )
def init_graphics(self):
for i in range(30):
tile = int(math.fmod(i, 2))
sp = sprite.Sprite(
test_image_load.name_map[objects.tiles.name(tile)],
x=i * 8,
y=i * 8,
z=-i,
batch=self.batch)
self.list_sprites.append(sp)
self.pointer = sprite.Sprite(test_image_load.name_map["WALL_WOOD"],
x=0,
y=0,
z=0,
group=groups.floor,
batch=self.batch)
def load_sprites():
global sprite_bank
for f in os.listdir("SPRITES\\compiled\\"):
if f.endswith(".sprite"):
sprite_bank += [sprite.Sprite('SPRITES\\compiled\\%s' % f)]
keep_sprites = ['CHAR_CART']
for i in range(len(sprite_bank)):
if sprite_bank[i].sprite_name in keep_sprites:
sprite_bank[i].keep_in_bank = True
def t_init(g,r,n,hit_groups,hit,*params):
t = sprite.Sprite(r,n)
for grp in hit_groups: t.hit_groups.add(grp)
def _hit(g,a,b):
return hit(g,a,b,*params)
t.hit = _hit
t.standable = 0
if len(params) > 0:
t.standable = params[0]
g.layer[r.centery/TH][r.centerx/TW] = t
return t
def __init__(self, x, y, colour, window, player_number):
self.previous_positions = [] #The last few positions it has been in
self.previous_inputs = [] #The last few inputs the player recieved
self.current_input = Player_Input(
0, 0, 0, 0, 0, 0, 0) #The current Input it thinks it has
self.current_position = Positional_Data(x, y, 0,
state.alive) #Current position
self.sprite = sprite.Sprite((x, y), sprite.drawCircle, (window, 3),
colour)
self.player_number = player_number
def create_sprite(self, name):
name = str(name)
if self.sprite_controller.get_sprite(name) is not False:
raise Exception(f'Sprite {name} already exists.')
sprite_id = len(self.sprite_controller.list_of_sprites)
new_spite = sprite.Sprite(sprite_id, name)
self.sprite_controller.list_of_sprites.append(new_spite)
return new_spite
def __init__(self, loc, action, spriteName, animationName, frameNum=0):
## Draw location on the screen
self.loc = loc
## Action to perfom if clicked
self.action = action
## Required to use sprites
self.facing = 1
## Sprite for drawing and mouse picking.
self.sprite = sprite.Sprite(spriteName, self)
self.sprite.setAnimation(animationName, False)
animation = self.sprite.getCurrentAnimationObject()
animation.frame = frameNum
animation.prevFrame = frameNum
def make(root, dataset, actions):
frame_number = 20
frame_size = (64, 64)
fps = 60
fmt = cv2.VideoWriter_fourcc('m', 'p', '4', 'v')
if os.path.exists(root):
shutil.rmtree(root)
os.makedirs(root)
else:
os.makedirs(root)
label_dict = { 'Action label' : {}, 'Video label' : {} }
camera_ = camera.Camera(frame_size)
for action_label, action_class in enumerate(actions):
action = action_class(sprite.Sprite(np.zeros((1, 1))))
action_name = action.__class__.__name__
label_dict['Action label'][action_name] = action_label
video_i = 0
total = len(dataset) * len(actions)
progress = tqdm(total=total, desc='Converting')
for image, label in dataset:
image = np.array(image, dtype=np.uint8)
sprite_ = sprite.Sprite(image)
for action_label, action_class in enumerate(actions):
action = action_class(sprite_)
action_name = action.__class__.__name__
video_i += 1
video_name = f'{video_i}.mp4'
video_path = f'{root}/{video_name}'
writer = cv2.VideoWriter(video_path, fmt, fps, frame_size, False)
action.start(frame_number, frame_size[1], frame_size[0])
for _ in range(frame_number):
action.update()
writer.write(camera_.rendering(sprite_))
writer.release()
label_dict['Video label'][video_name] = action_name
progress.update(1)
with open(f'{root}/0.toml', mode='w') as f:
toml.dump(label_dict, f)
def __init__(self, id, name, x, y):
self.name = name
self.id = id
self.sprite = sprite.Sprite("test")
self.player = 0
self.x = x
self.y = y
print x,y,self.x,self.y
self.moveQueue = MoveQueue(self)
def get_sprite(image_name, r, c):
if image_name == 'spike_trap':
s = sprite.AnimatedSprite(screen, c * size, r * size,
spike_floor_frames, 20)
elif image_name == 'wall_fountain_mid_red':
s = sprite.AnimatedSprite(screen, c * size, r * size,
fountain_mid_red_frames, 15)
elif image_name == 'wall_fountain_basin_red':
s = sprite.AnimatedSprite(screen, c * size, r * size, basin_red_frames,
15)
else:
s = sprite.Sprite(screen, c * size, r * size, images[image_name])
return s
def __init__(self):
width = 60
height = 50
x, y = 0, 0
concrete_shot_liquid = [
universal_var.projectiles['concrete_shot_1'],
universal_var.projectiles['concrete_shot_2']
]
concrete_shot_solid = [
universal_var.projectiles['concrete_block_1'],
universal_var.projectiles['concrete_block_2']
]
concrete_shatter = [
universal_var.projectiles['concrete_block_3'],
universal_var.projectiles['concrete_block_4']
]
bullet_sprite = sprite.Sprite(
universal_var.main_sprite, x, y, width, height,
[('concrete_shot_liquid', concrete_shot_liquid, 6),
('concrete_shot_solid', concrete_shot_solid, 6),
('concrete_block_shatter', concrete_shatter, 14)])
main_coll_box = sprite.Collision_box(universal_var.hitbox,
0,
0,
width - 20,
height - 17, (240, 240, 0),
x_offset=10)
ground_collbox = sprite.Collision_box('ground_collbox',
x,
y,
width - 30,
15, (150, 180, 100),
x_offset=15,
y_offset=height - 17)
super().__init__('Enemy_projectile_1',
x,
y, [bullet_sprite], [main_coll_box, ground_collbox],
width=width,
height=height,
display_layer=4)
self.damage_points = 13
self.grounded = False
self.solidified = False
self.is_shattered = False
self.all_timers = Timer()
self.all_timers.add_ID('shatter', 28)
Concrete_shot.all_p_stack.push(self)
Concrete_shot.add_to_class_lst(self, Concrete_shot.all_p_lst, self.ID)
def __init__(self, name):
self.sprite = sprite.Sprite(
os.path.join('effects', 'environments', name), self)
## All spaces that have the effect.
self.spaces = set()
## Name of the effect, which is the same as the module name for the
# effect's code (and not necessarily the same as the class in that
# module!).
self.name = name
## Dict of game objects currently in the effect.
self.residentObjects = dict()
## Dict of game objects that we handled this frame.
self.handledObjects = dict()
def __init__(self,
engine,
arquivo,
animado,
fps=15,
quadros=[1, 1],
colorkey=[255, 0, 255]):
self.engine = engine
self.updatetime = 0
self.fps = fps
self.sprite = sprite.Sprite(engine, arquivo, quadros, colorkey)
self.anim_range = self.sprite.frame_range
self.quadroat = 1
self.animado = animado
def constructMap(filename):
# Dictionary mapping tileset abbreviations to file names
image_dict = {
'empt': 'tile-clear.png',
'hole': 'tile-hole.png',
'1wl ': 'tile-wall-1a.png',
'1wu ': 'tile-wall-1b.png',
'1wr ': 'tile-wall-1c.png',
'1wd ': 'tile-wall-1d.png',
'chek': 'tile-hammer-wrench.png',
'cv1d': 'tile-conveyor-1a.png',
'cv1l': 'tile-conveyor-1b.png',
'cv1u': 'tile-conveyor-1c.png',
'cv1r': 'tile-conveyor-1d.png',
'cvlr': 'tile-conveyor-1-turnleft_a.png',
'cvld': 'tile-conveyor-1-turnleft_b.png',
'cvll': 'tile-conveyor-1-turnleft_c.png',
'cvlu': 'tile-conveyor-1-turnleft_d.png',
'cvrr': 'tile-conveyor-1-turnright_a.png',
'cvrd': 'tile-conveyor-1-turnright_b.png',
'cvrl': 'tile-conveyor-1-turnright_c.png',
'cvru': 'tile-conveyor-1-turnright_d.png',
'2wur': 'tile-wall-2a.png',
'2wrd': 'tile-wall-2b.png',
'2wdl': 'tile-wall-2c.png',
'2wlu': 'tile-wall-2d.png'
}
# Open file to read in text representation of the map
file_handle = open(filename, 'r')
line = file_handle.readline()
line = line.strip()
images = [] # 2d array of sprites
board = [] # 2d array of tile names
while line:
array = line.split(',')
row_array_img = []
row_array_name = []
for i in range(len(array)):
img = pygame.image.load('tiles/' + image_dict[array[i]])
# Scale image
img = pygame.transform.scale(img, (tile_width, tile_height))
row_array_img.append(
sprite.Sprite(i * tile_width,
len(images) * tile_width, img))
row_array_name.append(array[i])
images.append(row_array_img)
board.append(row_array_name)
line = file_handle.readline()
line = line.strip()
return images, board
def __init__(s, cfgfile):
cfg = loader.cfgloader.get(cfgfile)
s.cfgfile = cfgfile
s.name = cfg['name']
s.cls = cfg['class']
s.movement = cfg['movement']
s.movementMode = cfg['movementMode']
s.maxhp = cfg['maxhp']
s.hp = s.maxhp
s.strength = cfg['strength']
s.magic = cfg['magic']
s.speed = cfg['speed']
s.skill = cfg['skill']
s.luck = cfg['luck']
s.defense = cfg['defense']
s.mdefense = cfg['mdefense']
s.constitution = cfg['constitution']
s.hpg = cfg['hpg']
s.strengthg = cfg['strengthg']
s.magicg = cfg['magicg']
s.speedg = cfg['speedg']
s.skillg = cfg['skillg']
s.luckg = cfg['luckg']
s.defenseg = cfg['defenseg']
s.mdefenseg = cfg['mdefenseg']
s.weaponType = cfg['weaponType']
s.sword = cfg['sword']
s.axe = cfg['axe']
s.spear = cfg['spear']
s.bow = cfg['bow']
s.light = cfg['light']
s.dark = cfg['dark']
s.anima = cfg['anima']
s.staff = cfg['staff']
s.experience = cfg['experience']
s.level = cfg['level']
s.promotedcls = cfg['promotedcls']
s.items = []
s.equippedWeapon = 0
s.portraitFile = cfg['portraitFile']
s.spriteFile = cfg['spriteFile']
s.portrait = loader.imgloader.get(s.portraitFile)
s.sprite = sprite.Sprite(s.spriteFile)
s.sprite.setAnim('standAnim')
def t_init(g, r, n, hit_groups, hit,
*params): #MYNOTE t_init(g,pygame.Rect(x*TW,y*TH,TW,TH),n,[],None)
t = sprite.Sprite(r, n)
for grp in hit_groups:
t.hit_groups.add(grp)
def _hit(g, a, b):
return hit(g, a, b, *params)
t.hit = _hit
t.standable = 0
if len(params) > 0:
t.standable = params[0]
g.layer[r.centery / TH][r.centerx / TW] = t
return t #MYNOTE add the sprite into game.layer
def __init__(self):
sprite.Sprite.__init__(self)
"""
Create new paddle instance - actually two paddles mashed together
"""
self.width = 100
self.height = 5
self.drag = 5
self.timer = 0
self.flicker = 0
self.left_paddle = sprite.Sprite()
self.right_paddle = sprite.Sprite()
self.left_paddle.x = 10
self.left_paddle.y = 440
self.right_paddle.y = 440
self.left_paddle.width = 50
self.right_paddle.width = 50
self.right_paddle.x = self.left_paddle.x + self.left_paddle.width
self.left_paddle.max = 15
self.right_paddle.max = 15
self.left_paddle.height = 5
self.right_paddle.height = 5
self.split_timer = 0
self.number_of_powerups = 0
self.powerup = None
self.shot = None
# sound effects
self.sound_gameover = pygame.mixer.Sound('./breakout/gameover.ogg')
self.sound_powerup = pygame.mixer.Sound('./breakout/powerup.ogg')
self.sound_bounce = pygame.mixer.Sound('./breakout/bounce.ogg')
self.sound_rebuild = pygame.mixer.Sound('./breakout/rebuild.ogg')
self.sound_open = pygame.mixer.Sound('./breakout/open.ogg')
self.sound_shrink = pygame.mixer.Sound('./breakout/shrink.ogg')
self.sound_heal = pygame.mixer.Sound('./breakout/heal.ogg')
def __init__(self):
self.clock = pygame.time.Clock()
self.fps = 60
self.sprite_fps = 1
self.set_framerate(1)
self.surface = pygame.display.set_mode((400, 430), pygame.RESIZABLE)
self.running = True
self.test = spritesheet.load("cube.png", (34, 36))
self.sprite = sprite.Sprite(self.test)
self.backdrop = menu.BackDrop()
self.main_loop()
def getSprite(sprite_name, r, c, images, inset, buffer):
if sprite_name == 'wall_fountain_mid_red':
return sprite.AnimatedSprite(screen, inset + c * size,
r * size + buffer,
fountain_mid_red_frames, 15)
elif sprite_name == 'wall_fountain_basin_red':
return sprite.AnimatedSprite(screen, inset + c * size,
r * size + buffer, basin_red_frames, 15)
elif sprite_name == 'spike_trap':
return sprite.AnimatedSprite(screen, inset + c * size,
r * size + buffer, spike_floor_frames, 20)
elif sprite_name == '':
return None
else:
return sprite.Sprite(screen, inset + c * size, r * size + buffer,
images[sprite_name])
