• 1

• 2k
• 16
• 30

• 2k
• 16
• 30

I'm not a beginner to programming, but I am to programming in OOP (effectively at least). So to learn better I wrote an object oriented game of Snakes and Ladders. For background, see this question.

I wrote four classes: Board, Cell, Portal, and Player. All are self explanatory except for Portal. A Portal object represents a snake or a ladder cell. Portals are just cells with behaviour. Their behaviour is identical save for the direction they teleport you to. Snakes send you back, while ladders send you forward.

A Cell object keeps track of any players that land on it. It is also aware of its location.

class Cell
 attr_reader :location, :players
 def initialize(input)
 @location = input.fetch(:location)
 @players = []
 end
 def exit(player)
 evict player
 end
 def enter(player, board)
 admit player
 player.set_cell(self)
 end
private
 def admit(player)
 players << player
 end
 def evict(player)
 players.delete(player)
 end
end

A Portal object inherits from Cell. It adds behaviour, and has a destination attribute. It overrides the enter method in its superclass. Instead of admitting the player it tells the board to send it to the portal's destination.

class Portal < Cell
 attr_reader :destination
 def initialize(input)
 @destination = input.fetch(:destination)
 super
 raise ArgumentError, "Location and destination can not be the same" if location.equal?(destination)
 end
 def enter(player, board)
 board.move player, location, destination
 end
end

The Player object must know of the Cell it resides in. It is also responsible for rolling the die.

class Player
 attr_reader :name
 attr_accessor :current_cell
 def initialize(input)
 @name = input.fetch(:name)
 end
 def to_s
 name
 end
 def roll_dice
 rand(1..6)
 end
 def set_cell(cell)
 self.current_cell = cell
 end
 def position
 if current_cell
 current_cell.location
 else
 -1 # represents off the board state
 end
 end
end

Finally, the Board keeps track of the current player, the number of turns, and moves players in between cells. It also decides if the game has a winner.

class Board
 attr_reader :grid, :players, :die
 attr_accessor :turn
 def initialize(input = {})
 @grid = input.fetch(:grid, default_grid)
 @players = []
 @turn = 0
 end
 def add_player(player)
 players << player
 end
 def get_cell(index)
 grid[index]
 end
 def move(player, from, to)
 get_cell(from).exit player if game_started?
 get_cell(to).enter player, self
 end
 def play_turn
 current_player_position = current_player.position
 roll = current_player.roll_dice
 if winner?(roll)
 puts "#{current_player} rolls a #{roll} and wins! Congratulations!"
 exit
 end
 move current_player, current_player.position, current_player.position + roll
 puts "#{current_player} rolls a #{roll} and moves from #{current_player.position - roll} to #{current_player.position}"
 increment_turn
 play_turn
 end
private
 def default_grid
 Array.new(100)
 end
 def current_player
 players.fetch(turn % players.size)
 end
 def increment_turn
 self.turn += 1
 end
 def game_started?
 turn > 0
 end
 def winner?(last_roll)
 # +1 is to account for arrays starting at 0. So cell 1 is in fact cell 2 on a board.
 (current_player.position + 1 + last_roll) >= grid.size
 end
end

Concerns

I think I've done a decent job for my first crack, but I know this can be improved.

1. I am not sure about the die rolling and player moving mechanic. It feels clunky. Is passing the cell to the user a necessary dependency? I can't think of a better way to get the player to move and change its position.
2. The play turn uses recursion, but again, I'm not sure how to write it better.

That arrays in Ruby start at 0 is causing me all sorts of confusion.

1. To render the board I must add 1 to each cell location.
2. I must add 1 to the player position or deduct 1 from the grid size to work out the winner.
3. Players start off the board. I must check if the player has a cell, and if not, I have to return -1 to represent the off the board state.

There are probably lots of issues I'm not aware of. My objectives are the following. I think so far I might have succeeded with 2, but failed with 1 and 3.

1. Make the code easy to modify. Let's say I want to add a Rule object that can store different winning criteria (roll to an excess of 100 or land exactly on 100).
2. Introduce other cell subclasses with different effects.
3. Make the game state easy to save so that I can player across HTTP requests.

Here's an example of running the game:

game = SnakesAndLadders.classic
m = SnakesAndLadders::Player.new name: "Mario", color: "Red"
l = SnakesAndLadders::Player.new name: "Luigi", color: "Green"
game.add_player m
game.add_player l
game.play_turn