def __init__(self, screen, map, network, health=100, mana=100):
self.screen = screen
self.map = map
self.ready = False
self.is_centre = False
self.size = (map_module.TILE_PIX_WIDTH, map_module.TILE_PIX_HEIGHT)
self.step = 1
self.mute = 'True'
self.tileset = Tileset(client.player_animation_tileset_path, (3, 4),
(32, 32))
self.blue_tileset = Tileset('assets/tilesets/blue.png', (3, 4),
(32, 32))
self.red_tileset = Tileset('assets/tilesets/red.png', (3, 4), (32, 32))
self.name = ''
self.x, self.y = (0, 0)
self.animation_ticker = 0
self.network = network
self.particle_list = []
self.attached = []
self.particle_limit = 500
self.steptime = 0
self.can_step_ability = True
self.firetime = 0
self.can_fire_ability = True
self.switch_time = 0
self.can_switch_spell = True
self.projSpeed = 1
self.cast_spells = []
self.current_spell = 0
self.spell_limit = 50
initial_position = (0, 0)
self.set_position(initial_position)
self.team = None
self.health = health
self.mana = mana
self.maxMana = mana
self.swim_timer = 0
self.sand_timer = 0
self.move_timer = 0
self.can_swim = True
self.can_sand = True
self.can_move = True
self.font = pygame.font.Font(client.font, 30)
def setup_pygame(self):
# Initialise screen/display
self.screen = pygame.display.set_mode((width, height),
pygame.HWSURFACE)
# Initialise fonts.
pygame.font.init()
# Initialise music
pygame.mixer.init()
# Initialise the joystick.
pygame.joystick.init()
joysticks = [
pygame.joystick.Joystick(x)
for x in range(pygame.joystick.get_count())
]
for joystick in joysticks:
joystick.init()
pygame.event.set_allowed(None)
pygame.event.set_allowed([
pygame.locals.QUIT, pygame.locals.JOYAXISMOTION,
pygame.locals.KEYDOWN
])
self.levels = {"main": ProceduralLevel(42)}
self.map = Map(self.screen, self.levels.get("main"),
Tileset(level_tileset_path, (16, 16), (32, 32)),
LevelMusic('assets/music/song.mp3'))
self.map.music.load_music()
def setup_pygame(self):
# Initialise screen/display
self.screen = pygame.display.set_mode(
(width, height), pygame.HWSURFACE | pygame.DOUBLEBUF)
# Initialise fonts.
pygame.font.init()
# Initialise music
pygame.mixer.init()
# Initialise the joystick.
pygame.joystick.init()
joysticks = [
pygame.joystick.Joystick(x)
for x in range(pygame.joystick.get_count())
]
for joystick in joysticks:
joystick.init()
pygame.event.set_allowed(None)
pygame.event.set_allowed([
pygame.locals.QUIT, pygame.locals.JOYAXISMOTION,
pygame.locals.KEYDOWN, pygame.locals.MOUSEBUTTONDOWN,
pygame.locals.JOYBUTTONDOWN
])
self.levels = {"main": SaveLevel('./assets/maps/CAPFLAG MAP NAT')}
self.map = Map(self.screen, self.levels.get("main"),
Tileset(level_tileset_path, (16, 16), (32, 32)),
LevelMusic('assets/music/whizzersgame.mp3'))
self.map.music.load_music()
def __init__(self, screen, map, colour=(255, 255, 255)):
self.screen = screen
self.map = map
self.ready = False
self.is_centre = False
self.size = (map_module.TILE_PIX_WIDTH, map_module.TILE_PIX_HEIGHT)
self.step = 1
self.colour = colour
self.cast_spells = []
self.spell_limit = 50
self.mute = 'True'
self.tileset = Tileset(client.player_animation_tileset_path, (3, 4), (32, 32))
self.name = ''
self.x, self.y = (0, 0)
self.initial_position = (0, 0)
self.animation_ticker = 0
self.set_position(self.initial_position)
def main(args=None):
parser = get_parser()
args = parser.parse_args(args)
obj_root_dir = Path(args.input)
b3dm_root_path = Path(args.output)
converter = Converter(_obj2gltf_js_path=args._obj2gltf_js_path,
_3d_tiles_tools_js_path=args._3d_tiles_tools_js_path,
_node_path=args._node_path)
geom_error_list = [args.max_geom_error]
geom_error_division_factor = args.geom_error_division_factor
geom_error_list.append(geom_error_list[0] / geom_error_division_factor)
root_transform = args.root_transform
tileset_version = args.tileset_version
if b3dm_root_path.exists() is False:
b3dm_root_path.mkdir()
lod_list = [Lod(dir) for dir in obj_root_dir.iterdir() if dir.is_dir()]
lod_list.sort(key=lambda l: l.total_slices())
for lod in lod_list:
geom_error_list.append(geom_error_list[-1] /
geom_error_division_factor)
if (b3dm_root_path / lod.dir.name).exists() is False:
(b3dm_root_path / lod.dir.name).mkdir()
for tile in lod.tile_list:
b3dm_path = b3dm_root_path / lod.dir.name / tile.get_b3dm_name()
tile.geom_error = geom_error_list[-1]
obj_path = lod.dir / tile.get_obj_name()
tile.geom_box = Box.from_obj_geometry(str(obj_path))
if b3dm_path.exists():
print("UNISCAN: The '.b3dm' of " + lod.dir.name + "/" +
tile.get_name() +
" already exists in export location (" +
str(b3dm_root_path) + ")")
else:
amap_path = lod.dir / tile.get_albedo_map_name()
nmap_path = lod.dir / tile.get_normal_map_name()
converter.write_mtl_data(obj_path)
with tempfile.TemporaryDirectory() as temp_dir:
glb_path = Path(temp_dir) / tile.get_glb_name()
converter.obj_to_glb(obj_path, glb_path, amap_path,
nmap_path)
converter.glb_to_b3dm(glb_path, b3dm_path)
tile_list = Lod.sort_lods_into_tile_tree(lod_list)
world_box = Box.from_joining_box_list(
[tile.geom_box for tile in tile_list])
root_tile = RootTile(world_box, tile_list, 10000, root_transform)
tileset = Tileset("1.0", 100000, root_tile)
with (b3dm_root_path / "tileset.json").open('w') as file:
json.dump(dict(tileset), file, indent=4)
class Player():
def __init__(self, screen, map, colour=(255, 255, 255)):
self.screen = screen
self.map = map
self.ready = False
self.is_centre = False
self.size = (map_module.TILE_PIX_WIDTH, map_module.TILE_PIX_HEIGHT)
self.step = 1
self.colour = colour
self.cast_spells = []
self.spell_limit = 50
self.mute = 'True'
self.tileset = Tileset(client.player_animation_tileset_path, (3, 4), (32, 32))
self.name = ''
self.x, self.y = (0, 0)
self.initial_position = (0, 0)
self.animation_ticker = 0
self.set_position(self.initial_position)
def __raiseNoPosition(self):
raise PlayerException({"message": "Player does not have a position set", "player": self})
def save_to_config(self):
config = configparser.ConfigParser()
config['Player'] = {}
config['Player']['name'] = self.name
config['Player']['x'] = str(self.x)
config['Player']['y'] = str(self.y)
config['Player']['mute'] = str(self.mute)
with open('player_save', 'w') as configfile:
config.write(configfile)
return
def load_from_config(self):
config = configparser.ConfigParser()
config.read('player_save')
if 'Player' in config:
player_save_info = config['Player']
self.set_name(player_save_info['name'])
self.set_position(
(
int(player_save_info['x']),
int(player_save_info['y'])
)
)
self.set_mute(player_save_info.get('mute', 'True'))
return True
return False
def set_name(self, name, save = False):
self.name = name
if save: self.save_to_config()
def set_tileset(self, tileset):
self.tileset = tileset
def set_position(self, position):
# Derive direction (for networked players)
if self.x < position[0]:
self.animation_ticker = self.tileset.find_id(self.x % 3, 2)
elif self.x > position[0]:
self.animation_ticker = self.tileset.find_id(self.x % 3, 1)
if self.y < position[1]:
self.animation_ticker = self.tileset.find_id(self.y % 3, 0)
elif self.y > position[1]:
self.animation_ticker = self.tileset.find_id(self.y % 3, 3)
self.x, self.y = position
self.ready = True
def set_mute(self, mute, save = False):
self.mute = mute
if save: self.save_to_config()
def render(self):
font = pygame.font.Font(client.font, 30)
name_tag = font.render(self.name, False, (255, 255, 255))
centre = self.map.get_pixel_pos(self.x, self.y)
name_tag_pos = (
centre[0] + ((self.size[0] - name_tag.get_width()) // 2),
centre[1] - ((self.size[1] + name_tag.get_height()) // 2)
)
self.screen.blit(name_tag, name_tag_pos)
sprite = self.tileset.get_surface_by_id(self.animation_ticker)
self.screen.blit(sprite, centre)
# create collision rectangle
self.rect = sprite.get_rect()
self.rect.topleft = centre
def move(self, direction):
if not self.ready:
self.__raiseNoPosition()
tmp_x = self.x
tmp_y = self.y
if direction == Movement.UP:
tmp_y -= self.step
elif direction == Movement.DOWN:
tmp_y += self.step
if direction == Movement.RIGHT:
tmp_x += self.step
elif direction == Movement.LEFT:
tmp_x -= self.step
if not self.map.level.can_move_to(tmp_x, tmp_y):
return
self.set_position(Position(tmp_x, tmp_y))
def get_position(self):
if not self.ready:
self.__raiseNoPosition()
return Position(self.x, self.y)
def attack(self, action, direction):
if action == Action.SPELL:
if direction == Movement.UP:
spell = Spell(self, (0, -0.25))
elif direction == Movement.RIGHT:
spell = Spell(self, (0.25, 0))
elif direction == Movement.DOWN:
spell = Spell(self, (0, 0.25))
elif direction == Movement.LEFT:
spell = Spell(self, (-0.25, 0))
# Remove first element of list if limit reached.
if len(self.cast_spells) > self.spell_limit:
self.cast_spells[1:]
self.cast_spells.append(spell)
elif action == Action.SWIPE:
#TODO
return
class Player():
def __init__(self, screen, map, network, health=100, mana=100):
self.screen = screen
self.map = map
self.ready = False
self.is_centre = False
self.size = (map_module.TILE_PIX_WIDTH, map_module.TILE_PIX_HEIGHT)
self.step = 1
self.mute = 'True'
self.tileset = Tileset(client.player_animation_tileset_path, (3, 4),
(32, 32))
self.blue_tileset = Tileset('assets/tilesets/blue.png', (3, 4),
(32, 32))
self.red_tileset = Tileset('assets/tilesets/red.png', (3, 4), (32, 32))
self.name = ''
self.x, self.y = (0, 0)
self.animation_ticker = 0
self.network = network
self.particle_list = []
self.attached = []
self.particle_limit = 500
self.steptime = 0
self.can_step_ability = True
self.firetime = 0
self.can_fire_ability = True
self.switch_time = 0
self.can_switch_spell = True
self.projSpeed = 1
self.cast_spells = []
self.current_spell = 0
self.spell_limit = 50
initial_position = (0, 0)
self.set_position(initial_position)
self.team = None
self.health = health
self.mana = mana
self.maxMana = mana
self.swim_timer = 0
self.sand_timer = 0
self.move_timer = 0
self.can_swim = True
self.can_sand = True
self.can_move = True
self.font = pygame.font.Font(client.font, 30)
def __raiseNoPosition(self):
raise PlayerException({
"message":
"Everything is lava: Player does not have a position set",
"player": self
})
def save_to_config(self):
config = configparser.ConfigParser()
config['Player'] = {}
config['Player']['name'] = self.name
config['Player']['mute'] = str(self.mute)
with open('player_save', 'w') as configfile:
config.write(configfile)
return
def load_from_config(self):
config = configparser.ConfigParser()
config.read('player_save')
if 'Player' in config:
player_save_info = config['Player']
self.network.node.set_header('NAME', self.name)
self.set_name(player_save_info['name'])
self.set_mute(player_save_info.get('mute', 'True'))
return True
return False
def set_name(self, name, save=False):
self.name = name[:14]
if save:
self.network.node.shout("player:name",
bson.dumps({"name": self.name}))
self.save_to_config()
def set_tileset(self, tileset):
self.tileset = tileset
def set_position(self, position):
# Derive direction (for networked players)
if self.x < position[0]:
self.animation_ticker = self.tileset.find_id(self.x % 3, 2)
elif self.x > position[0]:
self.animation_ticker = self.tileset.find_id(self.x % 3, 1)
if self.y < position[1]:
self.animation_ticker = self.tileset.find_id(self.y % 3, 0)
elif self.y > position[1]:
self.animation_ticker = self.tileset.find_id(self.y % 3, 3)
self.x, self.y = position
self.ready = True
def set_mute(self, mute, save=False):
self.mute = mute
if save: self.save_to_config()
def change_spell(self):
if (self.current_spell == 5):
self.current_spell = 0
else:
self.current_spell += 1
def hudRender(self):
font = pygame.font.Font(client.font, 30)
mana = font.render("Mana: " + str(self.mana) + "/100", False,
(255, 255, 255))
health = font.render("Health: " + str(self.health) + "/100", False,
(255, 255, 255))
spell = font.render(
"Current Spell: " + str(Action.get_action(self.current_spell))[7:],
False,
(255, 255,
255)) # Removes first 7 characters off enum as we dont need them.
hudObjects = [mana.get_width(), health.get_width(), spell.get_width()]
rect = pygame.Surface((max(hudObjects) + 20, 75), pygame.SRCALPHA, 32)
rect.fill((0, 0, 0, 255))
self.screen.blit(rect, (0, 0))
self.screen.blit(mana, (10, 0))
self.screen.blit(health, (10, 25))
self.screen.blit(spell, (10, 50))
def render(self, isMe=False):
font = self.font
name_tag_colour = (255, 255, 255)
if self.team:
if self.team == "blue":
name_tag_colour = (0, 191, 255)
self.tileset = self.blue_tileset
elif self.team == "red":
name_tag_colour = (255, 0, 0)
self.tileset = self.red_tileset
name_tag = font.render(self.name, False, name_tag_colour)
centre = self.map.get_pixel_pos(self.x, self.y)
name_tag_pos = (centre[0] + ((self.size[0] -
(name_tag.get_width() + 10)) // 2),
centre[1] -
((self.size[1] + name_tag.get_height()) // 2))
rect = pygame.Surface(
(name_tag.get_width() + 10, name_tag.get_height()),
pygame.SRCALPHA, 32)
rect.fill((0, 0, 0, 160))
self.screen.blit(rect, name_tag_pos)
name_tag_pos = (centre[0] +
((self.size[0] - name_tag.get_width()) // 2),
centre[1] -
((self.size[1] + name_tag.get_height()) // 2))
self.screen.blit(name_tag, name_tag_pos)
sprite = self.tileset.get_surface_by_id(self.animation_ticker)
self.screen.blit(sprite, centre)
# create collision rectangle
self.rect = sprite.get_rect()
self.rect.topleft = centre
for attached_sprite in self.attached:
attached_sprite.set_position((self.x, self.y))
self.render_particles()
if isMe:
if self.map.level.get_tile(self.x, self.y).has_attribute(
TileAttribute.SPIKES):
self.deplete_health(5)
spawnAttribute = None
if self.team:
if self.team == "blue":
spawnAttribute = TileAttribute.BSPAWN
elif self.team == "red":
spawnAttribute = TileAttribute.RSPAWN
if spawnAttribute and self.map.level.get_tile(
self.x, self.y).has_attribute(spawnAttribute):
self.addMana(1)
self.increase_health(1)
self.hudRender()
def render_particles(self):
toRemove = []
for particle in self.particle_list:
pixel_pos = self.map.get_pixel_pos(particle["position"][0],
particle["position"][1])
if particle["life"] <= 0:
toRemove.append(particle)
particle["life"] -= 1
pygame.draw.circle(self.screen, particle["colour"],
(int(pixel_pos[0]), int(pixel_pos[1])),
int(particle["size"]), particle["metadata"])
particle["position"] = (particle["position"][0] +
particle["velocity"][0],
particle["position"][1] +
particle["velocity"][1])
particle["velocity"] = (particle["velocity"][0] +
particle["gravity"][0],
particle["velocity"][1] +
particle["gravity"][1])
particle["size"] += particle["grow"]
for p in toRemove:
self.remove_particle(p)
def move(self, direction):
if not self.ready:
self.__raiseNoPosition()
c = (255, 255, 255)
if self.team:
if self.team == "blue":
c = (0, 0, 255)
elif self.team == "red":
c = (255, 0, 0)
tmp_x = 0
tmp_y = 0
if self.map.level.get_tile(self.x, self.y).has_attribute(
TileAttribute.SWIM) and self.can_swim:
self.swim_timer = time.time()
self.sand_timer = time.time()
self.move_timer = time.time()
self.can_swim = False
elif self.map.level.get_tile(self.x, self.y).has_attribute(
TileAttribute.SWIM) and not self.can_swim:
return
elif self.map.level.get_tile(self.x, self.y).has_attribute(
TileAttribute.SLOW) and self.can_sand:
self.swim_timer = time.time()
self.sand_timer = time.time()
self.move_timer = time.time()
self.can_sand = False
elif self.map.level.get_tile(self.x, self.y).has_attribute(
TileAttribute.SLOW) and not self.can_sand:
return
elif self.can_move:
self.swim_timer = time.time()
self.sand_timer = time.time()
self.move_timer = time.time()
self.can_move = False
else:
return
id = self.map.level.get_tile(self.x, self.y).tileset_id[0]
c = self.map.tileset.get_average_colour(id)
# while (can keep moving) and (x difference is not more than step) and (y difference is not more than step)
while self.map.level.can_move_to(
self.x + tmp_x, self.y +
tmp_y) and abs(tmp_x) <= self.step and abs(tmp_y) <= self.step:
# amount, position, colour,size,velocity,gravity,life,metadata,grow
self.add_particle(3, (self.x + tmp_x + 0.5, self.y + tmp_y + 0.9),
c, 3, None, (-tmp_x / 1000, -tmp_y / 1000), 5, 2,
0.1)
if direction == Movement.RIGHT:
tmp_x += 1
elif direction == Movement.LEFT:
tmp_x -= 1
if direction == Movement.UP:
tmp_y -= 1
elif direction == Movement.DOWN:
tmp_y += 1
if tmp_x != 0:
tmp_x += (-1 if tmp_x > 0 else 1)
if tmp_y != 0:
tmp_y += (-1 if tmp_y > 0 else 1)
self.set_position(Position(self.x + tmp_x, self.y + tmp_y))
def get_position(self):
if not self.ready:
self.__raiseNoPosition()
return Position(self.x, self.y)
def attack(self, direction, position=None):
spell = Action.get_action(self.current_spell)
image = client.projectile_images[self.current_spell]
if self.mana >= spell.mana_cost:
if direction == Movement.UP:
spell = Spell(self, (0, -self.projSpeed), image, position)
elif direction == Movement.RIGHT:
spell = Spell(self, (self.projSpeed, 0), image, position)
elif direction == Movement.DOWN:
spell = Spell(self, (0, self.projSpeed), image, position)
elif direction == Movement.LEFT:
spell = Spell(self, (-self.projSpeed, 0), image, position)
else:
spell = Spell(self, direction, image, position)
# Remove first element of list if limit reached.
if len(self.cast_spells) > self.spell_limit:
self.cast_spells[1:]
self.cast_spells.append(spell)
return True
else:
return False
def remove_spell(self, spell):
self.cast_spells.remove(spell)
return
def set_team(self, team):
self.team = team
def add_particle(self,
amount,
position,
colour=(255, 255, 255),
size=3,
velocity=None,
gravity=(0, 0),
life=40,
metadata=0,
grow=0):
for i in range(amount):
if (len(self.particle_list) >= self.particle_limit):
self.remove_particle(self.particle_list[0])
newParticle = {
"position": position,
"velocity": velocity,
"gravity": gravity,
"colour": colour,
"size": size,
"life": life,
"metadata": metadata,
"grow": grow
}
i = 1000
if velocity != None:
newParticle["velocity"] = velocity
else:
newParticle["velocity"] = (random.randrange(-i, i) / (i * 10),
random.randrange(-i, i) / (i * 10))
self.particle_list.append(newParticle)
def remove_particle(self, particle):
self.particle_list.remove(particle)
return
def increase_health(self, amount):
self.health = min(100, self.health + amount)
def deplete_health(self, amount):
self.health -= amount
if self.health <= 0:
self.die()
def die(self): # Don't get confused with `def` and `death`!!! XD
self.health = 100
self.mana = 100
self.can_step_ability = True
self.network.node.whisper(UUID(self.network.authority_uuid),
bson.dumps({'type': 'death_report'}))
def addMana(self, amount):
if self.mana + amount > 100:
return
self.mana += amount
def depleatMana(self, amount):
self.mana -= amount