class Rock(GameImage):
img = Image(source=abstract_path('{}/img/rock-1.png'.format(_dir)))
TEXTURE = img.texture
texture = ObjectProperty(TEXTURE)
def on_collision(self, bike):
if bike.collide_widget(self):
self._collision(bike)
return True
return False
def _collision(self, bike):
bike.speed = 0
bike.power = 0
bike.acceleration = 0
bike.collected_currency = 0
bike.finish_dt = time.time()
bike.anim_collision()
self.draw_collision_rectangle(bike)
# show finish information
road = ValidObject.road(GetObject.get_child(bike.parent, 'Road'))
curtain = Curtain(road=road, font_size=FS.H1.value)
curtain.text = curtain.collision_text_rock()
curtain.add_to_game_screen()
def draw_collision_rectangle(self, bike):
with bike.canvas:
Color(rgba=(1, 0, 0, .2), group="background")
Rectangle(pos=bike.pos, size=bike.size, group="background")
class Start(GameImage):
img = Image(source=abstract_path('objects/finish/img/finish.jpg'))
TEXTURE = img.texture
texture = ObjectProperty(TEXTURE)
def __init__(self, **kwargs):
super(Start, self).__init__(**kwargs)
repeat_texture(self.texture, 8, 8)
class AnimationBike(Image):
source_go = StringProperty(abstract_path('bike/img/default.png'))
source_relax = StringProperty(abstract_path('bike/img/default.png'))
source_wait = StringProperty(abstract_path('bike/img/default.png'))
source_stop = StringProperty(abstract_path('bike/img/default.png'))
source_jump_up = StringProperty(abstract_path('bike/img/default.png'))
source_landing = StringProperty(abstract_path('bike/img/default.png'))
source_collision = StringProperty(abstract_path('bike/img/default.png'))
def init_source_animation(self, item: BikeModel):
self.source_go = item.source_go
self.source_relax = item.source_relax
self.source_wait = item.source_wait
self.source_stop = item.source_stop
self.source_jump_up = item.source_jump_up
self.source_landing = item.source_landing
self.source_collision = item.source_collision
def anim_go(self):
self.source = self.source_go
anim = Animation(angle=8, duration=.2)
anim.start(self)
def anim_relax(self):
self.source = self.source_relax
anim = Animation(angle=0, duration=.2)
anim.start(self)
def anim_wait(self):
self.source = self.source_wait
anim = Animation(angle=0, duration=.2)
anim.start(self)
def anim_stop(self):
self.source = self.source_stop
anim = Animation(angle=-1, duration=.1)
anim.start(self)
def anim_jump_up(self):
self.source = self.source_jump_up
anim = Animation(angle=8, duration=.2)
anim.start(self)
def anim_landing(self):
self.source = self.source_landing
self.source = self.source_landing
anim = Animation(angle=-8, duration=.2)
anim.start(self)
def anim_collision(self):
self.source = self.source_collision
anim = Animation(angle=180, duration=.2)
anim.start(self)
class Puddle(GameImage):
img = Image(source=abstract_path('objects/puddle/img/puddle.png'))
TEXTURE = img.texture
texture = ObjectProperty(TEXTURE)
def on_collision(self, bike):
if bike.collide_widget(self):
bike.anim_collision()
if bike.speed > 0 or bike.power > 0:
bike.acceleration -= bike.acceleration / 100
bike.set_speed(bike.speed - (bike.max_speed / 1000))
bike.set_power(bike.power - (bike.max_power / 1000))
return True
return False
from kivy.uix.widget import Widget
from utils.dir import abstract_path
from kivy.lang import Builder
from kivy.properties import ObjectProperty
from utils.color import Color
from utils.validation import ValidObject
Builder.load_file(abstract_path('devtools/devtools.kv'))
class DevTools(Widget):
scene = ObjectProperty(None)
road = ObjectProperty(None)
def format_map_elem(self, elem, newline=False):
name, pos = elem['name'], elem['pos']
color = Color.RED
if self.road.passed(pos):
color = Color.RED_LIGHT
elif self.road.visible(pos):
color = Color.GREEN
elif self.road.future(pos):
color = Color.ORANGE
res = '[color={}]{}[/color]:[size=9]{}[/size]'.format(
color, name,
str(pos).replace('(', '').replace(')', ''))
return '\n' + res if newline else res
def map_text(self):
from kivy.lang import Builder
from objects import Start
from objects.currency.currency import Currency
from utils.dir import abstract_path
Builder.load_file(abstract_path('objects/finish/finish.kv'))
class Finish(Start):
@staticmethod
def curtain_text(road, bike):
return '''
[size=80]Finish[/size]
Level: {}
Total Way: {}
Total Time: {:0.3f}
{}: {}
'''.format(
road.level.name,
road.total_way,
bike.finish_dt - bike.start_dt,
Currency.units, bike.currency)
def get_x(self):
bike = self.get_bike()
road = self.get_road()
return (road.total_way - road.distance_traveled) + bike.x + bike.width
from kivy.lang import Builder
from kivy.uix.screenmanager import Screen
from utils.dir import abstract_path
Builder.load_file(abstract_path('screen/game_screen.kv'))
class GameScreen(Screen):
pass
class Bike(AnimationBike):
source = StringProperty(abstract_path('bike/img/default.png'))
acceleration = NumericProperty(0.0)
power = NumericProperty(0)
max_power = NumericProperty(0)
speed = NumericProperty(0)
max_speed = NumericProperty(0)
agility = NumericProperty(0)
start_dt = NumericProperty(0)
finish_dt = NumericProperty(0)
collected_currency = NumericProperty(0)
currency = NumericProperty(0)
def __init__(self, **kwargs):
super(Bike, self).__init__(**kwargs)
self.init_app_config()
def init_params(self, bike_model: BikeModel) -> None:
self.source = bike_model.source
self.max_power = bike_model.power
self.max_speed = bike_model.speed
self.acceleration = bike_model.acceleration
self.agility = bike_model.agility
self.init_source_animation(bike_model)
def init_app_config(self) -> None:
bike_title = app_config('bike', 'title')
if bike_title:
bike_model = get_by_bike_title(bike_title)
self.init_params(bike_model)
else:
WarnBikeIsNotConfig(bike_title, self)
@staticmethod
def buy(bike_model: BikeModel) -> bool:
res_rm = calc_rest_rm(bike_model.price)
if res_rm > 0:
Bike.set_config(bike_model, res_rm)
return True
return False
@staticmethod
def set_config(bike_model, rest_rm) -> None:
Cache.remove('bike', 'rm')
Cache.append('bike', 'rm', rest_rm)
Cache.remove('bike', 'title')
Cache.remove('bike', 'power')
Cache.remove('bike', 'speed')
Cache.remove('bike', 'acceleration')
Cache.remove('bike', 'agility')
Cache.append('bike', 'title', bike_model.title)
Cache.append('bike', 'power', bike_model.power)
Cache.append('bike', 'speed', bike_model.speed)
Cache.append('bike', 'acceleration', bike_model.acceleration)
Cache.append('bike', 'agility', bike_model.agility)
def set_power(self, value: Union[int, float]) -> None:
self.power = self._max_val(value, self.max_power)
def set_speed(self, value: Union[int, float]) -> None:
self.speed = self._max_val(value, self.max_speed)
def _max_val(self, val: Union[int, float],
max_val: Union[int, float]) -> Union[int, float]:
if val <= 0:
return 0
elif val > max_val:
return max_val
else:
return val
def is_in_sky(self) -> bool:
road = self.get_road()
if road:
return road.line_points[-1] < self.y
# Collisions
def get_collisions(self, class_name: str) -> Optional[Widget]:
children = [
ro for ro in self.get_road().children[:]
if ro.__class__.__name__ == class_name
]
for w in children:
if w and self.collide_widget(w): return w
def on_collision_rock(self):
rock = self.get_collisions('Rock')
return rock and rock.on_collision(self)
def on_collision_currency(self):
currency = self.get_collisions('Currency')
return currency and currency.on_collision(self)
def on_collision_puddle(self) -> Optional[Widget]:
puddle = self.get_collisions('Puddle')
return puddle and puddle.on_collision(self)
# Game objects
def get_road(self) -> Optional[Widget]:
return self.parent and ValidObject.road(
GetObject.get_child(self.parent, 'Road'))
from typing import Union
from kivy.uix.boxlayout import BoxLayout
from kivy.lang import Builder
from utils.dir import abstract_path
from kivy.properties import NumericProperty, StringProperty, BooleanProperty
from utils.color import Color as UColor
Builder.load_file(abstract_path('screen/ui/character_wrap.kv'))
class CharacterWrap(BoxLayout):
key = StringProperty()
title = StringProperty()
value = NumericProperty()
max = NumericProperty()
has_value = BooleanProperty()
def format_number(self, key=None, value=None, max=None):
markup = "{key} [color=#{color_sub}][sub]{val}[/sub][/color]:[color=#{color_sup}][sup]{max}[/sup][/color]"
return markup.format(key=key or self.key,
val=value or self.value,
max=max or self.max,
color_sub=UColor.GREEN,
color_sup=UColor.ORANGE)
def format_string(self, value: Union[int, str, None] = None):
return "{}: {}".format(self.key, value or self.value)
import time
from kivy.core.window import Window
from kivy.lang import Builder
from kivy.uix.floatlayout import FloatLayout
from kivy.cache import Cache
from objects import Start, Finish, Lamp, Puddle, Rock, Currency
from utils.dir import abstract_path
from kivy.clock import Clock
from utils.get_object import GetObject
from kivy.logger import Logger
Builder.load_file(abstract_path('layout/scene.kv'))
CACHE_NAME = 'installed'
Cache.register(CACHE_NAME, limit=10000)
class Scene(FloatLayout):
def __init__(self, **kwargs):
super(Scene, self).__init__(**kwargs)
Clock.schedule_interval(self.start_timer, 1)
@staticmethod
def get_cache(sid):
return Cache.get(CACHE_NAME, sid)
def add_to_road(self, map_elem, gowid, size):
road = self.parent.ids['road']
sid = gowid.init_sid(map_elem['pos'])
from kivy.lang import Builder
from kivy.uix.screenmanager import Screen
from utils.dir import abstract_path
Builder.load_file(abstract_path('screen/bikes_screen.kv'))
class BikesScreen(Screen):
def __init__(self, **kwargs):
super(BikesScreen, self).__init__(**kwargs)
from kivy.lang import Builder
from kivy.uix.screenmanager import Screen
from utils.dir import abstract_path
from kivy.properties import ObjectProperty
Builder.load_file(abstract_path('screen/shop_screen.kv'))
class ShopScreen(Screen):
pass
import time
from kivy.graphics import Color, Rectangle
from kivy.lang import Builder
from kivy.properties import ObjectProperty
from kivy.uix.image import Image
from objects.base.game_image import GameImage
from utils.dir import abstract_path
from utils.validation import ValidObject
from utils.get_object import GetObject
from label.curtain import Curtain
from utils.sizes import FontSize as FS
_dir = 'objects/rock'
Builder.load_file(abstract_path('{}/rock.kv'.format(_dir)))
class Rock(GameImage):
img = Image(source=abstract_path('{}/img/rock-1.png'.format(_dir)))
TEXTURE = img.texture
texture = ObjectProperty(TEXTURE)
def on_collision(self, bike):
if bike.collide_widget(self):
self._collision(bike)
return True
return False
def _collision(self, bike):
bike.speed = 0
bike.power = 0
bike.acceleration = 0
class Lamp(GameImage):
img = Image(source=abstract_path('objects/lamp/img/lamp.png'))
TEXTURE = img.texture
texture = ObjectProperty(TEXTURE)
from kivy.animation import Animation
from kivy.core.window import Window
from kivy.app import App
from kivy.lang import Builder
from kivy.properties import ObjectProperty, StringProperty, ListProperty, ReferenceListProperty, \
NumericProperty, BooleanProperty, OptionProperty
from kivy.uix.button import Button
from utils.init import app_config
from utils.dir import abstract_path
from utils.sizes import FontSize as FS
from utils.sizes import GOSize as GOS
Builder.load_file(abstract_path('screen/ui/panel_button.kv'))
class MenuButton(Button):
width = NumericProperty(GOS.WIDTH_MenuButton.value)
height = NumericProperty(GOS.HEIGHT_MenuButton.value)
size_hint_x = NumericProperty(None)
size_hint_y = NumericProperty(None)
size_hint = ReferenceListProperty(size_hint_x, size_hint_y)
background_color = ListProperty([.4, .4, .4, 1])
font_size = NumericProperty(FS.LEAD.value)
app = ObjectProperty()
def __init__(self, **kwargs):
super(MenuButton, self).__init__(**kwargs)
self.app = App.get_running_app()
# def on_state(self, instance, value):
from kivy.clock import Clock
from kivy.lang import Builder
from kivy.properties import ObjectProperty, NumericProperty
from kivy.uix.behaviors.button import ButtonBehavior
from kivy.uix.image import Image
from conf import SECOND_GAME
from label.status_bar import StatusBar
from utils.dir import abstract_path
from utils.get_object import GetObject
from utils.sizes import GOSize as GOS
Builder.load_file(abstract_path('button/left_button.kv'))
class LeftButtonWidget(ButtonBehavior, Image):
height = NumericProperty(GOS.WH_BUTTON_LR.value)
width = NumericProperty(GOS.WH_BUTTON_LR.value)
road = ObjectProperty(None)
bike = ObjectProperty(None)
background = ObjectProperty(None)
@classmethod
def set_objects(cls):
cls.status_bar = StatusBar()
cls.road = cls.status_bar.get_road()
cls.bike = cls.status_bar.get_bike()
cls.background = cls.status_bar.get_background()
def button_state_style(self):
if 'down' in self.state:
self.canvas.opacity = 0.5
from kivy.properties import NumericProperty, ObjectProperty, ListProperty, OptionProperty
from kivy.uix.widget import Widget
from bike.bike import Bike
from level.one.level_one import LevelOne
from road.events import RoadEvents
from utils.dir import abstract_path
from utils.exception import WarnTrySetBikeFromLayoutWarn, ErrBikeIsNotConfig, InfoBikeInstalledFor
from utils.get_object import GetObject
from utils.state import State
from utils.texture import repeat_texture, set_texture_uvpos, image_texture
from utils.validation import ValidObject
from utils.init import app_config
from level.maps import get_by_title as get_map_by_title
Builder.load_file(abstract_path('road/road.kv'))
class Road(Widget, RoadEvents):
level = ObjectProperty()
texture = ObjectProperty(image_texture('road/img/road-asphalt.png'))
total_way = NumericProperty(0) # todo: need to fix tests
distance_traveled = NumericProperty(0)
gravity = NumericProperty(9.0)
state = OptionProperty(State.NONE, options=State.list_states())
last_states = ListProperty()
line_points = ListProperty([100, 100, 1000, 100])
def __init__(self, **kwargs):
super(Road, self).__init__(**kwargs)
self.set_bike()
from kivy.cache import Cache
from kivy.lang import Builder
# from kivy.logger import Logger
from kivy.properties import NumericProperty, StringProperty
from kivy.uix.widget import Widget
from bike.animation import AnimationBike
from bike.bikes import get_by_title as get_by_bike_title
from bike.model import BikeModel
from utils.dir import abstract_path
from utils.get_object import GetObject
from utils.init import app_config, calc_rest_rm
from utils.validation import ValidObject
from utils.exception import WarnBikeIsNotConfig
Builder.load_file(abstract_path('bike/bike.kv'))
class Bike(AnimationBike):
source = StringProperty(abstract_path('bike/img/default.png'))
acceleration = NumericProperty(0.0)
power = NumericProperty(0)
max_power = NumericProperty(0)
speed = NumericProperty(0)
max_speed = NumericProperty(0)
agility = NumericProperty(0)
start_dt = NumericProperty(0)
finish_dt = NumericProperty(0)
collected_currency = NumericProperty(0)
from typing import Union
from kivy.core.text import Label
from kivy.lang import Builder
from kivy.properties import ObjectProperty
from kivy.uix.image import Image
from kivy.uix.screenmanager import Screen
from bike.bikes import get_by_title as get_bike_by_title
from bike.model import BikeModel
from level.maps import get_by_title as get_map_by_title
from level.model import MapModel
from utils.dir import abstract_path
from utils.init import app_config
Builder.load_file(abstract_path('screen/menu_screen.kv'))
class MenuScreen(Screen):
bike_model = ObjectProperty()
level = ObjectProperty()
map_model = ObjectProperty(allownone=True)
def __init__(self, **kwargs):
super(MenuScreen, self).__init__(**kwargs)
if app_config('bike', 'title'):
self.init_bike()
if app_config('map', 'title'):
self.init_map()
def init_bike(self):
def image_texture(source):
return Image(source=abstract_path(source)).texture
