fork download
copy 
  1. #!/usr/bin/env python
  2. # -*- coding: UTF-8 -*-
  3.  
  4. import random
  5. import sys
  6.  
  7. import kivy
  8.  
  9. from kivy.app import App
  10. from kivy.uix.widget import Widget
  11.  
  12. from kivy.core.window import Window
  13. from kivy.core.audio import SoundLoader
  14. from kivy.clock import Clock
  15. # from kivy.config import Config
  16.  
  17. from kivy.uix.button import Button
  18.  
  19. from kivy.properties import NumericProperty, ObjectProperty
  20.  
  21.  
  22. PLATFORM = kivy.platform
  23.  
  24. if PLATFORM is not 'android':
  25.     # pass
  26.     Window.size = (1100, 650)
  27.  
  28.  
  29. FPS = 1.0 / 60.0
  30. FACTOR = Window.width // 12
  31. GAME_SPEED = Window.width / 315
  32. BEZIER_PRECISION = 0.2
  33.  
  34.  
  35. class FlyingObject(Widget):
  36.  
  37.     ''' Coins and floating islands'''
  38.  
  39.     def __init__(self, pos=None, speed_factor=1):
  40.         super(FlyingObject, self).__init__()
  41.         self.speed_factor = speed_factor
  42.  
  43.         if not pos:
  44.             interval = (0, int(Window.height - self.height))
  45.             pos = Window.width, random.randint(*interval)
  46.  
  47.         # print pos
  48.         self.pos = pos
  49.  
  50.         Clock.schedule_interval(self._move, FPS)
  51.  
  52.     def _move(self, *args):
  53.         if self.right <= 0:
  54.             self.parent.remove_widget(self)
  55.             return False
  56.  
  57.         self.x -= self.speed_factor * self.parent.get_game_speed()
  58.  
  59.     def __del__(self):
  60.         print 'Object %s deleted' % self
  61.  
  62.  
  63. class Coin(FlyingObject):
  64.  
  65.     ''' Coin. Main points currency'''
  66.     factor = NumericProperty(FACTOR)
  67.  
  68.  
  69. class FloatingIsland(FlyingObject):
  70.  
  71.     '''Main obstacle.'''
  72.  
  73.     factor = NumericProperty(FACTOR)
  74.  
  75.  
  76. class Hero(Widget):
  77.  
  78.     '''Main character class.'''
  79.  
  80.     factor = NumericProperty(FACTOR)
  81.     speed = NumericProperty(0)
  82.  
  83.     def __init__(self):
  84.         super(Hero, self).__init__()
  85.         Clock.schedule_interval(self.__move, FPS)
  86.  
  87.     def __up(self, *args):
  88.         if self.speed > 1.1 * self.parent.speed:
  89.             return
  90.  
  91.         self.speed += 0.2
  92.  
  93.     def __down(self, *args):
  94.         if self.speed < -1.3 * self.parent.speed:
  95.             return
  96.         self.speed -= 0.22
  97.  
  98.     def __lose_life(self):
  99.         pass
  100.  
  101.     def __jump(self, bottom=False):
  102.         if bottom:
  103.             self.__lose_life()
  104.  
  105.         # self.speed = 2 * self.parent.speed
  106.         self.up()
  107.  
  108.     def __move(self, *args):
  109.         # print self.speed, 1.1 * self.parent.speed, -1.3 * self.parent.speed
  110.         if self.top <= 0:
  111.             self.__jump(bottom=True)
  112.         elif self.y >= Window.height + self.height:
  113.             self.down()
  114.         self.y += self.speed * self.parent.speed
  115.  
  116.     def up(self):
  117.         Clock.unschedule(self.__down)
  118.         Clock.schedule_interval(self.__up, FPS)
  119.  
  120.     def down(self):
  121.         Clock.unschedule(self.__up)
  122.         Clock.schedule_interval(self.__down, FPS)
  123.  
  124.  
  125. class Game(Widget):
  126.  
  127.     '''Deals with gravity, movement, collisions, schedule'''
  128.  
  129.     speed = NumericProperty()
  130.     factor = NumericProperty(FACTOR)
  131.  
  132.     def __nn(self, s):
  133.         pass
  134.  
  135.     def __mm(self, sad):
  136.         print Clock.get_rfps()
  137.  
  138.     def __test(self, asd=None):
  139.         a = [(random.randint(self.width, 2 * self.width), random.randint(0, self.height)) for _ in range(4)]
  140.         a = self.__bezier(a)
  141.  
  142.         for x in range(3):
  143.             self.add_widget(FloatingIsland())
  144.  
  145.         for x in a:
  146.             self.add_widget(Coin(x))
  147.  
  148.         Clock.schedule_once(self.__test, 2)
  149.  
  150.         # self.__stop_time()
  151.  
  152.     @staticmethod
  153.     def __bezier(points, precision=BEZIER_PRECISION):
  154.         assert len(points) == 4 and precision < 1, len(points)
  155.         coords = []
  156.  
  157.         t = precision
  158.         while t <= 1:
  159.             x = [((1 - t) ** 3) * points[0][0],
  160.                  3 * t * ((1 - t) ** 2) * points[1][0],
  161.                  3 * (t ** 2) * (1 - t) * points[2][0],
  162.                  (t ** 3) * points[3][0]]
  163.             y = [((1 - t) ** 3) * points[0][1],
  164.                  3 * t * ((1 - t) ** 2) * points[1][1],
  165.                  3 * (t ** 2) * (1 - t) * points[2][1],
  166.                  (t ** 3) * points[3][1]]
  167.             coords.append((int(sum(x)), int(sum(y))))
  168.             t += precision
  169.         return coords
  170.  
  171.     def __increase_speed(self, timing):
  172.         if self.speed >= GAME_SPEED:
  173.             self.speed = GAME_SPEED
  174.             return False
  175.         self.speed += 0.5
  176.  
  177.     def __decrease_speed(self, arg=None):
  178.         if self.speed <= 0:
  179.             Clock.schedule_interval(self.__increase_speed, 0.1)
  180.             return False
  181.         self.speed -= 0.5
  182.  
  183.     def __stop_time(self):
  184.         interval_time = 0.1
  185.         Clock.schedule_interval(self.__decrease_speed, interval_time)
  186.  
  187.     def on_touch_down(self, touch):
  188.         if touch.is_double_tap:
  189.             self.__stop_time()
  190.             # self.__decrease_speed()
  191.         self.hero.up()
  192.  
  193.     def on_touch_up(self, touch):
  194.         self.hero.down()
  195.  
  196.     def get_game_speed(self):
  197.         return self.speed
  198.  
  199.     def start(self):
  200.         self.size = Window.size
  201.         self.speed = GAME_SPEED
  202.         self.hero = Hero()
  203.         self.add_widget(self.hero)
  204.         self.__test()
  205.         Clock.schedule_interval(self.__mm, 1)
  206.  
  207.  
  208. class YetApp(App):
  209.  
  210.     '''Just starts the game and clocks. Adds label'''
  211.  
  212.     def build(self):
  213.         # Window.fullscreen = True
  214.         game = Game()
  215.         game.start()
  216.         return game
  217.  
  218.  
  219. if __name__ == '__main__':
  220.     '''Simple game. Almost identical to The Shortest Story from WinPhone'''
  221.  
  222.     YetApp().run()
  223.  
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
compilation info 
Traceback (most recent call last):
  File "/usr/lib/python3.2/py_compile.py", line 119, in compile
    optimize=optimize)
  File "./prog.py", line 60
    print 'Object %s deleted' % self
                            ^
SyntaxError: invalid syntax

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "<string>", line 1, in <module>
  File "/usr/lib/python3.2/py_compile.py", line 123, in compile
    raise py_exc
py_compile.PyCompileError:   File "./prog.py", line 60
    print 'Object %s deleted' % self
                            ^
SyntaxError: invalid syntax
stdout
copy 
Standard output is empty
https://ideone.com/wL2F7b
language:
Python 3 (python  3.12)
created:
11 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!