diff options
Diffstat (limited to 'samples/99_genre_platformer/clepto_frog/app/main.rb')
| -rw-r--r-- | samples/99_genre_platformer/clepto_frog/app/main.rb | 864 |
1 files changed, 864 insertions, 0 deletions
diff --git a/samples/99_genre_platformer/clepto_frog/app/main.rb b/samples/99_genre_platformer/clepto_frog/app/main.rb new file mode 100644 index 0000000..a4eb069 --- /dev/null +++ b/samples/99_genre_platformer/clepto_frog/app/main.rb @@ -0,0 +1,864 @@ +MAP_FILE_PATH = 'app/map.txt' + +require 'app/map.rb' + +class CleptoFrog + attr_gtk + + def render_ending + state.game_over_at ||= state.tick_count + + outputs.labels << [640, 700, "Clepto Frog", 4, 1] + + if state.tick_count >= (state.game_over_at + 120) + outputs.labels << [640, 620, "\"I... I.... don't believe it.\" - New Guy", + 4, 1, 0, 0, 0, 255 * (state.game_over_at + 120).ease(60)] + end + + if state.tick_count >= (state.game_over_at + 240) + outputs.labels << [640, 580, "\"He actually stole all the mugs?\" - New Guy", + 4, 1, 0, 0, 0, 255 * (state.game_over_at + 240).ease(60)] + end + + if state.tick_count >= (state.game_over_at + 360) + outputs.labels << [640, 540, "\"Kind of feel bad STARTING HIM WITH NOTHING again.\" - New Guy", + 4, 1, 0, 0, 0, 255 * (state.game_over_at + 360).ease(60)] + end + + outputs.sprites << [640 - 50, 360 - 50, 100, 100, + "sprites/square-green.png"] + + outputs.labels << [640, 300, "Current Time: #{"%.2f" % state.stuff_time}", 4, 1] + outputs.labels << [640, 270, "Best Time: #{"%.2f" % state.stuff_best_time}", 4, 1] + + if state.tick_count >= (state.game_over_at + 550) + restart_game + end + end + + def restart_game + state.world = nil + state.x = nil + state.y = nil + state.dx = nil + state.dy = nil + state.stuff_score = 0 + state.stuff_time = 0 + state.intro_tick_count = nil + defaults + state.game_start_at = state.tick_count + state.scene = :game + state.game_over_at = nil + end + + def render_intro + outputs.labels << [640, 700, "Clepto Frog", 4, 1] + if state.tick_count >= 120 + outputs.labels << [640, 620, "\"Uh... your office has a pet frog?\" - New Guy", + 4, 1, 0, 0, 0, 255 * 120.ease(60)] + end + + if state.tick_count >= 240 + outputs.labels << [640, 580, "\"Yep! His name is Clepto.\" - Jim", + 4, 1, 0, 0, 0, 255 * 240.ease(60)] + end + + if state.tick_count >= 360 + outputs.labels << [640, 540, "\"Uh...\" - New Guy", + 4, 1, 0, 0, 0, 255 * 360.ease(60)] + end + + if state.tick_count >= 480 + outputs.labels << [640, 500, "\"He steals mugs while we're away...\" - Jim", + 4, 1, 0, 0, 0, 255 * 480.ease(60)] + end + + if state.tick_count >= 600 + outputs.labels << [640, 460, "\"It's not a big deal, we take them back in the morning.\" - Jim", + 4, 1, 0, 0, 0, 255 * 600.ease(60)] + end + + outputs.sprites << [640 - 50, 360 - 50, 100, 100, + "sprites/square-green.png"] + + if state.tick_count == 800 + state.scene = :game + state.game_start_at = state.tick_count + end + end + + def tick + defaults + if state.scene == :intro && state.tick_count <= 800 + render_intro + elsif state.scene == :ending + render_ending + else + render + end + calc + process_inputs + end + + def defaults + state.scene ||= :intro + state.stuff_score ||= 0 + state.stuff_time ||= 0 + state.stuff_best_time ||= nil + state.camera_x ||= 0 + state.camera_y ||= 0 + state.target_camera_scale ||= 1 + state.camera_scale ||= 1 + state.tongue_length ||= 100 + state.dev_action ||= :collision_mode + state.action ||= :aiming + state.tongue_angle ||= 90 + state.tile_size = 64 + state.gravity = -0.1 + state.air = -0.01 + state.player_width = 60 + state.player_height = 60 + state.collision_tolerance = 0.0 + state.previous_tile_size ||= state.tile_size + state.x ||= 2400 + state.y ||= 200 + state.dy ||= 0 + state.dx ||= 0 + attempt_load_world_from_file + state.world_lookup ||= { } + state.world_collision_rects ||= [] + state.mode ||= :creating + state.select_menu ||= [0, 720, 1280, 720] + state.sprite_quantity ||= 20 + state.sprite_coords ||= [] + state.banner_coords ||= [640, 680 + 720] + state.sprite_selected ||= 1 + state.map_saved_at ||= 0 + state.intro_tick_count ||= state.tick_count + if state.sprite_coords == [] + count = 1 + temp_x = 165 + temp_y = 500 + 720 + state.sprite_quantity.times do + state.sprite_coords += [[temp_x, temp_y, count]] + temp_x += 100 + count += 1 + if temp_x > 1280 - (165 + 50) + temp_x = 165 + temp_y -= 75 + end + end + end + end + + def start_of_tongue x = nil, y = nil + x ||= state.x + y ||= state.y + [ + x + state.player_width.half, + y + state.player_height.half + ] + end + + def stage_definition + outputs.sprites << [vx(0), vy(0), vw(10000), vw(5875), 'sprites/level-map.png'] + end + + def render + stage_definition + start_of_tongue_render = [vx(start_of_tongue.x), vy(start_of_tongue.y)] + end_of_tongue_render = [vx(end_of_tongue.x), vy(end_of_tongue.y)] + + if state.anchor_point + anchor_point_render = [vx(state.anchor_point.x), vy(state.anchor_point.y)] + outputs.sprites << { x: start_of_tongue_render.x, + y: start_of_tongue_render.y, + w: vw(2), + h: args.geometry.distance(start_of_tongue_render, anchor_point_render), + path: 'sprites/square-pink.png', + angle_anchor_y: 0, + angle: state.tongue_angle - 90 } + else + outputs.sprites << { x: vx(start_of_tongue.x), + y: vy(start_of_tongue.y), + w: vw(2), + h: vh(state.tongue_length), + path: 'sprites/square-pink.png', + angle_anchor_y: 0, + angle: state.tongue_angle - 90 } + end + + outputs.sprites << state.objects.map { |o| [vx(o.x), vy(o.y), vw(o.w), vh(o.h), o.path] } + + if state.god_mode + # SHOW HIDE COLLISIONS + outputs.sprites << state.world.map do |x, y, w, h| + x = vx(x) + y = vy(y) + if x > -80 && x < 1280 && y > -80 && y < 720 + { + x: x, + y: y, + w: vw(w || state.tile_size), + h: vh(h || state.tile_size), + path: 'sprites/square-gray.png', + a: 128 + } + end + end + end + + render_player + outputs.sprites << [vx(2315), vy(45), vw(569), vh(402), 'sprites/square-blue.png', 0, 40] + + # Label in top left of the screen + outputs.primitives << [20, 640, 180, 70, 255, 255, 255, 128].solid + outputs.primitives << [30, 700, "Stuff: #{state.stuff_score} of #{$mugs.count}", 1].label + outputs.primitives << [30, 670, "Time: #{"%.2f" % state.stuff_time}", 1].label + + if state.god_mode + if state.map_saved_at > 0 && state.map_saved_at.elapsed_time < 120 + outputs.primitives << [920, 670, 'Map has been exported!', 1, 0, 50, 100, 50].label + end + + + # Creates sprite following mouse to help indicate which sprite you have selected + outputs.primitives << [inputs.mouse.position.x, inputs.mouse.position.y, + state.tile_size, state.tile_size, 'sprites/square-indigo.png', 0, 100].sprite + end + + render_mini_map + outputs.primitives << [0, 0, 1280, 720, 255, 255, 255, 255 * state.game_start_at.ease(60, :flip)].solid + end + + def render_mini_map + x, y = 1170, 10 + outputs.primitives << [x, y, 100, 58, 0, 0, 0, 200].solid + outputs.primitives << [x + args.state.x.fdiv(100) - 1, y + args.state.y.fdiv(100) - 1, 2, 2, 0, 255, 0].solid + t_start = start_of_tongue + t_end = end_of_tongue + outputs.primitives << [ + x + t_start.x.fdiv(100), y + t_start.y.fdiv(100), + x + t_end.x.fdiv(100), y + t_end.y.fdiv(100), + 255, 255, 255 + ].line + + state.objects.each do |o| + outputs.primitives << [x + o.x.fdiv(100) - 1, y + o.y.fdiv(100) - 1, 2, 2, 200, 200, 0].solid + end + end + + def calc_camera percentage_override = nil + percentage = percentage_override || (0.2 * state.camera_scale) + target_scale = state.target_camera_scale + distance_scale = target_scale - state.camera_scale + state.camera_scale += distance_scale * percentage + + target_x = state.x * state.target_camera_scale + target_y = state.y * state.target_camera_scale + + distance_x = target_x - (state.camera_x + 640) + distance_y = target_y - (state.camera_y + 360) + state.camera_x += distance_x * percentage if distance_x.abs > 1 + state.camera_y += distance_y * percentage if distance_y.abs > 1 + state.camera_x = 0 if state.camera_x < 0 + state.camera_y = 0 if state.camera_y < 0 + end + + def vx x + (x * state.camera_scale) - state.camera_x + end + + def vy y + (y * state.camera_scale) - state.camera_y + end + + def vw w + w * state.camera_scale + end + + def vh h + h * state.camera_scale + end + + def calc + calc_camera + calc_world_lookup + calc_player + calc_on_floor + calc_score + end + + def set_camera_scale v = nil + return if v < 0.1 + state.target_camera_scale = v + end + + def process_inputs_god_mode + return unless state.god_mode + + if inputs.keyboard.key_down.equal_sign || (inputs.keyboard.equal_sign && state.tick_count.mod_zero?(10)) + set_camera_scale state.camera_scale + 0.1 + elsif inputs.keyboard.key_down.hyphen || (inputs.keyboard.hyphen && state.tick_count.mod_zero?(10)) + set_camera_scale state.camera_scale - 0.1 + elsif inputs.keyboard.eight || inputs.keyboard.zero + set_camera_scale 1 + end + + if input_up? + state.y += 10 + state.dy = 0 + elsif input_down? + state.y -= 10 + state.dy = 0 + end + + if input_left? + state.x -= 10 + state.dx = 0 + elsif input_right? + state.x += 10 + state.dx = 0 + end + end + + def process_inputs + if state.scene == :game + process_inputs_player_movement + process_inputs_god_mode + elsif state.scene == :intro + if args.inputs.keyboard.key_down.enter || args.inputs.keyboard.key_down.space + if Kernel.tick_count < 600 + Kernel.tick_count = 600 + end + end + end + end + + def input_up? + inputs.keyboard.w || inputs.keyboard.up || inputs.keyboard.k + end + + def input_up_released? + inputs.keyboard.key_up.w || + inputs.keyboard.key_up.up || + inputs.keyboard.key_up.k + end + + def input_down? + inputs.keyboard.s || inputs.keyboard.down || inputs.keyboard.j + end + + def input_down_released? + inputs.keyboard.key_up.s || + inputs.keyboard.key_up.down || + inputs.keyboard.key_up.j + end + + def input_left? + inputs.keyboard.a || inputs.keyboard.left || inputs.keyboard.h + end + + def input_right? + inputs.keyboard.d || inputs.keyboard.right || inputs.keyboard.l + end + + def set_object path, w, h + state.object = path + state.object_w = w + state.object_h = h + end + + def collision_mode + state.dev_action = :collision_mode + end + + def process_inputs_player_movement + if inputs.keyboard.key_down.g + state.god_mode = !state.god_mode + puts state.god_mode + end + + if inputs.keyboard.key_down.u && state.dev_action == :collision_mode + state.world = state.world[0..-2] + state.world_lookup = {} + end + + if inputs.keyboard.key_down.space && !state.anchor_point + state.tongue_length = 0 + state.action = :shooting + outputs.sounds << 'sounds/shooting.wav' + elsif inputs.keyboard.key_down.space + state.action = :aiming + state.anchor_point = nil + state.tongue_length = 100 + end + + if state.anchor_point + if input_up? + if state.tongue_length >= 105 + state.tongue_length -= 5 + state.dy += 0.8 + end + elsif input_down? + state.tongue_length += 5 + state.dy -= 0.8 + end + + if input_left? && state.dx > 1 + state.dx *= 0.98 + elsif input_left? && state.dx < -1 + state.dx *= 1.03 + elsif input_left? && !state.on_floor + state.dx -= 3 + elsif input_right? && state.dx > 1 + state.dx *= 1.03 + elsif input_right? && state.dx < -1 + state.dx *= 0.98 + elsif input_right? && !state.on_floor + state.dx += 3 + end + else + if input_left? + state.tongue_angle += 1.5 + state.tongue_angle = state.tongue_angle + elsif input_right? + state.tongue_angle -= 1.5 + state.tongue_angle = state.tongue_angle + end + end + end + + def add_floors + # floors + state.world += [ + [0, 0, 10000, 40], + [0, 1670, 3250, 60], + [6691, 1653, 3290, 60], + [1521, 3792, 7370, 60], + [0, 5137, 3290, 60] + ] + end + + def attempt_load_world_from_file + return if state.world + # exported_world = gtk.read_file(MAP_FILE_PATH) + state.world = [] + state.objects = [] + + if $collisions + $collisions.map do |x, y, w, h| + state.world << [x, y, w, h] + end + + add_floors + # elsif exported_world + # exported_world.each_line.map do |l| + # tokens = l.strip.split(',') + # x = tokens[0].to_i + # y = tokens[1].to_i + # type = tokens[2].to_i + # if type == 1 + # state.world << [x, y, state.tile_size, state.tile_size] + # elsif type == 2 + # w, h, path = tokens[3..-1] + # state.objects << [x, y, w.to_i, h.to_i, path] + # end + # end + + # add_floors + end + + if $mugs + $mugs.map do |x, y, w, h, path| + state.objects << [x, y, w, h, path] + end + end + end + + def calc_world_lookup + if state.tile_size != state.previous_tile_size + state.previous_tile_size = state.tile_size + state.world_lookup = {} + end + + return if state.world_lookup.keys.length > 0 + return unless state.world.length > 0 + + # Searches through the world and finds the cordinates that exist + state.world_lookup = {} + state.world.each do |x, y, w, h| + state.world_lookup[[x, y, w || state.tile_size, h || state.tile_size]] = true + end + + # Assigns collision rects for every sprite drawn + state.world_collision_rects = + state.world_lookup + .keys + .map do |x, y, w, h| + s = state.tile_size + w ||= s + h ||= s + { + args: [x, y, w, h], + left_right: [x, y + 4, w, h - 6], + top: [x + 4, y + 6, w - 8, h - 6], + bottom: [x + 1, y - 1, w - 2, h - 8], + } + end + + end + + def calc_pendulum + return if !state.anchor_point + target_x = state.anchor_point.x - start_of_tongue.x + target_y = state.anchor_point.y - + state.tongue_length - 5 - 20 - state.player_height + + diff_y = state.y - target_y + + if target_x > 0 + state.dx += 0.6 + elsif target_x < 0 + state.dx -= 0.6 + end + + if diff_y > 0 + state.dy -= 0.1 + elsif diff_y < 0 + state.dy += 0.1 + end + + state.dx *= 0.99 + + if state.dy.abs < 2 + state.dy *= 0.8 + else + state.dy *= 0.90 + end + + if state.tongue_length && state.y + state.dy += state.tongue_angle.vector_y state.tongue_length.fdiv(1000) + end + end + + def calc_tongue_angle + return unless state.anchor_point + state.tongue_angle = args.geometry.angle_from state.anchor_point, start_of_tongue + state.tongue_length = args.geometry.distance(start_of_tongue, state.anchor_point) + state.tongue_length = state.tongue_length.greater(100) + end + + def player_from_end_of_tongue + p = state.tongue_angle.vector(state.tongue_length) + derived_start = [state.anchor_point.x - p.x, state.anchor_point.y - p.y] + derived_start.x -= state.player_width.half + derived_start.y -= state.player_height.half + derived_start + end + + def end_of_tongue + p = state.tongue_angle.vector(state.tongue_length) + [start_of_tongue.x + p.x, start_of_tongue.y + p.y] + end + + def calc_shooting + return unless state.action == :shooting + state.tongue_length += 30 + potential_anchor = end_of_tongue + if potential_anchor.x <= 0 + state.anchor_point = potential_anchor + state.action = :anchored + outputs.sounds << 'sounds/attached.wav' + elsif potential_anchor.x >= 10000 + state.anchor_point = potential_anchor + state.action = :anchored + outputs.sounds << 'sounds/attached.wav' + elsif potential_anchor.y <= 0 + state.anchor_point = potential_anchor + state.action = :anchored + outputs.sounds << 'sounds/attached.wav' + elsif potential_anchor.y >= 5875 + state.anchor_point = potential_anchor + state.action = :anchored + outputs.sounds << 'sounds/attached.wav' + else + anchor_rect = [potential_anchor.x - 5, potential_anchor.y - 5, 10, 10] + collision = state.world_collision_rects.find_all do |v| + [v[:args].x, v[:args].y, v[:args].w, v[:args].h].intersect_rect?(anchor_rect) + end.first + if collision + state.anchor_point = potential_anchor + state.action = :anchored + outputs.sounds << 'sounds/attached.wav' + end + end + end + + def calc_player + calc_shooting + if !state.god_mode + state.dy += state.gravity # Since acceleration is the change in velocity, the change in y (dy) increases every frame + state.dx += state.dx * state.air + end + calc_pendulum + calc_box_collision + calc_edge_collision + if !state.god_mode + state.y += state.dy + state.x += state.dx + end + calc_tongue_angle + end + + def calc_box_collision + return unless state.world_lookup.keys.length > 0 + collision_floor + collision_left + collision_right + collision_ceiling + end + + def calc_edge_collision + # Ensures that player doesn't fall below the map + if next_y < 0 && state.dy < 0 + state.y = 0 + state.dy = state.dy.abs * 0.8 + state.collision_on_y = true + # Ensures player doesn't go insanely high + elsif next_y > 5875 - state.tile_size && state.dy > 0 + state.y = 5875 - state.tile_size + state.dy = state.dy.abs * 0.8 * -1 + state.collision_on_y = true + end + + # Ensures that player remains in the horizontal range its supposed to + if state.x >= 10000 - state.tile_size && state.dx > 0 + state.x = 10000 - state.tile_size + state.dx = state.dx.abs * 0.8 * -1 + state.collision_on_x = true + elsif state.x <= 0 && state.dx < 0 + state.x = 0 + state.dx = state.dx.abs * 0.8 + state.collision_on_x = true + end + end + + def next_y + state.y + state.dy + end + + def next_x + if state.dx < 0 + return (state.x + state.dx) - (state.tile_size - state.player_width) + else + return (state.x + state.dx) + (state.tile_size - state.player_width) + end + end + + def collision_floor + return unless state.dy <= 0 + + player_rect = [state.x, next_y, state.tile_size, state.tile_size] + + # Runs through all the sprites on the field and determines if the player hits the bottom of sprite (hence "-0.1" above) + floor_collisions = state.world_collision_rects + .find_all { |r| r[:top].intersect_rect?(player_rect, state.collision_tolerance) } + .first + + return unless floor_collisions + state.y = floor_collisions[:top].top + state.dy = state.dy.abs * 0.8 + end + + def collision_left + return unless state.dx < 0 + player_rect = [next_x, state.y, state.tile_size, state.tile_size] + + # Runs through all the sprites on the field and determines if the player hits the left side of sprite (hence "-0.1" above) + left_side_collisions = state.world_collision_rects + .find_all { |r| r[:left_right].intersect_rect?(player_rect, state.collision_tolerance) } + .first + + return unless left_side_collisions + state.x = left_side_collisions[:left_right].right + state.dx = state.dy.abs * 0.8 + state.collision_on_x = true + end + + def collision_right + return unless state.dx > 0 + + player_rect = [next_x, state.y, state.tile_size, state.tile_size] + # Runs through all the sprites on the field and determines if the player hits the right side of sprite (hence "-0.1" above) + right_side_collisions = state.world_collision_rects + .find_all { |r| r[:left_right].intersect_rect?(player_rect, state.collision_tolerance) } + .first + + return unless right_side_collisions + state.x = right_side_collisions[:left_right].left - state.tile_size + state.dx = state.dx.abs * 0.8 * -1 + state.collision_on_x = true + end + + def collision_ceiling + return unless state.dy > 0 + + player_rect = [state.x, next_y, state.player_width, state.player_height] + + # Runs through all the sprites on the field and determines if the player hits the ceiling of sprite (hence "+0.1" above) + ceil_collisions = state.world_collision_rects + .find_all { |r| r[:bottom].intersect_rect?(player_rect, state.collision_tolerance) } + .first + + return unless ceil_collisions + state.y = ceil_collisions[:bottom].y - state.tile_size + state.dy = state.dy.abs * 0.8 * -1 + state.collision_on_y = true + end + + def to_coord point + # Integer divides (idiv) point.x to turn into grid + # Then, you can just multiply each integer by state.tile_size + # later and huzzah. Grid coordinates + [point.x.idiv(state.tile_size), point.y.idiv(state.tile_size)] + end + + def export_map + export_string = state.world.map do |x, y| + "#{x},#{y},1" + end + export_string += state.objects.map do |x, y, w, h, path| + "#{x},#{y},2,#{w},#{h},#{path}" + end + gtk.write_file(MAP_FILE_PATH, export_string.join("\n")) + state.map_saved_at = state.tick_count + end + + def inputs_export_stage + end + + def calc_score + return unless state.scene == :game + player = [state.x, state.y, state.player_width, state.player_height] + collected = state.objects.find_all { |s| s.intersect_rect? player } + state.stuff_score += collected.length + if collected.length > 0 + outputs.sounds << 'sounds/collectable.wav' + end + state.objects = state.objects.reject { |s| collected.include? s } + state.stuff_time += 0.01 + if state.objects.length == 0 + if !state.stuff_best_time || state.stuff_time < state.stuff_best_time + state.stuff_best_time = state.stuff_time + end + state.game_over_at = nil + state.scene = :ending + end + end + + def calc_on_floor + if state.action == :anchored + state.on_floor = false + state.on_floor_debounce = 30 + else + state.on_floor_debounce ||= 30 + + if state.dy.round != 0 + state.on_floor_debounce = 30 + state.on_floor = false + else + state.on_floor_debounce -= 1 + end + + if state.on_floor_debounce <= 0 + state.on_floor_debounce = 0 + state.on_floor = true + end + end + end + + def render_player + path = "sprites/square-green.png" + angle = 0 + # outputs.labels << [vx(state.x), vy(state.y) - 30, "dy: #{state.dy.round}"] + if state.action == :idle + # outputs.labels << [vx(state.x), vy(state.y), "IDLE"] + path = "sprites/square-green.png" + elsif state.action == :aiming && !state.on_floor + # outputs.labels << [vx(state.x), vy(state.y), "AIMING AIR BORN"] + angle = state.tongue_angle - 90 + path = "sprites/square-green.png" + elsif state.action == :aiming # ON THE GROUND + # outputs.labels << [vx(state.x), vy(state.y), "AIMING GROUND"] + path = "sprites/square-green.png" + elsif state.action == :shooting && !state.on_floor + # outputs.labels << [vx(state.x), vy(state.y), "SHOOTING AIR BORN"] + path = "sprites/square-green.png" + angle = state.tongue_angle - 90 + elsif state.action == :shooting + # outputs.labels << [vx(state.x), vy(state.y), "SHOOTING ON GROUND"] + path = "sprites/square-green.png" + elsif state.action == :anchored + # outputs.labels << [vx(state.x), vy(state.y), "SWINGING"] + angle = state.tongue_angle - 90 + path = "sprites/square-green.png" + end + + outputs.sprites << [vx(state.x), + vy(state.y), + vw(state.player_width), + vh(state.player_height), + path, + angle] + end + + def render_player_old + # Player + if state.action == :aiming + path = 'sprites\frg\idle\frog_idle.png' + if state.dx > 2 + #directional right sprite was here but i needa redo it + path = 'sprites\frg\anchor\frog-anchor-0.png' + #directional left sprite was here but i needa redo it + elsif state.dx < -2 + path = 'sprites\frg\anchor\frog-anchor-0.png' + end + outputs.sprites << [vx(state.x), + vy(state.y), + vw(state.player_width), + vh(state.player_height), + path, + (state.tongue_angle - 90)] + elsif state.action == :anchored || state.action == :shooting + outputs.sprites << [vx(state.x), + vy(state.y), + vw(state.player_width), + vw(state.player_height), + 'sprites/animations_povfrog/frog_bwah_up.png', + (state.tongue_angle - 90)] + end + end +end + + +$game = CleptoFrog.new + +def tick args + if args.state.scene == :game + tick_instructions args, "SPACE to SHOOT and RELEASE tongue. LEFT, RIGHT to SWING and BUILD momentum. MINIMAP in bottom right corner.", 360 + end + $game.args = args + $game.tick +end + +def tick_instructions args, text, y = 715 + return if args.state.key_event_occurred + if args.inputs.keyboard.directional_vector || args.inputs.keyboard.key_down.space + args.state.key_event_occurred = true + end + + args.outputs.debug << [0, y - 50, 1280, 60].solid + args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label + args.outputs.debug << [640, y - 25, "(SPACE to dismiss instructions)" , -2, 1, 255, 255, 255].label +end |