Ruby Warrior is a clever rogue-like game where, instead of playing it directly, you implement a Ruby class with your player control logic.

class Player
  def play_turn(warrior)
    # add your code here
  end
end

Level 1

At the start of each level, a README describes the horrors you will face.

Level 1

Silence. The room feels large, but empty. Luckily you have a map of this tower 
to help find the stairs.

Tip: Use warrior.direction_of_stairs to determine which direction stairs are 
located. Pass this to warrior.walk! to walk in that direction.

 ------
|      |
|@     |
|      |
|  >   |
 ------

  > = Stairs
  @ = Juez (20 HP)


Available Abilities:

  warrior.feel
    Returns a Space for the given direction (forward by default).

  warrior.direction_of_stairs
    Returns the direction (:left, :right, :forward, :backward) the stairs are 
from your location.

  warrior.walk!
    Move in given direction (forward by default).

Following the README's advice, clearing the first level is easy.

class Player
  def play_turn(warrior)
    warrior.walk! warrior.direction_of_stairs
  end
end

Or if you're like me and find that code to be unacceptably verbose, you are liable to write something like the following.

module Delegate
  def method_missing symbol, *args
    @delegate.send symbol, *args
  end
end

class Player
  include Delegate

  def play_turn warrior
    @delegate = warrior
    step
  end
end

class Player
  def step
    walk! direction_of_stairs
  end
end

Some programmers are lazy in the worst possible way.

When you play a level, you see a turn-by-turn transcript.

Starting Level 1
- turn 1 -
 ------
|      |
|@     |
|      |
|  >   |
 ------
Juez walks right
- turn 2 -
 ------
|      |
|      |
|@     |
|  >   |
 ------
Juez walks forward
- turn 3 -
 ------
|      |
|      |
| @    |
|  >   |
 ------
Juez walks right
- turn 4 -
 ------
|      |
|      |
|      |
| @>   |
 ------
Juez walks forward
Success! You have found the stairs.
Level Score: 0
Time Bonus: 16
Clear Bonus: 3
Total Score: 19

Onto the second level.

Level 2

The README shows that we are up against three sludges. These undesirables do not move and, are, therefore easily dispatched.

Level 2

Another large room, but with several enemies blocking your way to the stairs.

Tip: Just like walking, you can attack! and feel in multiple directions 
(:forward, :left, :right, :backward).

 ----
| @s |
| sS>|
 ----

  > = Stairs
  @ = Juez (20 HP)
  s = Sludge (12 HP)
  S = Thick Sludge (24 HP)


Available Abilities:

  warrior.feel
    Returns a Space for the given direction (forward by default).

  warrior.rest!
    Gain 10% of max health back, but do nothing more.

  warrior.health
    Returns an integer representing your health.

  warrior.attack!
    Attack the unit in given direction (forward by default).

  warrior.direction_of_stairs
    Returns the direction (:left, :right, :forward, :backward) the stairs are 
from your location.

  warrior.walk!
    Move in given direction (forward by default).

How would you approach this challenge?

Agaram's Approach

A pair of solutions are posted. Kartik Agaram proposed the following solution. (I have edited it by removing comments and unused methods.)

class Player
  def initialize()
    @max_health = nil
    @prev_health = nil
    @warrior = nil
    @direction = :forward
    @health_history = []
    @direction_history = []
  end

  def play_turn(warrior)
    @max_health ||= warrior.health

    @warrior = warrior
    updateHistory

    return walk! if feel.stairs?
    return rest! if needRest && !beingShotAt
    return attack! unless feel.empty?

    reverse_direction if walking_into_fire
    walk!
  end

  def needRest
    @warrior.health < @max_health
  end

  def beingShotAt
    @warrior.health < @prev_health
  end

  def updateHistory
    @prev_health = @curr_health
    @curr_health = @warrior.health
    @health_history << @curr_health
    @direction = @warrior.direction_of_stairs
  end

  def walk!
    @warrior.walk! @direction
  end

  def attack!
    @warrior.attack! @direction
  end

  def rest!
    @warrior.rest!
  end

  def feel
    @warrior.feel @direction
  end

  def walking_into_fire
    return false if @direction_history[-1] != @direction_history[-2] ||
        @direction_history[-2] != @direction_history[-3]
    @health_history[-1] < @health_history[-2] &&
      @health_history[-2] < @health_history[-3]
  rescue
    false
  end

  def reverse_direction
    @direction = (@direction == :forward) ? :backward : :forward
  end
