A Game of Othello - PowerPoint PPT Presentation


PPT – A Game of Othello PowerPoint presentation | free to download - id: 3cd4cb-NDI1O


The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation

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 Othello: Rules and Game Play The ... – PowerPoint PPT presentation

Number of Views:257
Avg rating:3.0/5.0
Slides: 44
Provided by: wwwinstEe2


Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: A Game of Othello

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

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
  • 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.

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
  • 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
  • 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.

  • 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.

  • 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.

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

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

Game Controller
  • Global Game State
  • Orchestrates individual move logic

Game Controller State Machine
Game Over
Flip Current Color
Flip Current Color
Legal Move?
Legal Move?
Current Color White
Update Board
Enable Move
Move selected
Move selected
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

Move Selected
Current Color
Legal Move
Move Enabled
Square Finite State Machine
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

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

Originating and Continuing a Run
Begins a black run
Continues a white run
Begins a white run
Legal Moves
Legal to move white
Legal to move black
How do we build a circuit to pick this up?
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.

Originating and Continuing a Run
remoteWhiteEast remoteOrLocalBlack (all
directions) remoteOrLocalBlack East
remoteOrLocalWhite (all directions) remoteOrLocalB
lackWest remoteBlackWest
remoteOrLocalWhite (all directions) remoteOrLocalB
lackWest remoteBlackWest
Cell circuit picture
RemoteBlack (Continue White Run)
White run to NW
White run from SE
RemoteOrLocal black (on white run or neighbor can
start white run)
Cell circuit picture
On each link 2 wires in 4 wires out
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

Computation of Legal
Replicate here from each neighbor
Computation from one direction
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

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
  • Total 64 gates/cell (so far)
  • Also need at least 2 latches for color one for
  • More logic to come

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

How can we build a flip function?
Move black
  • 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

Flip Calculation
Computation of Next Cell State
Cell circuit picture
On each link 4 wires in 6 wires out
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

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
  • 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?

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

Revised Board
Shadow Cells
Normal Cells weve designed
Shadow Cells
  • Always empty (no next-state logic)
  • Cant be selected
  • localOrRemote, local false for all colors and
  • Just a small collection of 6 wires connected to
  • 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

Timing Diagram for Each Move
Logic for controller
Game Control Logic
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

Timing Bugs
  • Nastiest, hardest to catch
  • Two common examples Read-Before-Wirte and
  • 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

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
  • Can become event-driven Reader only reads when
    new value
  • Still have to check overflow, etc
  • Automatically implemented in V
About PowerShow.com