A Game of Othello

1
A Game of Othello

• Othello popular board game (often known as
  Reversi)
• 8x8 board, black and white tokens
• Today, we will use it as a design example

2
Othello Rules and Game Play

• The object of the game is to have the majority of
  your colour discs on the board at the end of the
  game
• Rules
• Black places two black discs and White places two
  white discs as shown in here. The game always
  begins with this setup.
• A move consists of "outflanking" your opponent's
  disc(s), then flipping the outflanked disc(s) to
  your colour.
• To outflank means to place a disc on the board so
  that your opponent's row (or rows) of disc(s) is
  bordered at each end by a disc of your colour. (A
  "row" may be made up of one or more discs).
• Here's one example White disc A was already in
  place on the board. The placement of white disc B
  outflanks the row of three black discs.

3
Outflanking Example
White disc A was already in place on the board.
The placement of white disc B outflanks the row
of three black discs.
White flips the outflanked discs and now the row
looks like this
4
Rules

• Black always moves first.
• If on your turn you cannot outflank and flip at
  least one opposing disc, your turn is forfeited
  and your opponent moves again. However, if a move
  is available to you, you may not forfeit your
  turn.
• A disc may outflank any number of discs in one or
  more rows in any number of directions at the same
  time - horizontally, vertically or diagonally.
• You may not skip over your own color disc to
  outflank an opposing disc.

5
Rules

• Discs may only be outflanked as a direct result
  of a move and must fall in the direct line of the
  disc placed down.

• All discs outflanked in any one move must be
  flipped, even if it is to the player's advantage
  not to flip them at all.
• Once a disc is placed on a square, it can never
  be moved to another square later in the game.

6
Rules

• When it is no longer possible for either player
  to move, the game is over. Discs are counted and
  the player with the majority of his or her colour
  discs on the board is the winner.

7
Our Design Problem

• Design an Othello Board and Gamekeeper.
• The gamekeeper will
• Keep track of the score and state of the board
• Indicate whose move it is
• Indicate where legal moves can be made
• Accept and make a legal move
• Flip all the discs who have been outflanked
• Focus of todays lecture
• Game engine and logic alone
• We will assume
• Display device for an 8x8 board
• Input device which tells us where to move on an
  8x8 board

8
Global Picture of Our System

• Circuit in Each Square to
• Keep State of the Square
• Compute whether move in square is legal

Game Controller

1. Global Game State
2. Orchestrates individual move logic

9
Game Controller State Machine
Game Over
Flip Current Color
Flip Current Color
N
Legal Move?
N
Legal Move?
Current Color White
Y
Y
Update Board
Enable Move
Move selected
Move selected
10
Square FSM

• Basic Functions
• Store state of square (Empty, White, Black)
• Report when move is legal
• Report when user moves into square
• Update state of square in response to a move

Square
Move Selected
Current Color
Legal Move
Move Enabled
11
Square Finite State Machine
12
Whats a Legal Move?

• Decided in each square
• Square state must be empty
• Run of colors
• Straight line of squares of one color bordered by
  a square of the other color
• White run line of white squares terminated by
  black square
• Black run line of black squares terminated by
  white square
• Current run line of squares of current color
  terminated by square of other color
• Legal move
• Square is empty and neighbor square is part of
  current run

13
Key Consideration for Cell

• Is it on a run in any direction?
• Originates a white (black) run
• Cell is white (black) and
• Neighbor in direction is black (white)
• Continues a white (black) run
• Cell is white (black) and
• Neighbor in direction continues or originates a
  white (black) run
• Move to a square is legal if and only if
• Current Mover is white (black)
• Current State is empty
• Some neighbor continues or orginates a black
  (white) run

14
Originating and Continuing a Run
Begins a black run
Continues a white run
Begins a white run
15
Legal Moves
Legal to move white
Legal to move black
How do we build a circuit to pick this up?
16
Two Functions Per Color and direction

• Remote
• Black this square is white
• all the squares in some direction are white until
  we hit a black
• Reverse black/white for Remote White
• RemoteOrLocal
• Black this square is black OR remoteBlack is
  true for this square
• Note that if a square is empty both remote and
  remoteOrLocal are false.

17
Originating and Continuing a Run
remoteWhiteEast remoteOrLocalBlack (all
directions) remoteOrLocalBlack East
remoteOrLocalWhite (all directions) remoteOrLocalB
lackWest remoteBlackWest
remoteOrLocalWhite (all directions) remoteOrLocalB
lackWest remoteBlackWest
18
Cell circuit picture
19
RemoteBlack (Continue White Run)
White run to NW
White run from SE
20
RemoteOrLocal black (on white run or neighbor can
start white run)
21
Cell circuit picture
On each link 2 wires in 4 wires out
22
Legal Move