end

What is his strategy? On each turn, Agaram makes a prioritized choice:

• If he is next to the stairs, then he takes them.
• If he needs to rest and is safe to do so, then he rests.
• If he feels something in the direction of the stairs, then he attacks it.
• If he is "walking into fire", then he walks away from the stairs.
• Otherwise he walks toward the stairs.

How does Agaram decide whether he is "walking into fire"? Though a little tough to read, the definition boils down to:

• For Agaram, "walking into fire" means that for the last two turns he has both lost health and faced the same direction.

When confronted with the map, how does Agaram's strategy play out?

Starting Level 2
- turn 1 -
 ----
| @s |
| sS>|
 ----
Agaram attacks Sludge
Sludge takes 5 damage, 7 health power left
Sludge attacks Agaram
Agaram takes 3 damage, 17 health power left
Sludge attacks Agaram
Agaram takes 3 damage, 14 health power left

Agaram attacks the Sludge to his east until it is good and dead.

- turn 3 -
 ----
| @s |
| sS>|
 ----
Agaram attacks Sludge
Sludge takes 5 damage, -3 health power left
Sludge dies
Agaram earns 12 points
Sludge attacks Agaram
Agaram takes 3 damage, 5 health power left
- turn 4 -
 ----
| @  |
| sS>|
 ----
Agaram walks backward
Sludge attacks and hits nothing
- turn 5 -
 ----
|@   |
| sS>|
 ----
Agaram receives 2 health from resting, up to 7 health

He retreats and recovers.

- turn 12 -
 ----
|@   |
| sS>|
 ----
Agaram receives 1 health from resting, up to 20 health
- turn 13 -
 ----
|@   |
| sS>|
 ----
Agaram walks forward
- turn 14 -
 ----
| @  |
| sS>|
 ----
Agaram walks forward
Sludge attacks and hits nothing

Another sludge stands in his way.

- turn 15 -
 ----
|  @ |
| sS>|
 ----
Agaram attacks Thick Sludge
Thick Sludge takes 5 damage, 19 health power left
Thick Sludge attacks Agaram
Agaram takes 3 damage, 17 health power left

He fights the sludge.

- turn 19 -
 ----
|  @ |
| sS>|
 ----
Agaram attacks Thick Sludge
Thick Sludge takes 5 damage, -1 health power left
Thick Sludge dies
Agaram earns 24 points
- turn 20 -
 ----
|  @ |
| s >|
 ----
Agaram receives 2 health from resting, up to 10 health

He heals again.

- turn 25 -
 ----
|  @ |
| s >|
 ----
Agaram receives 2 health from resting, up to 20 health
- turn 26 -
 ----
|  @ |
| s >|
 ----
Agaram walks right
- turn 27 -
 ----
|    |
| s@>|
 ----
Agaram walks forward
Sludge attacks and hits nothing
Success! You have found the stairs.
Level Score: 36
Time Bonus: 13
Total Score: 68

After recovering, Agaram finds his way to the stairs.

Will's Approach

Since Ruby Warrior requires that you write a play_turn method, the easiest way to dive into a solution is to come up with a turn-by-turn strategy saving little bits of state (@direction_history and @direction_history) as needed.

What if it were easy to express a step-by-step plan instead? Then you would:

• Fight the Sludge.
• Walk forward twice.
• Walk right up the stairs.

Piece of cake: ignore the Thick Sludge.

class Player
  def fight!
    attack! while feel.enemy?
  end

  def main
    fight!
    2.times{walk!}
    walk! :right
  end
end

There's only one little problem with this code. The Player class expects turn-by-turn inverted control in its play_turn method. We want a player with good old fashioned step-by-step procedural control. We have suffered inverted control frameworks for far too long. Assert your rights. Revert control. Embrace the imperative. Restore the natural sequence. And iterate until your heart's content. By Ruby, it shall be done:

require 'generator'

class Symbol
  def action?
    to_s[-1] == ?!
  end
end

class Player
  def initialize
    @generator = Generator.new do |g|
      g.yield nil
      main
    end
  end

  def play_turn warrior
    @warrior = warrior
    @generator.next
  end

  def method_missing symbol, *args
    @warrior.send symbol, *args
  ensure
    @generator.yield nil if symbol.action?
  end
end

Beauty. Now I present you with a challenge. My magic stems from the generator library. What would you do if generators, coroutines, continuations, actors, threads, setjmp/longjmp, and all other natural concurrency constructs were unavailable?