be
`
`116 of the
`
`robot
`
`where a
`
`lati 011.9.
`as
`
`

`
` Chapter 20 - Board Games
`
`
`
`Introduction
`
`Board Games are among the most challenging projects you can take on with 3:0,
`l\/HNDSTORJMS kit.The RCX does have the power to run software that playg
`Tic—Tac—Toe, Checkers, and even Chess (at some level), but this doesn’t mean
`such a program is easy to write and test.
`We believe that the hardest but most important part of the job is the creatio
`of the interface between your robot and the physical world.Though running 2, ’
`Chess program on the RCX is quite a challenging task in itself, having a robot
`physically interpret and interact with the data is another giant step.
`The method you choose to represent the board and make your robot actually
`move the pieces determines in large part the technical difficulties you will have
`to solve. In this chapter, we are going to describe some of the possible
`approaches, from the easiest to the trickiest.
`
`
`
`'
`
`Playing TEc—Tac—Toe
`
`As we described in our introduction to the book, in October 1999 we attended
`
`the first Mindfest gathering at the l\/lassachtisetts Institute ofTechnology (MIT) at
`the l\/ledia Lab facility.
`The l\/lindfest event featured many activities: lectures, workshops, a construc-
`tion zone...There was also a large exhibition area were the participants could
`show off their MINDSTORMS creations.
`
`A couple ofmonths before the event, we had already booked the plane and
`the hotel, and asked for a table in the exhibition area, but hadn’t yet prepared our
`robot. Showing brilliant intuition, Marco Beri, the third member of our small
`
`group, came up with the idea of building a Tic—Tac—Toe machine, a robot able to
`play a board version of the well—known ganie.We immediately felt it was the
`right idea: Board games have been historically considered a good test for machine
`intelligence, so even ifTic—Tac—Toe can't compare to Chess in complexity we
`thought it was the right project to present in the “temple” ofAl at MIT.
`Marco wrote the software, we built the hardware, and just a few days before
`leaving, we met and refined our prodigy. Our robot, named TTT, worked per-
`fectly and aroused much interest.
`Though we made an effort to keep the requirements minimal, our machine
`used many extra LEGO parts. For this reason, we decided to build a new, simpli~
`fied version for use in this book.The description of our original version is still
`online, however; you can find the link to it in Appendix A.
`
`
`
`

`
`“--—--I-jg
`
`Board Games - chapter 20
`
`393
`
`Building the Hardware
`
`To keep the project replicable using only parts from the l\/ilNDSTORl\/lS kit, we
`gave up the idea of making our robot physically mark its moves with a pen Or
`with pieces.Thus this robotjust indicates its move and requires your assistance in
`recording it on the paper.
`lfvou look at Figure 20.1, you will probably recognize the structure: It’s the
`Maze Solver of Chapter 19, withjust some minor modifications. (We won’t
`describe the whole robot again, just the changes we made, referring you to
`Chapter l9 for the remaining details.)
`
`Figure 20.1 The Tic-Tac—Toe Player
`
`
`
`The main difference concerns the number ollpegs used to mark the position
`along the X andY axis. In this project, you need just three stops in each direc-
`tion, and a fourth for the resting position of the robot. We also removed the base-
`plate and linked the two longitudinal rails with some plates.
`The board is represented by a White sheet of paper, the idea]. surface when
`l00king for the highest contrast in light readings. On the sheet, we traced the
`Tic-Tac—Toe schen1e.The centers ofits squares align with the stop pegs placed
`3l0I1g the rails (Figure 20.2).
`
`
`
`

`
`
`
`This robot is designed to read the light value in the center of the squares.You
`can either mark the moves placing thin LEGO pieces to represent Xs and Os, or
`drawing large dots with colored markers. In both cases, be sure that the light
`sensor is very close to the surface, otherwise its readings will be badly affected by
`the ambient light.
`
`Our robot need not know that a game is made of many moves. Every run of the
`program is a single move, made of the following steps:
`
`1. The robot scans the board, storing a copy of it in a memory array
`2.
`It evaluates the situation and decides what move to make.
`3.
`It performs the move.
`
`be
`
`an‘
`
`394
`
`Chapter 20 - Board Games
`
`Figure 20.2'The Tic-Tac—Toe Board
`
`We tested our robot using the 2 X 2 plates included in MINDSTORMS as
`
`marl<ers:The gray ones for one team and the blue ones for the other. (You can
`use green plates with the blue, since they read as almost the same value under the
`light sensor.)
`
`Writing the Program
`
`

