445 lines
10 KiB
Ruby
445 lines
10 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
# this is the main gameplay!
|
|
class CubeTubeGame < GameplayScene
|
|
def initialize(args, opts = {})
|
|
super
|
|
|
|
@args = args
|
|
|
|
@blocksize = 30
|
|
@grid_w = 10
|
|
@grid_h = 20
|
|
@grid_x = 180
|
|
@grid_y = ((1280 - (@grid_h * @blocksize)) / 2) - 21
|
|
@start_grid_x = @grid_x
|
|
@start_grid_y = @grid_y
|
|
@bg_x = 0
|
|
@bg_w = Sprite.for(:tunnel_loop).w
|
|
|
|
@next_piece_box = [2, -9, 7, 7]
|
|
|
|
@sprite_index = [
|
|
Sprite.for(:black),
|
|
Sprite.for(:red),
|
|
Sprite.for(:green),
|
|
Sprite.for(:blue),
|
|
Sprite.for(:yellow),
|
|
Sprite.for(:indigo),
|
|
Sprite.for(:violet),
|
|
Sprite.for(:orange),
|
|
Sprite.for(:gray)
|
|
]
|
|
|
|
@grid = []
|
|
|
|
@lines = 0
|
|
@level = 0
|
|
@current_speed = 0
|
|
@next_move = 0
|
|
@gameover = false
|
|
@showgameover = false
|
|
|
|
@current_piece_x = 0
|
|
@current_piece_y = 0
|
|
@current_piece = nil
|
|
@next_piece = nil
|
|
@lines_to_clear = []
|
|
@line_clear_timer = 0
|
|
|
|
@current_music = :music1
|
|
|
|
reset(args)
|
|
end
|
|
|
|
def render_background
|
|
# draw a solid black background
|
|
@args.outputs.solids << [
|
|
0,
|
|
0,
|
|
1280,
|
|
1280,
|
|
0, 0, 0
|
|
]
|
|
|
|
@bg_x += (@level + 2) * 2 unless @gameover
|
|
@bg_x %= @bg_w if @bg_x >= @bg_w
|
|
|
|
Sprite.for(:tunnel_loop).render(@args, { x: @bg_x, y: 0, w: @bg_w, h: 720 })
|
|
Sprite.for(:tunnel_loop).render(@args, { x: @bg_x - @bg_w, y: 0, w: @bg_w, h: 720 })
|
|
|
|
# @grid_y = ((1280 - (@grid_h * @blocksize)) / 2) - 21
|
|
Sprite.for(:train).render(@args, { x: 0, y: @grid_x - 140.75 })
|
|
end
|
|
|
|
def render_foreground
|
|
Sprite.for(:tracks).render(@args, { x: @bg_x, y: 0, w: @bg_w })
|
|
Sprite.for(:tracks).render(@args, { x: @bg_x - @bg_w, y: 0, w: @bg_w })
|
|
|
|
Sprite.for(:train_fore).render(@args, { x: 0, y: @grid_x - 140.75 })
|
|
end
|
|
|
|
# x and y are positions in the grid, not pixels
|
|
def render_block(x, y, color)
|
|
@sprite_index[color].render(
|
|
@args,
|
|
{
|
|
x: (1280 - @grid_y) - (y * @blocksize) - 6,
|
|
y: @grid_x + (x * @blocksize),
|
|
w: @blocksize + 6,
|
|
h: @blocksize
|
|
}
|
|
)
|
|
end
|
|
|
|
def render_grid
|
|
(0..@grid_w - 1).each do |x|
|
|
(0..@grid_h - 1).each do |y|
|
|
if @grid[x][y] != 0 && (!@lines_to_clear.include?(y) || (@line_clear_timer % 14) < 7)
|
|
render_block(x, y, @grid[x][y])
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def render_piece(piece, piece_x, piece_y)
|
|
(0..piece.length - 1).each do |x|
|
|
(0..piece[x].length - 1).each do |y|
|
|
render_block(piece_x + x, piece_y + y, piece[x][y]) if piece[x][y] != 0
|
|
end
|
|
end
|
|
end
|
|
|
|
def render_current_piece
|
|
render_piece(@current_piece, @current_piece_x, @current_piece_y) if @line_clear_timer <= 0
|
|
end
|
|
|
|
def render_next_piece
|
|
screen_x = @grid_y + 705
|
|
screen_y = @grid_x + 80
|
|
screen_w = 250
|
|
screen_h = 200
|
|
|
|
Sprite.for(:screen).render(@args, { x: screen_x, y: screen_y + 10, w: screen_w, h: screen_h + 10 })
|
|
|
|
next_piece = @line_clear_timer <= 0 ? @next_piece : @current_piece
|
|
centerx = (@next_piece_box[2] - next_piece.length) / 2
|
|
centery = (@next_piece_box[3] - next_piece[0].length) / 2
|
|
|
|
render_piece next_piece, @next_piece_box[0] + centerx, @next_piece_box[1] + centery
|
|
|
|
@args.outputs.labels << [screen_x + 33, screen_y + screen_h - 8, 'Next piece', 8, 255, 255, 255, 255 ]
|
|
|
|
screen_s =
|
|
case (@args.state.tick_count % 32)
|
|
when 0..7 then :screen_s1
|
|
when 8..15 then :screen_s2
|
|
when 16..23 then :screen_s3
|
|
when 24..31 then :screen_s4
|
|
end
|
|
|
|
Sprite.for(screen_s).render(@args, { x: screen_x, y: screen_y + 10, w: screen_w, h: screen_h + 10 })
|
|
end
|
|
|
|
def render_score
|
|
@args.outputs.labels << [200, 600, "Lines: #{@lines}", 10, 255, 255, 255, 255]
|
|
@args.outputs.labels << [400, 600, "Level: #{@level}", 10, 255, 255, 255, 255]
|
|
end
|
|
|
|
def render_gameover
|
|
@args.outputs.solids << [0, 245, 1280, 200, 0, 0, 0, 255]
|
|
@args.outputs.labels << [200, 450, 'GAME OVER', 100, 255, 255, 255, 255]
|
|
end
|
|
|
|
def render
|
|
render_background
|
|
render_next_piece
|
|
render_current_piece
|
|
render_grid
|
|
render_foreground
|
|
render_score
|
|
render_gameover if @showgameover
|
|
end
|
|
|
|
def current_piece_colliding
|
|
(0..@current_piece.length - 1).each do |x|
|
|
(0..@current_piece[x].length - 1).each do |y|
|
|
next if @current_piece[x][y].zero?
|
|
if (@current_piece_y + y >= @grid_h) ||
|
|
((@current_piece_y + y) >= 0 && @grid[@current_piece_x + x][@current_piece_y + y] != 0)
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
false
|
|
end
|
|
|
|
def get_speed
|
|
case @level
|
|
when 0 then 53
|
|
when 1 then 49
|
|
when 2 then 45
|
|
when 3 then 41
|
|
when 4 then 37
|
|
when 5 then 33
|
|
when 6 then 28
|
|
when 7 then 22
|
|
when 8 then 17
|
|
when 9 then 11
|
|
when 10 then 10
|
|
when 11 then 9
|
|
when 12 then 8
|
|
when 13 then 7
|
|
when 14..15 then 6
|
|
when 16..17 then 5
|
|
when 18..19 then 4
|
|
else 3
|
|
end
|
|
end
|
|
|
|
def change_music
|
|
@current_music = @current_music == :music1 ? :music2 : :music1
|
|
Music.queue_up(@current_music)
|
|
end
|
|
|
|
def line_full?(row)
|
|
(0..@grid_w - 1).each do |x|
|
|
return false if @grid[x][row].zero?
|
|
end
|
|
true
|
|
end
|
|
|
|
def plant_current_piece
|
|
(0..@current_piece.length - 1).each do |x|
|
|
(0..@current_piece[x].length - 1).each do |y|
|
|
next if @current_piece[x][y].zero?
|
|
|
|
@grid[@current_piece_x + x][@current_piece_y + y] = @current_piece[x][y]
|
|
end
|
|
end
|
|
|
|
@lines_to_clear = []
|
|
|
|
# see if any rows need to be cleared out
|
|
(0..@grid_h - 1).each do |y|
|
|
next unless line_full?(y)
|
|
|
|
# no empty space in the row
|
|
@lines_to_clear.push y
|
|
@lines += 1
|
|
@line_clear_timer = 70
|
|
if (@lines % 10).floor.zero?
|
|
@level += 1
|
|
change_music
|
|
end
|
|
end
|
|
|
|
select_next_piece
|
|
if @lines_to_clear.empty?
|
|
Sound.play(@args, :drop)
|
|
if current_piece_colliding
|
|
@gameover = true
|
|
Music.stop(@args)
|
|
end
|
|
else
|
|
Sound.play(@args, :clear)
|
|
@current_speed = get_speed
|
|
end
|
|
|
|
@next_move = @current_speed + 2
|
|
end
|
|
|
|
def select_next_piece
|
|
@current_piece = @next_piece
|
|
|
|
@current_piece_x = 4
|
|
@current_piece_y = -1
|
|
|
|
r = (rand 7) + 1
|
|
@next_piece =
|
|
case r
|
|
when 1 then [[r, 0], [r, r], [0, r]]
|
|
when 2 then [[0, r], [r, r], [r, 0]]
|
|
when 3 then [[r, r, r], [r, 0, 0]]
|
|
when 4 then [[r, r], [r, r] ]
|
|
when 5 then [[r], [r], [r], [r]]
|
|
when 6 then [[r, 0], [r, r], [r, 0]]
|
|
when 7 then [[r, 0, 0], [r, r, r]]
|
|
end
|
|
select_next_piece if @current_piece.nil?
|
|
end
|
|
|
|
def rotate_current_piece_left
|
|
Sound.play(@args, :rotate)
|
|
@current_piece = @current_piece.transpose.map(&:reverse)
|
|
@current_piece_x = @grid_w - @current_piece.length if (@current_piece_x + @current_piece.length) >= @grid_w
|
|
end
|
|
|
|
def rotate_current_piece_right
|
|
Sound.play(@args, :rotate)
|
|
@current_piece = @current_piece.transpose.map(&:reverse)
|
|
@current_piece = @current_piece.transpose.map(&:reverse)
|
|
@current_piece = @current_piece.transpose.map(&:reverse)
|
|
end
|
|
|
|
def fill_grid
|
|
b = false
|
|
(0..@grid_h - 1).each do |y|
|
|
(0..@grid_w - 1).each do |x|
|
|
if @grid[x][y].zero?
|
|
@grid[x][y] = (rand 7) + 1
|
|
b = true
|
|
end
|
|
end
|
|
return nil if b
|
|
end
|
|
@showgameover = true
|
|
end
|
|
|
|
def restart_game
|
|
reset(@args)
|
|
end
|
|
|
|
def move_current_piece_up
|
|
if (@current_piece_x + @current_piece.length) < @grid_w
|
|
@current_piece_x += 1
|
|
if current_piece_colliding
|
|
Sound.play(@args, :move_deny)
|
|
@current_piece_x -= 1
|
|
else
|
|
Sound.play(@args, :move)
|
|
end
|
|
else
|
|
Sound.play(@args, :move_deny)
|
|
end
|
|
end
|
|
|
|
def move_current_piece_down
|
|
if @current_piece_x.positive?
|
|
@current_piece_x -= 1
|
|
if current_piece_colliding
|
|
Sound.play(@args, :move_deny)
|
|
@current_piece_x += 1
|
|
else
|
|
Sound.play(@args, :move)
|
|
end
|
|
else
|
|
Sound.play(@args, :move_deny)
|
|
end
|
|
end
|
|
|
|
def iterate_line_clear
|
|
return false unless @line_clear_timer.positive?
|
|
|
|
@line_clear_timer -= 1
|
|
return true unless @line_clear_timer.zero?
|
|
|
|
@lines_to_clear.each do |y|
|
|
y.downto(1).each do |i|
|
|
(0..@grid_w - 1).each do |j|
|
|
@grid[j][i] = @grid[j][i - 1]
|
|
end
|
|
end
|
|
(0..@grid_w - 1).each do |i|
|
|
@grid[i][0] = 0
|
|
end
|
|
end
|
|
Sound.play(@args, :drop)
|
|
@lines_to_clear = []
|
|
false
|
|
end
|
|
|
|
def iterate_input
|
|
restart_game if Input.pressed?(@args, :primary) && @gameover && @showgameover
|
|
return if @gameover
|
|
|
|
move_current_piece_down if Input.pressed?(@args, :down)
|
|
move_current_piece_up if Input.pressed?(@args, :up)
|
|
@next_move -= @current_speed / 3 if Input.pressed_or_held?(@args, :left)
|
|
rotate_current_piece_left if Input.pressed?(@args, :rotate_left)
|
|
rotate_current_piece_right if Input.pressed?(@args, :rotate_right)
|
|
end
|
|
|
|
# train bounce effect
|
|
def iterate_train_bounce
|
|
# TODO: time it better to the music
|
|
case @args.state.tick_count % (@current_speed * 6)
|
|
when 0..3, (@current_speed * 2)..((@current_speed * 2) + 3)
|
|
@grid_x = @start_grid_x + 3
|
|
else
|
|
@grid_x = @start_grid_x
|
|
end
|
|
end
|
|
|
|
def iterate_movement
|
|
@next_move -= 1
|
|
return unless @next_move <= 0
|
|
|
|
@next_move = @current_speed
|
|
@current_piece_y += 1
|
|
|
|
return unless current_piece_colliding
|
|
|
|
@current_piece_y -= 1
|
|
plant_current_piece
|
|
end
|
|
|
|
def iterate
|
|
# input first
|
|
iterate_input
|
|
|
|
fill_grid if @gameover && !@showgameover
|
|
# skip the rest if it's game over
|
|
return if @gameover
|
|
|
|
# resume music if it's paused
|
|
Music.resume(@args) if !Music.stopped(@args) && Music.paused(@args)
|
|
|
|
iterate_train_bounce
|
|
|
|
# if we're currently animating a line clear, then skip the movement logic
|
|
return if iterate_line_clear
|
|
|
|
iterate_movement
|
|
end
|
|
|
|
# called every tick of the game loop
|
|
def tick(args)
|
|
iterate
|
|
render
|
|
super
|
|
end
|
|
|
|
# custom logic to reset this scene
|
|
def reset(args)
|
|
super
|
|
|
|
@lines = 0
|
|
@level = 0
|
|
@current_speed = get_speed
|
|
@next_move = @current_speed
|
|
@gameover = false
|
|
@showgameover = false
|
|
|
|
@current_piece_x = 4
|
|
@current_piece_y = -1
|
|
@current_piece = nil
|
|
@next_piece = nil
|
|
select_next_piece
|
|
@lines_to_clear = []
|
|
@line_clear_timer = 0
|
|
|
|
@bg_x = 0
|
|
|
|
(0..@grid_w - 1).each do |x|
|
|
@grid[x] = []
|
|
(0..@grid_h - 1).each do |y|
|
|
@grid[x][y] = 0
|
|
end
|
|
end
|
|
|
|
@current_music = :music1
|
|
Music.play(args, @current_music)
|
|
Music.set_volume(args, args.state.setting.music ? 0.8 : 0.0)
|
|
end
|
|
end
|