| Package | com.lookbackon.AI.searching |
| Class | public class SearchingBase |
| Inheritance | SearchingBase  AbstractProcess Object |
| Implements | ISearching |
| Subclasses | AlphaBeta, AttackFalse, MiniMax, MinMax, NegaMax, NegaScout, PVS, Quiescence, RandomWalk, ShortSighted |
| Property | Defined By | ||
|---|---|---|---|
| captures : Vector.<ConductVO> [read-only]
This function generates all possible captures and stores them in the vector.
It returns the vector of the legal captures for Quiescene searching.
| SearchingBase | ||
| evaluation : IEvaluation | SearchingBase | ||
 | isSelfManaging : Boolean | AbstractProcess | |
| moves : Vector.<ConductVO> [read-only]
| SearchingBase | ||
| orderingMoves : Vector.<ConductVO>
Ordering Moves To Speed Up Search
As we will see next time, search efficiency depends on the order in which moves are searched.
The gains and losses related to good or poor move ordering are not trivial:
a good ordering, defined as one which will cause a large number of cutoffs,
will result in a search tree about the square root of
the size of the tree associated with the worst possible ordering!
Unfortunately, it turns out that the best possible ordering is simply defined by trying the best move first. | SearchingBase | ||
| percentage : Number [override] [read-only]
inheritDoc
| SearchingBase | ||
| processDone : Boolean | SearchingBase | ||
| Property | Defined By | ||
|---|---|---|---|
| alpha : int | SearchingBase | ||
| bestMove : ConductVO | SearchingBase | ||
| bestValue : int | SearchingBase | ||
| beta : int | SearchingBase | ||
| chessBoardModel : ChessBoardModel | SearchingBase | ||
| chessGasketsModel : ChessGasketsModel | SearchingBase | ||
| chessPiecesModel : ChessPiecesModel | SearchingBase | ||
| depth : int | SearchingBase | ||
| gamePosition : PositionVO | SearchingBase | ||
| generatedMoves : Vector.<ConductVO> | SearchingBase | ||
| _isSelfManaging : Boolean | AbstractProcess | |
| positionEvaluated : int | SearchingBase | ||
| tempCapture : ConductVO | SearchingBase | ||
| tempMove : ConductVO | SearchingBase | ||
| tempValue : int | SearchingBase | ||
| Method | Defined By | ||
|---|---|---|---|
SearchingBase(gamePosition:PositionVO, isSelfManaging:Boolean = false)
To sum up this in one sentence:
Computers play strategy games by generating
all possible continuations up to a (more or less) fixed depth
and evaluating the resulting positions,
which allows them to choose the best of these continuations. | SearchingBase | ||
| SearchingBase | |||
The evaluation function will return positive values if the position is good for red and negative values.
if the position is bad for red in the MinMax formulation.
Many things could be said about evaluation functions,
for me,the two main objectives in designing a evaluation function are speed and accuracy.
The faster your evaluation function is,the better is.
and the more accurate its evaluation is,the beeter.
Obviously,these two things are somewhat at odds:
an accurate evaluation function probably is slower than a 'quick-and-dirty' one.
The evaluation function I'm taking about here is a heuristic one -not a exact one.
| SearchingBase | ||
generateMoves(pieces:Vector.<ChessPiece>):Vector.<ConductVO>
This function generates all possible moves and stores them in the vector.
It returns the vector of the legal moves.
While is checking,defend moves with high priority.
| SearchingBase | ||
Obviously,the struct move must contain all information necessary to support this operations.
As always,the structures are passed by reference,
in this case it is not only a speed question:
the position will be modified by this functions.
| SearchingBase | ||
noneMove():int | SearchingBase | ||
run():void [override]
inheritDoc
| SearchingBase | ||
| runAndManage(allocation:int):void | AbstractProcess | |
| terminate():void | AbstractProcess | |
unmakeMove(conductVO:ConductVO):void
Unmake previous move,for all kinds of searching tree algorithms. | SearchingBase | ||
willNoneMove(gamePosition:PositionVO):Boolean | SearchingBase | ||
| yield():void | AbstractProcess | |
| Constant | Defined By | ||
|---|---|---|---|
| MAX_SEARCH_DEPTH : int = 5 | SearchingBase | ||
| alpha | property |
Hide Inherited Public Properties
Show Inherited Public Propertiesprotected var alpha:int| bestMove | property |
protected var bestMove:ConductVO| bestValue | property |
protected var bestValue:int| beta | property |
protected var beta:int| captures | property |
captures:Vector.<ConductVO> [read-only] This function generates all possible captures and stores them in the vector. It returns the vector of the legal captures for Quiescene searching.
public function get captures():Vector.<ConductVO>| chessBoardModel | property |
protected var chessBoardModel:ChessBoardModel| chessGasketsModel | property |
protected var chessGasketsModel:ChessGasketsModel| chessPiecesModel | property |
protected var chessPiecesModel:ChessPiecesModel| depth | property |
protected var depth:int| evaluation | property |
evaluation:IEvaluation public function get evaluation():IEvaluation public function set evaluation(value:IEvaluation):void| gamePosition | property |
protected var gamePosition:PositionVO| generatedMoves | property |
protected var generatedMoves:Vector.<ConductVO>| moves | property |
| orderingMoves | property |
orderingMoves:Vector.<ConductVO> public function get orderingMoves():Vector.<ConductVO> public function set orderingMoves(value:Vector.<ConductVO>):voidSee also
| percentage | property |
percentage:Number [read-only] [override] inheritDoc
public function get percentage():Number| positionEvaluated | property |
protected var positionEvaluated:int| processDone | property |
processDone:Boolean public function get processDone():Boolean public function set processDone(value:Boolean):void| tempCapture | property |
protected var tempCapture:ConductVO| tempMove | property |
protected var tempMove:ConductVO| tempValue | property |
protected var tempValue:int| SearchingBase | () | Constructor |
public function SearchingBase(gamePosition:PositionVO, isSelfManaging:Boolean = false)gamePosition:PositionVO | |
isSelfManaging:Boolean (default = false) |
| applyMove | () | method |
| doEvaluation | () | method |
public function doEvaluation(conductVO:ConductVO, gamePosition:PositionVO):intThe evaluation function will return positive values if the position is good for red and negative values. if the position is bad for red in the MinMax formulation. Many things could be said about evaluation functions, for me,the two main objectives in designing a evaluation function are speed and accuracy. The faster your evaluation function is,the better is. and the more accurate its evaluation is,the beeter. Obviously,these two things are somewhat at odds: an accurate evaluation function probably is slower than a 'quick-and-dirty' one. The evaluation function I'm taking about here is a heuristic one -not a exact one.
Parameters
conductVO:ConductVO — the current condutVO value.
| |
gamePosition:PositionVO — the current game board positon info.
|
int — evaluation result
|
See also
| generateMoves | () | method |
public final function generateMoves(pieces:Vector.<ChessPiece>):Vector.<ConductVO>This function generates all possible moves and stores them in the vector. It returns the vector of the legal moves. While is checking,defend moves with high priority.
Parameters
pieces:Vector.<ChessPiece> — chess pieces collection.
|
Vector.<ConductVO> — all possible moves.
|
| makeMove | () | method |
| noneMove | () | method |
public final function noneMove():intReturnsint |
| run | () | method |
override public function run():voidinheritDoc
| unmakeMove | () | method |
public final function unmakeMove(conductVO:ConductVO):voidUnmake previous move,for all kinds of searching tree algorithms.
Parameters
conductVO:ConductVO |
| willNoneMove | () | method |
public final function willNoneMove(gamePosition:PositionVO):BooleanParameters
gamePosition:PositionVO |
Boolean |
| MAX_SEARCH_DEPTH | Constant |
public const MAX_SEARCH_DEPTH:int = 5