def update(self):
if (Time.now() - self.last_update_time) * Time.time_scale >= self.time_to_update_score:
self.score = self.score + self.score_per_step
self.last_update_time = Time.now()
Constants.current_score = self.score
self.game_object_list[0].text_mesh.message = str(int(self.score))
def should_spawn(self):
"""
:return: if it should spawn
"""
if Time.now() - self.time > self.period:
self.time = Time.now()
return True
else:
return False
def should_spawn(self):
if self.num_of_periods != "inf":
self.actual_period += 1
if self.num_of_periods > self.actual_period:
return False
if (Time.now() - self.last_time) > self.period:
self.last_time = Time.now()
return True
else:
return False
def change_scene(self):
"""
Will fade screen out and the change it
"""
if self.should_fade_out:
ScreenFader(fade="out", fade_duration=self.fade_out_duration)
self.should_fade_out = False
self.should_change_scene = True
self.change_scene_timer = Time.now()
Time.time_scale = 0
if self.should_change_scene and Time.now(
) - self.change_scene_timer > self.fade_out_duration + 0.2:
Time.time_scale = 1.0
Scene.change_scene(2)
def update(self):
if Time.time_scale == 0.0:
#Paused Balance. Adjust timers
self.time_of_last_invencibily += Time.delta_time(True)
difference_time = Time.now() - self.time_of_last_invencibily
if difference_time > self.invecible_time:
for i in range(2):
self.player_controller.game_object_list[i].is_invencible = False
self.get_back_to_original_colors()
self.current_animation_tick_index = 0
else:
value = min(difference_time / self.invecible_time, 1) # Just to convert between 0 and 1
diff = abs(value - self.animation_ticks_times[self.current_animation_tick_index])
if(diff < 0.01):
self.current_animation_tick_index += 1
self.tick_colors()
for obstacle in self.game_object_list:
if obstacle.transform.position.y > Constants.screen_height:
self.game_object_list.remove(obstacle)
obstacle.destroy(obstacle)
GameObject.destroy(obstacle)
else:
self.fall(obstacle)
self.delete_power_up_text()
def update(self):
"""
Will be destroyed after a time
"""
self.physics.inst_velocity = self.inst_vel
if Time.now() - self.spawn_time > 0.01:
self.destroy_me()
def start(self):
"""
Will start a particle effect
"""
self.physics.inst_velocity = self.inst_vel
self.particle_system = ParticleSystem(self,
Particle,
quant=15,
period=0.01,
vel_min=30,
vel_max=130,
duration=0.9,
gravity=130,
layer=10,
inherit_vel=True,
inherit_vel_mult=0.5,
unscaled=True,
num_of_periods=1)
self.particle_system.set_circ_gen(self.transform.position,
radius=self.radius,
mode="radial",
direct_met=self.direct_met,
ini_angle_met=self.ini_angle_met,
fin_angle_met=self.fin_angle_met)
self.particle_system.play()
self.spawn_time = Time.now()
def start(self):
"""
NomalBehaivor start method
will be called when the object is instantiate on scene
"""
self.time = Time.now()
self.period = 1.5
font_path = "Balance/assets/fonts/neuropolxrg.ttf"
message_x = 15
message_y = 300
message_size = 14
score = str(int(Constants.current_score))
score_size = 28
score_x = 30
score_y = 240
title_x = 20
title_y = 180
title_size = 50
self.game_object_list = [
Text(Vector2(title_x, title_y), "You died", Material(Color.red),
title_size, font_path),
Text(Vector2(score_x, score_y), "Score: " + score,
Material(Color.white), score_size, font_path),
Text(Vector2(message_x,
message_y), "Press arrows keys to try again",
Material(Color.white), message_size, font_path)
]
self.setup_fader()
BackgroundParticlesController()
def start(self):
"""
NomalBehaivor start method
will be called when the object is instantiate on scene
"""
self.time = Time.now()
self.period = 0.9
font_path = "Balance/assets/fonts/neuropolxrg.ttf"
message_x = 10
message_y = 270
message_size = 14
title_x = 37
title_y = 200
title_size = 50
self.setup_soundtrack()
BackgroundParticlesController()
self.game_object_list = [
Text(Vector2(message_x,
message_y), "Press arrows keys to start playing",
Material(Color.white), message_size, font_path),
Text(Vector2(title_x, title_y), "Balance", Material(Color.white),
title_size, font_path)
]
self.setup_fader()
def initial_animation(self):
if self.in_initial_animation:
if self.should_play:
self.should_play = False
self.game_object_list[0].animator.play()
self.game_object_list[1].animator.play()
if Time.now() - self.initial_time > 1.0:
self.in_initial_animation = False
def start(self):
self.obstacle_generators = [
SimpleObstacleController(Vector2(0, 0), 0, Vector2(0, 0), 0)
]
self.rect_x_controller = RandomXFinalObstacleController(
Vector2(0, 0), 0, Vector2(0, 0), 0)
self.obstacle_geneation_delta = 1500
self.last_generation_time = 1000 * Time.now()
self.game_object_list = []
self.last_increases_dificculty_time = Time.now()
self.game_difficuty = 1
self.time_to_increase_difficult = 6.2
self.generation_obstacle_difficult = 1
self.max_difficult = 10
self.should_delete_difficulty_text = False
self.diff_text_gen_time = 0.0
for obstacle_generator in self.obstacle_generators:
obstacle_generator.start()
def update(self):
"""
NomalBehaivor update method
will be call every frame
"""
if self.should_spawn():
self.spawn_block()
if self.pressed_button() and self.can_press_button:
self.should_timer = True
self.can_press_button = False
if self.should_timer:
ScreenFader(fade="out")
self.timer = Time.now()
self.should_timer = False
self.should_change_scene = True
if self.should_change_scene:
if Time.now() - self.timer > 0.68:
Scene.change_scene(1)
def die(self):
# TODO: change how collider works: dont use the collider list
Collider.remove(self)
self.circle_collider = None
self.animator.play_next_animation()
self.should_die = True
self.die_time = Time.now()
def update(self):
if Time.time_scale == 0.0:
#Adjust timer when paused
self.last_power_up_time += 1000 * Time.delta_time(True)
if 1000 * Time.now() - self.last_power_up_time > self.power_up_generation_delta * \
self.generation_obstacle_difficult:
self.generate_random_power_up()
def start(self):
self.power_up_generators = [
StarScoreController(Vector2(0, 0), 0, Vector2(0, 0), 0),
InvenciblePowerUpController(Vector2(0, 0), 0, Vector2(0, 0), 0)
]
self.power_up_generation_delta = 6500
self.last_power_up_time = 1000 * Time.now()
self.generation_obstacle_difficult = 1
for power_up_generator in self.power_up_generators:
power_up_generator.start()
def initialize_scene(self):
"""
When is the correct time, initialize scene
This will happen just once
"""
if Time.now() - self.initial_time > 0.45 and self.should_initialize:
self.should_initialize = False
self.background_particle_controller = BackgroundParticlesController(
)
self.player_controller = PlayerController()
self.obstacle_controller_wrapper = ObstacleControllerWrapper()
self.items_controller = ItemsControllerWrapper()
self.score_controller = ScoreController()
def generate_random_obstacle(self):
self.last_generation_time = 1000 * Time.now()
number_of_obstacles = int(
min(self.game_difficuty, len(self.obstacle_generators)))
random_ind = rand(0, number_of_obstacles - 1)
random_obstacle_generator = self.obstacle_generators[random_ind]
if type(random_obstacle_generator) == RectTranslateXObstacleController:
self.last_generation_time -= 300
if self.game_difficuty == self.max_difficult:
self.rect_x_controller.generate_obstacle()
random_obstacle_generator.generate_obstacle()
def start(self):
self.angle = 0.0
self.angularSpeed = 5.0
self.game_object_list = [
PlayerCircle(
Vector2(Constants.circCenter_x + Constants.circRadius,
Constants.screen_height + 15), 15,
Material(Color.blue, alpha=240)),
PlayerCircle(
Vector2(Constants.circCenter_x - Constants.circRadius,
Constants.screen_height + 15), 15,
Material(Color.orange, alpha=240))
]
self.in_initial_animation = True
self.should_play = True
self.initial_time = Time.now()
def get_star(self):
self.sound_collect.play()
obstacle = self.game_object_list[0]
#plus score effect
font_path = "Balance/assets/fonts/neuropolxrg.ttf"
plus_score = Text(obstacle.transform.position, "+50", Material(Color.white, alpha=255), 15, font_path)
plus_score.transform.position.x -= plus_score.text_mesh.size
plus_score.animation = TextUpFadeOutAnimation(plus_score)
plus_score.animator = Animator(plus_score, [plus_score.animation])
plus_score.animator.play()
self.time_of_last_plus_score = Time.now()
self.plus_score = plus_score
self.should_delete_plus_score_text = True
self.score_controller.score += self.points_per_star
def update(self):
if Time.time_scale < 0.5:
#Adjust timers to new delta
self.last_generation_time += 1000 * Time.delta_time(True)
self.last_increases_dificculty_time += Time.delta_time(True)
self.increase_difficult()
self.delete_difficulty_text()
if (1000 * Time.now() - self.last_generation_time) * Time.time_scale > self.obstacle_geneation_delta * \
self.generation_obstacle_difficult:
self.generate_random_obstacle()
for obstacle_generator in self.obstacle_generators:
game_objs = obstacle_generator.game_object_list
self.game_object_list.extend(game_objs)
def __init__(self,
game_object,
spawn_game_obj_class,
layer=0,
quant=1,
quant_proport_to_len=False,
period=0.05,
vel_min=80,
vel_max=160,
duration=1.0,
gravity=0,
inherit_vel=False,
inherit_vel_mult=1,
spawn_prob="lin",
vel_prob="lin",
unscaled=False,
num_of_periods="inf"):
super().__init__(game_object)
self.duration = duration
self.gravity = gravity
self.vel_min = vel_min
self.layer = layer
self.vel_max = vel_max
self.inherit_vel = inherit_vel
self.quant_proport_to_len = quant_proport_to_len
self.inherit_vel_mult = inherit_vel_mult
self.quant = quant
self.turned_on = False
self.period = period
self.spawn_game_obj_class = spawn_game_obj_class
self.last_time = Time.now()
self.ini_point_method = None
self.fin_point_method = None
self.generation_mode = None
self.obj_list = list()
self.spawn_prob = None
self.vel_prob = None
self.define_vel_prob(vel_prob)
self.define_spawn_prob(spawn_prob)
self.unscaled = unscaled
self.num_of_periods = num_of_periods
self.actual_period = 0
if self.inherit_vel:
if self.game_object.physics is None:
self.game_object.physics = Physics(self.game_object)
def start(self):
self.particle_system = ParticleSystem(self,
Particle,
quant=30,
period=0.02,
vel_min=40,
vel_max=80,
duration=2,
gravity=98,
layer=10)
self.particle_system.set_circ_gen(self.transform.position,
1,
mode="radial",
direct_met=self.direct_met,
ini_angle_met=self.ini_angle_met,
fin_angle_met=self.fin_angle_met)
self.particle_system.play()
self.spawn_time = Time.now()
def get_power_up(self):
self.sound_collect.play()
power_up = self.game_object_list[0]
#Power up text effect
font_path = "Balance/assets/fonts/neuropolxrg.ttf"
text_size = 15
power_up_text = Text(power_up.transform.position, "INVENCIBLE!", Material(Color.purple, alpha=255), text_size, font_path)
power_up_text.transform.position.x -= power_up_text.text_mesh.size
power_up_text.animation = TextUpFadeOutAnimation(power_up_text)
power_up_text.animator = Animator(power_up_text, [power_up_text.animation])
power_up_text.animator.play()
for i in range(2):
self.player_controller.game_object_list[i].is_invencible = True
self.change_colors_to_green()
self.time_of_last_invencibily = Time.now()
self.power_up_text = power_up_text
self.should_delete_power_up_text = True
def start(self):
"""
Create a animation that fades the entire screen
Pass this animation to animator and play it
"""
key_frames = list()
if self.fade == "in":
key_frames.append(KeyFrame(0.0, alpha=255))
key_frames.append(KeyFrame(self.fade_duration, alpha=0))
else:
key_frames.append(KeyFrame(0.0, alpha=0))
key_frames.append(KeyFrame(self.fade_duration, alpha=255))
self.animation = Animation(self,
key_frames,
should_loop=False,
unscaled="True")
self.animator = Animator(self, animation_list=[self.animation])
self.animator.play()
self.creation_time = Time.now()
def start(self):
font_path = "Balance/assets/fonts/neuropolxrg.ttf"
self.time_to_update_score = 0.095
self.score_per_step = 1 # Number of steps of the Balance required to update the score
self.last_update_time = Time.now()
self.score = 0.0
score_x = 10.0
score_y = 5.0
score_message = str(int(self.score))
score_color = Color.white
score_size = 15
self.game_object_list = [
Text(Vector2(score_x, score_y), score_message, Material(score_color), score_size, font_path)
]
self.game_object_list[0].text_mesh.message = str(int(self.score))
def generate_difficulty_text(self):
title_x = 0.35 * Constants.screen_width
title_y = 0.3 * Constants.screen_height
title_size = 50
text = "HARDER!"
if self.game_difficuty == self.max_difficult:
text = "MAX DIFFICULTY!"
title_size = 28
title_x = 0.20 * Constants.screen_width
font_path = "Balance/assets/fonts/neuropolxrg.ttf"
diff_text = Text(Vector2(title_x - title_size, title_y), text,
Material(Color.red, alpha=255), title_size, font_path)
diff_text.transform.position.x -= diff_text.text_mesh.size
diff_text.animation = TextUpFadeOutAnimation(diff_text)
diff_text.animator = Animator(diff_text, [diff_text.animation])
diff_text.animator.play()
self.diff_text = diff_text
self.diff_text_gen_time = Time.now()
self.should_delete_difficulty_text = True
def update(self):
if self.should_die:
if Time.now() - self.die_time > 0.4:
self.destroy_me()
def update(self):
if self.change:
self.change = False
self.material = Material(self.creator_obj.material.color)
if Time.now() - self.creation_time > self.destroy_time:
self.destroy_me()
def update(self):
"""
Will destroy the animation after finished it
"""
if Time.now() - self.creation_time > self.fade_duration * 2:
GameObject.destroy(self)
def update(self):
if Time.now() - self.spawn_time > 0.03:
self.destroy_me()
