public override void placeSelected(BoardVector pos)
{
switch (_currentChessVidMode)
{
case SHOW_PLACE:
checkStaleMate();
if (showMovePoint(pos))
{
_currentChessVidMode = SELECT_PLACE;
}
break;
case SELECT_PLACE:
if (selectMovePoint(pos))
{
_actionPoint -= 2;
checkNext();
}
break;
case STAY_HOME:
if (stayHome(pos))
{
_actionPoint--;
checkNext();
}
break;
}
}
public bool stayHome(BoardVector pos)
{
var piece = Info.Board.getPiece(pos);
if (piece == null || piece.getOwner().getId() != getCurrentPlayer().getId())
{
return(false);
}
if (piece.hasAttribute <StayHomeAttribute>())
{
var stayHome = piece.getAttribute <StayHomeAttribute>();
if (stayHome.IsStayHome)
{
stayHome.outHome();
}
else
{
stayHome.stayHome();
}
return(true);
}
return(false);
}
public MoveInfo(BoardVector direction, int moveAmounts, bool isEndless = false, bool isJump = false)
{
this.direction = direction;
this.moveAmounts = moveAmounts;
this.isEndless = isEndless;
this.isJump = isJump;
}
bool placeProcess(BoardVector pos)
{
var piece = Info.Board.getPiece(pos);
if (piece == null)
{
return(false);
}
if (piece.hasAttribute <CoVidAttribute>() && piece.hasAttribute <StayHomeAttribute>())
{
CoVidAttributeUtil.influenceCheck(Info.Board, pos, getTurn());
var attr = piece.getAttribute <CoVidAttribute>();
attr.updateTurn(getTurn());
if (attr.isDeadByCoVid())
{
Info.Board.takePiece(pos);
}
var stayHome = piece.getAttribute <StayHomeAttribute>();
var id = piece.getOwner().getId();
if (attr.getStage() == 0 && !stayHome.IsStayHome)
{
_unInfluencedPoses[id].Add(pos);
}
stayHome.updateTurn();
}
return(false);
}
public override void placeSelected(BoardVector pos)
{
if (_gamePlayer == null)
{
_gamePlayer = info.getFirstPlayer();
}
switch (_currentMode)
{
case ScmMode.SHOW_MOVE_POINT:
checkStaleMate();
if (showMovePoint(pos))
{
_currentMode = ScmMode.SELECT_MOVE_POINT;
}
break;
case ScmMode.SELECT_MOVE_POINT:
if (selectMovePoint(pos))
{
_currentMode = ScmMode.SHOW_MOVE_POINT;
updateTurn();
}
break;
}
}
public void moveTo(Vector2 boardStart, Vector2 squareLength, BoardVector nextPos, float screenScaleRate)
{
var deltaVec = new Vector2(
getRealDeltaPos(squareLength.x, nextPos.x, screenScaleRate),
getRealDeltaPos(squareLength.y, nextPos.y, screenScaleRate));
var realVec = boardStart + deltaVec;
moveTo(realVec);
}
protected bool selectMovePoint(BoardVector pos)
{
if (!_currentMovePoints.Contains(pos))
{
return(false);
}
info.Board.movePiece(_selectingPos, pos);
cancelMove();
return(true);
}
bool checkPos(BoardVector pos)
{
var piece = Info.Board.getPiece(pos);
if (piece == null || piece.getOwner().getId() != getCurrentPlayer().getId())
{
return(false);
}
if (chessMoveSystem.getMovablePos(info, pos).Count > 0)
{
_staleMate = false;
return(true);
}
return(false);
}
public override List <BoardVector> getMovablePos(GameInfo info, BoardVector piecePos)
{
var piece = info.Board.getPiece(piecePos);
bool useModMoveInfo = false;
List <MoveInfo> movableInfo = new List <MoveInfo>();
if (piece.hasAttribute <StayHomeAttribute>())
{
var stayHomeAttr = piece.getAttribute <StayHomeAttribute>();
if (stayHomeAttr.IsStayHome)
{
movableInfo = stayHomeAttr.getStayHomeMoveInfo();
useModMoveInfo = true;
}
}
if (!useModMoveInfo && piece.hasAttribute <CoVidAttribute>())
{
var coVidAttr = piece.getAttribute <CoVidAttribute>();
if (coVidAttr.useModifiedMoveInfo())
{
movableInfo = coVidAttr.getModifiedMoveInfo();
useModMoveInfo = true;
}
}
if (useModMoveInfo)
{
var id = piece.getOwner().getId();
var dir = info.getPlayer(id).FrontDirection;
var allMovable = new List <BoardVector>();
foreach (var moveInfo in movableInfo)
{
allMovable.AddRange(BoardUtil.getInfoPos(moveInfo, dir, piecePos, info.Board, id));
}
return(allMovable);
}
return(base.getMovablePos(info, piecePos));
}
public static void influenceCheck(Board board, BoardVector pos, int turn)
{
var piece = board.getPiece(pos);
if (piece == null || !piece.hasAttribute <CoVidAttribute>())
{
return;
}
var coVid = piece.getAttribute <CoVidAttribute>();
if (coVid.getStage() <= 0)
{
return;
}
var id = piece.getOwner().getId();
var influenceInfo = coVid.getInfluenceInfo(turn);
var influenceList = influenceInfo.getInfluenceDir();
foreach (var influenceDir in influenceList)
{
if (influenceInfo.willInfluence())
{
var influencePos = pos + influenceDir;
if (board.getStatus(id, influencePos) == SquareStatus.ALLY)
{
var influencePiece = board.getPiece(influencePos);
if (influencePiece.hasAttribute <CoVidAttribute>())
{
var attr = influencePiece.getAttribute <CoVidAttribute>();
attr.influenced(turn);
}
}
}
}
}
protected bool showMovePoint(BoardVector pos)
{
var board = info.Board;
var piece = board.getPiece(pos);
if (piece == null || piece.getOwner().getId() != _gamePlayer.getId())
{
return(false);
}
var movable = chessMoveSystem.getMovablePos(info, pos);
if (movable.Count == 0)
{
return(false);
}
_currentMovePoints = movable;
_selectingPos = pos;
boardVisual.reset();
boardVisual.highLightAll(_currentMovePoints);
return(true);
}
public abstract void turnEndCheck(BoardVector currPos);
public bool canMoveTwice(BoardVector currPos)
{
return(currPos == _startPos);
}
public void setStartPos(BoardVector startPos)
{
_startPos = startPos;
}
public static Vector2 Vector2Scale(this BoardVector boardVector, Vector2 scale)
{
return(new Vector2(boardVector.horizontal * scale.x, boardVector.vertical * scale.y));
}
public abstract List <BoardVector> getMovablePos(GameInfo info, BoardVector piecePos);
public abstract void placeSelected(BoardVector pos);
public virtual void takePiece(BoardVector tookPos)
{
_chessPlayer.setPieceNum(_chessPlayer.getPieceNum() - 1);
Destroy(gameObject);
}
public void highLight(BoardVector pos)
{
_boards[pos.x][pos.y].color = highLightColor;
}
public override void turnEndCheck(BoardVector currPos)
{
//NONE
}
public static Vector2 AsVector2(this BoardVector boardVector)
{
return(new Vector2(boardVector.horizontal, boardVector.vertical));
}
public void unHighLight(BoardVector pos)
{
_boards[pos.x][pos.y].color = _colors[pos.x][pos.y];
}
public override void takePiece(BoardVector tookPos)
{
getOwner().kingTaken();
base.takePiece(tookPos);
}
