Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- from collections import defaultdict
- import tmx
- from cymunk.cymunk import Vec2d
- from kivent_maps.map_utils import _load_obj_models, _load_tile_map, _load_tile_properties
- from kivent_maps.map_utils import _load_tilesets
- from kivy.app import App, platform
- from kivy.core.window import Window, Keyboard
- from kivy.clock import Clock
- from kivy.uix.widget import Widget
- from kivy.properties import StringProperty
- from kivent_core.managers.resource_managers import texture_manager
- from os.path import dirname, join, abspath, basename
- from kivent_maps import map_utils
- import kivent_cymunk
- from kivent_maps.map_system import MapSystem
- Window.size = (1600, 900)
- def get_asset_path(asset, asset_loc):
- return join(dirname(dirname(abspath(__file__))), asset_loc, asset)
- keys = defaultdict(lambda: False)
- texture_manager.load_atlas(join(dirname(dirname(abspath(__file__))), 'assets',
- 'background_objects.atlas'))
- class Game(Widget):
- def __init__(self, **kwargs):
- super(Game, self).__init__(**kwargs)
- map_render_args = {'zones': ['general'], 'frame_count': 2, 'gameview': 'camera1',
- 'shader_source': get_asset_path('positionshader.glsl', 'assets/glsl')}
- map_anim_args = {'zones': ['general'], }
- map_poly_args = {'zones': ['general'], 'frame_count': 2, 'gameview': 'camera1',
- 'shader_source': 'poscolorshader.glsl'}
- self.map_layers, self.map_layer_animators = map_utils.load_map_systems(
- 4, self.gameworld, map_render_args, map_anim_args, map_poly_args)
- self.moving = False
- self.gameworld.init_gameworld(
- ['cymunk_physics', 'position', 'color', 'camera1', 'tile_map']
- + self.map_layers + self.map_layer_animators, callback=self.init_game)
- def parse_tmx(self, filename, gameworld):
- '''
- Uses the tmx library to load the TMX into an object and then calls all the
- util functions with the relevant data.
- Args:
- filename (str): Name of the tmx file.
- gameworld (Gameworld): instance of the gameworld.
- Return:
- str: name of the loaded map which is the filename
- '''
- texture_manager = gameworld.managers['texture_manager']
- model_manager = gameworld.managers['model_manager']
- map_manager = gameworld.managers['map_manager']
- animation_manager = gameworld.managers['animation_manager']
- # Get tilemap object with all the data from tmx
- tilemap = tmx.TileMap.load(filename)
- tiles, tiles_z, objects, objects_z, tile_ids, objmodels = \
- _load_tile_map(tilemap.layers, tilemap.width,
- _load_tile_properties(tilemap.tilesets))
- _load_tilesets(tilemap.tilesets, dirname(filename), tile_ids,
- texture_manager.load_atlas,
- model_manager.load_textured_rectangle,
- animation_manager.load_animation)
- _load_obj_models(objmodels, model_manager.load_textured_rectangle,
- model_manager.load_model)
- name = '.'.join(basename(filename).split('.')[:-1])
- map_manager.load_map(name, tilemap.width, tilemap.height,
- tiles, len(tiles_z),
- objects, sum([len(o) for o in objects]),
- tilemap.orientation)
- loaded_map = map_manager.maps[name]
- loaded_map.tile_size = (tilemap.tilewidth, tilemap.tileheight)
- loaded_map.z_index_map = tiles_z + objects_z
- if tilemap.staggerindex:
- loaded_map.stagger_index = tilemap.staggerindex
- if tilemap.staggeraxis:
- loaded_map.stagger_axis = tilemap.staggeraxis
- if tilemap.hexsidelength:
- loaded_map.hex_side_length = tilemap.hexsidelength
- self.map_size = [tilemap.width, tilemap.height]
- return name
- def init_game(self):
- self.move_to = None
- self.setup_states()
- self.set_state()
- self.setup_tile_map()
- self.add_player()
- self.camera1.render_system_order = reversed(self.map_layers)
- self.camera1.entity_to_focus = self.player_id
- self.camera1.focus_entity = True
- Clock.schedule_interval(self.update, 1 / 60)
- def add_player(self):
- pos = self.current_map.get_tile_position(*self.player_tile)
- print('starting position', pos)
- renderer_name = 'map_layer%d' % self.current_map.z_index_map[1]
- shape_dict = {'inner_radius': 0, 'outer_radius': 0, 'mass': 0, 'offset': (0, 0)}
- col_shape = {'shape_type': 'circle', 'elasticity': .5, 'collision_type': 1, 'shape_info': shape_dict,
- 'friction': 1.0}
- col_shapes = [col_shape]
- physics_component = {'main_shape': 'circle',
- 'velocity': (0, 0), 'position': pos, 'angle': 0,
- 'angular_velocity': 0, 'vel_limit': 0,
- 'ang_vel_limit': 0, 'mass': 0, 'col_shapes': col_shapes}
- component_data = {'position': pos,
- renderer_name: {'model': 'asteroid', 'texture': 'asteroid1', 'size': [20, 20]},
- 'rotate': 0,
- 'cymunk_physics': physics_component}
- systems = ['position', renderer_name, 'rotate', 'cymunk_physics']
- self.player_id = self.gameworld.init_entity(component_data, systems)
- self.player = self.gameworld.entities[self.player_id]
- def setup_tile_map(self):
- filename = get_asset_path('isometric.tmx', 'assets/maps/')
- map_manager = self.gameworld.managers['map_manager']
- map_name = self.parse_tmx(filename, self.gameworld)
- map_utils.init_entities_from_map(map_manager.maps[map_name], self.gameworld.init_entity)
- self.current_map = map_manager.maps[map_name]
- # print(self.current_map.width)
- self.player_tile = (self.map_size[0]-1, self.map_size[1]-1)
- def on_touch_up(self, touch):
- print(self.camera1.convert_from_screen_to_world(touch.pos))
- def setup_states(self):
- self.gameworld.add_state(state_name='main', systems_added=self.map_layers,
- systems_unpaused=self.map_layer_animators + self.map_layers)
- def set_state(self):
- self.gameworld.state = 'main'
- def update(self, dt):
- direction = None
- if keys.get(Keyboard.keycodes['down']):
- direction = (1, 0)
- keys[Keyboard.keycodes['down']] = False
- elif keys.get(Keyboard.keycodes['right']):
- direction = (0, 1)
- keys[Keyboard.keycodes['right']] = False
- elif keys.get(Keyboard.keycodes['up']):
- direction = (-1, 0)
- keys[Keyboard.keycodes['up']] = False
- elif keys.get(Keyboard.keycodes['left']):
- direction = (0, -1)
- keys[Keyboard.keycodes['left']] = False
- if direction:
- print('moving from', self.player_tile)
- x = direction[0] + self.player_tile[0]
- y = direction[1] + self.player_tile[1]
- go = True
- go = False if (x < 0 or y < 0) else go
- go = False if (x > self.map_size[0]-1 or y > self.map_size[0]-1) else go
- go = False if (x == self.player_tile[0] and y == self.player_tile[1]) else go
- if go:
- entity = self.gameworld.entities[self.player_id]
- coords = self.current_map.get_tile_position(x, y)
- self.player_tile = (x, y)
- print('moving to', coords, self.player_tile)
- entity.cymunk_physics.body.position = Vec2d(coords)
- else:
- print('too far or same tile', x, y)
- self.gameworld.update(dt)
- class DebugPanel(Widget):
- fps = StringProperty(None)
- def __init__(self, **kwargs):
- super(DebugPanel, self).__init__(**kwargs)
- Clock.schedule_once(self.update_fps)
- def update_fps(self, dt):
- self.fps = str(int(Clock.get_fps()))
- Clock.schedule_once(self.update_fps, .1)
- class YourAppNameApp(App):
- pass
- if __name__ == '__main__':
- if platform != 'android':
- def on_key_down(window, keycode, *rest):
- keys[keycode] = True
- def on_key_up(window, keycode, *rest):
- keys[keycode] = False
- Window.bind(on_key_down=on_key_down, on_key_up=on_key_up)
- YourAppNameApp().run()
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement