def setup(self):
import json
atlas_path = asset_path('{}.atlas'.format(self.atlas),
'assets/textures')
texture_manager.load_atlas(atlas_path)
ld_rec = self.gameworld.model_manager.load_textured_rectangle
with open(atlas_path) as atlas:
js = json.load(atlas)
self.tile_keys = js['{}-0.png'.format(self.atlas)].keys()
for tile in self.tile_keys:
ld_rec('vertex_format_4f', 64., 64., tile, tile)
self.initialized = True
self.tile_trigger()
# if "DEBUG" in os.environ:
# Config.set('graphics', 'width', '800')
# Config.set('graphics', 'height', '400')
# import kivent_core
from kivent_core.managers.resource_managers import texture_manager # noqa: E402
from defedict import defedict # noqa: E402
import defs # noqa: E402
import fear # noqa:
import steering # noqa:
import virtjoy # noqa:
texture_manager.load_atlas('assets/objects.atlas')
class SneakGame(Widget): # pylint: disable=too-many-instance-attributes
levelnum = NumericProperty(0)
arrow_tip = ObjectProperty(None, allownone=True)
arrow_angle = NumericProperty(30)
num_stones_left = NumericProperty(0)
def __init__(self, **kwargs):
super(SneakGame, self).__init__(**kwargs)
self.gameworld.init_gameworld(
['renderer', 'rotate', 'position', 'steering', 'cymunk_physics',
'fear', 'animation'],
callback=self.init_game)
from kivent_core.systems.position_systems import PositionSystem2D
from kivent_core.systems.rotate_systems import RotateSystem2D
from kivent_cymunk.interaction import CymunkTouchSystem
from kivy.properties import StringProperty, NumericProperty
from math import radians, pi, sin, cos
from random import randint, choice
from functools import partial
from os.path import dirname, join, abspath
from maze import Maze
__version__ = '0.0.1'
texture_manager.load_atlas(join(dirname(abspath(__file__)),
'assets', 'dungeon.atlas'))
class Dungeon(Widget):
def __init__(self, **kwargs):
super(Dungeon, self).__init__(**kwargs)
self.gameworld.init_gameworld(
['cymunk_physics', 'rotate_renderer', 'rotate', 'position',
# 'cymunk_touch',
'camera1'],
callback=self.init_game)
self.mazeobj = Maze()
self.mazeobj.makeMap(50, 50, 100, 10, 30)
self.maze = self.mazeobj.mapArr
def init_game(self):
from kivy.clock import Clock
from kivy.core.window import Window
from random import randint, choice
import kivent_core
from kivent_core.gameworld import GameWorld
from kivent_core.systems.position_systems import PositionSystem2D
from kivent_core.systems.renderers import Renderer
from kivent_core.systems.gamesystem import GameSystem
from kivent_core.managers.resource_managers import texture_manager
from kivy.properties import StringProperty
from kivy.factory import Factory
from velocity_module.velocity import VelocitySystem2D
from os.path import dirname, join, abspath
texture_manager.load_atlas(
join(dirname(dirname(abspath(__file__))), 'assets',
'background_objects.atlas'))
class TestGame(Widget):
def __init__(self, **kwargs):
super(TestGame, self).__init__(**kwargs)
self.gameworld.init_gameworld(['renderer', 'position', 'velocity'],
callback=self.init_game)
def init_game(self):
self.setup_states()
self.load_models()
self.set_state()
self.draw_some_stuff()
import kivy
from kivy.app import App
from kivy.uix.widget import Widget
import kivent_core
import kivent_particles
from kivent_core.managers.resource_managers import texture_manager
texture_manager.load_atlas('assets/stars.atlas')
class TestGame(Widget):
def __init__(self, **kwargs):
super(TestGame, self).__init__(**kwargs)
self.gameworld.init_gameworld([
'position', 'scale', 'rotate', 'color', 'particles', 'emitters',
'particle_renderer', 'renderer'
],
callback=self.init_game)
def init_game(self):
self.setup_states()
self.set_state()
self.load_emitter()
def load_emitter(self):
emitter_system = self.ids.emitter
data = {
'number_of_particles': 1000,
'texture': 'star3',
'paused': False,
'pos_variance': (150., 150.),
import kivy
from kivy.app import App
from kivy.uix.widget import Widget
from kivy.clock import Clock
from kivy.core.window import Window
from random import randint, choice
import kivent_core
from kivent_core.gameworld import GameWorld
from kivent_core.systems.position_systems import PositionSystem2D
from kivent_core.systems.renderers import Renderer
from kivent_core.managers.resource_managers import texture_manager
from kivy.properties import StringProperty
from os.path import dirname, join, abspath
texture_manager.load_atlas('assets/background_objects.atlas')
class TestGame(Widget):
def on_kv_post(self, *args):
self.gameworld.init_gameworld(
['renderer', 'position'],
callback=self.init_game)
def init_game(self):
self.setup_states()
self.set_state()
self.load_models()
self.draw_some_stuff()
def load_models(self):
from kivy.uix.widget import Widget
from kivy.clock import Clock
from kivy.core.window import Window
from random import randint, choice, randrange
import kivent_core
from kivent_core.gameworld import GameWorld
from kivent_core.systems.position_systems import PositionSystem2D
from kivent_core.systems.renderers import Renderer
from kivent_core.systems.gamesystem import GameSystem
from kivent_core.managers.resource_managers import texture_manager
from kivy.properties import StringProperty, ObjectProperty
from kivy.factory import Factory
from kivent_core.managers.resource_managers import texture_manager
from os.path import dirname, join, abspath
texture_manager.load_atlas(
join(dirname(dirname(abspath(__file__))), 'assets', 'stars.atlas'))
def lerp(v0, v1, t):
return (1. - t) * v0 + t * v1
class FadingSystem(GameSystem):
make_entity = ObjectProperty(None)
def update(self, dt):
entities = self.gameworld.entities
for component in self.components:
if component is not None:
entity_id = component.entity_id
entity = entities[entity_id]
from kivy.app import App
from kivy.uix.widget import Widget
from kivy.clock import Clock
from kivy.core.window import Window
from random import randint, choice, randrange
import kivent_core
from kivent_core.gameworld import GameWorld
from kivent_core.systems.position_systems import PositionSystem2D
from kivent_core.systems.renderers import Renderer
from kivent_core.systems.gamesystem import GameSystem
from kivent_core.managers.resource_managers import (texture_manager,
model_manager)
from kivy.properties import StringProperty, ObjectProperty
from kivy.factory import Factory
texture_manager.load_atlas('assets/stars.atlas')
keys = ['star1', 'star2', 'star3', 'star_circle', 'star_square']
model_keys = []
mk_a = model_keys.append
load_textured_rectangle = model_manager.load_textured_rectangle
for x in range(250):
model_key = 'star_m_' + str(x)
tex_key = choice(keys)
wh = randrange(1., 7.)
load_textured_rectangle(4, wh, wh, choice(keys), model_key)
mk_a((model_key, tex_key))
def lerp(v0, v1, t):
return (1-t)*v0 + t * v1
from kivy.core.window import Window
from random import randint, choice
from math import radians, pi, sin, cos
import kivent_core
import kivent_cymunk
from kivent_core.gameworld import GameWorld
from kivent_core.managers.resource_managers import texture_manager
from kivent_core.systems.renderers import RotateRenderer
from kivent_core.systems.position_systems import PositionSystem2D
from kivent_core.systems.rotate_systems import RotateSystem2D
from kivent_cymunk.interaction import CymunkTouchSystem
from kivy.properties import StringProperty, NumericProperty
from functools import partial
from os.path import dirname, join, abspath
texture_manager.load_atlas(join(dirname(dirname(abspath(__file__))), "assets", "background_objects.atlas"))
class TestGame(Widget):
def __init__(self, **kwargs):
super(TestGame, self).__init__(**kwargs)
self.gameworld.init_gameworld(
["cymunk_physics", "rotate_renderer", "rotate", "position", "cymunk_touch", "camera1"],
callback=self.init_game,
)
def init_game(self):
self.setup_states()
self.set_state()
def draw_some_stuff(self):
from kivy.core.window import Window
from random import randint, choice
from math import radians, pi, sin, cos
import kivent_core
import kivent_cymunk
from kivent_core.gameworld import GameWorld
from kivent_core.managers.resource_managers import texture_manager
from kivent_core.systems.renderers import RotateRenderer
from kivent_core.systems.position_systems import PositionSystem2D
from kivent_core.systems.rotate_systems import RotateSystem2D
from kivent_cymunk.interaction import CymunkTouchSystem
from kivy.properties import StringProperty, NumericProperty
from functools import partial
from os.path import dirname, join, abspath
texture_manager.load_atlas(join(dirname(dirname(abspath(__file__))), 'assets',
'background_objects.atlas'))
class TestGame(Widget):
def __init__(self, **kwargs):
super(TestGame, self).__init__(**kwargs)
self.gameworld.init_gameworld(
['cymunk_physics', 'rotate_renderer', 'rotate', 'position',
'cymunk_touch'],
callback=self.init_game)
def init_game(self):
self.setup_states()
self.set_state()
from kivent_core.managers.resource_managers import texture_manager
#texture_manager.load_atlas('Sprites/Ejemplo.atlas')
texture_manager.load_atlas('Sprites/ProtoSprite_Estar.atlas')
class Animatron():
def __init__(self, Nux, Modelo):
self.Nux = Nux
self.Mod = Modelo
self.EstadoActual = 'DePie'
self.EstadoAnterior = 'DePie'
self.DireccionActual = 'Derecha'
self.DireccionAnterior = 'Derecah'
self.C01 = 0
self.C02 = 0
self.C03 = 0
self.C04 = 0
self.Retraso = 0
self.RT = 4
self.Invertir = False
def Anim001(self):
self.Retraso += 1
if self.Retraso >= self.RT:
self.Retraso = 0
self.C01 += 1
if self.C01 > 7:
self.C01 = 0
self.Mod.renderer.texture_key = 'Ejemplo_Paso0' + str(self.C01)
def Anim002(self):
import kivy
from kivy.app import App
from kivy.clock import Clock
from kivy.uix.widget import Widget
from kivy.core.window import Window
import kivent_core
import kivent_cymunk
from kivent_core.systems.renderers import RotateRenderer
from kivent_core.managers.resource_managers import texture_manager
from os.path import dirname, join, abspath
from operator import itemgetter
from playersystem import PlayerSystem
texture_manager.load_atlas(join(dirname(
dirname(abspath(__file__))), 'images',
'sprite_sheet_001.atlas'))
SHADER_POSROT = join(dirname(dirname(abspath(__file__))),
'kivent_stuff', 'glsl','positionrotateshader.glsl')
def get_physics_dictionary(position, radius, mass):
circle = {
'inner_radius': 0,
'outer_radius': radius,
'mass': mass,
'offset': (0,0)}
col_shape = {
'shape_type': 'circle',
'elasticity': 0.0,
'collision_type': 1,
def load_assets(self):
model_manager = self.gameworld.model_manager
emitter_system = self.ids.emitter
projectile_system = self.ids.projectiles
weapon_system = self.ids.weapons
sound_manager = self.gameworld.sound_manager
asteroid_system = self.ids.asteroids
physics_system = self.ids.physics
shield_system = self.ids.shields
explosion_system = self.ids.explosions
texture_manager.load_atlas(
get_asset_path('assets', 'particles', 'particles.atlas'))
texture_manager.load_image(
get_asset_path('assets', 'objects', 'asteroid1.png'))
texture_manager.load_image(
get_asset_path('assets', 'objects', 'asteroid1-radar.png'))
texture_manager.load_image(
get_asset_path('assets', 'particles', 'particle3.png'))
asteroid_model = model_manager.load_textured_rectangle(
'vertex_format_4f',
64,
64,
'asteroid1',
'4f_asteroid1',
)
asteroid_radar_model = model_manager.load_textured_rectangle(
'vertex_format_4f',
64,
64,
'asteroid1-radar',
'4f_asteroid1_radar',
)
asteroid_collision_type = physics_system.register_collision_type(
'asteroids')
ship_collision_type = physics_system.register_collision_type('ships')
projectile_system.add_origin_collision_type(asteroid_collision_type)
projectile_system.add_origin_collision_type(ship_collision_type)
self.load_weapons()
ship_hit_asteroid = sound_manager.load_sound('ship_hit_asteroid',
get_asset_path(
'assets', 'soundfx',
'shiphit.wav'),
track_count=2)
asteroid_hit_asteroid = sound_manager.load_sound(
'asteroid_hit_asteroid',
get_asset_path('assets', 'soundfx', 'asteroidhitasteroid.wav'),
track_count=2)
emitter_system.load_effect(
get_asset_path('assets', 'vfx', 'asteroidexplosion.kep'))
emitter_system.load_effect(
get_asset_path('assets', 'vfx', 'shipexplosion.kep'))
explosion_system.register_template('ship_explosion', 'shipexplosion',
3.0, 1.5)
asteroid_system.register_template(
'asteroid1',
asteroid_collision_type,
mass=125.,
radius=30.,
texture='asteroid1',
model_key=asteroid_model,
health=15.,
armor=4.,
ship_collision_sound=ship_hit_asteroid,
asteroid_collision_sound=asteroid_hit_asteroid,
radar_model=asteroid_radar_model,
radar_texture='asteroid1-radar')
explosion_system.register_template('asteroid_explosion',
'asteroidexplosion', 1.5, 1.0)
physics_system.add_collision_handler(
asteroid_collision_type,
ship_collision_type,
begin_func=asteroid_system.on_collision_begin_asteroid_ship)
physics_system.add_collision_handler(
asteroid_collision_type,
asteroid_collision_type,
begin_func=asteroid_system.on_collision_begin_asteroid_asteroid)
physics_system.add_collision_handler(
asteroid_collision_type,
shield_system.shield_collision_type,
begin_func=shield_system.on_collision_begin_asteroid_shield)
physics_system.add_collision_handler(
shield_system.shield_collision_type,
shield_system.shield_collision_type,
begin_func=shield_system.on_collision_begin_shield_shield)
physics_system.add_collision_handler(
ship_collision_type,
shield_system.shield_collision_type,
begin_func=shield_system.on_collision_begin_ship_shield)
projectile_system.add_custom_collision_type(
shield_system.shield_collision_type,
shield_system.on_collision_begin_bullet_shield)
self.load_ships(ship_collision_type)
from kivent_core.systems.renderers import RotateRenderer
from kivent_core.systems.position_systems import PositionSystem2D
from kivent_core.systems.rotate_systems import RotateSystem2D
from kivent_core.systems.gamesystem import GameSystem
from kivent_core.managers.resource_managers import texture_manager
from spider_system import SpiderSystem
from beetle_system import BeetleSystem
from tyrant_system import TyrantSystem
from boxes import Boxes
from base import Base
from web import Web
from panel import Panel
texture_manager.load_atlas('assets/beetles.atlas')
win_x = Window.size[0]
win_y = Window.size[1]
class SpideyGame(Widget):
go_right = False
go_left = False
go_up = False
go_down = False
speed = 3
message = StringProperty('')
win_y = win_y
destination = [None, None]
lev_initiated = False
from os.path import dirname, join, abspath
from test_game import TestGame
def get_asset_path(asset, asset_loc):
return join(dirname(dirname(abspath(__file__))), asset_loc, asset)
# def _get_args_dict(fn, args, kwargs):
# args_names = fn.__code__.co_varnames[:fn.__code__.co_argcount]
# return {**dict(zip(args_names, args)), **kwargs}
texture_manager.load_atlas(
get_asset_path("background_objects.atlas", "assets")
)
# texture_manager.load_atlas(get_asset_path('dalek_objects.atlas','assets'))
# texture_manager.load_atlas(join(atlas_dir, 'robot_objects.atlas'))
print(join(dirname(dirname(abspath(__file__))), "assets", "glsl"))
class ScrollableLabel(ScrollView):
text = StringProperty("")
class DebugPanel(Widget):
fps = StringProperty(None)
def __init__(self, **kwargs):
from kivy.uix.widget import Widget
from kivy.clock import Clock
from kivy.core.window import Window
from random import randint, choice
import kivent_core
from kivent_core.gameworld import GameWorld
from kivent_core.systems.position_systems import PositionSystem2D
from kivent_core.systems.renderers import Renderer
from kivent_core.systems.gamesystem import GameSystem
from kivent_core.managers.resource_managers import (
texture_manager, model_manager)
from kivy.properties import StringProperty
from kivy.factory import Factory
texture_manager.load_atlas('assets/background_objects.atlas')
model_manager.load_textured_rectangle(4, 7., 7., 'star1', 'star1-4')
model_manager.load_textured_rectangle(4, 10., 10., 'star1', 'star1-4-2')
class VelocitySystem2D(GameSystem):
def update(self, dt):
entities = self.gameworld.entities
for component in self.components:
if component is not None:
entity_id = component.entity_id
entity = entities[entity_id]
position_comp = entity.position
position_comp.x += component.vx * dt
position_comp.y += component.vy * dt
from kivy.app import App
from kivy.uix.widget import Widget
from kivy.clock import Clock
from kivy.core.window import Window
from kivy.properties import StringProperty
from kivent_core.managers.resource_managers import texture_manager
from random import randint, choice
import kivent_core
import kivent_cymunk
from math import radians
from assets_ids import ent
from cymunk import PivotJoint
texture_manager.load_atlas('assets/platform.atlas')
class TestGame(Widget):
def __init__(self, **kwargs):
super(TestGame, self).__init__(**kwargs)
self.gameworld.init_gameworld(
['renderer', 'position', 'rotate', 'color', 'scale',
'renderer2', 'camera1', 'cymunk_physics', 'cymunk_touch'],
callback=self.init_game)
def init_game(self):
self.setup_states()
self.set_state()
self.draw_objects()
self.enable_gravity()
self.pivot_joint()
def draw_objects(self):
from random import randint, choice
from math import radians, pi, sin, cos
import kivent_core
import kivent_cymunk
from kivent_core.gameworld import GameWorld
from kivent_core.managers.resource_managers import texture_manager
from kivent_core.rendering.vertmesh import VertMesh
from kivent_core.systems.renderers import RotateRenderer
from kivent_core.systems.position_systems import PositionSystem2D
from kivent_core.systems.rotate_systems import RotateSystem2D
from kivent_cymunk.interaction import CymunkTouchSystem
from kivy.properties import StringProperty, NumericProperty
from functools import partial
texture_manager.load_atlas("../assets/background_objects.atlas")
class TestGame(Widget):
def __init__(self, **kwargs):
super(TestGame, self).__init__(**kwargs)
self.gameworld.init_gameworld(
["cymunk_physics", "rotate_renderer", "rotate", "position", "cymunk_touch", "camera1"],
callback=self.init_game,
)
def init_game(self):
self.setup_states()
self.set_state()
def destroy_created_entity(self, ent_id, dt):