`
`
`
`are that completes a
`
`squares of the external
`
`to
`
`3.
`
`4.
`
`1. Check if there’s any move that makes you win, a squ
`row, a column or a diagonal of three.
`Block the opponent if there’s any row, column, or diagonal with two of
`his pieces and one empty square.
`in the case where you have a pie
`ce in the center and the opponent has
`two pieces at the ends ofa di
`agonal, choose one of the four central
`rows and columns to force him to block you.
`If the central square is free, play there.
`lfone corner is free, play there.
`5.
`6. Play in any free square.
`
`<
`
`Board Games -
`
`Chapter 20
`
`39
`
`axis, first peg on the X axis). It stops there
`ofthe light sensor,
`We suggest you use raw Values, because, as expl
`ained in Chapter 4, they provide
`finer granularity. In our Version, there’s a clear
`—cut division among the readings of
`the white sheet, the gray plate, and th
`e blue plate, definitely enough to distin-
`guish the three cases with no ambig
`uity. lt"s crucial you place the plates directly
`below the reading positions of the sensor; you can make the placement more
`exact by marking the squares on the sheet with a thin black line.
`Having scanned and stored the first square, the rol
`vot will move to the second
`one, then to the third and so on until the whol
`e board has been scanned. Our
`TTT software, written in NQC, assi
`gned each square to a Variable, but it’s pos-
`sible to use a much more compact representation using individual bits, as demon-A
`strated by Antonio laniero’s YATTT (Yet Another Tic—Tac~Toe) th
`at employs only
`two variables for the entire board (see Appendix A).
`As for the strategy, when properly played,Tic-Tac—Toe ends in a tied game in
`which nobody wins.The following list enumerates, in order of priority, the steps
`to play a perfect defensive game:
`
`A Once the robot has
`BCEPS to show it W
`Practicing wit
`ld Play a few
`
`figured out its move, it goes to that particular square and
`ants to play there. then returns to its resting position.
`h the described strategy is a good idea; t
`ake a sheet of paper
`games against a friend, or by y
`'ourself, following the suggested
`were the robot.This wil
`l make you familiar with the possible board
`e moves required to oppose the attacks.
`
`h
`
`

`
`
`
`396
`
`Chapter 20 ' Board Games
`
`human player cheatsl).
`
`“he
`
`out
`
`8375‘
`(Fig
`
`N
`
`P0“
`the
`111116
`Whi‘
`l
`Conf
`alme
`331115
`state.
`
`Improving Your Game
`The hardware of the robot offers many possibilities for variations and improv
`merits. If you have enough racks, you can cover the side rails with them and us
`gears in place of wheels, the latter having an unpleasant tendency to slip.
`C
`Using a third motor, you can equip your robot with pliers to carry and drop
`its own pieces, as in our original version. The Mindfest TTT still needed the help
`of a human assistant to load the piece in a special platform where the robot
`caught it, but it’s possible to devise an. automatic dispenser that contains a stack of
`pieces and drops one on demand.
`’
`On the software side, the strategy we described will never let your robot lose "
`but it’s not particularly aggressive either.You can improve it in this area so your
`robot tries to confuse its opponent whenever possible.
`If you have a solid background in programming (and in Al in particular), you
`can develop a leammg version of this robot. It would start with no knowledge,
`playing purely at random in the beginning, but learning fiom its own mistakes
`and becoming better and better as the number of played games increases. In our
`opinion, this is quite a difficult but very impressive and instructive improvement,
`that makes the robot much more attractive to see in action.
`Playng Chess
`It’s a big step from Tic—Tac—Toe to Chess, but people have succeeded in writing
`a version for the RCX, proving that the goal is definitely achievable (see
`Appendix A).
`We didn’t test the robots in this chapter with the proper Chess—playing soft~
`ware but instead used a reduced set of moves to check the inechanics.We did,
`however, make an effort to present ideas about interfacing a Chess software with
`the real world. As always, too, these robots offer tips and suggestions applicable to
`other areas.
`'
`For example, the visual interface employs the Fiber—Optic System (FOS) as an
`input/output device, using it to emulate a rotation sensor (see Chapter 4) and at
`the same time give a visual indication of the nioves.This demonstrates that the
`unit, usually considered solely decorative, has greater potential:You can use its eight
`fibers anytime you want to show the user of your robot a value between 1 and 8.
`
`
`
`'
`
`
`
`

`
`grabbing arms designed for various appli
`lating a human arm, whose structure is b
`
`Building a Visual interface
`Comparing Chess to Tic—Tac—Toe, the firs
`t thought that comes to mind is that
`the scan—the—board approach is very complex, ifnot impossible, to implement.
`How could a robot tell one piece from another? Even if, with specially coded
`pieces, you succeeded in the task, the time required for the robot to scan 64
`squares would make the game quite borin.
`g.
`This means you must use a different t
`echnique. The most obvious solution is
`that your robot keeps a copy of the board situation in its memory, updating it
`with the moves of the players. It knows its own moves, thus all it needs is an
`input about those ofits human opponent.With this approach, the robot no
`longer needs to scan the board and differentiate the chess pieces, because it uses
`the copy of the board contained in its memory.
`The standard convention to describe board situations in Chess is based on a
`simple coordinate system where rows are numbered l to 8 and c l
`Thus all you need is a way to choose a starting column
`the piece the human player wants to move, and a second column
`outlines its destination.
`Our first Chess interface works exactly like that. We used the Fiber~Optic
`System (F03) to display the selected coordinates beside a small all~LEGO board
`(Figure 20.3).
`An FOS unit contains a rotor Which has a tiny red light.\X/iring the unit to a
`power source, like the output port of an RCX, turns the light on.Th* ‘
`the FOS device has an aXle—hole in its center, through
`which you can rotate the
`if 1I1r1€1' rotor.This rotation alions the li ht with one of ei
`,
`D
`g
`ght possible holes, from
`which you can drive the beam of light into the LEGO optic fibers.
`In our setup, the FOS units connect to two input ports of the RCX, which are
`, Configured as light sensors. T
`he electrical current the units receive firom the RCX,
`t filnled at power activated sensors, is enough to make their LED turn on.At the
`. 53.316 W713, the fact that they are attached to input ports allow you to read their
`s‘
`,
`.
`.
`.-l§5‘t€‘- In fact, the FOS unit returns two different v
`alues, the first when the rotating
`
`
`
`

`
`
`
`'
`light is aligned with one of the eight holes, and the second when the light is ,
`hidden between two holes.This is the property that makes them good candjdat
`emulate rotation sensors:You can implement an internal counter which is incre
`mented every time you detect a transition from one value to the other (see
`Chapter 4).The FOS can’t tell you the direction, but if you couple it with a m
`like we did, you know in which direction you are making it turn. in our robot,
`each FOS unit is powered by its independent motor through a 1:5 reduction stage,
`
`Controlling the FOS flrom the program is quite straightfoiyvard.The first thing
`you have to do is display the readings returned by the F03; you will discover they
`assume only two very dififerent Values, one corresponding to the eight output holes
`and another to the intermediate positions. Use the average of the two as the
`threshold of the two states. In our case, using raw Values, we defined a constant
`
`Tl-IRSH equal to 775.The following NQC subroutine moves the PCS one step:
`
`
`
`Chapter 20 - Board Games
`
`Figure 20.3 The Chess Visual Interface
`
`P-‘NW-bUlm’~£6‘D
`
`

`
`#define THRSH 775
`
`int pos;
`
`void FOS_step ()
`{
`
`OnFwd(OUT_A);
`
`pos-+-+,'
`
`BoanlGames. chapterzo
`
`39
`
`while(SENSOR_1 < THRSH);
`
`while(SENSOR_l
`Off (OUT_A);
`
`> fHRSH);
`
`if (pos > 8)
`
`poszl;
`
`Every time you call this subroutine, the light will move one step, and the
`inner variable pos will keep track of its position (provided that it started from a
`known point).
`i
`To input the user’s moves to the RCX, we used an interface as simple as a
`single touch sensor. This is how the “dialog” between the players unfolds:
`1. The user clicks to choose the column of the piece to move. For every
`click, the F08 increments one position.When okay, the user double-
`clicks.
`
`to
`
`Now the touch sensor controls the row position, and in a similar Way
`the user selects the row of the piece to move.
`3. Then he inputs the destination column and the destination row of the
`chosen piece.
`
`4. The program records the required move and checks if it’s valid, con-
`firniing the result with an appropriate sound. If the move is rejected, the
`procedure starts again fi“on1 Step 1.
`5. The RCX evaluates its own move, and shows the coordinates of the
`starting square using the FOS lights. It then waits for a confirmation
`click from the user.
`
`6. Now it shows the destination square, and waits for another confirmation
`click.
`
`
`
`

`
`400
`
`Chapter 20 ° Board Games
`
`
`
`Suppose you’re not satisfied by the previous simple Visual interface, and want
`your Chess robot to really move its pieces.\X/hat difficulties can you expect?
`Your system needs at least three degrees of freedom, two to get to all the
`squares of the board, and a third for the Vertical niovenient necessary to lift and put
`down the pieces. Moreover, it needs some grabbing ability to handle the pieces.
`The size of the board and the shape of the pieces greatly affect the design or"
`your machine.\X/e challenged ourselves by building :1 robot able to play on a reg—
`ular wooden Chess set, and this led to an eXtra—large robot (Figure 20.4).
`
`Figure 20.4 The Chess Mechanical Interface
`
`You can speed up the input process making the program show only the
`rows and columns where the user has pieces for Steps 1 and 2, and the valid de
`tinations for the chosen piece during Steps 3 and 4.
`Its possible to improve the communication protocol, too; for example,
`allowing decrenients of position when the sensor gets pressed for a “long” cjme
`instead of receiving a fast click.
`
`Building a Mechanical Interface
`
`

`
`~————-—---um
`
`Board Games . chapter 20
`The first thing you notice is that this time we didn’t use a Carts
`address the square. Our robotic arm emulates the kind of
`513“ System to
`movement a humm
`aifni uses, with two articulations that correspond to the sh
`oulder and the elbow
`Even the size is not too flu‘ from that ofa human 21‘I’l’1.l
`As We made wide use of blue par
`ts, we decided to name this machine Broad
`Blue. (Its 21 play on words, considering “Deep Blue” was the name of
`the fflfnfius
`IBM computer that was the first defeat Chess World champion G
`?“'1"/ Kasparov!)
`This system is able to address any point on the Chessboard, as sh
`own in Figureg
`
`20.5 and 20.6.
`
`401
`
`Figure 20.5 Broad Blue Plays in H1
`
`The pliers at the end of the zirni must be capable ofa long vertical 1‘2U1gL‘,
`l since the pieces must be lifted high enough so they don’t touch the other pieces
`On the board while the arm moves.Tlieirj;1ws h‘
`the pieces, but not so much that they lI’lVOlL1I]tL11'lly shift the adjacent ones. At the
`ave to open enough to capture
`Same time, the pliers must be able to grab all the different pieces, from the Pawn
`to the King.
`
`
`
`

`
`Chapter 20 - Board Games
`
`Figure 20.6 Broad Blue Plays in A8
`
`402
`
`We used a rack and pinion assembly for the lifting mechanism, and a small
`pneumatic: cylinder for the pliers (Figure 20.7).
`On the other side of the lifting mechanism you see a touch sensor that gets
`closed by two cams at the extreme positions of the rack (Figure 20.8).
`The motor that operates the lifting system lies at the opposite end of the sec—
`ondary arm, behind the turntable (Figure 20.9), and uses a worm gear—to—16t
`reduction stage.
`The advantage of this configuration is that the Weight of the motor acts as a
`counterweight to the mass of the lifting mechanism. To this same purpose, we
`also added a Weighed brick side to the motor. It’s Very important that the sec~
`ondary arm is Well—balanced, otherwise it will introduce a strong torsion
`(twisting) on the primary one, and torsion is much more difficult than Weight to _
`oppose and compensate for. In the same picture, note also that the secondary
`turntable gets turned by an 8t gear. This is connected through a pair of bevel
`gears to the longjoined axle that reaches the motor at the opposite side of the
`primary arm.
`
`
`
`

`
`

`
`
`
`
`
`404
`
`Chapter 20 - Board Games
`
`Figure 20.9 The Lifting Motor at the End of the Secondary Arm
`
`
`
`
`
`
`The primary arm has a more solid structure, designed to bear its own Weight
`plus the Whole secondary a1"m.At its opposite end you find the motor that rotates
`the secondary arm, connected also to the rotation sensor that monitors that
`movement (Figure 20.10).The reduction geartrain is made by an 8:24 stage and a
`8:40 one, for a total ratio of1:15.
`
`
`
`Figure 20.10 The Motors at the End of the Primary Arm
`
`

`
`
`
`Board Games ° Chapter 20
`
`
`
`
`
`On the lower deck of the arm is the motor that operates the valve switch for
`arm, both the motors and a couple of Weight
`y arm vs/ell—balanced. lfyou don’t do this and
`consequently induce a strong asymmetric loa
`cl on the turntalole, it may fall apart.
`The base of the robot has to be very soli
`cl. It contains two RCXS, the motor
`that moves the primary arm and it
`5 rotation sensor, a compressor for the pliers
`and a pressure switch. All this weig
`ht helps in 1naki.ng Broad Bl e very stable
`(Figure 20.11).
`
`Figure 2G.?’i The Base
`
`The geartrain of the priniary turntable has the s ame configuration as the sec-
`ondary one.
`To provide the necessary supply ofair, we used the double—acting compressor
`(because we had it ready), but the robot really needs a small quantity of air and
`
`any compressor should. work.
`
`

`
`
`
`406
`
`Chapter 20 - Board Games
`
`It’s important that you make all the wires emerge from a point close to the
`cen.ter of the primary turntable so they don’t aflect its rotation. In large robots like
`this, clean and well—organized Wiring helps a lot in keeping things under control.
`For the input of the human moves, We replaced the single touch sensor with a
`slightly more sophisticated unit also made from a rotation sensor.This speeds up the
`choice of the coordinates, changed according to rotations, displayed on the master
`RCX, and confirmed by a click _on the touch sensor (Figure 20.12).
`
`Figure 20.12 The input Unit
`
`
`
`Connecting and Prograrrirning Broad Blue
`This is the only project in the book that requires two RCXS. As in most dual-
`RCX projects, it uses a rnaster—slaye configuration: The master decides What to
`do while the slave merely performs the required actions.Table 20.1 summarizes
`the Wirings and resource allocations of Broad Blue; RCXl is the master, and
`RCX2 the slave.
`
`
`
`
`
`
`
`
`
`
`
` Table 20.1 Broad Blue Resource Allocations
`
`Resource
`Function
`
`
`RCX1 IN 1
`Rotation sensor of the input unit; sets use-r’s move.
`
`
`RCX1 IN 2
`Touch sensor of the input unit; confirms user's move.
`Motor that operates the pneumatic valve switch forth
`RCX1 OUT B
`
`
`
`pliers.
`
`
`
`

`
` Board Games 9 Chapter 20
`
`407
`
`
`
`
`
`Table 20.1 Continued
`
` R
`
`esource
`Function
`
`.__.__....__,._.____..__......._
`
` RCX1 OUT C Always ON, only used to supply power to compressor
`
`(via the pressure switch).
`Shows the input square in the form Column.Row.
`5 moves with an appro-
`Confirms or invalidates user’
`priate sound.
`Rotation sensor of the primary arm; controls its position.
`Rotation sensor of the secondary arm.
`Touch sensor of the lifting system, closes at all up or
`down positions.
`Motor of the primary arm.
`Motor of the secondary arm.
`Motor of the lifting system.
`
`RCX1 Display
`RCX1 Loudspeaker
`RCX2 IN 1
`RCX2 IN 2
`RCX2 IN 3
`RCX2 OUT A
`RCX2 OUT B
`RCX2 OUT C
`
`
`evaluates its own move, then pe
`The communication protocol between the two programrnable units is rather
`
` two more for the
`sin1ple:You need 64 Values corresponding to the squares, plus
`pliers—up and pliers—down commands. Include a “done’ ’return Value that the slave
`
`
`RCX uses to inform the master when it has finished the required action.
`a 3»:
`
`
`
`
`
`
`
`
`
`
`
`Each turntable is like at 56t ge
`ar, and the 8t pinion acting on them results in a
`1:7 ratio. The rotation sensor is pl
`aced after the first 1:3 stage, thus each complete
`turn of the arm corresponds to 2
`1 turns of the sensor. The latter features 16 ticks
`
`
`
`
`
`
`
`

`
`
`
`408
`Chapter 20 9 Board Games
`nt of 336 units, corresponding
`
`per turn, meaning that each turn increments a con
`to 1.07 degrees per tick.
`ur chessboard, and consequently of the arms of your
`The actual size of yo
`r the arms, the higher the angular resolution
`robot, is very critical. The longe
`e arms of Broad Blue are both 22cm long
`needed to control their movements.Th
`from the center of their supporting turntable; this means that the end of the sec-
`overs a circle of a.bout 138cm (22X2xT£). Each degree corresponds to
`ondary arm c
`mference of 0.38cn1.\7i/hen the arms are aligned and aiming
`a sector with a circu
`board, each degree of rotation of the primary
`at the farthest squares of the
`adius and corresponds to movement of
`turntable acts on a circle 44cm in r
`O.77crn at the pliers.We said that our resolution is 1.07 degrees per tick, and this
`O.82cm in that area of the board.This is a bit critical:You might prefer
`before the first 1:5 reduction stage to increase pre-
`to connect the rotation sensor
`cision by a factor of five.
`tically decreases the accuracy of the rnovements.To
`The slack between gears dras
`d Blue always approaches the squares from
`reduce the problem to a minimum, Broa
`d coming back when necessary.
`the same side of the board, going a bit farther an
`
`results in
`
`Variations on the Construction
`ge XY system like
`ou from building a Chess robot with a lar
`otation sen~
`ic—Tac—Toe.This way you can avoid the r
`touch sensors and pegs technique to address all
`
`Nothing prevents y
`the one we described forT
`sors entirely and use the good old
`
`the squares.
`lt in a smaller robot, meaning less parts, less weight
`A smaller board will resu
`smaller pieces will
`to support, and
`consequently a simpler structure. Similarly,
`need a shorter range for the lifting mechanisrn.
`but use only one
`Is it possible to build a mechanical interface similar to ours,
`out-
`RCX? We believe so. If you are able to use pneumatics for the lifting system
`side that used for the pliers, you can coordinate their movement in a predefined
`sequence (starts with pliers up and opened):
`
`1. Go down.
`
`
`
`2. Close pliers (grabs the piece).
`Go up (now the robot moves to the destination square).
`
`3 4
`
`. Go down.
`
`5 Open pliers (drops the piece).
`
`6 Go up.
`
`
`
`

`
`Board Games ° Chapter 20
`
`409
`
`What you need is a control system that operates the valve switches in the
`proper sequence, a rotational or linear mechanism activated by a single motor.
`Can you devise one?
`Applying a completely different technique, you can copy the system used in
`some commercial chessboards that employ an electromagnet to move magnetic
`pieces from the bottom. Did you ever see them in action? They drag the pieces,
`sliding them along the borderlines of the square, so they don’t interfere with the
`other pieces on the board.The advantages of this technique include the fact that
`you don’t need any lifting/ grabbing system anymore, thus a single RCX can do
`all the work; in the way of disadvantages consider that you need many non-
`LEGO parts, including magnetic chess pieces, a special board, and an electroniag—
`netic coil. LEGO doesn’t produce electric coils for the RCX, but they aren’t
`difficult to make. Be aware that they absorb much more current than motors.
`Now that we think of it, you can use the sliding technique even from the
`top. Imagine a robot similar to ours, that instead of grabbing and lifting the piece,
`simply surrounds it with a sort of cage lowered from above and then pushes it
`along the proper path.This will save one output port, but will make the software
`a bit more complex because the arms cannot go straight to the destination square
`but rather must follow an optimal path to avoid the other pieces.
`
`Playing Gther Board Games
`The techniques we described in this chapter apply to many other board games,
`each one having its own peculiarities and requiring some adaptations.
`Checkers shares with Chess similar difficulties about moves, with the differ-
`ence being that you must find a way to crown the pieces when required. Moving
`crowned pieces without letting them come apart might be not so easy. On the
`other hand, Checkers needs much simpler software than Chess.
`Go, in its slightly diverse variants, is the world’s most popular board game.
`Even though it’s not played much in the West, it’s widespread throughout all
`Asian countries. Because the pieces, called stones, get dropped on the board but
`never moved, it seems ideal for a robot equipped with an automatic dispenser.
`The fact that the stones are black and white also suggests the possibility of using
`a scanning technique similar to the one we incorporated into the Tic-Tac—Toe
`robot, though it would likely prove impractical on the official 19 by 19 board and
`Wen on the 13 by 13 reduced one.We recommend you limit your robot to the 5
`by 5 training board. It will require more than enough effort in the way of pro-
`gfflmniing. Go, in fact, is considered the most difficult game for computers to
`
`

`
`
`
`
`ficial Intelligence.‘\X/hile the
`learn how to play Well~—a sort of frontier for Arti
`ampion, the strongest Go
`feated the human world ch
`strongest Chess program de
`ge for your RCX‘.
`program cannot even beat a good amateur.A tough challen
`
`Chapter 20 - Board Games
`
`
`
`Summary
`
`er describes some
`in board games, this chapt
`Whether or not you have an interest
`have seen that
`other situations, too.You
`that may prove useful in
`combined knowledge of a position
`interesting tricks
`nto your system using the
`d in the Tic—Tac—Toe robot.
`you can input data i
`e light sensor, as we showe
`and a Value read from th
`en the F08 units, usually
`nterface taught you that ev
`The simple Chess Visuall
`Vices. It also showed
`may work as output de
`d for decorative purposes only,
`t interface around a single touch sensor.
`designe
`can build a complete inpu
`f the book. It employs some of the
`you that you
`he most complex robot 0
`Broad Blue is t
`Chapters 10 and 11 about pneumatics, object grabbing,
`concepts illustrated in
`ers. More importantly, it demonstrates that the
`degrees of freedom, and oth
`h the MINDSTORMS system are Very far
`bounds of what can be done wit
`
`reaching.