def __init__(self, choose_song):
super(MainMenuDisplay, self).__init__()
self.label = TextLabel(
text="Click on a song to select it, and press ENTER to confirm",
pos=(0, 0),
font=Window.height / 30)
self.add(self.label)
self.buttons = []
self.choose_song = choose_song
x = Window.width - 1 / 6 * Window.width
y = 200
i = 0
label = CoreLabel(text="CHOOSE A SONG", font_size=Window.height / 10)
label.refresh()
text = label.texture
title = Rectangle(texture=text,
pos=(Window.width / 2 - text.size[0] / 2,
Window.height * 3 / 4),
size=text.size)
self.add(title)
for song in songs:
button = SongButtons(y=y,
song=song,
start_end=start_end[i],
key=keys[i])
self.buttons.append(button)
self.add(button)
i += 1
y += Window.height / 7
def __init__(self,
text,
pos,
font=40,
align='left',
color=Color(1, 1, 1),
anim=None):
super(TextLabel, self).__init__()
self.t = 0
self.size_func = anim
self.font = font
label = CoreLabel(text=text, font_size=self.font, font_name='Verdana')
label.refresh()
self.text = label.texture
self.color = color
self.add(self.color)
self.ratio = self.text.size[0] / self.text.size[1]
if align == 'left':
self.pos = pos
else:
self.pos = (pos[0] - self.text.size[0] / 2,
pos[1] - self.text.size[1] / 2)
self.item = Rectangle(size=self.text.size,
pos=self.pos,
texture=self.text)
self.add(self.item)
def __init__(self, **kwargs):
super().__init__(**kwargs)
# Request reference to keyboard
self._keyboard = Window.request_keyboard(self._on_keyboard_close, self)
self._keyboard.bind(on_key_down=self._on_key_down)
self._keyboard.bind(on_key_up=self._on_key_up)
self._score_label = CoreLabel(text="Score: 0", font_size=20)
self._score_label.refresh()
self._score = 0
self.register_event_type("on_frame") # Inherited from super class
# Create textures
self.space_texture = Image(source="assets/background.png").texture
self.space_texture.wrap = "repeat"
self.space_texture.uvsize = (Window.height / self.space_texture.height,
-1)
with self.canvas:
Rectangle(texture=self.space_texture,
pos=(0, 0),
size=(Window.width, Window.height))
self._score_instruction = Rectangle(
texture=self._score_label.texture,
pos=(10, Window.height - 50),
size=self._score_label.texture.size)
self._keys_pressed = set()
self._entities = set()
# Spawn enemies
Clock.schedule_interval(self.spawn_enemies, 1)
# Execute move every frame
Clock.schedule_interval(self._on_frame, 0)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self._keyboard = Window.request_keyboard(self._on_keyboard_closed,
self)
self._keyboard.bind(on_key_down=self._on_key_down)
self._keyboard.bind(on_key_up=self._on_key_up)
self._score_label = CoreLabel(text="Score: 0")
self._score_label.refresh()
self._score = 0
self.register_event_type("on_frame")
with self.canvas:
self._score_instruction = Rectangle(
texture=self._score_label.texture,
pos=(0, 550),
size=self._score_label.texture.size)
self.keysPressed = set()
self._entities = set()
Clock.schedule_interval(self._on_frame, 0) # 0 means every frame
# play sound
self.sound = SoundLoader.load("assets/sound.wav")
self.sound.play()
Clock.schedule_interval(self.spawn_enemies, 2)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.sound = SoundLoader.load('start.mp3')
self.sound.volume = 0.1
self.sound.play()
Clock.schedule_interval(self._player1_, 0)
Clock.schedule_interval(self._player2_, 0)
self._player1score_label = CoreLabel(text="Player 1 score: 0",
font_size=40)
self._player1score_label.refresh()
self._player1score = 0
self._player2score_label = CoreLabel(text="Player 2 score: 0",
font_size=40)
self._player2score_label.refresh()
self._player2score = 0
with self.canvas:
Color(1, 0, .3)
self._player1score_instruction = Rectangle(
texture=self._player1score_label.texture,
pos=(100, 750),
size=self._player1score_label.texture.size)
Color(0, 1, .6)
self._player2score_instruction = Rectangle(
texture=self._player2score_label.texture,
pos=(1100, 750),
size=self._player2score_label.texture.size)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self._keyboard = Window.request_keyboard(self._on_keyboard_closed,
self)
self._keyboard.bind(on_key_down=self._on_key_down)
self._keyboard.bind(on_key_up=self._on_key_up)
self._score_label = CoreLabel(text="Score: 0", font_size=20)
self._score_label.refresh()
self._score = 0
self.register_event_type("on_frame")
with self.canvas:
Rectangle(source="assets/background.png",
pos=(0, 0),
size=(Window.width, Window.height))
self._score_instruction = Rectangle(
texture=self._score_label.texture,
pos=(0, Window.height - 50),
size=self._score_label.texture.size)
self.keysPressed = set()
self._entities = set()
Clock.schedule_interval(self._on_frame, 0)
self.sound = SoundLoader.load("assets/music.wav")
self.sound.play()
Clock.schedule_interval(self.spawn_enemies, 2)
def __init__(self, **kwargs): #**kwargs is a dictionary of keyword arguments
super(GameWidget,self).__init__(**kwargs)
self._keyboard = Window.request_keyboard(self._on_keyboard_closed, self)
self._keyboard.bind(on_key_down=self._on_key_down)
self._keyboard.bind(on_key_up=self._on_key_up)
self._lives_label = CoreLabel(text="Lives: 0", font_size=100, font_name='./fonts/absolutepink.otf')
self._lives_label.refresh()
self._lives = 3
self._stars = -1 #to initialise, however will never get this value
self._levels = 0 #initialise
self._num_portals = 0
#Registering event types allows the dispatcher to validate event handler names as they are attached and to search attached objects for suitable handlers.
self.register_event_type("on_frame")
with self.canvas:
self._lives_instruction = Rectangle(texture=self._lives_label.texture, pos=(7, Window.height *0.93), size=self._lives_label.texture.size)
self.keysPressed = set()
self._entities = set()
Clock.schedule_interval(self._on_frame, 0)
Clock.schedule_interval(self.checks_win_lose, 0)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self._keyboard = Window.request_keyboard(self._on_keyboard_closed,
self)
self._keyboard.bind(on_key_down=self._on_key_down)
self._keyboard.bind(on_key_up=self._on_key_up)
self._score_label = CoreLabel(text='Score: 0', font_size=20)
self._score_label.refresh()
self._score = 0
self.register_event_type('on_frame')
with self.canvas:
Color(1, 1, 1)
Rectangle(source='background.jpg',
pos=(0, 0),
size=(Window.width, Window.height))
self._score_instruction = Rectangle(
texture=self._score_label.texture,
pos=(0, Window.height - 50),
size=(self._score_label.texture.size))
self.keysPressed = set()
self._entities = set()
Clock.schedule_interval(self._on_frame, 0)
self.sound = SoundLoader.load('Cats_Searching_for_the_Truth.mp3')
self.sound.play()
Clock.schedule_interval(self.spawn_enemies, 2)
def __init__(self, x, y):
self._score_label = CoreLabel(text="Score : 0", font_size=30)
self._score_label.refresh()
self.score_label_instruction = Rectangle(
texture=self._score_label.texture,
pos=(x, y),
size=self._score_label.texture.size)
self._score = 0
def __init__(self, **kwargs):
super().__init__(**kwargs)
self._keyboard = Window.request_keyboard(self._on_keyboard_closed,
self)
self._keyboard.bind(on_key_down=self._on_key_down)
self._keyboard.bind(on_key_up=self._on_key_up)
self._goldLabel = CoreLabel(text="Gold: " + str(money), font_size=15)
self._goldLabel.refresh()
self._gold = money
self._tHealthLabel = CoreLabel(text="Health: 100", font_size=20)
self._tHealthLabel.refresh()
self._tHealth = 100
self._pHealth = 10
self.register_event_type(
"on_frame") # This is from the super thing that we are inheriting
with self.canvas.before:
Rectangle(source=bg_img,
pos=(0, 0),
size=(Window.width, Window.height))
self._gold_instruction = Rectangle(
texture=self._goldLabel.texture,
pos=(0, Window.height - 100),
size=self._goldLabel.texture.size)
self._tHealth_instruction = Rectangle(
texture=self._tHealthLabel.texture,
pos=(Window.width / 2 - (130 / 2) + 10, 260),
size=self._tHealthLabel.texture.size)
with self.canvas.after:
Rectangle(source="images/Shop.png",
pos=(0, Window.height - 75),
size=(100, 50))
btn1 = Button(text="Shop",
pos=(0, Window.height - 90),
background_color=(0, 0, 0, 0))
btn1.bind(on_press=show_popup)
self.add_widget(btn1)
btn_save = Button(text="Save",
pos=((Window.width - self.size[0]),
Window.height - self.size[1]))
btn_save.bind(on_press=save)
self.add_widget(btn_save)
self.keysPressed = set()
self._entities = set()
Clock.schedule_interval(self._on_frame, 0)
self.sound = SoundLoader.load("Music\Ominous Music.mp3")
self.sound.play()
Clock.schedule_interval(self.spawn_enemies, 2)
self.last_time_a = 0
self.last_time_w = 0
Clock.schedule_interval(self.check_time, 0.1)
def __init__(self, x, y, txt, src="", fontsize=30):
self.live_label = CoreLabel(text=txt, font_size=fontsize)
self.live_label.refresh()
self.label_instruction = Rectangle(texture=self.live_label.texture,
pos=(x, y),
size=self.live_label.texture.size)
self.image_instruction = Rectangle(source=src,
pos=(x + 100, y),
size=(30, 30))
def createCoins(self, parts, shape, color):
# Шрифт
LabelBase.register(name='CG', fn_regular=paths['font'])
with self.canvas:
Color(0, 0, 0, 1) #black
# Базовые размеры
w = 595
h = 842
# Размеры жетона
x = 94
y = 94
# Отступ от края листа
margin = 70
# Фон
Color(1, 1, 1, 1) #white
self.canvas.add(Rectangle(size=[w, h], pos=[0, 0]))
# Жетоны
for i in range(len(parts)):
# Ряд жетонов на листе
row = 1
row += int(i / 6)
# Надпись на жетоне
name = CoreLabel(font_name='CG', text=parts[i], font_size=45)
name.refresh()
name = name.texture
Color(0, 0, 0, 1) #black
if shape == 'round':
self.canvas.add(
Line(circle=(x * (i - (row - 1) * 6) + margin, y * row,
47),
width=1))
if shape == 'square':
self.canvas.add(
Line(rectangle=(x * (i - (row - 1) * 6) + margin -
x / 2, y * row - y / 2, 94, 94),
width=1))
Color(rgba=color)
self.canvas.add(
Rectangle(size=name.size,
pos=[(x * (i - (row - 1) * 6) + margin) -
(name.size[0] / 2),
y * row - name.size[1] / 2],
texture=name))
def __init__(self, **kw):
super().__init__(**kw)
if app.root:
Clock.schedule_once(self.render_background)
self.children[0].children[2].markup = True
label = CoreLabel(text=self.icon,
font_name='fnt/segmdl2.ttf',
font_size=72,
color=theme.sec,
padding=[18, 18])
label.refresh()
self._icon_tex = label.texture
self._icon_rect = self.canvas.get_group('icon')[0]
# close button texture
label = CoreLabel(text='\u00d7', font_size=36, size=(36, 36))
label.refresh()
self.canvas.after.get_group('close_button')[0].texture = label.texture
self._close_button_color = theme.sec
# close button hovering behavior
Window.bind(mouse_pos=self.on_mouse_pos)
Clock.schedule_interval(self.dance_icon, 2)
def __init__(self, y, text, action):
super(GeneralButton, self).__init__()
self.action = action
self.color = Color(*(1, 1, 1))
self.add(self.color)
#added lable for texturing the buttons
label = CoreLabel(text=text, font_size=Window.height / 20)
label.refresh()
text = label.texture
self.size = text.size
x = Window.width / 2 - text.size[0] / 2
self.pos = (x, y)
self.button = Rectangle(texture=text, pos=self.pos, size=text.size)
self.add(self.button)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.keyboard = Window.request_keyboard(self.on_keyboard_closed, self)
self.keyboard.bind(on_key_down=self.on_key_down)
self.keyboard.bind(on_key_up=self.on_key_up)
self.score = 0
self.score_label = CoreLabel(text=str("Score: " + str(self.score)))
self.score_label.refresh()
self.level = 1
# Create a set of pressed keys for the given moment
self.keysPressed = set()
def update_text(self, text, color):
label = CoreLabel(text=text, font_size=self.font)
label.refresh()
self.remove(self.color)
self.remove(self.item)
self.color = Color(*color)
self.add(self.color)
self.text = label.texture
self.item.texture = self.text
self.item.size = self.text.size
self.add(self.item)
self.ratio = self.text.size[0] / self.text.size[1]
# run(MainWidget, None)
def __init__(self, y, song, start_end, key):
super(SongButtons, self).__init__()
self.start_end = start_end
self.song = song
self.key = key
self.color = Color(*(1, 1, 1))
self.add(self.color)
#added lable for texturing the buttons
label = CoreLabel(text=song, font_size=Window.height / 20)
label.refresh()
text = label.texture
self.size = text.size
x = Window.width / 2 - text.size[0] / 2
self.pos = (x, y)
self.button = Rectangle(texture=text, pos=self.pos, size=text.size)
self.add(self.button)
def __init__(self, **kwargs):
super().__init__(**kwargs)
#to use keyboard to play
self._keyboard = Window.request_keyboard(self._on_keyboard_closed,
self)
self._keyboard.bind(on_key_down=self._on_key_down)
self._keyboard.bind(on_key_up=self._on_key_up)
self._score_label = CoreLabel(text="Score: 0",
font_size=20) #init score label
self._score_label.refresh() #so can update score
self._score = 0 #initial score
self._life_label = CoreLabel(text="Life: 10",
font_size=20) #init life lbel
self._life_label.refresh() #so can update life
self._life = 10 #initial life
self.register_event_type("on_frame")
with self.canvas:
#my background
Rectangle(source="assets/background.png",
pos=(0, 0),
size=(Window.width, Window.height))
#my score text on top left
self._score_instruction = Rectangle(
texture=self._score_label.texture,
pos=(0, Window.height - 50),
size=self._score_label.texture.size)
#life text top left
self._life_instruction = Rectangle(
texture=self._life_label.texture,
pos=(0, Window.height - 75),
size=self._life_label.texture.size)
self.keysPressed = set()
self._entities = set()
Clock.schedule_interval(self._on_frame, 0)
self.sound = SoundLoader.load("assets/music.WAV")
self.sound.play()
Clock.schedule_interval(self.spawn_enemies,
1.5) #to spawn enemies every 1.5secs
def __init__(self, **kwargs):
Widget.__init__(self, **kwargs)
# create keyboard
self.keyboard = Window.request_keyboard(self.keyboard_closed, self)
self.keyboard.bind(on_key_down=self.on_keyboard_down)
# custom events
self.register_event_type('on_land')
self.bind(on_land=self.check_landing)
# canvas core labels
self.lose_label = CoreLabel(text='', font_size=40)
self.lose_label.refresh()
self.lose_instruction = Rectangle(texture=self.lose_label.texture,
pos=(85, 430),
size=self.lose_label.texture.size)
self.aim_label = CoreLabel(text='', font_size=20)
self.aim_label.refresh()
self.aim_instruction = Rectangle(texture=self.aim_label.texture,
pos=(415, 300),
size=self.aim_label.texture.size)
self.score_label = CoreLabel(text='Score: 0', font_size=20)
self.score_label.refresh()
self.score_instruction = Rectangle(texture=self.score_label.texture,
pos=(400, 530),
size=self.score_label.texture.size)
self.speed_label = CoreLabel(text='Speed: 1.0', font_size=20)
self.speed_label.refresh()
self.speed_instruction = Rectangle(texture=self.speed_label.texture,
pos=(400, 485),
size=self.speed_label.texture.size)
self.canvas.add(self.lose_instruction)
self.canvas.add(self.score_instruction)
self.canvas.add(self.aim_instruction)
self.canvas.add(self.speed_instruction)
# graphics
line_instruction = InstructionGroup()
line_instruction.add(Color(1, 1, 1, 1))
line_instruction.add(Line(points=[0, 518, 500, 518], width=2))
self.canvas.add(line_instruction)
self.canvas.add(self.next_block.instruction)
# run these functions continuously
Clock.schedule_interval(self.move_tower, 0.02)
Clock.schedule_interval(self.move_block, 0.04)
Clock.schedule_interval(self.drop_block, 0)
Clock.schedule_interval(self.check_tower, 0)
class Progress(ProgressBar):
def __init__(self, **kwargs):
super(Progress, self).__init__(**kwargs)
self.label = CoreLabel(text='Time Left: ', font_size=20)
self.texture_size = None
self.refresh_text()
self.draw()
def draw(self):
with self.canvas:
self.canvas.clear()
# Draw no progress bar
Color(.188, .209, .148)
RoundedRectangle(pos=self.pos, size=self.size)
Color(.5, 0, 0)
if self.value > 0:
var = 100.0 / self.value
# Draw progress bar
RoundedRectangle(pos=self.pos,
size=(self.width / var, self.height))
# Center and draw the text
Color(1, 1, 1, 1)
RoundedRectangle(texture=self.label.texture,
size=self.texture_size,
pos=(self.size[0] / 2 - self.texture_size[0] / 2,
self.size[1] / 2 - self.texture_size[1] / 2))
def refresh_text(self):
# Render the label
self.label.refresh()
# Set the texture size each refresh
self.texture_size = list(self.label.texture.size)
def set_value(self, value):
self.value = value
self.refresh_text()
self.size = (400, 30)
self.draw()
def reset(self):
self.clear_widgets()
for wall in self.walls:
del wall
del self.current_bottom_wall
del self.current_top_wall
self.canvas.clear()
Clock.unschedule(self.birdy_update)
Clock.unschedule(self.wall_update)
self.birdy = Bird()
self.add_widget(self.birdy)
self.birdy.size_hint = (50 / Window.size[0], 50 / Window.size[1])
self.birdy.pos_hint = {'x': 0.5, 'y': 0.5}
self.birdy_windowpos = [
self.birdy.pos_hint['x'] * Window.size[0],
self.birdy.pos_hint['y'] * Window.size[1]
]
self.resetbtn = ResetBtn()
self.add_widget(self.resetbtn)
self.resetbtn.size_hint = (0.15, 0.06)
self.resetbtn.pos_hint = {'x': 0.8, 'y': 0.90}
self.walls = []
self.current_bottom_wall = None
self.current_top_wall = None
self.add_random_wall()
self.score = 0
self.score_label = CoreLabel(text="Score:" + str(self.score),
font_size=30,
color=(1, 0.7, 0, 0.8))
self.score_label.refresh()
with self.canvas:
self.score_instruction = Rectangle(
texture=self.score_label.texture,
pos=(20, Window.size[1] - 50),
size=self.score_label.texture.size)
self.birdy_update = Clock.schedule_interval(self.birdy.update, 0.03)
self.wall_update = Clock.schedule_interval(self.update, 0)
class Score(Widget):
def __init__(self, x, y):
self._score_label = CoreLabel(text="Score : 0", font_size=30)
self._score_label.refresh()
self.score_label_instruction = Rectangle(
texture=self._score_label.texture,
pos=(x, y),
size=self._score_label.texture.size)
self._score = 0
@property
def score(self):
return self._score
@score.setter
def score(self, val):
self._score = val
self._score_label.text = "Score : " + str(val)
self._score_label.refresh()
self.score_label_instruction.texture = self._score_label.texture
self.score_label_instruction.size = self._score_label.texture.size
def __init__(self, **kwargs):
super().__init__(**kwargs)
self._keyboard = Window.request_keyboard(self._on_keyboard_closed,
self)
self._keyboard.bind(on_key_down=self._on_key_down)
self._keyboard.bind(on_key_up=self._on_key_up)
self._score_label = CoreLabel(text="Score: 0")
self._score_label.refresh()
self._score = 0
self.register_event_type("on_frame")
with self.canvas:
self._score_instruction = Rectangle(
texture=self._score_label.texture,
pos=(Window.width / 2, Window.height - 25),
size=self._score_label.texture.size)
self.keysPressed = set()
self._entities = set()
Clock.schedule_interval(self._on_frame, 0)
Clock.schedule_interval(self.spawn_enemies, 3)
def gen_texture(text: str, font_size: int):
num_label = CoreLabel(text=text, font_size=font_size)
num_label.refresh()
return num_label.texture
class GameWidget(Widget):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self._keyboard = Window.request_keyboard(self._on_keyboard_closed,
self)
self._keyboard.bind(on_key_down=self._on_key_down)
self._keyboard.bind(on_key_up=self._on_key_up)
self._goldLabel = CoreLabel(text="Gold: " + str(money), font_size=15)
self._goldLabel.refresh()
self._gold = money
self._tHealthLabel = CoreLabel(text="Health: 100", font_size=20)
self._tHealthLabel.refresh()
self._tHealth = 100
self._pHealth = 10
self.register_event_type(
"on_frame") # This is from the super thing that we are inheriting
with self.canvas.before:
Rectangle(source=bg_img,
pos=(0, 0),
size=(Window.width, Window.height))
self._gold_instruction = Rectangle(
texture=self._goldLabel.texture,
pos=(0, Window.height - 100),
size=self._goldLabel.texture.size)
self._tHealth_instruction = Rectangle(
texture=self._tHealthLabel.texture,
pos=(Window.width / 2 - (130 / 2) + 10, 260),
size=self._tHealthLabel.texture.size)
with self.canvas.after:
Rectangle(source="images/Shop.png",
pos=(0, Window.height - 75),
size=(100, 50))
btn1 = Button(text="Shop",
pos=(0, Window.height - 90),
background_color=(0, 0, 0, 0))
btn1.bind(on_press=show_popup)
self.add_widget(btn1)
btn_save = Button(text="Save",
pos=((Window.width - self.size[0]),
Window.height - self.size[1]))
btn_save.bind(on_press=save)
self.add_widget(btn_save)
self.keysPressed = set()
self._entities = set()
Clock.schedule_interval(self._on_frame, 0)
self.sound = SoundLoader.load("Music\Ominous Music.mp3")
self.sound.play()
Clock.schedule_interval(self.spawn_enemies, 2)
self.last_time_a = 0
self.last_time_w = 0
Clock.schedule_interval(self.check_time, 0.1)
def check_time(self, dt):
global original_a
global original_w
global pause
if pause == 1:
if time.time() - self.last_time_a >= 1:
if assassin_lives == 1 and original_a:
self.add_entity(AssassinLT(
(((Window.width / 2) - 200), 0)))
self.last_time_a = time.time()
if time.time() - self.last_time_w >= 3:
if wizard_lives == 1:
self.add_entity(fireball(((Window.width / 2) + 190, 5)))
self.last_time_w = time.time()
def spawn_enemies(self, dt):
global pause
if pause == 1:
for i in range(2):
random_spd = random.randint(25, 50)
self.add_entity(EnemyLT((Window.width, 0), random_spd))
self.add_entity(EnemyRT((0, 0), random_spd))
def _on_frame(self, dt):
self.dispatch("on_frame", dt)
def on_frame(self, dt):
pass
@property
def gold(self): # Score getter
return self._gold
@gold.setter
def gold(self, value): # Score setter
self._gold = value
self._goldLabel.text = "Gold: " + str(value)
self._goldLabel.refresh()
self._gold_instruction.texture = self._goldLabel.texture
self._gold_instruction.size = self._goldLabel.size
@property
def tHealth(self): # Score getter
return self._tHealth
@tHealth.setter
def tHealth(self, value): # Score setter
self._tHealth = value
self._tHealthLabel.text = "Health: " + str(value)
self._tHealthLabel.refresh()
self._tHealth_instruction.texture = self._tHealthLabel.texture
self._tHealth_instruction.size = self._tHealthLabel.size
def set_wizard(self):
rect1 = Rectangle(pos=(((Window.width / 2) + 150), 0),
size=(50, 50),
source='images/wizard frames/tile023.png')
self.add_entity(WizardRT((((Window.width / 2) + 150), 0)))
self.canvas.add(rect1)
def set_assassin(self):
rect2 = Rectangle(pos=(((Window.width / 2) - 200), 0),
size=(50, 50),
source='images/Bad guy frames/tile015.png')
self.add_entity(AssassinLT((((Window.width / 2) - 200), 0)))
self.canvas.add(rect2)
def buy(self):
global money
global weapon
global person
global weap_rt
global weap_lt
global weap_size
global durability
if weapon == 1 and self._gold >= 10:
global durability
weapon = 0
game.gold -= 10
money -= 10
durability = 2
weap_rt = 'images/swordB_RT.png'
weap_lt = 'images/swordB_LT.png'
weap_size[0] = 30
weap_size[1] = 30
if person == 1 and self._gold >= 100:
person = 0
game.gold -= 100
money -= 100
#rect1 = Rectangle(pos=(((Window.width / 2) + 150), 0), size=(50, 50), source='images/wizard frames/tile023.png')
self.add_entity(WizardRT((((Window.width / 2) + 150), 0)))
#self.canvas.add(rect1)
if person == 2 and self._gold >= 100:
person = 0
game.gold -= 100
money -= 100
rect2 = Rectangle(pos=(((Window.width / 2) - 200), 0),
size=(50, 50),
source='images/Bad guy frames/tile015.png')
self.add_entity(AssassinLT((((Window.width / 2) - 200), 0)))
self.canvas.add(rect2)
def add_entity(self, entity):
self._entities.add(entity)
self.canvas.add(entity._instruction)
def remove_entity(self, entity):
if entity in self._entities:
self._entities.remove(entity)
self.canvas.remove(entity._instruction)
def collides(
self, e1, e2, value
): # Gets two tuples of rectangles position and returns a boolean if they collide.
r1x = e1.pos[0] + value
r1y = e1.pos[1]
r2x = e2.pos[0]
r2y = e2.pos[1]
r1w = e1.size[0] + value
r1h = e1.size[1]
r2w = e2.size[0]
r2h = e2.size[1]
if (
r1x < r2x + r2w and r1x + r1w > r2x and r1y < r2y + r2h
and r1y + r1h > r2y
): # The bottom left has the position then the height adds to the value to see if the bottom left of the second picture is collding.
return True
else:
return False
def colliding_entities(self, entity, dir):
result = set()
for e in self._entities:
if self.collides(
e, entity, dir
) and e != entity: # e == entry checks if the entity is colliding with itself.
result.add(e)
return result
def _on_keyboard_closed(self):
self._keyboard.unbind(on_key_down=self._on_key_down)
self._keyboard.unbind(on_key_up=self._on_key_up)
self.keyboard = None
def _on_key_down(self, keyboard, keycode, text, modifiers):
self.keysPressed.add(keycode[1])
def _on_key_up(self, keyboard, keycode):
text = keycode[1]
if text in self.keysPressed:
self.keysPressed.remove(text)
class GameWidget(Widget):
drop, lose = (False, False)
tower = [Block(230, 0)]
next_block = Block(230, 520)
score = 0
speed = 1.0
def __init__(self, **kwargs):
Widget.__init__(self, **kwargs)
# create keyboard
self.keyboard = Window.request_keyboard(self.keyboard_closed, self)
self.keyboard.bind(on_key_down=self.on_keyboard_down)
# custom events
self.register_event_type('on_land')
self.bind(on_land=self.check_landing)
# canvas core labels
self.lose_label = CoreLabel(text='', font_size=40)
self.lose_label.refresh()
self.lose_instruction = Rectangle(texture=self.lose_label.texture,
pos=(85, 430),
size=self.lose_label.texture.size)
self.aim_label = CoreLabel(text='', font_size=20)
self.aim_label.refresh()
self.aim_instruction = Rectangle(texture=self.aim_label.texture,
pos=(415, 300),
size=self.aim_label.texture.size)
self.score_label = CoreLabel(text='Score: 0', font_size=20)
self.score_label.refresh()
self.score_instruction = Rectangle(texture=self.score_label.texture,
pos=(400, 530),
size=self.score_label.texture.size)
self.speed_label = CoreLabel(text='Speed: 1.0', font_size=20)
self.speed_label.refresh()
self.speed_instruction = Rectangle(texture=self.speed_label.texture,
pos=(400, 485),
size=self.speed_label.texture.size)
self.canvas.add(self.lose_instruction)
self.canvas.add(self.score_instruction)
self.canvas.add(self.aim_instruction)
self.canvas.add(self.speed_instruction)
# graphics
line_instruction = InstructionGroup()
line_instruction.add(Color(1, 1, 1, 1))
line_instruction.add(Line(points=[0, 518, 500, 518], width=2))
self.canvas.add(line_instruction)
self.canvas.add(self.next_block.instruction)
# run these functions continuously
Clock.schedule_interval(self.move_tower, 0.02)
Clock.schedule_interval(self.move_block, 0.04)
Clock.schedule_interval(self.drop_block, 0)
Clock.schedule_interval(self.check_tower, 0)
def move_tower(self, dt):
'''
Oscillates the towers based on
the step size from move_towerSM.
'''
step_size = move_towerSM.step()
for towerblock in self.tower:
self.canvas.remove(towerblock.instruction)
towerblock.x += step_size
towerblock.shape.pos = (towerblock.x, towerblock.y)
towerblock.instruction.add(towerblock.shape)
self.canvas.add(towerblock.instruction)
def move_block(self, dt):
'''
Oscillates the building block based on
the step size from move_blockSM.
'''
if self.drop == False:
step_size = move_blockSM.step()
self.canvas.remove(self.next_block.instruction)
self.next_block.x += step_size
self.next_block.shape.pos = (self.next_block.x, self.next_block.y)
self.next_block.instruction.add(self.next_block.shape)
self.canvas.add(self.next_block.instruction)
def check_tower(self, dt):
'''
Removes the bottommost block if
tower is more than 4 blocks tall.
'''
if len(self.tower) == 5:
self.canvas.remove(self.tower[0].instruction)
self.tower.pop(0)
# shift remaining blocks down
for towerblock in self.tower:
towerblock.y -= towerblock.size[1]
def drop_block(self, dt):
'''
Drops the building block was the SPACEBAR is pressed.
'''
if self.drop == False:
return
current_y = self.next_block.y
top_towerblock = len(self.tower) - 1
top_towerblock_y = self.tower[top_towerblock].y
height = self.tower[top_towerblock].size[1]
if current_y > top_towerblock_y + height:
# change y coordinate and redraw
self.canvas.remove(self.next_block.instruction)
self.next_block.y -= 450 * dt
self.next_block.shape.pos = (self.next_block.x, self.next_block.y)
self.next_block.instruction.add(self.next_block.shape)
self.canvas.add(self.next_block.instruction)
if current_y <= top_towerblock_y + height:
# stop dropping
self.next_block.y = top_towerblock_y + height
self.drop = False
self.dispatch('on_land', dt)
def check_landing(self, value, dt):
'''
Checks the accuracy of the landing.
Update score, speed and labels accordingly.
'''
top_block = len(self.tower) - 1
top_x = self.tower[top_block].x
top_y = self.tower[top_block].y
width = self.tower[top_block].size[0]
height = self.tower[top_block].size[1]
# failed landing
if self.next_block.x < top_x - width or self.next_block.x > top_x + width:
self.lose = True
self.update_labels('lose')
# successful landing
else:
self.score += 1
# bad landing
if self.next_block.x < top_x - 0.5 * width or self.next_block.x > top_x + 0.5 * width:
self.update_labels('Bad..')
if move_towerSM.coeff <= 14:
move_towerSM.coeff *= 1.2
move_blockSM.coeff *= 1.2
self.speed += 0.2
# good landing
elif self.next_block.x < top_x - 0.1 * width or self.next_block.x > top_x + 0.1 * width:
self.update_labels('Good')
if move_towerSM.coeff <= 14:
move_towerSM.coeff *= 1.1
move_blockSM.coeff *= 1.1
self.speed += 0.1
# great landing
else:
self.update_labels('Great!')
if move_towerSM.coeff > 2:
self.speed -= 0.1
move_towerSM.coeff *= 0.9
move_blockSM.coeff *= 0.9
# append next_block to self.tower
self.tower.append(self.next_block)
# update labels, draw new building block
self.update_speed()
self.update_score()
self.draw_new_block()
def update_labels(self, result):
'''
Updates aim and lose label.
'''
if result == 'lose':
self.aim_label.text = ''
self.lose_label.text = "OH NO! YOU LOST!"
self.lose_label.refresh()
self.lose_instruction.texture = self.lose_label.texture
self.lose_instruction.size = self.lose_label.texture.size
elif result == 'restart':
self.aim_label.text = ''
self.lose_label.text = ''
self.lose_label.refresh()
self.lose_instruction.texture = self.lose_label.texture
self.lose_instruction.size = self.lose_label.texture.size
else:
self.aim_label.text = result
self.aim_label.refresh()
self.aim_instruction.texture = self.aim_label.texture
self.aim_instruction.size = self.aim_label.texture.size
def update_speed(self):
'''
Updates speed label.
'''
self.speed_label.text = "Speed: " + str(round(self.speed, 1))
self.speed_label.refresh()
self.speed_instruction.texture = self.speed_label.texture
self.speed_instruction.size = self.speed_label.texture.size
def update_score(self):
'''
Updates score label.
'''
self.score_label.text = "Score: " + str(self.score)
self.score_label.refresh()
self.score_instruction.texture = self.score_label.texture
self.score_instruction.size = self.score_label.texture.size
def draw_new_block(self):
'''
Creates a new Block object at the starting position.
'''
move_blockSM.start()
self.next_block = Block(230, 520)
self.canvas.add(self.next_block.instruction)
def restart(self):
'''
Reset tower and building blocks,
SM, class variables and labels.
'''
for towerblock in self.tower:
self.canvas.remove(towerblock.instruction)
self.tower = [Block(230, 0)]
self.canvas.remove(self.next_block.instruction)
self.next_block = Block(230, 520)
move_blockSM.start()
move_towerSM.start()
move_blockSM.coeff = 4
move_towerSM.coeff = 2
# reset labels
self.score = 0
self.speed = 1.0
self.update_score()
self.update_speed()
self.update_labels('restart')
self.drop, self.lose = (False, False)
def on_land(self, dt):
'''
Default handler for the custom event 'on_land'.
'''
pass
def keyboard_closed(self):
pass
def on_keyboard_down(self, keyboard, keycode, text, modifiers):
'''
Listens for SPACE BAR key down to trigger self.drop_block().
'''
if self.manager.current == 'play':
if keycode[1] == 'spacebar' and self.lose == False:
self.drop = True
def createTickets(self, parts, font_color, border_color):
# Шрифт
LabelBase.register(name='CG', fn_regular=paths['font'])
with self.canvas:
Color(0, 0, 0, 1) #black
# Базовые размеры
w = 595
h = 842
# Отступ
margin = 28
marginY = 369
# Промежуток
middleX = 9
middleY = 65
# Размеры билета
ticketX = 567
ticketY = 369
# Размеры ячейки
cell = 128
# Фон
Color(1, 1, 1, 1) #white
self.canvas.add(Rectangle(size=[w, h], pos=[0, 0]))
# Изображение
imageX = 111
imageY = 45
# Билеты
tickets = [None] * int(len(parts) / 8)
for i in range(len(tickets)):
tickets[i] = [None] * 8
num = 0
for i in range(len(parts)):
if (num / 8 == 1):
num = 0
tickets[int(i / 8)][num] = parts[i]
num += 1
# trigger запускает отрисовку второго билета на листе
trigger = 0
for i in range(len(tickets)):
Color(0, 0, 0, 1) #black
self.canvas.add(
Line(rectangle=(0, marginY * trigger, w, ticketY),
width=1))
for num in range(len(tickets[i])):
# Ряд в билете
j = 1
j += int(num / 4)
# Формирование содержимого ячейки
name = CoreLabel(font_name='CG',
text=str(tickets[i][num]),
font_size=45)
name.refresh()
name = name.texture
Color(rgba=border_color)
self.canvas.add(
Line(rectangle=(margin + (cell + middleX) *
(num - (j - 1) * 4),
margin + (cell + middleY) * (j - 1) +
marginY * trigger, cell, cell),
width=3))
Color(rgba=font_color)
self.canvas.add(
Rectangle(size=name.size,
pos=(margin + (cell + middleX) *
(num - (j - 1) * 4) + cell / 2 -
name.size[0] / 2, margin +
(cell + middleY) * (j - 1) + cell / 2 -
name.size[1] / 2 + marginY * trigger),
texture=name))
# Добавление логотипов на билет
self.canvas.add(
Rectangle(source=paths['logo'],
size=(imageX, imageY),
pos=(ticketX / 3 - imageX / 2,
margin + cell + middleY / 2 - imageY / 2 +
marginY * trigger)))
self.canvas.add(
Rectangle(source=paths['logo'],
size=(imageX, imageY),
pos=((ticketX / 3) * 2 - imageX / 2,
margin + cell + middleY / 2 - imageY / 2 +
marginY * trigger)))
trigger = 1
class Game(FloatLayout):
def __init__(self):
super().__init__()
self.birdy = Bird()
self.add_widget(self.birdy)
self.birdy.size_hint = (50 / Window.size[0], 50 / Window.size[1])
self.birdy.pos_hint = {'x': 0.5, 'y': 0.5}
self.birdy_windowpos = [
self.birdy.pos_hint['x'] * Window.size[0],
self.birdy.pos_hint['y'] * Window.size[1]
]
self.resetbtn = ResetBtn()
self.add_widget(self.resetbtn)
self.resetbtn.size_hint = (0.15, 0.06)
self.resetbtn.pos_hint = {'x': 0.8, 'y': 0.90}
self.walls = []
self.current_bottom_wall = None
self.current_top_wall = None
self.add_random_wall()
self.score = 0
self.score_label = CoreLabel(text="Score:" + str(self.score),
font_size=30,
color=(1, 0.7, 0, 0.8))
self.score_label.refresh()
with self.canvas:
self.score_instruction = Rectangle(
texture=self.score_label.texture,
pos=(20, Window.size[1] - 50),
size=self.score_label.texture.size)
self.high_score = 0
self.birdy_update = Clock.schedule_interval(self.birdy.update, 0.03)
self.wall_update = Clock.schedule_interval(self.update, 0)
def add_bottom_wall(self, pos, size):
with self.canvas:
self.rect = Rectangle(source='Bottom wall.png', pos=pos, size=size)
self.walls.append(self.rect)
self.current_bottom_wall = self.rect
def add_top_wall(self, pos, size):
with self.canvas:
self.rect = Rectangle(source='Top wall.png', pos=pos, size=size)
self.walls.append(self.rect)
self.current_top_wall = self.rect
# Add wall at random height
def add_random_wall(self):
height = random.uniform(100, Window.size[1] - 300)
self.add_bottom_wall((0.9 * Window.size[0], 0), (50, height))
self.add_top_wall((0.9 * Window.size[0], height + 200),
(50, Window.size[1] - height - 200))
def game_speed(self):
bds = 0
if self.score % 5 == 0:
bds = bds + self.score / 5
else:
bds = bds + self.score // 5
bs = bird_stateSM(bds)
bs.start()
return bs.step(self.score)
# Run updates
def update(self, dt):
self.score_instruction.pos = (20, Window.size[1] - 50)
self.birdy_windowpos = [
self.birdy.pos_hint['x'] * Window.size[0],
self.birdy.pos_hint['y'] * Window.size[1]
]
self.k = self.game_speed() + App.userspeed * 20
# move the wall
for wall in self.walls:
wall.pos = (wall.pos[0] - self.k * dt, wall.pos[1])
# Remove wall from the list after it leaves screen
self.walls = [i for i in self.walls if i.pos[0] >= -50]
#add new wall when wall pass 0.48 of the window
if self.walls[-1].pos[0] <= 0.48 * Window.size[0]:
self.add_random_wall()
self.score += 1
self.new_score()
self.gameover()
def new_score(self):
self.score_label.text = "Score: " + str(self.score)
self.score_label.refresh()
self.score_instruction.texture = self.score_label.texture
self.score_instruction.size = self.score_label.texture.size
def get_high_score(self):
if self.high_score < self.score:
self.high_score = self.score
else:
return self.high_score
def gameover(self):
#when bird within the width of wall
if self.current_bottom_wall.pos[0] <= (
self.birdy_windowpos[0] +
25) and (self.birdy_windowpos[0] +
25) <= self.current_bottom_wall.pos[0] + 50:
#i bird hit the bottom wall
if (self.current_bottom_wall.pos[1] +
self.current_bottom_wall.size[1]) > (
self.birdy_windowpos[1] + 8):
self.get_high_score()
self.label = Label(text="Game Over\n" + 'Score:' +
str(self.score) + '\n' + 'High Score:' +
str(self.high_score),
halign='center',
valign='center',
font_size=60)
self.add_widget(self.label)
self.label.size_hint = (0.5, 0.2)
self.label.pos_hint = {'x': 0.25, 'y': 0.5}
self.canvas.remove(self.score_instruction)
Clock.unschedule(self.birdy_update)
Clock.unschedule(self.wall_update)
# if bird hit top wall
elif self.current_top_wall.pos[1] < (self.birdy_windowpos[1] + 60):
self.get_high_score()
self.label = Label(text="Game Over\n" + 'Score:' +
str(self.score) + '\n' + 'High Score:' +
str(self.high_score),
halign='center',
valign='center',
font_size=60)
self.add_widget(self.label)
self.label.size_hint = (0.5, 0.2)
self.label.pos_hint = {'x': 0.25, 'y': 0.5}
self.canvas.remove(self.score_instruction)
Clock.unschedule(self.birdy_update)
Clock.unschedule(self.wall_update)
# if bird out of zone
elif self.birdy_windowpos[1] + 10 <= 0:
self.get_high_score()
self.label = Label(text="Game Over\n" + 'Score:' +
str(self.score) + '\n' + 'High Score:' +
str(self.high_score),
halign='center',
valign='center',
font_size=60)
self.add_widget(self.label)
self.label.size_hint = (0.5, 0.2)
self.label.pos_hint = {'x': 0.25, 'y': 0.5}
self.canvas.remove(self.score_instruction)
Clock.unschedule(self.birdy_update)
Clock.unschedule(self.wall_update)
elif self.birdy_windowpos[1] + 50 >= Window.size[1]:
self.get_high_score()
self.label = Label(text="Game Over\n" + 'Score:' +
str(self.score) + '\n' + 'High Score:' +
str(self.high_score),
halign='center',
valign='center',
font_size=60)
self.add_widget(self.label)
self.label.size_hint = (0.5, 0.2)
self.label.pos_hint = {'x': 0.25, 'y': 0.5}
self.canvas.remove(self.score_instruction)
Clock.unschedule(self.birdy_update)
Clock.unschedule(self.wall_update)
def reset(self):
self.clear_widgets()
for wall in self.walls:
del wall
del self.current_bottom_wall
del self.current_top_wall
self.canvas.clear()
Clock.unschedule(self.birdy_update)
Clock.unschedule(self.wall_update)
self.birdy = Bird()
self.add_widget(self.birdy)
self.birdy.size_hint = (50 / Window.size[0], 50 / Window.size[1])
self.birdy.pos_hint = {'x': 0.5, 'y': 0.5}
self.birdy_windowpos = [
self.birdy.pos_hint['x'] * Window.size[0],
self.birdy.pos_hint['y'] * Window.size[1]
]
self.resetbtn = ResetBtn()
self.add_widget(self.resetbtn)
self.resetbtn.size_hint = (0.15, 0.06)
self.resetbtn.pos_hint = {'x': 0.8, 'y': 0.90}
self.walls = []
self.current_bottom_wall = None
self.current_top_wall = None
self.add_random_wall()
self.score = 0
self.score_label = CoreLabel(text="Score:" + str(self.score),
font_size=30,
color=(1, 0.7, 0, 0.8))
self.score_label.refresh()
with self.canvas:
self.score_instruction = Rectangle(
texture=self.score_label.texture,
pos=(20, Window.size[1] - 50),
size=self.score_label.texture.size)
self.birdy_update = Clock.schedule_interval(self.birdy.update, 0.03)
self.wall_update = Clock.schedule_interval(self.update, 0)
class GameWidget(Widget):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self._keyboard = Window.request_keyboard(self._on_keyboard_closed,
self)
self._keyboard.bind(on_key_down=self._on_key_down)
self._keyboard.bind(on_key_up=self._on_key_up)
self._score_label = CoreLabel(text="Score: 0", font_size=20)
self._score_label.refresh()
self._score = 0
self.register_event_type("on_frame")
with self.canvas:
Rectangle(source="assets/background.png",
pos=(0, 0),
size=(Window.width, Window.height))
self._score_instruction = Rectangle(
texture=self._score_label.texture,
pos=(0, Window.height - 50),
size=self._score_label.texture.size)
self.keysPressed = set()
self._entities = set()
Clock.schedule_interval(self._on_frame, 0)
self.sound = SoundLoader.load("assets/music.wav")
self.sound.play()
Clock.schedule_interval(self.spawn_enemies, 2)
def spawn_enemies(self, dt):
for i in range(5):
random_x = random.randint(0, Window.width)
y = Window.height
random_speed = random.randint(100, 300)
self.add_entity(Enemy((random_x, y), random_speed))
def _on_frame(self, dt):
self.dispatch("on_frame", dt)
def on_frame(self, dt):
pass
@property
def score(self):
return self._score
@score.setter
def score(self, value):
self._score = value
self._score_label.text = "Score: " + str(value)
self._score_label.refresh()
self._score_instruction.texture = self._score_label.texture
self._score_instruction.size = self._score_label.texture.size
def add_entity(self, entity):
self._entities.add(entity)
self.canvas.add(entity._instruction)
def remove_entity(self, entity):
if entity in self._entities:
self._entities.remove(entity)
self.canvas.remove(entity._instruction)
def collides(self, e1, e2):
r1x = e1.pos[0]
r1y = e1.pos[1]
r2x = e2.pos[0]
r2y = e2.pos[1]
r1w = e1.size[0]
r1h = e1.size[1]
r2w = e2.size[0]
r2h = e2.size[1]
if (r1x < r2x + r2w and r1x + r1w > r2x and r1y < r2y + r2h
and r1y + r1h > r2y):
return True
else:
return False
def colliding_entities(self, entity):
result = set()
for e in self._entities:
if self.collides(e, entity) and e != entity:
result.add(e)
return result
def _on_keyboard_closed(self):
self._keyboard.unbind(on_key_down=self._on_key_down)
self._keyboard.unbind(on_key_up=self._on_key_up)
self._keyboard = None
def _on_key_down(self, keyboard, keycode, text, modifiers):
self.keysPressed.add(keycode[1])
def _on_key_up(self, keyboard, keycode):
text = keycode[1]
if text in self.keysPressed:
self.keysPressed.remove(text)
class GameWidget(Widget):
def __init__(self, **kwargs):
super().__init__(**kwargs)
#to use keyboard to play
self._keyboard = Window.request_keyboard(self._on_keyboard_closed,
self)
self._keyboard.bind(on_key_down=self._on_key_down)
self._keyboard.bind(on_key_up=self._on_key_up)
self._score_label = CoreLabel(text="Score: 0",
font_size=20) #init score label
self._score_label.refresh() #so can update score
self._score = 0 #initial score
self._life_label = CoreLabel(text="Life: 10",
font_size=20) #init life lbel
self._life_label.refresh() #so can update life
self._life = 10 #initial life
self.register_event_type("on_frame")
with self.canvas:
#my background
Rectangle(source="assets/background.png",
pos=(0, 0),
size=(Window.width, Window.height))
#my score text on top left
self._score_instruction = Rectangle(
texture=self._score_label.texture,
pos=(0, Window.height - 50),
size=self._score_label.texture.size)
#life text top left
self._life_instruction = Rectangle(
texture=self._life_label.texture,
pos=(0, Window.height - 75),
size=self._life_label.texture.size)
self.keysPressed = set()
self._entities = set()
Clock.schedule_interval(self._on_frame, 0)
self.sound = SoundLoader.load("assets/music.WAV")
self.sound.play()
Clock.schedule_interval(self.spawn_enemies,
1.5) #to spawn enemies every 1.5secs
def spawn_enemies(self, dt):
if self._score > -1 and self._score < 15:
for i in range(self._score + int(2)):
random_y = random.randint(10, Window.height - 100)
x = Window.width
random_speed = random.randint(
150, 400
) #to spawn enemies with a random speed between 150 to 400
self.add_entity(Enemy((x, random_y), random_speed))
elif self._score > 14 and self._score < 100:
for i in range(15):
random_y = random.randint(10, Window.height - 100)
x = Window.width
random_speed = random.randint(350, 500)
self.add_entity(Enemy((x, random_y), random_speed))
elif self._score > 99 and self._score < 200:
for i in range(14):
random_y = random.randint(10, Window.height - 100)
x = Window.width
random_speed = random.randint(450, 600)
self.add_entity(Enemy((x, random_y), random_speed))
elif self._score > 199:
for i in range(10):
random_y = random.randint(10, Window.height - 100)
x = Window.width
random_speed = random.randint(650, 800)
self.add_entity(Enemy((x, random_y), random_speed))
elif self._score < 0 and self._score > -50:
for i in range(10):
random_y = random.randint(10, Window.height - 100)
x = Window.width
random_speed = random.randint(800, 900)
self.add_entity(Enemy((x, random_y), random_speed))
elif self._score < -49:
for i in range(15):
random_y = random.randint(10, Window.height - 100)
x = Window.width
random_speed = random.randint(800, 1000)
self.add_entity(Enemy((x, random_y), random_speed))
def _on_frame(self, dt):
self.dispatch("on_frame", dt)
def on_frame(self, dt):
pass
@property
def score(self): #score getter
return self._score
@score.setter
def score(self, value): #score setter
self._score = value #set private attribute of score
self._score_label.text = "Score: " + str(
value) #to add a value to 'score'
self._score_label.refresh() #update label text
self._score_instruction.texture = self._score_label.texture #update texture of instruction
self._score_instruction.size = self._score_label.texture.size #update size of instruction
@property
def life(self): #life getter
return self._life
@life.setter
def life(self, lifes): #life setter
self._life = lifes #set private attribute of score
self._life_label.text = "Life: " + str(
lifes) #to add a value to 'score'
self._life_label.refresh() #update label text
self._life_instruction.texture = self._life_label.texture #update texture of instruction
self._life_instruction.size = self._life_label.texture.size #update size of instruction
def add_entity(self, entity):
self._entities.add(entity)
self.canvas.add(entity._instruction)
def remove_entity(self, entity):
if entity in self._entities:
self._entities.remove(entity)
self.canvas.remove(entity._instruction)
def collides(
self, e1, e2
): #axis aligned bounding box collision pos,0 position is xvalue,1 position is yvalue
r1x = e1.pos[0]
r1y = e1.pos[1]
r2x = e2.pos[0]
r2y = e2.pos[1]
r1w = e1.size[0]
r1h = e1.size[1]
r2w = e2.size[0]
r2h = e2.size[1]
if (r1x < r2x + r2w and r1x + r1w > r2x and r1y < r2y + r2h
and r1y + r1h > r2y):
return True
else:
return False
def colliding_entities(
self, entity
): #takes in an entity and see if it collides with our entity.
result = set() #empty set
for e in self._entities:
if self.collides(
e, entity
) and e != entity: #the entity we checking for will also be in entity list, so we must have !, to show not equal.if not will show self collision
result.add(e)
return result
def _on_keyboard_closed(self):
self._keyboard.unbind(on_key_down=self._on_key_down)
self._keyboard.unbind(on_key_up=self._on_key_up)
self._keyboard = None
def _on_key_down(self, keyboard, keycode, text, modifiers):
self.keysPressed.add(keycode[1])
def _on_key_up(self, keyboard, keycode):
text = keycode[1]
if text in self.keysPressed:
self.keysPressed.remove(text)
