amirrajan · October 24, 2025 13:11
diff --git a/main.rb b/main.rb
 class Game
  attr_gtk

  GREEN = { r: 98, g: 140, b: 84 }
  YELLOW = { r: 177, g: 159, b: 54 }
  GRAY = { r: 64, g: 64, b: 64 }

  def initialize
    # get the list of words that can be inputed
    @valid_words = GTK.read_file("data/valid.txt")
                      .each_line
                      .map { |l| l.strip }
                      .reject { |l| l.length == 0 }

    # get the list of words that will be picked from
    @play_words = GTK.read_file("data/play.txt")
                      .each_line
                      .map { |l| l.strip }
                      .reject { |l| l.length == 0 }

    @player_progress = (GTK.read_file("user-data/progress.txt") || "")
                         .each_line
                         .map { |l| l.strip }
                         .reject { |l| l.length == 0 }
                         .map do |l|
                           word, result = l.split ","
                           { word: word, result: result.to_sym }
                         end

    # animation spline for when a letter is typed
    @enter_char_spline_duration = 15
    @enter_char_spline = [
      [0.0, 0.0,  0.66, 1.0],
      [1.0, 1.0,  1.0,  1.0],
      [1.0, 0.33, 0.0,  0.0]
    ]

    # animation spline for when a letter is flipped
    @flip_spline_duration = 15
    @flip_spline = [
      [1.0, 0.66, 0.33, 0.0],
      [0.0, 0.33, 0.66, 1.0],
    ]

    # animation spline for an invalid word
    @invalid_spline_duration = 15
    @invalid_spline = [
      [0.0, -0.5, 0.0, 0.5],
      [0.0, -0.5, 0.0, 0.5],
    ]

    # start a new game
    new_game!
  end

  def save_progress!
    content = @player_progress.map do |h|
      "#{h.word},#{h.result}"
    end.join "\n"

    GTK.write_file "user-data/progress.txt", content
  end

  def new_game!
    # from the list of playable words, choose a word
    @target_word = @play_words.reject do |w|
      @player_progress.any? { |h| h.word == w }
    end.sample

    # this is a look up table for coloring the keys
    @key_colors = { }

    # the current row the player is on
    @current_guess_index = 0

    # the current char the player is on
    @current_guess_char_index = 0

    # point at which the game has ended
    @game_over_at = nil

    # flag for when the game has endend
    @game_over = false

    # flag denoting whether the player won or lost when the game has ended
    @winner = false

    @new_game_at = Kernel.tick_count

    # data structure for where the guesses will be stored,
    # { rect:, action:, action_at:, char: }

    # Layout api is used to create the board
    @guesses = [
      [
        { rect: Layout.rect(row: 4, col: 1, w: 2, h: 2) },
        { rect: Layout.rect(row: 4, col: 3, w: 2, h: 2) },
        { rect: Layout.rect(row: 4, col: 5, w: 2, h: 2) },
        { rect: Layout.rect(row: 4, col: 7, w: 2, h: 2) },
        { rect: Layout.rect(row: 4, col: 9, w: 2, h: 2) },
      ],
      [
        { rect: Layout.rect(row: 6, col: 1, w: 2, h: 2) },
        { rect: Layout.rect(row: 6, col: 3, w: 2, h: 2) },
        { rect: Layout.rect(row: 6, col: 5, w: 2, h: 2) },
        { rect: Layout.rect(row: 6, col: 7, w: 2, h: 2) },
        { rect: Layout.rect(row: 6, col: 9, w: 2, h: 2) },
      ],
      [
        { rect: Layout.rect(row: 8, col: 1, w: 2, h: 2) },
        { rect: Layout.rect(row: 8, col: 3, w: 2, h: 2) },
        { rect: Layout.rect(row: 8, col: 5, w: 2, h: 2) },
        { rect: Layout.rect(row: 8, col: 7, w: 2, h: 2) },
        { rect: Layout.rect(row: 8, col: 9, w: 2, h: 2) },
      ],
      [
        { rect: Layout.rect(row: 10, col: 1, w: 2, h: 2) },
        { rect: Layout.rect(row: 10, col: 3, w: 2, h: 2) },
        { rect: Layout.rect(row: 10, col: 5, w: 2, h: 2) },
        { rect: Layout.rect(row: 10, col: 7, w: 2, h: 2) },
        { rect: Layout.rect(row: 10, col: 9, w: 2, h: 2) },
      ],
      [
        { rect: Layout.rect(row: 12, col: 1, w: 2, h: 2) },
        { rect: Layout.rect(row: 12, col: 3, w: 2, h: 2) },
        { rect: Layout.rect(row: 12, col: 5, w: 2, h: 2) },
        { rect: Layout.rect(row: 12, col: 7, w: 2, h: 2) },
        { rect: Layout.rect(row: 12, col: 9, w: 2, h: 2) },
      ],
      [
        { rect: Layout.rect(row: 14, col: 1, w: 2, h: 2) },
        { rect: Layout.rect(row: 14, col: 3, w: 2, h: 2) },
        { rect: Layout.rect(row: 14, col: 5, w: 2, h: 2) },
        { rect: Layout.rect(row: 14, col: 7, w: 2, h: 2) },
        { rect: Layout.rect(row: 14, col: 9, w: 2, h: 2) },
      ],
    ]

    # generate the keyboard layout and wire up the button callbacks
    @keyboard =  [
      *keyboard_buttons(17.25 + 1.5 * 0, 0, ["Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P"]),
      *keyboard_buttons(17.25 + 1.5 * 1, 0.6, ["A", "S", "D", "F", "G", "H", "J", "K", "L"]),
      *keyboard_buttons(17.25 + 1.5 * 2, 0, ["ENT", "Z", "X", "C", "V", "B", "N", "M", "BKSP"],
                        {
                          "ENT" => lambda { guess_word! },
                          "BKSP" => lambda { unset_char! }
                        })
    ]
  end

  def guess_word!
    # when the player presses enter, or clicks the "ENT" button

    # get the full word for the current row
    full_word = @guesses[@current_guess_index].map { |guess| guess.char }.join

    # the word is valid if its length is 5 and it's in the valid word dictionary
    is_valid = full_word.length == 5 && @valid_words.include?(full_word)

    # if it's valid, then enumerate each one of the guess entries and queue up
    # their animations
    if is_valid
      @guesses[@current_guess_index].each_with_index do |guess, i|
        if @target_word[i] == guess.char
          # if the index of the word matches exactly, then flip to green
          guess.action = :flip_green
          guess.action_at = Kernel.tick_count + i * @flip_spline_duration

          # update the keyboard color lookup and queue it to be rendered
          # after all animations have completed
          if !@key_colors[guess.char] || @key_colors[guess.char].color_id == :yellow || @key_colors[guess.char].color_id == :gray
            @key_colors[guess.char] ||= { **GREEN, at: Kernel.tick_count + 5 * @flip_spline_duration, color_id: :green }
          end
        elsif @target_word.include? guess.char
          # if the target word contains the character, then flip to yellow
          guess.action = :flip_yellow
          guess.action_at = Kernel.tick_count + i * @flip_spline_duration

          # update the keyboard color lookup and queue it to be rendered
          # after all animations have completed
          if !@key_colors[guess.char] || @key_colors[guess.char].color_id == :gray
            @key_colors[guess.char] ||= { **YELLOW, at: Kernel.tick_count + 5 * @flip_spline_duration, color_id: :yellow }
          end
        else
          # otherwise flip to gray
          guess.action = :flip_gray
          guess.action_at = Kernel.tick_count + i * @flip_spline_duration

          # update the keyboard color lookup and queue it to be rendered
          # after all animations have completed
          if !@key_colors[guess.char]
            @key_colors[guess.char] ||= { **GRAY, at: Kernel.tick_count + 5 * @flip_spline_duration, color_id: :gray }
          end
        end
      end

      if full_word == @target_word
        # the player has won if their guess matches the target word
        @game_over = true
        @game_over_at = Kernel.tick_count + 5 * @flip_spline_duration
        @winner = true

        @player_progress << { word: @target_word, result: :win }
      elsif @current_guess_index == 5
        # the player has lost if they've run out of rows
        @game_over = true
        @game_over_at = Kernel.tick_count + 5 * @flip_spline_duration
        @winner = false

        @player_progress << { word: @target_word, result: :loss }
      else
        # increment to the next row after the guess
        @current_guess_index += 1
        @current_guess_char_index = 0
      end
    else
      # if the word they selected isn't in the valid word dictionary,
      # then queue the invalid animation
      @guesses[@current_guess_index].each_with_index do |guess, i|
        guess.action = :invalid
        guess.action_at = Kernel.tick_count
      end
    end
  end

  def generate_letter_prefabs!
    # on frame zero, generate textures/glpyhs for all the letters
    return if Kernel.tick_count != 0

    r = Layout.rect(row: 0, col: 0, w: 2, h: 2)
    ["Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P",
     "A", "S", "D", "F", "G", "H", "J", "K", "L",
     "Z", "X", "C", "V", "B", "N", "M"].each do |c|
       outputs[c.downcase].w = r.w
       outputs[c.downcase].h = r.h
       outputs[c.downcase].background_color = [0, 0, 0, 0]
       outputs[c.downcase].primitives << { x: r.w / 2, y: r.h / 2, text: c, anchor_x: 0.5, anchor_y: 0.5, size_px: r.h / 2, r: 255, g: 255, b: 255 }
     end
  end

  def calc
    return if @game_over_at && @game_over_at.elapsed_time < 30
    return if @new_game_at && @new_game_at.elapsed_time < 30

    if @game_over
      # if they clicked or pressed enter, then start a new game
      if inputs.mouse.click || inputs.keyboard.key_up.char == "\r" || inputs.keyboard.key_down == "\r"
        save_progress!
        new_game!
      end
    else
      if inputs.mouse.click
        # if they are using the mouse and they click, find the key that the mouse intersects with
        keyboard_key = Geometry.find_intersect_rect(inputs.mouse, @keyboard, using: :rect)

        # if the key is found, then call the on_click callback on the key
        if keyboard_key
          keyboard_key.on_click.call
        end
      elsif inputs.keyboard.key_up.char

        # if they used the keyboard and it's backspace or enter,
        # then delete or guess word
        if inputs.keyboard.key_up.char == "\b"
          unset_char!
        elsif inputs.keyboard.key_up.char == "\r"
          guess_word!
        else
          # if it's any other key, then check to see if the keyboard buttons has
          # the key that was pressed
          key = @keyboard.find do |k|
            k.char == inputs.keyboard.key_up.char.upcase
          end

          # if so, then invoke the on_click callback (as if they clicked it with the mouse)
          key.on_click.call if key
        end
      end
    end
  end

  def tick
    generate_letter_prefabs!
    calc
    render
    # outputs.primitives << Layout.debug_primitives(invert_colors: true)
  end

  def unset_char!
    # unsetting a char/deleting a char logic
    if @current_guess_char_index == 4 && @guesses[@current_guess_index][@current_guess_char_index].char
      # if it's the last spot and there is a char to be deleted, then clear out the char
      @guesses[@current_guess_index][@current_guess_char_index].char = nil
    elsif @current_guess_char_index == 0 && @guesses[@current_guess_index][@current_guess_char_index].char
      # if it's the first spot and there is a char to be deleted, then clear out the char
      @guesses[@current_guess_index][@current_guess_char_index].char = nil
    elsif @current_guess_char_index != 0
      # otherwise move back a spot, and clear out the char in that spot
      @current_guess_char_index -= 1
      @guesses[@current_guess_index][@current_guess_char_index].char = nil
    end
  end

  def set_char! c
    # set the current spot's char and increment to the next spot if they aren't already on the las
    # spot
    if !@guesses[@current_guess_index][@current_guess_char_index].char
      @guesses[@current_guess_index][@current_guess_char_index].char = c
      @guesses[@current_guess_index][@current_guess_char_index].action_at = Kernel.tick_count
      @guesses[@current_guess_index][@current_guess_char_index].action = :set_char
      @current_guess_char_index += 1 if @current_guess_char_index != 4
    end
  end

  def keyboard_buttons(start_row, start_col, chars, callback_overrides = {})
    # button construction
    # layout api is used to create the rectangle, and the call back is set to
    # set_char!(char) by default unless there is a callback override (eg for ENT and BKSP)
    running_col = 0
    chars.map_with_index do |c, i|
      w = if c.length > 1
            1.8
          else
            1.2
          end
      r = if c.length > 1
            Layout.rect(row: start_row, col: start_col + running_col, w: w, h: 1.5)
          else
            Layout.rect(row: start_row, col: start_col + running_col, w: w, h: 1.5)
          end
      running_col += w
      on_click = callback_overrides[c] || ->() { set_char! c }
      { rect: r, char: c, on_click: on_click }
    end
  end

  def guess_char_prefab guess_char
    # this is the prefab for rendering a tile

    # get the location of the spot and a char (if one is there)
    r = guess_char.rect
    c = guess_char.char

    # the default color for the tile is a grayish border
    # with a dark background, and the character texture (if the spot has a character set)
    border_color = if c
                     { r: 90, g: 90, b: 90 }
                   else
                     { r: 45, g: 45, b: 45 }
                   end

    outer_tile = r.center.merge(path: :solid, **border_color, w: r.w, h: r.h, anchor_x: 0.5, anchor_y: 0.5)
    inner_tile = r.center.merge(path: :solid, r: 18, g: 18, b: 18, w: r.w - 4, h: r.h - 4, anchor_x: 0.5, anchor_y: 0.5)
    label_prefab = r.center.merge(path: c.downcase, w: r.w, h: r.h, anchor_x: 0.5, anchor_y: 0.5) if c

    # sorting for rendering so that animations aren't behind other tiles (default is 0)
    sort_order = 0

    if guess_char.action_at && guess_char.action == :set_char
      # if an action as been queued, and the action is :set_char

      # use the enter_char_spline animation to compute the percentage
      perc = if guess_char.action_at && guess_char.action_at.elapsed_time < @enter_char_spline_duration
               Easing.spline(guess_char.action_at, Kernel.tick_count, @enter_char_spline_duration, @enter_char_spline)
             else
               0
             end

      # the percentage is used to scale the rect up, and back down
      label_prefab = r.center.merge(path: c.downcase, w: r.w + 32 * perc, h: r.h + 32 * perc, anchor_x: 0.5, anchor_y: 0.5) if c
      outer_tile = r.center.merge(path: :solid, **border_color, w: r.w + 32 * perc, h: r.h + 32 * perc, anchor_x: 0.5, anchor_y: 0.5)
      inner_tile = r.center.merge(path: :solid, r: 18, g: 18, b: 18, w: r.w - 4 + 32 * perc, h: r.h - 4 + 32 * perc, anchor_x: 0.5, anchor_y: 0.5)

      # set the sort order to 1 so that it renders at the top
      sort_order = 1
    elsif guess_char.action_at && guess_char.action == :flip_green
      # if the animation is flip to green, then use the flip animation spline to compute the percentage
      perc = if guess_char.action_at && guess_char.action_at.elapsed_time < @flip_spline_duration && guess_char.action_at.elapsed_time > 0
               Easing.spline(guess_char.action_at, Kernel.tick_count, @flip_spline_duration, @flip_spline)
             else
               1
             end

      # default colors before the flip/reveal occurs
      outer_tile_color = { r: 90, g: 90, b: 90 }
      inner_tile_color = { r: 18, g: 18, b: 18 }

      # half way through the animation, flip to green
      if guess_char.action_at.elapsed_time > @flip_spline_duration.idiv(2)
        outer_tile_color = GREEN
        inner_tile_color = GREEN
      end

      # the perc value is used to control the height of the prefab
      label_prefab = r.center.merge(path: c.downcase, w: r.w, h: r.h * perc, anchor_x: 0.5, anchor_y: 0.5) if c
      outer_tile = r.center.merge(path: :solid, w: r.w, h: r.h * perc, anchor_x: 0.5, anchor_y: 0.5, **outer_tile_color)
      inner_tile = r.center.merge(path: :solid, w: r.w - 4, h: (r.h - 4) * perc, anchor_x: 0.5, anchor_y: 0.5, **inner_tile_color)
      sort_order = 1
    elsif guess_char.action_at && guess_char.action == :flip_yellow
      # same as flip_green, but yellow color
      perc = if guess_char.action_at && guess_char.action_at.elapsed_time < @flip_spline_duration && guess_char.action_at.elapsed_time > 0
               Easing.spline(guess_char.action_at, Kernel.tick_count, @flip_spline_duration, @flip_spline)
             else
               1
             end

      outer_tile_color = { r: 90, g: 90, b: 90 }
      inner_tile_color = { r: 18, g: 18, b: 18 }

      if guess_char.action_at.elapsed_time > @flip_spline_duration.idiv(2)
        outer_tile_color = YELLOW
        inner_tile_color = YELLOW
      end

      label_prefab = r.center.merge(path: c.downcase, w: r.w, h: r.h * perc, anchor_x: 0.5, anchor_y: 0.5) if c
      outer_tile = r.center.merge(path: :solid, w: r.w, h: r.h * perc, anchor_x: 0.5, anchor_y: 0.5, **outer_tile_color)
      inner_tile = r.center.merge(path: :solid, w: r.w - 4, h: (r.h - 4) * perc, anchor_x: 0.5, anchor_y: 0.5, **inner_tile_color)
      sort_order = 1
    elsif guess_char.action_at && guess_char.action == :flip_gray
      # same logic as flip_green, but gray color
      perc = if guess_char.action_at && guess_char.action_at.elapsed_time < @flip_spline_duration && guess_char.action_at.elapsed_time > 0
               Easing.spline(guess_char.action_at, Kernel.tick_count, @flip_spline_duration, @flip_spline)
             else
               1
             end

      outer_tile_color = { r: 90, g: 90, b: 90 }
      inner_tile_color = { r: 18, g: 18, b: 18 }

      if guess_char.action_at.elapsed_time > @flip_spline_duration.idiv(2)
        outer_tile_color = GRAY
        inner_tile_color = GRAY
      end

      label_prefab = r.center.merge(path: c.downcase, w: r.w, h: r.h * perc, anchor_x: 0.5, anchor_y: 0.5) if c
      outer_tile = r.center.merge(path: :solid, w: r.w, h: r.h * perc, anchor_x: 0.5, anchor_y: 0.5, **outer_tile_color)
      inner_tile = r.center.merge(path: :solid, w: r.w - 4, h: (r.h - 4) * perc, anchor_x: 0.5, anchor_y: 0.5, **inner_tile_color)
      sort_order = 1
    elsif guess_char.action_at && guess_char.action == :invalid
      # if the animation that's queued is an invalid word,
      # compute the prec using the @invalid_spline
      perc = if guess_char.action_at && guess_char.action_at.elapsed_time < @invalid_spline_duration && guess_char.action_at.elapsed_time > 0
               Easing.spline(guess_char.action_at, Kernel.tick_count, @invalid_spline_duration, @invalid_spline)
             else
               0
             end

      # the perc value is used to shift the x value (shake animation)
      label_prefab = { x: r.center.x + 64 * perc, y: r.center.y, w: r.w, h: r.h, anchor_x: 0.5, anchor_y: 0.5, path: c.downcase } if c
      outer_tile = { x: r.center.x + 64 * perc, y: r.center.y, path: :solid, **border_color, w: r.w, h: r.h, anchor_x: 0.5, anchor_y: 0.5 }
      inner_tile = { x: r.center.x + 64 * perc, y: r.center.y, path: :solid, r: 18, g: 18, b: 18, w: r.w - 4, h: r.h - 4, anchor_x: 0.5, anchor_y: 0.5 }
      sort_order = 1
    end

    # return a structure that contains the sort order for rendering, and the prefab/primitives to render
    {
      sort_order: sort_order,
      prefab: [
        outer_tile,
        inner_tile,
        label_prefab
      ]
    }
  end

  def render
    # set the back ground color
    outputs.background_color = [18, 18, 18]

    # enumerate all the guesses, flat map the prefabs
    # then sort each prefab by the sort order
    # and shovel the prefab data into output.primitives
    outputs.primitives << @guesses.flat_map do |guess|
      guess.map do |guess_char|
        guess_char_prefab(guess_char)
      end
    end.sort_by { |pf_container| pf_container.sort_order }
       .map { |pf| pf.prefab }

    # render the keyboard
    outputs.primitives << @keyboard.map do |keyboard_key|
      c = keyboard_key.char
      r = keyboard_key.rect
      # the color of the key is set to a defualt gray, unless there is a color override
      # in the key_colors lookup (along with a time stamp of when to show the color -> we don't want to change the
      # color during the reveal of a guess)
      color = if @key_colors[keyboard_key.char] && @key_colors[keyboard_key.char].at < Kernel.tick_count
                @key_colors[keyboard_key.char]
              else
                { r: 131, g: 131, b: 131 }
              end

      # return the prefab for the key which is a combination of the color, plus a label representing the key
      [
        r.merge(path: :solid, **color),
        r.center.merge(text: c, anchor_x: 0.5, anchor_y: 0.5, r: 255, g: 255, b: 255, size_px: 40)
      ]
    end
  end
 end

 # boot up of game
 def boot args
  args.state = {}
 end

 # top level tick function
 def tick args
  $game ||= Game.new
  $game.args = args
  $game.tick
 end

 # reset logic used when hotloading
 def reset args
  $game = nil
 end

 GTK.reset
	class Game
	attr_gtk

	GREEN = { r: 98, g: 140, b: 84 }
	YELLOW = { r: 177, g: 159, b: 54 }
	GRAY = { r: 64, g: 64, b: 64 }

	def initialize
	# get the list of words that can be inputed
	@valid_words = GTK.read_file("data/valid.txt")
	.each_line
	.map { \|l\| l.strip }
	.reject { \|l\| l.length == 0 }

	# get the list of words that will be picked from
	@play_words = GTK.read_file("data/play.txt")
	.each_line
	.map { \|l\| l.strip }
	.reject { \|l\| l.length == 0 }

	@player_progress = (GTK.read_file("user-data/progress.txt") \|\| "")
	.each_line
	.map { \|l\| l.strip }
	.reject { \|l\| l.length == 0 }
	.map do \|l\|
	word, result = l.split ","
	{ word: word, result: result.to_sym }
	end

	# animation spline for when a letter is typed
	@enter_char_spline_duration = 15
	@enter_char_spline = [
	[0.0, 0.0, 0.66, 1.0],
	[1.0, 1.0, 1.0, 1.0],
	[1.0, 0.33, 0.0, 0.0]
	]

	# animation spline for when a letter is flipped
	@flip_spline_duration = 15
	@flip_spline = [
	[1.0, 0.66, 0.33, 0.0],
	[0.0, 0.33, 0.66, 1.0],
	]

	# animation spline for an invalid word
	@invalid_spline_duration = 15
	@invalid_spline = [
	[0.0, -0.5, 0.0, 0.5],
	[0.0, -0.5, 0.0, 0.5],
	]

	# start a new game
	new_game!
	end

	def save_progress!
	content = @player_progress.map do \|h\|
	"#{h.word},#{h.result}"
	end.join "\n"

	GTK.write_file "user-data/progress.txt", content
	end

	def new_game!
	# from the list of playable words, choose a word
	@target_word = @play_words.reject do \|w\|
	@player_progress.any? { \|h\| h.word == w }
	end.sample

	# this is a look up table for coloring the keys
	@key_colors = { }

	# the current row the player is on
	@current_guess_index = 0

	# the current char the player is on
	@current_guess_char_index = 0

	# point at which the game has ended
	@game_over_at = nil

	# flag for when the game has endend
	@game_over = false

	# flag denoting whether the player won or lost when the game has ended
	@winner = false

	@new_game_at = Kernel.tick_count

	# data structure for where the guesses will be stored,
	# { rect:, action:, action_at:, char: }

	# Layout api is used to create the board
	@guesses = [
	[
	{ rect: Layout.rect(row: 4, col: 1, w: 2, h: 2) },
	{ rect: Layout.rect(row: 4, col: 3, w: 2, h: 2) },
	{ rect: Layout.rect(row: 4, col: 5, w: 2, h: 2) },
	{ rect: Layout.rect(row: 4, col: 7, w: 2, h: 2) },
	{ rect: Layout.rect(row: 4, col: 9, w: 2, h: 2) },
	],
	[
	{ rect: Layout.rect(row: 6, col: 1, w: 2, h: 2) },
	{ rect: Layout.rect(row: 6, col: 3, w: 2, h: 2) },
	{ rect: Layout.rect(row: 6, col: 5, w: 2, h: 2) },
	{ rect: Layout.rect(row: 6, col: 7, w: 2, h: 2) },
	{ rect: Layout.rect(row: 6, col: 9, w: 2, h: 2) },
	],
	[
	{ rect: Layout.rect(row: 8, col: 1, w: 2, h: 2) },
	{ rect: Layout.rect(row: 8, col: 3, w: 2, h: 2) },
	{ rect: Layout.rect(row: 8, col: 5, w: 2, h: 2) },
	{ rect: Layout.rect(row: 8, col: 7, w: 2, h: 2) },
	{ rect: Layout.rect(row: 8, col: 9, w: 2, h: 2) },
	],
	[
	{ rect: Layout.rect(row: 10, col: 1, w: 2, h: 2) },
	{ rect: Layout.rect(row: 10, col: 3, w: 2, h: 2) },
	{ rect: Layout.rect(row: 10, col: 5, w: 2, h: 2) },
	{ rect: Layout.rect(row: 10, col: 7, w: 2, h: 2) },
	{ rect: Layout.rect(row: 10, col: 9, w: 2, h: 2) },
	],
	[
	{ rect: Layout.rect(row: 12, col: 1, w: 2, h: 2) },
	{ rect: Layout.rect(row: 12, col: 3, w: 2, h: 2) },
	{ rect: Layout.rect(row: 12, col: 5, w: 2, h: 2) },
	{ rect: Layout.rect(row: 12, col: 7, w: 2, h: 2) },
	{ rect: Layout.rect(row: 12, col: 9, w: 2, h: 2) },
	],
	[
	{ rect: Layout.rect(row: 14, col: 1, w: 2, h: 2) },
	{ rect: Layout.rect(row: 14, col: 3, w: 2, h: 2) },
	{ rect: Layout.rect(row: 14, col: 5, w: 2, h: 2) },
	{ rect: Layout.rect(row: 14, col: 7, w: 2, h: 2) },
	{ rect: Layout.rect(row: 14, col: 9, w: 2, h: 2) },
	],
	]

	# generate the keyboard layout and wire up the button callbacks
	@keyboard = [
	keyboard_buttons(17.25 + 1.5 0, 0, ["Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P"]),
	keyboard_buttons(17.25 + 1.5 1, 0.6, ["A", "S", "D", "F", "G", "H", "J", "K", "L"]),
	keyboard_buttons(17.25 + 1.5 2, 0, ["ENT", "Z", "X", "C", "V", "B", "N", "M", "BKSP"],
	{
	"ENT" => lambda { guess_word! },
	"BKSP" => lambda { unset_char! }
	})
	]
	end

	def guess_word!
	# when the player presses enter, or clicks the "ENT" button

	# get the full word for the current row
	full_word = @guesses[@current_guess_index].map { \|guess\| guess.char }.join

	# the word is valid if its length is 5 and it's in the valid word dictionary
	is_valid = full_word.length == 5 && @valid_words.include?(full_word)

	# if it's valid, then enumerate each one of the guess entries and queue up
	# their animations
	if is_valid
	@guesses[@current_guess_index].each_with_index do \|guess, i\|
	if @target_word[i] == guess.char
	# if the index of the word matches exactly, then flip to green
	guess.action = :flip_green
	guess.action_at = Kernel.tick_count + i * @flip_spline_duration

	# update the keyboard color lookup and queue it to be rendered
	# after all animations have completed
	if !@key_colors[guess.char] \|\| @key_colors[guess.char].color_id == :yellow \|\| @key_colors[guess.char].color_id == :gray
	@key_colors[guess.char] \|\|= { *GREEN, at: Kernel.tick_count + 5 @flip_spline_duration, color_id: :green }
	end
	elsif @target_word.include? guess.char
	# if the target word contains the character, then flip to yellow
	guess.action = :flip_yellow
	guess.action_at = Kernel.tick_count + i * @flip_spline_duration

	# update the keyboard color lookup and queue it to be rendered
	# after all animations have completed
	if !@key_colors[guess.char] \|\| @key_colors[guess.char].color_id == :gray
	@key_colors[guess.char] \|\|= { *YELLOW, at: Kernel.tick_count + 5 @flip_spline_duration, color_id: :yellow }
	end
	else
	# otherwise flip to gray
	guess.action = :flip_gray
	guess.action_at = Kernel.tick_count + i * @flip_spline_duration

	# update the keyboard color lookup and queue it to be rendered
	# after all animations have completed
	if !@key_colors[guess.char]
	@key_colors[guess.char] \|\|= { *GRAY, at: Kernel.tick_count + 5 @flip_spline_duration, color_id: :gray }
	end
	end
	end

	if full_word == @target_word
	# the player has won if their guess matches the target word
	@game_over = true
	@game_over_at = Kernel.tick_count + 5 * @flip_spline_duration
	@winner = true

	@player_progress << { word: @target_word, result: :win }
	elsif @current_guess_index == 5
	# the player has lost if they've run out of rows
	@game_over = true
	@game_over_at = Kernel.tick_count + 5 * @flip_spline_duration
	@winner = false

	@player_progress << { word: @target_word, result: :loss }
	else
	# increment to the next row after the guess
	@current_guess_index += 1
	@current_guess_char_index = 0
	end
	else
	# if the word they selected isn't in the valid word dictionary,
	# then queue the invalid animation
	@guesses[@current_guess_index].each_with_index do \|guess, i\|
	guess.action = :invalid
	guess.action_at = Kernel.tick_count
	end
	end
	end

	def generate_letter_prefabs!
	# on frame zero, generate textures/glpyhs for all the letters
	return if Kernel.tick_count != 0

	r = Layout.rect(row: 0, col: 0, w: 2, h: 2)
	["Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P",
	"A", "S", "D", "F", "G", "H", "J", "K", "L",
	"Z", "X", "C", "V", "B", "N", "M"].each do \|c\|
	outputs[c.downcase].w = r.w
	outputs[c.downcase].h = r.h
	outputs[c.downcase].background_color = [0, 0, 0, 0]
	outputs[c.downcase].primitives << { x: r.w / 2, y: r.h / 2, text: c, anchor_x: 0.5, anchor_y: 0.5, size_px: r.h / 2, r: 255, g: 255, b: 255 }
	end
	end

	def calc
	return if @game_over_at && @game_over_at.elapsed_time < 30
	return if @new_game_at && @new_game_at.elapsed_time < 30

	if @game_over
	# if they clicked or pressed enter, then start a new game
	if inputs.mouse.click \|\| inputs.keyboard.key_up.char == "\r" \|\| inputs.keyboard.key_down == "\r"
	save_progress!
	new_game!
	end
	else
	if inputs.mouse.click
	# if they are using the mouse and they click, find the key that the mouse intersects with
	keyboard_key = Geometry.find_intersect_rect(inputs.mouse, @keyboard, using: :rect)

	# if the key is found, then call the on_click callback on the key
	if keyboard_key
	keyboard_key.on_click.call
	end
	elsif inputs.keyboard.key_up.char

	# if they used the keyboard and it's backspace or enter,
	# then delete or guess word
	if inputs.keyboard.key_up.char == "\b"
	unset_char!
	elsif inputs.keyboard.key_up.char == "\r"
	guess_word!
	else
	# if it's any other key, then check to see if the keyboard buttons has
	# the key that was pressed
	key = @keyboard.find do \|k\|
	k.char == inputs.keyboard.key_up.char.upcase
	end

	# if so, then invoke the on_click callback (as if they clicked it with the mouse)
	key.on_click.call if key
	end
	end
	end
	end

	def tick
	generate_letter_prefabs!
	calc
	render
	# outputs.primitives << Layout.debug_primitives(invert_colors: true)
	end

	def unset_char!
	# unsetting a char/deleting a char logic
	if @current_guess_char_index == 4 && @guesses[@current_guess_index][@current_guess_char_index].char
	# if it's the last spot and there is a char to be deleted, then clear out the char
	@guesses[@current_guess_index][@current_guess_char_index].char = nil
	elsif @current_guess_char_index == 0 && @guesses[@current_guess_index][@current_guess_char_index].char
	# if it's the first spot and there is a char to be deleted, then clear out the char
	@guesses[@current_guess_index][@current_guess_char_index].char = nil
	elsif @current_guess_char_index != 0
	# otherwise move back a spot, and clear out the char in that spot
	@current_guess_char_index -= 1
	@guesses[@current_guess_index][@current_guess_char_index].char = nil
	end
	end

	def set_char! c
	# set the current spot's char and increment to the next spot if they aren't already on the las
	# spot
	if !@guesses[@current_guess_index][@current_guess_char_index].char
	@guesses[@current_guess_index][@current_guess_char_index].char = c
	@guesses[@current_guess_index][@current_guess_char_index].action_at = Kernel.tick_count
	@guesses[@current_guess_index][@current_guess_char_index].action = :set_char
	@current_guess_char_index += 1 if @current_guess_char_index != 4
	end
	end

	def keyboard_buttons(start_row, start_col, chars, callback_overrides = {})
	# button construction
	# layout api is used to create the rectangle, and the call back is set to
	# set_char!(char) by default unless there is a callback override (eg for ENT and BKSP)
	running_col = 0
	chars.map_with_index do \|c, i\|
	w = if c.length > 1
	1.8
	else
	1.2
	end
	r = if c.length > 1
	Layout.rect(row: start_row, col: start_col + running_col, w: w, h: 1.5)
	else
	Layout.rect(row: start_row, col: start_col + running_col, w: w, h: 1.5)
	end
	running_col += w
	on_click = callback_overrides[c] \|\| ->() { set_char! c }
	{ rect: r, char: c, on_click: on_click }
	end
	end

	def guess_char_prefab guess_char
	# this is the prefab for rendering a tile

	# get the location of the spot and a char (if one is there)
	r = guess_char.rect
	c = guess_char.char

	# the default color for the tile is a grayish border
	# with a dark background, and the character texture (if the spot has a character set)
	border_color = if c
	{ r: 90, g: 90, b: 90 }
	else
	{ r: 45, g: 45, b: 45 }
	end

	outer_tile = r.center.merge(path: :solid, **border_color, w: r.w, h: r.h, anchor_x: 0.5, anchor_y: 0.5)
	inner_tile = r.center.merge(path: :solid, r: 18, g: 18, b: 18, w: r.w - 4, h: r.h - 4, anchor_x: 0.5, anchor_y: 0.5)
	label_prefab = r.center.merge(path: c.downcase, w: r.w, h: r.h, anchor_x: 0.5, anchor_y: 0.5) if c

	# sorting for rendering so that animations aren't behind other tiles (default is 0)
	sort_order = 0

	if guess_char.action_at && guess_char.action == :set_char
	# if an action as been queued, and the action is :set_char

	# use the enter_char_spline animation to compute the percentage
	perc = if guess_char.action_at && guess_char.action_at.elapsed_time < @enter_char_spline_duration
	Easing.spline(guess_char.action_at, Kernel.tick_count, @enter_char_spline_duration, @enter_char_spline)
	else
	0
	end

	# the percentage is used to scale the rect up, and back down
	label_prefab = r.center.merge(path: c.downcase, w: r.w + 32 * perc, h: r.h + 32 * perc, anchor_x: 0.5, anchor_y: 0.5) if c
	outer_tile = r.center.merge(path: :solid, *border_color, w: r.w + 32 perc, h: r.h + 32 * perc, anchor_x: 0.5, anchor_y: 0.5)
	inner_tile = r.center.merge(path: :solid, r: 18, g: 18, b: 18, w: r.w - 4 + 32 * perc, h: r.h - 4 + 32 * perc, anchor_x: 0.5, anchor_y: 0.5)

	# set the sort order to 1 so that it renders at the top
	sort_order = 1
	elsif guess_char.action_at && guess_char.action == :flip_green
	# if the animation is flip to green, then use the flip animation spline to compute the percentage
	perc = if guess_char.action_at && guess_char.action_at.elapsed_time < @flip_spline_duration && guess_char.action_at.elapsed_time > 0
	Easing.spline(guess_char.action_at, Kernel.tick_count, @flip_spline_duration, @flip_spline)
	else
	1
	end

	# default colors before the flip/reveal occurs
	outer_tile_color = { r: 90, g: 90, b: 90 }
	inner_tile_color = { r: 18, g: 18, b: 18 }

	# half way through the animation, flip to green
	if guess_char.action_at.elapsed_time > @flip_spline_duration.idiv(2)
	outer_tile_color = GREEN
	inner_tile_color = GREEN
	end

	# the perc value is used to control the height of the prefab
	label_prefab = r.center.merge(path: c.downcase, w: r.w, h: r.h * perc, anchor_x: 0.5, anchor_y: 0.5) if c
	outer_tile = r.center.merge(path: :solid, w: r.w, h: r.h * perc, anchor_x: 0.5, anchor_y: 0.5, **outer_tile_color)
	inner_tile = r.center.merge(path: :solid, w: r.w - 4, h: (r.h - 4) * perc, anchor_x: 0.5, anchor_y: 0.5, **inner_tile_color)
	sort_order = 1
	elsif guess_char.action_at && guess_char.action == :flip_yellow
	# same as flip_green, but yellow color
	perc = if guess_char.action_at && guess_char.action_at.elapsed_time < @flip_spline_duration && guess_char.action_at.elapsed_time > 0
	Easing.spline(guess_char.action_at, Kernel.tick_count, @flip_spline_duration, @flip_spline)
	else
	1
	end

	outer_tile_color = { r: 90, g: 90, b: 90 }
	inner_tile_color = { r: 18, g: 18, b: 18 }

	if guess_char.action_at.elapsed_time > @flip_spline_duration.idiv(2)
	outer_tile_color = YELLOW
	inner_tile_color = YELLOW
	end

	label_prefab = r.center.merge(path: c.downcase, w: r.w, h: r.h * perc, anchor_x: 0.5, anchor_y: 0.5) if c
	outer_tile = r.center.merge(path: :solid, w: r.w, h: r.h * perc, anchor_x: 0.5, anchor_y: 0.5, **outer_tile_color)
	inner_tile = r.center.merge(path: :solid, w: r.w - 4, h: (r.h - 4) * perc, anchor_x: 0.5, anchor_y: 0.5, **inner_tile_color)
	sort_order = 1
	elsif guess_char.action_at && guess_char.action == :flip_gray
	# same logic as flip_green, but gray color
	perc = if guess_char.action_at && guess_char.action_at.elapsed_time < @flip_spline_duration && guess_char.action_at.elapsed_time > 0
	Easing.spline(guess_char.action_at, Kernel.tick_count, @flip_spline_duration, @flip_spline)
	else
	1
	end

	outer_tile_color = { r: 90, g: 90, b: 90 }
	inner_tile_color = { r: 18, g: 18, b: 18 }

	if guess_char.action_at.elapsed_time > @flip_spline_duration.idiv(2)
	outer_tile_color = GRAY
	inner_tile_color = GRAY
	end

	label_prefab = r.center.merge(path: c.downcase, w: r.w, h: r.h * perc, anchor_x: 0.5, anchor_y: 0.5) if c
	outer_tile = r.center.merge(path: :solid, w: r.w, h: r.h * perc, anchor_x: 0.5, anchor_y: 0.5, **outer_tile_color)
	inner_tile = r.center.merge(path: :solid, w: r.w - 4, h: (r.h - 4) * perc, anchor_x: 0.5, anchor_y: 0.5, **inner_tile_color)
	sort_order = 1
	elsif guess_char.action_at && guess_char.action == :invalid
	# if the animation that's queued is an invalid word,
	# compute the prec using the @invalid_spline
	perc = if guess_char.action_at && guess_char.action_at.elapsed_time < @invalid_spline_duration && guess_char.action_at.elapsed_time > 0
	Easing.spline(guess_char.action_at, Kernel.tick_count, @invalid_spline_duration, @invalid_spline)
	else
	0
	end

	# the perc value is used to shift the x value (shake animation)
	label_prefab = { x: r.center.x + 64 * perc, y: r.center.y, w: r.w, h: r.h, anchor_x: 0.5, anchor_y: 0.5, path: c.downcase } if c
	outer_tile = { x: r.center.x + 64 * perc, y: r.center.y, path: :solid, **border_color, w: r.w, h: r.h, anchor_x: 0.5, anchor_y: 0.5 }
	inner_tile = { x: r.center.x + 64 * perc, y: r.center.y, path: :solid, r: 18, g: 18, b: 18, w: r.w - 4, h: r.h - 4, anchor_x: 0.5, anchor_y: 0.5 }
	sort_order = 1
	end

	# return a structure that contains the sort order for rendering, and the prefab/primitives to render
	{
	sort_order: sort_order,
	prefab: [
	outer_tile,
	inner_tile,
	label_prefab
	]
	}
	end

	def render
	# set the back ground color
	outputs.background_color = [18, 18, 18]

	# enumerate all the guesses, flat map the prefabs
	# then sort each prefab by the sort order
	# and shovel the prefab data into output.primitives
	outputs.primitives << @guesses.flat_map do \|guess\|
	guess.map do \|guess_char\|
	guess_char_prefab(guess_char)
	end
	end.sort_by { \|pf_container\| pf_container.sort_order }
	.map { \|pf\| pf.prefab }

	# render the keyboard
	outputs.primitives << @keyboard.map do \|keyboard_key\|
	c = keyboard_key.char
	r = keyboard_key.rect
	# the color of the key is set to a defualt gray, unless there is a color override
	# in the key_colors lookup (along with a time stamp of when to show the color -> we don't want to change the
	# color during the reveal of a guess)
	color = if @key_colors[keyboard_key.char] && @key_colors[keyboard_key.char].at < Kernel.tick_count
	@key_colors[keyboard_key.char]
	else
	{ r: 131, g: 131, b: 131 }
	end

	# return the prefab for the key which is a combination of the color, plus a label representing the key
	[
	r.merge(path: :solid, **color),
	r.center.merge(text: c, anchor_x: 0.5, anchor_y: 0.5, r: 255, g: 255, b: 255, size_px: 40)
	]
	end
	end
	end

	# boot up of game
	def boot args
	args.state = {}
	end

	# top level tick function
	def tick args
	$game \|\|= Game.new
	$game.args = args
	$game.tick
	end

	# reset logic used when hotloading
	def reset args
	$game = nil
	end

	GTK.reset
No results found