• Move to a square is legal if and only if
• Current Mover is white (black)
• Current State is empty
• Some neighbor continues or orginates a black
  (white) run
• Translate into our circuit
• Current Mover is white (black)
• Current State is empty
• For some direction neighbors remoteWhite
  (black)

23
Computation of Legal
Replicate here from each neighbor
Computation from one direction
24
Whats the delay?

• Worst case is on edge or corner
• At most 7 AND or OR gates on remote chain
• Computation of legal is 6 gates (figure 3 gate
  delays for 8-input OR)
• Total delay is 13 gates
• Note (Synchronous Mealy) we want to latch the
  output of legal!
• What about the edges and corners? More later

25
How much logic in a cell?

• 8x2 AND gates for remote 16
• 8x2 OR gates for localOrRemote 16
• 3 gates for leaf of legal computation (8 leaves),
  so 8x3 24
• 7 OR gates 1 AND gate for rest of legal
  computation
• Total 64 gates/cell (so far)
• Also need at least 2 latches for color one for
  legal
• More logic to come

26
Doing The Move

• This is easy
• One external select (keyed by button or
  multiplexer from joystick not our problem
  today)
• Select legal (previously computed)
• Still have to flip

27
Flipping
Move
Flip
How can we build a flip function?
28
Flipping
Move black
29
Key

• Mover sends out a flip signal, with color and
  direction, to each neighbor
• 8x2 wires
• Flip black if
• Flip black signal from one direction (SE) and
• Color is white and
• remoteBlack is true in other direction (NW)
• FlipBlackNW FlipBlackFromSE AND Colorwhite
  AND RemoteBlackNW
• Send FlipBlackNW out to NW neighbor
• OR all FlipBackDirections to get Direction

30
Flip Calculation
31
Computation of Next Cell State
32
Cell circuit picture
On each link 4 wires in 6 wires out
33
Gate Delay Calculation for Clip

• 7x2 gates to propagate 14 gate delays
• But need to consider the remote chain!
• Adds another 7 delays (from slide 24)
• 3 gate delays through 8-way OR 1 gate delay to
  comput next state
• Worst-case is 25 gate delays
• Can reduce to 18 by latching remote signals
  computed in legal-move phase

34
How Many Gates

• 2 gates/direction-color x 2 colors x 8 directions
  32 gates
• 2 gates for current move (one black, one white)
• 8 gates/color for upper end of next-state tree
  16
• Total 50 gates
• Add to 64 from slide 25
• Total 114 gates/cell
• 64 cells 7296 gates for design
• But what about the corners and edges?

35
Two choices

• Cell design assumes neighbors in all directions
• Note true at edges and corners
• One special-case cells on the edge
• Now have 9 different types of cell!
• 1/49 cells in center of board (type 1) cell
  weve designed
• 4/7 cells each on each edge (types 2-5)
• 4/7 cells each for each corner (types 6-9)
• Note each specialty type is simpler than general
  case, but
• 9 cell types to design! ?
• Two Surround the board with shadow squares
• Less efficient, but much simpler

36
Revised Board










Shadow Cells
Normal Cells weve designed
37
Shadow Cells

• Always empty (no next-state logic)
• Cant be selected
• localOrRemote, local false for all colors and
  directions
• Just a small collection of 6 wires connected to
  ground
• Key advantage only two cell types, one trivial
• Disadvantage lose a little efficiency from
  specialization of edge, corner cells
• Always worth it! Let a synthesizer optimize away
  the constants

38
Timing Diagram for Each Move
39
Logic for controller
40
Game Control Logic
41
Key Steps to Making the Design Work

• Software implementation first!
• I did it in Smalltalk
• Tastes Differ, but
• OO programming model tends to fit circuits well
• Map each object onto a circuit
• Variables tend to map to latches
• Functions tend to map to logic circuits
• Unit test, unit test, unit test!
• Design test circuits for each component
• Synthesize test circuits as part of the design
• Audit, audit, audit!
• Pin out internal state where possible
• E.g., Legal should be displayed visually

42
Timing Bugs

• Nastiest, hardest to catch
• Two common examples Read-Before-Wirte and
  Write-Before-Read
• Read-Before-Write
• Reader reads sequential value before writer has
  updated it
• Acts on old value
• E.G. no legal move but controller sees legal move
  from previous value
• Write-Before-Read
• Writer writes before old value has been acted on
• Reader doesnt act on value

43
Two Solution

• Dirty/Clean bits
• Writer sets dirty bit, reader cleans it when read
• Writer checks dirty bits clean before writing,
  reader checks set before reading
• Error raised if condition not met
• FIFO Queues
• Writer writes, reader reads
• Decouples send/receive asymmetries by a cycle or
  so
• Can become event-driven Reader only reads when
  new value
• Still have to check overflow, etc
• Automatically implemented in V