public Cell(CellStates cellStates, int x, int y)
{
// TODO: Complete member initialization
this.state = cellStates;
this.x = x;
this.y = y;
}
public Cell(CellStates cellState, float x, float y, int id)
{
this.cellState = cellState;
this.x = x;
this.y = y;
this.id = id;
}
//<Summary>
//Check neighboring Cell states and then change the states as per rules
//</Summary>
public void NewState(Cell prevCell, Cell currentCell, Cell nextCell)
{
CellStates prevState = prevCell.state; //state of previous cell
CellStates nextState = nextCell.state; //state of next cell
CellStates current = currentCell.state; //state of current cell
CellStates previous = currentCell.PreviousState; //Previous state of current cellstate
CellStates next = currentCell.NextState; //Next state of current cellstate
if (prevState == next && nextState == next)
{
state = previous;
}
else if (prevState == next || nextState == next)
{
state = next;
}
else if (prevState == current && nextState == current)
{
state = next;
}
else
{
state = current;
}
}
void PieceInit(int type, int rotate, Color color, int x, int y)
{
CellStates[,] matrix = new CellStates[5, 5];
for (int i = 0; i < 5; i++)
{
for (int j = 0; j < 5; j++)
{
matrix[i, j] = CellStates.EMPTY;
}
}
piece = new Piece(matrix, type, color, x, y);
for (int i = 0; i < 5; i++)
{
for (int j = 0; j < 5; j++)
{
piece.matrixPiece[i, j] = (CellStates)Const.mPieces[type, rotate, i, j];
}
}
piece.pieceType = type;
}
public static CellStates GetDeadState(CellStates state)
{
switch (state)
{
case CellStates.SmallShip:
return(CellStates.DeadSmallShip);
case CellStates.ShipBackUp:
return(CellStates.ShipBackUpDead);
case CellStates.ShipBackRight:
return(CellStates.ShipBackRightDead);
case CellStates.ShipHeadUp:
return(CellStates.ShipHeadUpDead);
case CellStates.ShipHeadRight:
return(CellStates.ShipHeadRightDead);
case CellStates.ShipMiddleUp:
return(CellStates.ShipMiddleUpDead);
case CellStates.ShipMiddleRight:
return(CellStates.ShipMiddleRightDead);
default:
throw new ArgumentException();
}
}
private void SetCellColorByMode(Vertex2D pos)
{
CellStates cellMode = GetSelectedCellStateMode();
UpdateStartOrTargetByMode(pos, cellMode);
gridMaze.SetCellColorAtPosition(pos, GetCellColorByMode(cellMode));
}
public CellRow(int seed)
{
cellLine = new Cell[TOTALCELLS];
newLine = new Cell[TOTALCELLS];
//Set up random object and initialise with given seed value
Random random = new Random(seed);
int randomNumber;
for (int i = 0; i < TOTALCELLS; i++)
{
//Generate a random number of 0 to 3
randomNumber = random.Next((int)(CellStates.THREE) + 1);
//Based on random number, generate corresponding cell states
CellStates state = Cell.CurrentState(randomNumber);
//<summary>
//Create (TOTALCELLLS) instances of of Cell class with
//constructor parameter and put them in array
//Resulting Array - cellLine[x].state = CellStates.(state)
//cellLine for storing automa and newLine for building new generation
//</Summary>
cellLine[i] = new Cell(state);
newLine[i] = new Cell(state);
}
}
private void CheckTheEnd(CellStates s)
{
if (s == CellStates.OPEN_BOMB || CountOpenCells == NumCols * NumRows - NumBombs)
{
TheEnd = true;
}
}
private int CalculateSouthEastValue(int row, int column, CellStates player, CellStates opponent)
{
int originOffset = Math.Min(row, column);
int endOffset = Math.Min(_game.Columns - 1 - column, _game.Rows - 1 - row);
if ((originOffset + endOffset + 1) < _game.PiecesToWin)
{
return(0);
}
int ownedPieces = 0;
int lostPieces = 0;
bool blocked = false;
int r = row - originOffset;
for (int c = column - originOffset; c <= (column + endOffset);)
{
CellStates cellState = CellStates.Empty;
switch (_game.Board[r++, c++])
{
case Players.Black:
cellState = CellStates.Black;
break;
case Players.Red:
cellState = CellStates.Red;
break;
}
if (cellState == opponent)
{
// this iteration should add 0 value
lostPieces++;
blocked = true;
}
else if (cellState == player)
{
ownedPieces++;
}
else
{
// do nothing if this is a blank cell
}
}
if (!blocked)
{
return(2 ^ ownedPieces);
}
else if (lostPieces == (_game.PiecesToWin - 1) && ownedPieces == 1)
{
// if this is a true block, make its value fall midway between a win, and 1 away from a win
return(2 ^ (_game.PiecesToWin - 1) + (2 ^ _game.PiecesToWin - 2));
}
return(0);
}
public static Bitmap GetResource(CellStates state)
{
switch (state)
{
case CellStates.Water:
return(Resource1.Water);
case CellStates.SmallShip:
return(Resource1.SmallShip);
case CellStates.DeadSmallShip:
return(Resource1.SmallShipDead);
case CellStates.Empty:
return(Resource1.Miss);
case CellStates.ShipHeadUp:
return(Resource1.ship_head);
case CellStates.ShipHeadUpDead:
return(Resource1.ship_head_dead);
case CellStates.ShipHeadRight:
return(Resource1.ship_head_r);
case CellStates.ShipHeadRightDead:
return(Resource1.ship_head_dead_r);
case CellStates.ShipMiddleUp:
return(Resource1.ship_middle);
case CellStates.ShipMiddleUpDead:
return(Resource1.ship_middle_dead);
case CellStates.ShipMiddleRight:
return(Resource1.ship_middle_r);
case CellStates.ShipMiddleRightDead:
return(Resource1.ship_middle_dead_r);
case CellStates.ShipBackUp:
return(Resource1.ship_back);
case CellStates.ShipBackUpDead:
return(Resource1.ship_back_dead);
case CellStates.ShipBackRight:
return(Resource1.ship_back_r);
case CellStates.ShipBackRightDead:
return(Resource1.ship_back_dead_r);
default:
throw new ArgumentException();
}
}
public bool IfIsWinner(CellStates player, CellStates[,] grid)
{
var _TotalRows = grid.GetLength(1);
var _TotalColumns = grid.GetLength(0);
if (player == 0)
{
return(false);
}
// horizontalCheck
for (int j = 0; j < _TotalRows - 3; j++)
{
for (int i = 0; i < _TotalColumns; i++)
{
if (grid[i, j] == player && grid[i, j + 1] == player && grid[i, j + 2] == player && grid[i, j + 3] == player)
{
return(true);
}
}
}
// verticalCheck
for (int i = 0; i < _TotalColumns - 3; i++)
{
for (int j = 0; j < _TotalRows; j++)
{
if (grid[i, j] == player && grid[i + 1, j] == player && grid[i + 2, j] == player && grid[i + 3, j] == player)
{
return(true);
}
}
}
// ascendingDiagonalCheck
for (int i = 3; i < _TotalColumns; i++)
{
for (int j = 0; j < _TotalRows - 3; j++)
{
if (grid[i, j] == player && grid[i - 1, j + 1] == player && grid[i - 2, j + 2] == player && grid[i - 3, j + 3] == player)
{
return(true);
}
}
}
// descendingDiagonalCheck
for (int i = 3; i < _TotalColumns; i++)
{
for (int j = 3; j < _TotalRows; j++)
{
if (grid[i, j] == player && grid[i - 1, j - 1] == player && grid[i - 2, j - 2] == player && grid[i - 3, j - 3] == player)
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="Eto.Forms.CellEventArgs"/> class.
/// </summary>
/// <param name="grid">Grid the event is triggered for.</param>
/// <param name="cell">Cell the event is triggered for.</param>
/// <param name="row">Row for the cell.</param>
/// <param name="column">Column for the cell.</param>
/// <param name="item">Item the cell is displaying.</param>
/// <param name="cellState">State of the cell.</param>
/// <param name="control">Control object for the cell (if any)</param>
public CellEventArgs(Grid grid, Cell cell, int row, int column, object item, CellStates cellState, Control control)
{
Grid = grid;
Cell = cell;
Column = column;
Row = row;
Item = item;
CellState = cellState;
Control = control;
}
public void MarkCell()
{
if (State == CellStates.CLOSE)
{
State = CellStates.MARKED;
}
else if (State == CellStates.MARKED)
{
State = CellStates.CLOSE;
}
}
// Use this for initialization
void Start()
{
xoScripts = gameObject.GetComponentsInChildren <XOScript> ();
if (xoScripts == null)
{
Debug.Log("XO Scripts Array is EMPTY");
}
state = CellStates.empty; // all cells are initially empty.
}
internal Utility CalculateValues(Players player)
{
CellStates playerState = (player == Players.Black) ? CellStates.Black : CellStates.Red;
CellStates opponentState = (player == Players.Black) ? CellStates.Red : CellStates.Black;
Utility result = new Utility();
result.PlayerValue = CalculatePlayerValues(playerState, opponentState);
result.OpponentValue = CalculatePlayerValues(opponentState, playerState);
return(result);
}
private void UpdateStartOrTargetByMode(Vertex2D pos, CellStates cellMode)
{
switch (cellMode)
{
case CellStates.Start:
UpdateStartCellColor(pos);
break;
case CellStates.Target:
UpdateTargetCellColor(pos);
break;
}
}
public string DrawStringBuilder(int nk)
{
var mybuilder = new StringBuilder();
List <string> mypick = new List <string>();
foreach (var item in chosingColorRandomly())
{
mypick.Add(item);
}
foreach (var item in mypick)
{
finalpick.Add(item);
}
CellStates[,] cells = new CellStates[6, 7];
var builder = new StringBuilder();
var header = " 0 1 2 3 4 5 6";
var divisor = "-------------------------------------------------------------------";
builder.AppendLine(header);
builder.AppendLine(divisor);
int p = 0;
for (int i = 0; i < cells.GetLength(0); i++)
{
for (int j = 0; j < cells.GetLength(1); j++)
{
int counter1 = 0;
int counter2 = 1;
cells[5, nk] = CellStates.Player;
//cells[5, 0] = CellStates.User;
var str = cells[i, j] == CellStates.Empty ? "| ······· " : (cells[i, j] == CellStates.User ? "| 0 " : "| x ");
builder.Append(str);
counter1 = counter1 + 2;
counter2++;
}
builder.Append('|');
builder.AppendLine();
builder.AppendLine(divisor);
}
SendingPacket(builder);
return(builder.ToString(0, builder.Length - 1));
}
/// <summary>
/// Convert a cellstate (logical) to its static gfx resourceID
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public static ResourceID Convert(CellStates input)
{
switch(input)
{
case(CellStates.Void) : return ResourceID.StaticTileVoid;
case (CellStates.Wall): return ResourceID.StaticTileWall;
case (CellStates.Floor): return ResourceID.StaticTileFloor;
case (CellStates.FloorCrate): return ResourceID.StaticTileFloorCrate;
case (CellStates.FloorGoal): return ResourceID.StaticTileFloorGoal;
case (CellStates.FloorGoalPlayer): return ResourceID.StaticTileFloorGoalPlayer;
case (CellStates.FloorGoalCrate): return ResourceID.StaticTileFloorGoalCrate;
case (CellStates.FloorPlayer): return ResourceID.StaticTileFloorPlayer;
}
throw new Exception("Unhandled enum");
}
public void Open()
{
if (State == CellStates.CLOSE || State == CellStates.MARKED)
{
if (IsBomb)
{
State = CellStates.OPEN_BOMB;
}
else
{
Title = BombQuantityAround == 0 ? "" : BombQuantityAround.ToString();
State = CellStates.OPEN_CLEAR;
}
}
}
public static Bitmap GetResource(CellStates state)
{
switch (state)
{
case CellStates.Water:
return Resource1.Water;
case CellStates.Ship:
return Resource1.ship1;
case CellStates.DeadShip:
return Resource1.ship1_dead;
case CellStates.Empty:
return Resource1.morj;
default:
throw new ArgumentException();
}
}
private int CalculateCellValue(int row, int column, CellStates cellState, CellStates player, CellStates opponent)
{
// if the cell is owned by the opponent, it has zero value
if (cellState == opponent)
{
return(0);
}
int result = 0;
result += CalculateEastWestValue(row, column, player, opponent);
result += CalculateSouthEastValue(row, column, player, opponent);
result += CalculateNorthSouthValue(row, column, player, opponent);
result += CalculateSouthWestValue(row, column, player, opponent);
return(result);
}
public void DrawCell(Vector2 position, int type, CellStates state)
{
Vector2[] posArr = new Vector2[4];
posArr[0] = position;
listOfBuildings[type].Draw(posArr);
for (int i = 0; i < posArr.Length; i++)
{
if (CellStates.ground.Equals(map[(int)posArr[i].x, (int)posArr[i].y].gameObject.GetComponent <HexagonClick>().getCellState()))
{
map[(int)posArr[i].x, (int)posArr[i].y].gameObject.GetComponent <HexagonClick>().setCellState(state);
}
else
{
map[(int)posArr[i].x, (int)posArr[i].y].gameObject.GetComponent <HexagonClick>().setCellState(CellStates.error);
}
}
}
public static ShipDirection GetDirection(CellStates cell)
{
if (cell == CellStates.Water || cell == CellStates.Empty)
{
throw new ArgumentException();
}
if (cell == CellStates.SmallShip || cell == CellStates.DeadSmallShip)
{
return(ShipDirection.Up);
}
if (cell == CellStates.ShipBackRight || cell == CellStates.ShipBackRightDead ||
cell == CellStates.ShipHeadRight || cell == CellStates.ShipHeadRightDead ||
cell == CellStates.ShipMiddleRight || cell == CellStates.ShipMiddleRightDead)
{
return(ShipDirection.Right);
}
else
{
return(ShipDirection.Up);
}
}
private int CalculatePlayerValues(CellStates player, CellStates opponent)
{
int result = 0;
for (int r = 0; r < _game.Rows; r++)
{
for (int c = 0; c < _game.Rows; c++)
{
CellStates value = CellStates.Empty;
if (_game.Board[r, c] == Players.Black)
{
value = CellStates.Black;
}
else if (_game.Board[r, c] == Players.Red)
{
value = CellStates.Red;
}
result += CalculateCellValue(r, c, value, player, opponent);
}
}
return(result);
}
private void StateBuilder()
{
//Print Corresponding special character of CellStates in the row
for (int i = 0; i < TOTALCELLS; i++)
{
CellStates state = cellLine[i].State;
if (state == CellStates.ZERO)
{
Console.Write(" ");
}
else if (state == CellStates.ONE)
{
Console.Write(".");
}
else if (state == CellStates.TWO)
{
Console.Write("+");
}
else
{
Console.Write("#");
}
}
}
public void SetStateToCells (List<int> pmCellsList, CellStates pmStatus)
{
foreach (int lvField in pmCellsList) {
CellStatus lvStatus = instance.mCells [lvField].GetComponent<CellStatus> ();
lvStatus.SetState (pmStatus);
}
}
/// <summary>
/// Update the cursor position
/// </summary>
/// <param name="X">Mouse X</param>
/// <param name="Y">Mouse Y</param>
/// <param name="ClickCount">Number of clicks</param>
/// <param name="Button">Button enum 0=None, 1=Left, 2=Right</param>
/// <returns>true is cursor is drawn by game</returns>
public bool SetCursor(int X, int Y, int ClickCount, GameUI.MouseButtons Button, GameUI.MouseClicks ClickType)
{
bool manualDraw = false;
// Relative position
int rX = X - GameUI.GameCoords.GlobalOffset.X;
int rY = Y - GameUI.GameCoords.GlobalOffset.Y;
// Set the mouse cursor, if it is on the page
//if (rX >= 0 && rY >= 0)
{
this.CurrentLogical = new VectorInt(rX, rY);
}
// Find the puzzle cell position
VectorInt puzPos = GameUI.GameCoords.PuzzleFromPositionAbs(this.CurrentAbsolute);
CellStates puzCell = CellStates.Void;
if (GameUI.Current.Rectangle.Contains(puzPos))
{
// Is this cursor within the puzzle
manualDraw = true;
puzCell = GameUI.Current[puzPos];
}
// Click started
if (ClickCount > 0 && ClickType == GameUI.MouseClicks.Down)
{
dragStarted = true;
dragStartPixelLocation = this.CurrentAbsolute;
dragStartCellLocation = puzPos;
dragStartCell = puzCell;
}
// Click ended
if (ClickCount > 0 && ClickType == GameUI.MouseClicks.Up)
{
dragStarted = false;
if (dragStartCell == CellStates.Floor || dragStartCell == CellStates.FloorGoal)
{
PerformPlayerMovement(puzPos, puzCell);
}
else if (dragStartCell == CellStates.FloorCrate || dragStartCell == CellStates.FloorGoalCrate)
{
PerformCrateMovement(dragStartCellLocation, puzPos);
}
}
// Let the rest of the world know...
if (OnClick != null)
{
OnClick(this, new NodeCursorEventArgs(this, "Click", this, X, Y, ClickCount, Button, ClickType));
}
return manualDraw;
}
private int CalculateSouthWestValue(int row, int column, CellStates player, CellStates opponent)
{
return 0;
}
DrawableCellStates(CellStates value)
{
this.value = value;
}
/// <summary>
/// Convert logic cell's to combination cell states
/// </summary>
/// <param name="cell"></param>
/// <returns></returns>
public static Cell Convert(CellStates cell)
{
switch (cell)
{
case (CellStates.Void): return Cell.Void;
case (CellStates.Wall): return Cell.Wall;
case (CellStates.Floor): return Cell.Floor;
case (CellStates.FloorPlayer): return Cell.Player;
case (CellStates.FloorGoal): return Cell.Goal;
case (CellStates.FloorGoalCrate): return Cell.Goal;
case (CellStates.FloorCrate): return Cell.Crate;
case (CellStates.FloorGoalPlayer): return Cell.Player;
}
throw new InvalidOperationException();
}
public void SetState(CellStates state)
{
switch (state) {
case CellStates.DISABLED:
this.avaiable = false;
break;
case CellStates.ENABLED:
this.avaiable = true;
break;
case CellStates.TARGET:
this.target = true;
break;
case CellStates.OPPORTUNITY:
this.lvOportunity = true;
break;
case CellStates.MOVABLE:
this.movable = true;
break;
case CellStates.CLOSE_RANGE:
this.closeRange = true;
break;
case CellStates.FAR_RANGE:
this.farRange = true;
break;
default:
this.avaiable = true;
break;
}
}
public Board(int x, int y)
{
CreateNewBoard(x, y);
movesPerformed = 0;
winner = CellStates.Empty;
}
/// <summary>
/// Generate a bitmap for a particular cell state
/// </summary>
/// <param name="cell">Search for</param>
/// <returns></returns>
public Bitmap ToBitmap(CellStates cell)
{
SizeInt size = Size;
Bitmap result = new Bitmap(size);
for (int cx = 0; cx < size.X; cx++)
for (int cy = 0; cy < size.Y; cy++)
{
if (this[cx, cy] == cell) result[cx, cy] = true;
}
return result;
}
/// <summary>
/// Initializes a new instance of the <see cref="Eto.Forms.DrawableCellPaintEventArgs"/> class.
/// </summary>
/// <param name="graphics">Graphics context for drawing.</param>
/// <param name="clipRectangle">Clip rectangle for the cell's region.</param>
/// <param name="cellState">State of the cell.</param>
/// <param name="item">Item from the data store for the row that is being painted.</param>
public CellPaintEventArgs(Graphics graphics, RectangleF clipRectangle, CellStates cellState, object item)
: base(graphics, clipRectangle)
{
CellState = cellState;
Item = item;
}
public Cell(CellStates cellState, float x, float y)
{
this.cellState = cellState;
this.x = x;
this.y = y;
}
protected override bool CheckForMatch(CellStates player, params Vector2[] coordinates)
{
int matches = 0;
foreach (Vector2 v in coordinates)
{
//retrieve the correct cell
Board currentCell = board[(int)v.x, (int)v.y];
//get its current value
CellStates displayedValue = currentCell.Winner;
//compare to confirm match
//p1 == x, p2 == y
if (player == displayedValue) //Player will be either p1 or p2, and can check against the winner field directly
{
matches++;
}
}
return matches == coordinates.Length;
}
//<Summary>
//Check neighboring Cell states and then change the states as per rules
//</Summary>
public void NewState(Cell prevCell, Cell currentCell, Cell nextCell)
{
CellStates prevState = prevCell.state; //state of previous cell
CellStates nextState = nextCell.state; //state of next cell
CellStates current = currentCell.state; //state of current cell
CellStates previous = currentCell.PreviousState; //Previous state of current cellstate
CellStates next = currentCell.NextState; //Next state of current cellstate
if (prevState == next && nextState == next)
{
state = previous;
}
else if (prevState == next || nextState == next)
{
state = next;
}
else if (prevState == current && nextState == current)
{
state = next;
}
else
state = current;
}
//Constructor that populate the property
public Cell(CellStates setState)
{
state = setState;
}
private int CalculateCellValue(int row, int column, CellStates cellState, CellStates player, CellStates opponent)
{
// if the cell is owned by the opponent, it has zero value
if (cellState == opponent)
return 0;
int result = 0;
result += CalculateEastWestValue(row, column, player, opponent);
result += CalculateSouthEastValue(row, column, player, opponent);
result += CalculateNorthSouthValue(row, column, player, opponent);
result += CalculateSouthWestValue(row, column, player, opponent);
return result;
}
private int CalculatePlayerValues(CellStates player, CellStates opponent)
{
int result = 0;
for (int r = 0; r < _game.Rows; r++)
{
for (int c = 0; c < _game.Rows; c++)
{
CellStates value = CellStates.Empty;
if(_game.Board[r, c] == Players.Black)
value = CellStates.Black;
else if(_game.Board[r, c] == Players.Red)
value = CellStates.Red;
result += CalculateCellValue(r, c, value, player, opponent);
}
}
return result;
}
public Board()
{
movesPerformed = 0;
winner = CellStates.Empty;
}
/// <summary>
/// Fill a box, not the insides with a CellState
/// </summary>
/// <param name="R"></param>
/// <param name="C"></param>
public void FillBox(RectangleInt R, CellStates C)
{
for (int px = R.TopLeft.X; px <= R.BottomRight.X; px++)
for (int py = R.TopLeft.Y; py <= R.BottomRight.Y; py++)
{
if (px == R.TopLeft.X || py == R.TopLeft.Y || px == R.BottomRight.X || py == R.BottomRight.Y)
{
this[new VectorInt(px, py)] = C;
}
}
}
public virtual void CheckForWin()
{
bool foundWin = false;
//check all 8 ways a win can happen, for each player
for(int i = 1; i <= 2; i++)
{
//There are a lot of goto's in this method.
//Since checking is fairly expensive, once we find a single match, others won't change anything
//The gotos spare the computer this unnecessary expense
CellStates desiredPlayer = (i == 1 ? CellStates.P1 : CellStates.P2);
//rows
if(CheckCoordinates(0, 0, 0, 1, 0, 2, desiredPlayer))
{
foundWin = true;
goto EndOfWinChecks;
}
if (CheckCoordinates(1, 0, 1, 1, 1, 2, desiredPlayer))
{
foundWin = true;
goto EndOfWinChecks;
}
if (CheckCoordinates(2, 0, 2, 1, 2, 2, desiredPlayer))
{
foundWin = true;
goto EndOfWinChecks;
}
//columns
if (CheckCoordinates(0, 0, 1, 0, 2, 0, desiredPlayer))
{
foundWin = true;
goto EndOfWinChecks;
}
if (CheckCoordinates(0, 1, 1, 1, 2, 1, desiredPlayer))
{
foundWin = true;
goto EndOfWinChecks;
}
if (CheckCoordinates(0, 2, 1, 2, 2, 2, desiredPlayer))
{
foundWin = true;
goto EndOfWinChecks;
}
//diagonals
if (CheckCoordinates(0, 0, 1, 1, 2, 2, desiredPlayer))
{
foundWin = true;
goto EndOfWinChecks;
}
if (CheckCoordinates(2, 0, 1, 1, 0, 2, desiredPlayer))
{
foundWin = true;
goto EndOfWinChecks;
}
EndOfWinChecks:
if(foundWin)
{
winner = (i == 1 ? CellStates.P1 : CellStates.P2);
DisableBoard();
return;
}
}
if (winner == CellStates.Empty && ThisBoardIsFull())
{
GameObject.Find("Controller Scripts").GetComponent<InputManager>().SetContestedBoard(this);
}
}
/// <summary>
/// Fill the entire puzzle with <paramref name="C"/>
/// </summary>
/// <param name="C"></param>
public void Fill(CellStates C)
{
Fill(Rectangle, C);
}
/// <summary>
/// Get a state image
/// </summary>
/// <param name="cellState"></param>
/// <returns></returns>
public Image GetImage(CellStates cellState)
{
return tiles[(int) cellState];
}
/// <summary>
/// Initializes a new instance of the <see cref="Eto.Forms.DrawableCellPaintEventArgs"/> class.
/// </summary>
/// <param name="graphics">Graphics.</param>
/// <param name="clipRectangle">Clip rectangle.</param>
/// <param name="cellState">Cell state.</param>
/// <param name="item">Item.</param>
public DrawableCellPaintEventArgs(Graphics graphics, RectangleF clipRectangle, CellStates cellState, object item)
: base(graphics, clipRectangle, cellState, item)
{
}
public WpfCellEventArgs(Grid grid, CustomCell cell, int row, swc.DataGridColumn column, object item, CellStates cellState, Control control = null)
: base(grid, cell, row, -1, item, cellState, control)
{
_gridColumn = column;
}
/// <summary>
/// Initializes a new instance of the <see cref="Eto.Forms.DrawableCellPaintEventArgs"/> class.
/// </summary>
/// <param name="graphics">Graphics.</param>
/// <param name="clipRectangle">Clip rectangle.</param>
/// <param name="cellState">Cell state.</param>
/// <param name="item">Item.</param>
public DrawableCellPaintEventArgs(Graphics graphics, RectangleF clipRectangle, CellStates cellState, object item)
: base(graphics, clipRectangle, cellState, item)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="Eto.Forms.DrawableCellPaintEventArgs"/> class.
/// </summary>
/// <param name="graphics">Graphics context for drawing.</param>
/// <param name="clipRectangle">Clip rectangle for the cell's region.</param>
/// <param name="cellState">State of the cell.</param>
/// <param name="item">Item from the data store for the row that is being painted.</param>
public CellPaintEventArgs(Graphics graphics, RectangleF clipRectangle, CellStates cellState, object item)
: base(graphics, clipRectangle)
{
CellState = cellState;
Item = item;
}
private int CalculateSouthEastValue(int row, int column, CellStates player, CellStates opponent)
{
int originOffset = Math.Min(row, column);
int endOffset = Math.Min(_game.Columns - 1 - column, _game.Rows - 1 - row);
if ((originOffset + endOffset + 1) < _game.PiecesToWin) return 0;
int ownedPieces = 0;
int lostPieces = 0;
bool blocked = false;
int r = row - originOffset;
for(int c = column - originOffset; c <= (column + endOffset);)
{
CellStates cellState = CellStates.Empty;
switch (_game.Board[r++, c++])
{
case Players.Black:
cellState = CellStates.Black;
break;
case Players.Red:
cellState = CellStates.Red;
break;
}
if (cellState == opponent)
{
// this iteration should add 0 value
lostPieces++;
blocked = true;
}
else if (cellState == player)
{
ownedPieces++;
}
else
{
// do nothing if this is a blank cell
}
}
if (!blocked)
{
return 2 ^ ownedPieces;
}
else if (lostPieces == (_game.PiecesToWin - 1) && ownedPieces == 1)
{
// if this is a true block, make its value fall midway between a win, and 1 away from a win
return (2 ^ (_game.PiecesToWin - 1) + (2 ^ _game.PiecesToWin - 2));
}
return 0;
}
/// <summary>
/// Count the number of cellstate found in the entire puzzle
/// </summary>
/// <param name="cs"></param>
/// <returns></returns>
public int Count(CellStates cs)
{
int c = 0;
for (int x=0; x<Size.X; x++)
for (int y = 0; y < Size.Y; y++)
{
if (this[x, y] == cs) c++;
}
return c;
}
public MutableCellEventArgs(int row, object item, CellStates cellState)
: base(row, item, cellState)
{
}
private Color GetCellColorByMode(CellStates state)
{
return(stateModeColorMap[state]);
}
//it is easier for the caller to pass in 6, but easier for the function to process 3
//use this to make them meet in the middle
protected bool CheckCoordinates(int aa, int ab, int ba, int bb, int ca, int cb, CellStates player)
{
Vector2 a = new Vector2(aa, ab);
Vector2 b = new Vector2(ba, bb);
Vector2 c = new Vector2(ca, cb);
return CheckForMatch(player, a, b, c);
}
/// <summary>
/// Move the player
/// </summary>
/// <param name="puzPos"></param>
/// <param name="puzCell"></param>
private void PerformPlayerMovement(VectorInt puzPos, CellStates puzCell)
{
// Do not allow the move, it other previous moves are still pending
if (puzCell != CellStates.Void && !GameUI.Player.HasFutureMoves)
{
// Draw the path from the player to the this as a path
VectorInt playerPos = GameUI.Current.Player;
// Try Path movement
List<Direction> path = Convert(MoveAnalysis.FindPlayerPath(GameUI.Current, puzPos));
if (path != null)
{
foreach (Direction aMove in path)
{
GameUI.Player.doMove(aMove);
}
}
}
}
//check if all coordinates passed in match
protected virtual bool CheckForMatch(CellStates player, params Vector2[] coordinates)
{
int matches = 0;
for (int i = 0; i < coordinates.Length; i++ )
{
Vector2 v = coordinates[i];
//retrieve the correct cell
GameObject currentCell = cells[(int)v.x, (int)v.y];
CellStatus cellStatus = currentCell.GetComponent<CellStatus>();
if (cellStatus == null)
{
Debug.LogError("Cell missing its CellStatus component");
}
//get its current value
CellStatus.Piece displayedValue = cellStatus.CurrentPiece;
//compare to confirm match
//p1 == x, p2 == y
if (player == CellStates.P1 && displayedValue == CellStatus.Piece.X ||
player == CellStates.P2 && displayedValue == CellStatus.Piece.O)
{
matches++;
}
}
return matches == coordinates.Length;
}
public Cell(CellStates cellState)
{
this.cellState = cellState;
}
private int CalculateNorthSouthValue(int row, int column, CellStates player, CellStates opponent)
{
int grandTotal = 0;
int ownedPieces = 0;
int lostPieces = 0;
bool blocked = false;
for (int r = Math.Max(row - (_game.PiecesToWin - 1), 0); r <= Math.Min(_game.Rows - _game.PiecesToWin, row); r++)
{
blocked = false;
ownedPieces = 0;
lostPieces = 0;
for (int offset = 0; offset < _game.PiecesToWin; offset++)
{
CellStates cellState = CellStates.Empty;
switch (_game.Board[r + offset, column])
{
case Players.Black:
cellState = CellStates.Black;
break;
case Players.Red:
cellState = CellStates.Red;
break;
}
if (cellState == opponent)
{
// this iteration should add 0 value
lostPieces++;
blocked = true;
}
else if (cellState == player)
{
ownedPieces++;
}
else
{
// do nothing if this is a blank cell
}
}
if (!blocked)
{
if (ownedPieces >= _game.PiecesToWin)
grandTotal = 20000;
else
grandTotal += 2 ^ ownedPieces;
}
else if (lostPieces == (_game.PiecesToWin - 1) && ownedPieces == 1)
{
// if this is a true block, make its value fall midway between a win, and 1 away from a win
grandTotal += (2 ^ (_game.PiecesToWin - 1) + (2 ^ _game.PiecesToWin - 2));
}
}
return grandTotal;
}
private string GetImageURL(CellStates states)
{
switch(states)
{
case (CellStates.Floor): return "images/F.png";
case (CellStates.Wall): return "images/W.png";
case (CellStates.FloorCrate): return "images/C.png";
case (CellStates.FloorGoal): return "images/G.png";
case (CellStates.FloorPlayer): return "images/P.png";
case (CellStates.FloorGoalPlayer): return "images/GP.png";
case (CellStates.FloorGoalCrate): return "images/GC.png";
default:
return "images/FV.png";
}
}
DrawableCellStates(CellStates value)
{
this.value = value;
}
