void OnTriggerEnter(Collider other)
{
if (GameMovieCtrl.IsActivePlayer)
{
if (Network.peerType == NetworkPeerType.Server)
{
}
else
{
return;
}
}
XkPlayerCtrl script = other.GetComponent <XkPlayerCtrl>();
if (script == null)
{
return;
}
//Debug.Log("Unity:"+"*********************name "+gameObject.name);
PSDingDianAimCamera.DingDianAimCamera = null;
PSDingDianNoAimCamera.DingDianNoAimCamera = null;
PSZiYouMoveCamera.ZYMoveCamera = null;
if (CamState == PSCameraState.GenSuiMoveCam)
{
PlayerTypeEnum playerType = script.PlayerSt;
switch (playerType)
{
case PlayerTypeEnum.FeiJi:
PSGenSuiMoveCamera.GetInstanceFeiJi().ActiveGenSuiMoveCam(IndexGenSuiMove);
break;
case PlayerTypeEnum.TanKe:
PSGenSuiMoveCamera.GetInstanceTanKe().ActiveGenSuiMoveCam(IndexGenSuiMove);
break;
}
}
if (DingDianAimCam != null && CamState == PSCameraState.DingDianAimCam)
{
GameObject playerObj = XkGameCtrl.GetInstance().GetRandAimPlayerObj();
Transform aimTr = playerObj == null ? null : playerObj.transform;
DingDianAimCam.ActiveCamera(aimTr);
}
CheckZiYouMoveCam(script);
CheckDingDianNoAimCam();
if (GameMovieCtrl.IsActivePlayer /*|| XkGameCtrl.GetInstance().IsServerCameraTest*/)
{
return;
}
CheckCameraTimeShake();
CheckExplodePoint();
CheckTanKePlayerAimPoint();
CheckAutoFireCom();
CheckTriggerPlayAni();
CheckWorldTimeScale();
CheckAutoFirePlayerAmmoType();
}
public void RefreshGameInfo()
{
player1type = PlayerTypeEnum.None;
player2type = PlayerTypeEnum.None;
player3type = PlayerTypeEnum.None;
player4type = PlayerTypeEnum.None;
player1char = CharacterEnum.None;
player2char = CharacterEnum.None;
player3char = CharacterEnum.None;
player4char = CharacterEnum.None;
player1score = -1;
player2score = -1;
player3score = -1;
player4score = -1;
player1lifes = -1;
player2lifes = -1;
player3lifes = -1;
player4lifes = -1;
player1deaths = -1;
player2deaths = -1;
player3deaths = -1;
player4deaths = -1;
}
public void RefreshGameInfo()
{
player1type = PlayerTypeEnum.None;
player2type = PlayerTypeEnum.None;
player3type = PlayerTypeEnum.None;
player4type = PlayerTypeEnum.None;
player1char = CharacterEnum.None;
player2char = CharacterEnum.None;
player3char = CharacterEnum.None;
player4char = CharacterEnum.None;
player1score = -1;
player2score = -1;
player3score = -1;
player4score = -1;
player1lifes = -1;
player2lifes = -1;
player3lifes = -1;
player4lifes = -1;
player1deaths = -1;
player2deaths = -1;
player3deaths = -1;
player4deaths = -1;
}
// Use this for initialization
void Awake()
{
PlayerScript = GetComponentInParent <XkPlayerCtrl>();
PlayerScript.SetPlayerZhiShengJiScript(this);
PlayerType = PlayerScript.PlayerSt;
RigidbodyCom = GetComponent <Rigidbody>();
switch (PlayerType)
{
case PlayerTypeEnum.FeiJi:
break;
case PlayerTypeEnum.TanKe:
RigidbodyCom.useGravity = false;
RigidbodyCom.centerOfMass = MessCenterVal;
RigidbodyCom.maxAngularVelocity = 2f;
if (XkGameCtrl.GameJiTaiSt != GameJiTaiType.TanKeJiTai)
{
if (Network.peerType != NetworkPeerType.Disconnected)
{
RigidbodyCom.isKinematic = true;
}
//RigidbodyCom.isKinematic = true; //test
}
Invoke("DelaySetTanKeParent", 2f);
break;
}
IsTestRigMessCenter = false;
}
private List<string> _GetPotentialMoves(ChessGame g, PlayerTypeEnum player, string source)
{
List<string> potentialMoves = new List<string>();
var chessboard = g.ChessBoard;
ChessPiece sourcePiece = chessboard.Get(source);
Tuple<int, int> sourceLocation = NotationHelper.Translate(source);
var relativeMoveProvider = m_relativePathProviderFactory.GetProviderByPieceType(sourcePiece.Type);
var relativePaths = relativeMoveProvider.GetRelativePaths(sourcePiece);
var absolutePaths = BoardLogic.ConvertToAbsolutePaths(sourceLocation, relativePaths);
foreach (Tuple<int, int>[] absolutePath in absolutePaths)
{
foreach (Tuple<int, int> absoluteMove in absolutePath)
{
string destinationAsNotation = NotationHelper.Translate(absoluteMove);
var canMove = _rules.CanMove(
chessboard,
source + destinationAsNotation, player, g.GetMoves().LastOrDefault());
if (canMove.Success)
{
potentialMoves.Add(destinationAsNotation);
}
}
}
return potentialMoves;
}
private bool isAuthorized(PlayerTypeEnum playerType)
{
if ((int)playerType >= (int)Authorized)
{
return(true);
}
return(false);
}
// Use this for initialization
void Start()
{
CamShakeCom = gameObject.AddComponent <CameraShake>();
PlayerCamera = camera;
camera.targetTexture = null;
CameraTran = transform;
XkPlayerCtrl script = GetComponentInParent <XkPlayerCtrl>();
switch (script.PlayerSt)
{
case PlayerTypeEnum.FeiJi:
_InstanceFeiJi = this;
PlayerSt = PlayerTypeEnum.FeiJi;
FeiJiCameraTan = transform;
gameObject.SetActive(false);
if (XkGameCtrl.GetInstance().m_CaiPiaoFlyData != null)
{
XkGameCtrl.GetInstance().m_CaiPiaoFlyData.m_CaiPiaoEndTrP1 = m_CaiPiaoEndTrP1;
XkGameCtrl.GetInstance().m_CaiPiaoFlyData.m_CaiPiaoEndTrP2 = m_CaiPiaoEndTrP2;
XkGameCtrl.GetInstance().m_CaiPiaoFlyData.m_CaiPiaoEndTrP3 = m_CaiPiaoEndTrP3;
}
break;
case PlayerTypeEnum.TanKe:
_InstanceTanKe = this;
PlayerSt = PlayerTypeEnum.TanKe;
TanKeCameraTan = transform;
gameObject.SetActive(false);
break;
case PlayerTypeEnum.CartoonCamera:
_InstanceCartoon = this;
PlayerSt = PlayerTypeEnum.CartoonCamera;
break;
}
CameraObj = gameObject;
PlayerScript = GetComponentInParent <XkPlayerCtrl>();
if (PlayerScript != null)
{
PlayerScript.SetPlayerCamera(this);
}
GameObject obj = new GameObject();
obj.name = "CameraParent";
CameraParent = obj.transform;
CameraParent.parent = CameraTran.parent;
CameraParent.localPosition = CameraTran.localPosition;
CameraParent.rotation = CameraTran.rotation;
CameraTran.parent = null;
CameraTran.rotation = CameraParent.localRotation;
SetEnableCamera(false);
for (int i = 0; i < PlayerSpawnPoint.Length; i++)
{
PlayerSpawnPoint[i].gameObject.SetActive(false);
}
}
// Take a monster and add it to the player
public PlayerInfo(Monster data)
{
PlayerType = PlayerTypeEnum.Monster;
Guid = data.Guid;
Alive = data.Alive;
ExperiencePoints = data.ExperienceTotal;
Level = data.Level;
Name = data.Name;
Speed = data.GetSpeed();
}
// Use this for initialization
void Start()
{
SpawnParticleCom = gameObject.AddComponent <XKSpawnParticle>();
for (int i = 0; i < QianGuanTwRot.Length; i++)
{
QianGuanTwRot[i].enabled = false;
}
FireLayer = XkGameCtrl.GetInstance().PlayerAmmoHitLayer;
PlayerScript = GetComponent <XkPlayerCtrl>();
PlayerScript.SetPlayerAutoFireScript(this);
PlayerStEnum = PlayerScript.PlayerSt;
AmmoStatePOne = PlayerAmmoType.PuTongAmmo;
AmmoStatePTwo = PlayerAmmoType.PuTongAmmo;
if (PlayerStEnum != PlayerTypeEnum.CartoonCamera)
{
PlayerAudio = PlayerScript.PlayerAudio;
for (int i = 0; i < 7; i++)
{
if (i < 6)
{
PlayerAudio[i].loop = false;
}
else
{
PlayerAudio[i].loop = true;
}
PlayerAudio[i].Stop();
}
InitPlayerAmmoList();
//InputEventCtrl.GetInstance().ClickFireBtOneEvent += ClickFireBtOneEvent;
InputEventCtrl.GetInstance().ClickFireBtTwoEvent += ClickFireBtTwoEvent;
//InputEventCtrl.GetInstance().ClickDaoDanBtOneEvent += ClickDaoDanBtOneEvent;
InputEventCtrl.GetInstance().ClickDaoDanBtTwoEvent += ClickDaoDanBtTwoEvent;
// if (Network.peerType == NetworkPeerType.Server) {
// InitPlayerAmmoList();
// }
//
// if ((PlayerStEnum == PlayerTypeEnum.FeiJi && XkGameCtrl.GameJiTaiSt == GameJiTaiType.FeiJiJiTai)
// || (PlayerStEnum == PlayerTypeEnum.TanKe && XkGameCtrl.GameJiTaiSt == GameJiTaiType.TanKeJiTai)){
// InitPlayerAmmoList();
// InputEventCtrl.GetInstance().ClickFireBtOneEvent += ClickFireBtOneEvent;
// InputEventCtrl.GetInstance().ClickFireBtTwoEvent += ClickFireBtTwoEvent;
// InputEventCtrl.GetInstance().ClickDaoDanBtOneEvent += ClickDaoDanBtOneEvent;
// InputEventCtrl.GetInstance().ClickDaoDanBtTwoEvent += ClickDaoDanBtTwoEvent;
// }
}
else
{
this.enabled = false;
}
}
// Take a character and add it to the Player
public PlayerInfo(Character data)
{
PlayerType = PlayerTypeEnum.Character;
Guid = data.Guid;
Alive = data.Alive;
ExperiencePoints = data.ExperienceTotal;
Level = data.Level;
Name = data.Name;
Speed = data.GetSpeed();
CurrentHealth = data.GetHealthCurrent();
MaxHealth = data.GetHealthMax();
}
private IPlayer AddPlayer(PlayerTypeEnum playerType, GamePlayerEnum gamePlayer)
{
if (gamePlayer == GamePlayerEnum.Player1)
{
this.player1 = PlayerFactory.Create(playerType, gamePlayer);
return(this.player1);
}
else
{
this.player2 = PlayerFactory.Create(playerType, gamePlayer);
return(this.player2);
}
}
public override void OnStartLocalPlayer()
{
base.OnStartLocalPlayer();
if (playerIndex == 0)
{
_playerType = PlayerTypeEnum.Officer;
}
else
{
Camera.main.orthographicSize /= 5;
_playerType = PlayerTypeEnum.Witness;
}
}
// Use this for initialization
void Start()
{
PlayerCamera = camera;
camera.targetTexture = null;
CameraTran = transform;
XkPlayerCtrl script = GetComponentInParent <XkPlayerCtrl>();
switch (script.PlayerSt)
{
case PlayerTypeEnum.FeiJi:
_InstanceFeiJi = this;
PlayerSt = PlayerTypeEnum.FeiJi;
FeiJiCameraTan = transform;
gameObject.SetActive(false);
break;
case PlayerTypeEnum.TanKe:
_InstanceTanKe = this;
PlayerSt = PlayerTypeEnum.TanKe;
TanKeCameraTan = transform;
gameObject.SetActive(false);
break;
case PlayerTypeEnum.CartoonCamera:
_InstanceCartoon = this;
PlayerSt = PlayerTypeEnum.CartoonCamera;
break;
}
CameraObj = gameObject;
PlayerScript = GetComponentInParent <XkPlayerCtrl>();
if (PlayerScript != null)
{
PlayerScript.SetPlayerCamera(this);
}
GameObject obj = new GameObject();
obj.name = "CameraParent";
CameraParent = obj.transform;
CameraParent.parent = CameraTran.parent;
CameraParent.localPosition = CameraTran.localPosition;
CameraParent.rotation = CameraTran.rotation;
CameraTran.parent = null;
if (PlayerSt != PlayerTypeEnum.CartoonCamera)
{
SetEnableCamera(false);
}
}
/// <summary>
/// Playerの生成
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static Player Create(PlayerTypeEnum type)
{
switch (type)
{
case PlayerTypeEnum.Null:
return(new NullPlayer());
case PlayerTypeEnum.Human:
return(new HumanPlayer());
case PlayerTypeEnum.UsiEngine:
return(new UsiEnginePlayer());
}
return(null);
}
// Take a monster and add it to the player
public PlayerInfo(Monster data)
{
PlayerType = PlayerTypeEnum.Monster;
Guid = data.Guid;
Alive = data.Alive;
ExperiencePoints = data.ExperienceTotal;
Level = data.Level;
Name = data.Name;
Speed = data.GetSpeed();
RemainingHP = data.GetHealthCurrent();
TotalHP = data.GetHealthMax();
Attack = data.GetAttack();
Defense = data.GetDefense();
ImageURI = data.GetImageURI();
}
public Dictionary<string, List<string>> GetPotentialMoves(ChessGame g, PlayerTypeEnum player)
{
Dictionary<string, List<string>> movesBySquare = new Dictionary<string, List<string>>();
var chessBoard = g.ChessBoard;
List<string> sourceSquares = chessBoard.GetPiecesForPlayer(player);
foreach (var sourceSquare in sourceSquares)
{
var potentialMoves = _GetPotentialMoves(g, player, sourceSquare);
if (potentialMoves.Count > 0) movesBySquare[sourceSquare] = potentialMoves;
}
return movesBySquare;
}
public bool ClearMessages()
{
PlayerType = PlayerTypeEnum.Unknown;
HitStatus = HitStatusEnum.Unknown;
AttackerName = string.Empty;
TargetName = string.Empty;
AttackStatus = string.Empty;
TurnMessage = string.Empty;
TurnMessageSpecial = string.Empty;
ExperienceEarned = string.Empty;
LevelUpMessage = string.Empty;
DamageAmount = 0;
CurrentHealth = 0;
return(true);
}
private bool CanMoveIntoAttackersPath(PlayerTypeEnum player, string lastMoveNotation, ChessBoard board, List<string> attackers, Tuple<int, int> opponentKingTuple)
{
if (attackers.Count > 1)
return false;
bool canBlockPathOfAttackers = false;
string attackerNotation = attackers.First();
Tuple<int, int> attackerTuple = NotationHelper.Translate(attackerNotation);
ChessPiece attackerPiece = board.Get(attackerTuple);
if (attackerPiece.Type == PieceTypeEnum.Knight)
return false;
// get star pattern of each attacker
List<Tuple<int, int>[]> relativePaths = new QueenRelativePathProvider().GetRelativePaths(
new ChessPiece() { Player = player });
var absolutePaths = BoardLogic.ConvertToAbsolutePaths(attackerTuple, relativePaths);
// get path that leads to king
var pathOfAttacker = BoardLogic.GetPathContaining(opponentKingTuple, absolutePaths);
var trimmedPathOfAttacker = BoardLogic.TrimToBeforeDestination(opponentKingTuple, pathOfAttacker);
// can any opponents move into path and block?
var opponentPlayerSquares = board.GetPiecesForPlayer(GetOppositePlayer(player));
foreach (var opponentSquare in opponentPlayerSquares)
{
bool canMoveIntoAttackersPath =
trimmedPathOfAttacker.Any(location =>
{
string dest = NotationHelper.Translate(location);
return CanMove(board, opponentSquare + dest, GetOppositePlayer(player), lastMoveNotation).Success;
});
if (canMoveIntoAttackersPath)
{
canBlockPathOfAttackers = true;
break;
}
}
return canBlockPathOfAttackers;
}
public ChessGame(
ChessBoard b,
PlayerTypeEnum player,
Dictionary<PlayerTypeEnum,
List<ChessPiece>> takenPieces,
IRulesOfChess rules)
{
_chessBoard = b;
_currentPlayer = player;
_moves = new List<string>();
_takenPieces = takenPieces ?? new Dictionary<PlayerTypeEnum, List<ChessPiece>>();
List<ChessPiece> takenOut;
if (!_takenPieces.TryGetValue(PlayerTypeEnum.White, out takenOut) || takenOut == null)
_takenPieces[PlayerTypeEnum.White] = new List<ChessPiece>();
if (!_takenPieces.TryGetValue(PlayerTypeEnum.Black, out takenOut) || takenOut == null)
_takenPieces[PlayerTypeEnum.Black] = new List<ChessPiece>();
_rules = rules;
}
public MoveResult PlayerMove(PlayerTypeEnum player, string move)
{
if (player != _currentPlayer)
return new MoveResult() { Error = "out of turn.", Turn = _currentPlayer };
var moveResult = _rules.CanMove(
_chessBoard,
move,
player,
_moves.LastOrDefault());
ChessPiece taken = null;
if (moveResult.Success)
{
var o = _chessBoard.RecordMoves(
moveResult.Moves,
moveResult.TakenPiece == null ? null : new[] { moveResult.TakenPiece },
moveResult.Swap);
_moves.AddRange(moveResult.Moves);
if (o.TakenPieces != null)
{
taken = o.TakenPieces.FirstOrDefault();
_takenPieces[_currentPlayer].Add(taken);
}
_currentPlayer = player == PlayerTypeEnum.White ? PlayerTypeEnum.Black : PlayerTypeEnum.White;
}
return new MoveResult()
{
Success = moveResult.Success,
Error = moveResult.Message,
Moves = moveResult.Moves,
Taken = taken,
Turn = _currentPlayer,
MoveType = moveResult.MoveType,
};
}
public static IPlayer Create(PlayerTypeEnum type, GamePlayerEnum gamePlayer)
{
IPlayer player = new RandomComputerPlayer();
player.Description = "RANDOM COMPUTER";
if (type == PlayerTypeEnum.Human)
{
player = new HumanPlayer();
player.Description = "HUMAN";
}
if (type == PlayerTypeEnum.TaticalComputer)
{
player = new TaticalComputerPlayer();
player.Description = "TATICAL COMPUTER";
}
player.Index = (int)gamePlayer;
return(player);
}
private Tuple<bool, List<string>> IsInCheck(PlayerTypeEnum playerType, ChessBoard board, string lastMoveNotation)
{
PlayerTypeEnum opponentPlayerType = GetOppositePlayer(playerType);
List<string> opponentSquares = board.GetPiecesForPlayer(opponentPlayerType);
string kingNotation = board.GetKing(playerType);
if (kingNotation == null)
return new Tuple<bool, List<string>>(false, null);
bool isInCheck = false;
List<string> attackers = new List<string>();
foreach (var square in opponentSquares)
{
var opponentMoveResult = CanMove(board, square, kingNotation, opponentPlayerType, lastMoveNotation, false);
if (opponentMoveResult.Success)
{
isInCheck = true;
attackers.Add(square);
}
}
return new Tuple<bool, List<string>>(isInCheck, attackers);
}
public ValidateMoveResult CanMove(ChessBoard board, string move, PlayerTypeEnum player,
string lastMoveNotation)
{
Tuple<string, string> breakdown = NotationHelper.Breakdown(move);
string source = breakdown.Item1;
string destination = breakdown.Item2;
bool playerInCheck = IsInCheck(player, board, lastMoveNotation).Item1;
ValidateMoveResult canMoveResult = CanMove(board, source, destination, player, lastMoveNotation, playerInCheck);
if (canMoveResult.Success)
{
// pawn to queen swap
ChessPiece sourceBeforeSimulate = board.Get(source);
bool pawnSwap =
sourceBeforeSimulate != null &&
sourceBeforeSimulate.Type == PieceTypeEnum.Pawn &&
(sourceBeforeSimulate.Direction == -1 ? (int.Parse(destination[1].ToString()) == 8) : (int.Parse(destination[1].ToString()) == 1));
string swap = pawnSwap ? destination : null;
canMoveResult.Swap = swap;
ChessBoard boardAfterMove = board.SimulateMoves(move, canMoveResult.TakenPiece, swap);
// did player move into check?
var movedIntoCheckResult = IsInCheck(player, boardAfterMove, lastMoveNotation);
if (movedIntoCheckResult.Item1)
{
canMoveResult.Success = false;
return canMoveResult.SetMessage("cannot move into check.");
}
// did player put opponent in check?
var isOpponentInCheckResult = IsInCheck(GetOppositePlayer(player), boardAfterMove, lastMoveNotation);
bool isOpponentInCheck = isOpponentInCheckResult.Item1;
canMoveResult.MoveType = isOpponentInCheck ? MoveTypeEnum.Check : MoveTypeEnum.Normal;
// if player checked opponent, can opponent get out of check? if not, check mate
if (isOpponentInCheck)
{
string opponentKingNotation = boardAfterMove.GetKing(GetOppositePlayer(player));
Tuple<int, int> opponentKingTuple = NotationHelper.Translate(opponentKingNotation);
// can checked king move out of check?
bool canMoveOutOfCheck = CanMoveOutOfCheck(player, lastMoveNotation, boardAfterMove, opponentKingNotation, opponentKingTuple);
// can opponent kill piece that put king in check? is still in check afterwards?
bool canTakedownAttacker = false;
if (!canMoveOutOfCheck)
canTakedownAttacker = CanTakedownAttackers(player, lastMoveNotation, boardAfterMove, isOpponentInCheckResult.Item2);
// can block path of piece that put king in check? (brute force method)
bool canBlockPathOfAttackers = false;
if (!canMoveOutOfCheck && !canTakedownAttacker)
canBlockPathOfAttackers = CanMoveIntoAttackersPath(player, lastMoveNotation, boardAfterMove, isOpponentInCheckResult.Item2, opponentKingTuple);
if (!canMoveOutOfCheck && !canTakedownAttacker && !canBlockPathOfAttackers)
canMoveResult.MoveType = MoveTypeEnum.Checkmate;
}
}
return canMoveResult;
}
private bool CanMoveOutOfCheck(PlayerTypeEnum player, string lastMoveNotation, ChessBoard board, string opponentKingNotation, Tuple<int, int> opponentKingTuple)
{
bool canMoveOutOfCheck = false;
ChessPiece opponentKingPiece = board.Get(opponentKingTuple);
var relativeMoves = m_relativeMoveProviderFactory
.GetProviderByPieceType(opponentKingPiece.Type)
.GetRelativePaths(opponentKingPiece);
var absolutePaths = BoardLogic.ConvertToAbsolutePaths(opponentKingTuple, relativeMoves);
var flattenedAbsoluteMoves = absolutePaths.SelectMany(x => x);
foreach (var square in flattenedAbsoluteMoves)
{
// simulate move of king to available move
string destinationNotation = NotationHelper.Translate(square);
var getKingOutOfCheckMoveResult = CanMove(board, opponentKingNotation + destinationNotation,
GetOppositePlayer(player), lastMoveNotation);
if (getKingOutOfCheckMoveResult.Success)
{
canMoveOutOfCheck = true;
break;
}
}
return canMoveOutOfCheck;
}
private bool CanTakedownAttackers(PlayerTypeEnum player, string lastMoveNotation, ChessBoard board, List<string> attackers)
{
if (attackers.Count > 1)
return false;
bool canTakedownAttacker = false;
PlayerTypeEnum opponentPlayerType = GetOppositePlayer(player);
List<string> opponentSquares = board.GetPiecesForPlayer(opponentPlayerType);
string attackerNotation = attackers.First();
foreach (var square in opponentSquares)
{
bool canDefeatAllAttackers = CanMove(board, square + attackerNotation, opponentPlayerType, lastMoveNotation).Success;
if (canDefeatAllAttackers)
{
canTakedownAttacker = true;
break;
}
}
return canTakedownAttacker;
}
public static bool Is(this Citizen citizen, PlayerTypeEnum playerType)
{
return(citizen.GetPlayerType() == playerType);
}
public SociatisAuthorize(PlayerTypeEnum playerType)
{
Authorized = playerType;
}
public PlayerFactory GetPlayerFactory(PlayerTypeEnum playerType)
{
return(playerFactories[playerType]);
}
public void PrintBoard(ChessPiece[,] board, PlayerTypeEnum player)
{
PrintBoard(board, player, null);
}
private ValidateMoveResult CanMove(ChessBoard board, string source, string dest, PlayerTypeEnum player, string lastMoveNotation, bool playerInCheck)
{
var result = new ValidateMoveResult();
var sourceTuple = NotationHelper.Translate(source);
if (!BoardLogic.IsOnBoard(sourceTuple))
return result.SetMessage(source + " is not on board");
var destTuple = NotationHelper.Translate(dest);
if (!BoardLogic.IsOnBoard(destTuple))
return result.SetMessage(dest + " is not on board");
if (source.Equals(dest, StringComparison.OrdinalIgnoreCase))
return result.SetMessage("source and dest are the same");
var sourcePiece = board.Get(sourceTuple);
if (sourcePiece == null)
return result.SetMessage("source piece is null");
if (sourcePiece.Player != player)
return result.SetMessage("piece does not belong to player.");
var destPiece = board.Get(destTuple);
if (destPiece != null && sourcePiece.Player == destPiece.Player)
return result.SetMessage("cannot move on top of own piece");
var relativeMoves = m_relativeMoveProviderFactory
.GetProviderByPieceType(sourcePiece.Type)
.GetRelativePaths(sourcePiece);
var absoluteMoves = BoardLogic.ConvertToAbsolutePaths(sourceTuple, relativeMoves);
bool destInPath = BoardLogic.IsInAtleastOnePath(destTuple, absoluteMoves);
if (!destInPath)
return result.SetMessage("destination not in available path");
string takenPiece = null;
string additionalMove = null;
switch (sourcePiece.Type)
{
case PieceTypeEnum.Pawn:
{
bool isRankOnlyMove = BoardLogic.IsRankOnlyMove(sourceTuple, destTuple);
if (isRankOnlyMove)
{
var pathContaingDestination = BoardLogic.GetPathContaining(destTuple, absoluteMoves);
if (!BoardLogic.IsPathClear(board, pathContaingDestination))
return result.SetMessage("path blocked");
var absDelta = BoardLogic.GetAbsoluteDelta(sourceTuple, destTuple);
if (absDelta.Item1 == 2 && sourcePiece.HasMoved)
return result.SetMessage("pawn has already moved, cannot jump 2 squares");
}
else
{
// en-passant
// > is piece in source *rank, destination *file an enemy pawn?
// > if yes, was its last move two squares?e
var pieceBehindTuple = new Tuple<int, int>(
sourceTuple.Item1,
destTuple.Item2);
var pieceBehind = board.Get(pieceBehindTuple);
bool targetWasLastMove = false;
bool twoSquareLastMove = false;
Tuple<string, string> lastMove = null;
if (lastMoveNotation != null)
{
lastMove = NotationHelper.Breakdown(lastMoveNotation);
var lastMoveSourceTuple = NotationHelper.Translate(lastMove.Item1);
var lastMoveDestTuple = NotationHelper.Translate(lastMove.Item2);
var lastMoveAbsDelta = BoardLogic.GetAbsoluteDelta(lastMoveSourceTuple, lastMoveDestTuple);
twoSquareLastMove = lastMoveAbsDelta.Item1 == 2;
targetWasLastMove =
pieceBehindTuple.Item1 == lastMoveDestTuple.Item1 &&
pieceBehindTuple.Item2 == lastMoveDestTuple.Item2;
}
bool enPassant =
pieceBehind != null &&
pieceBehind.Player != player &&
pieceBehind.Type == PieceTypeEnum.Pawn &&
twoSquareLastMove &&
targetWasLastMove
;
if (enPassant)
{
takenPiece = lastMove.Item2;
break;
}
if (destPiece == null)
return result.SetMessage("enemy piece not present at destination");
}
break;
}
case PieceTypeEnum.King:
{
// castle
if (BoardLogic.IsFileOnlyMove(sourceTuple, destTuple) &&
BoardLogic.GetAbsoluteDelta(sourceTuple, destTuple).Item2 == 2)
{
if (sourcePiece.HasMoved)
return result.SetMessage("king has already moved.");
ChessPiece rook = null;
Tuple<int, int> rookTuple = null;
Tuple<int, int> toRookDelta = null;
var rookNotations = board.GetPiecesOfType(player, PieceTypeEnum.Rook);
if (rookNotations != null && rookNotations.Count > 0)
{
var moveDelta = BoardLogic.GetDelta(sourceTuple, destTuple);
foreach (var rn in rookNotations)
{
rookTuple = NotationHelper.Translate(rn);
toRookDelta = BoardLogic.GetDelta(sourceTuple, rookTuple);
if (BoardLogic.IsFileOnlyMove(sourceTuple, rookTuple) &&
BoardLogic.AreDeltasInSameDirection(moveDelta.Item2, toRookDelta.Item2))
{
rook = board.Get(rn);
break;
}
}
}
if (rook == null)
return result.SetMessage("no rook present on rank " + sourceTuple.Item1);
if (rook.HasMoved)
return result.SetMessage("rook has moved.");
Tuple<int, int>[] kingToRookPath = BoardLogic.GetRankPath(sourceTuple, rookTuple);
Tuple<int, int>[] trimmedPath = BoardLogic.TrimToBeforeDestination(rookTuple,
kingToRookPath);
bool isPathClear = BoardLogic.IsPathClear(board, trimmedPath);
if (!isPathClear)
return result.SetMessage("path blocked");
if (playerInCheck)
return result.SetMessage("cannot castle out of check");
bool moveToLeft = toRookDelta.Item2 < 0;
additionalMove = NotationHelper.Translate(rookTuple) +
NotationHelper.Translate(new Tuple<int, int>(rookTuple.Item1,
destTuple.Item2 + (moveToLeft ? 1 : -1)));
}
break;
}
case PieceTypeEnum.Knight:
{
break;
}
case PieceTypeEnum.Bishop:
case PieceTypeEnum.Rook:
case PieceTypeEnum.Queen:
{
// cases handled in general
var pathContaingDestination = BoardLogic.GetPathContaining(destTuple, absoluteMoves);
var trimmedPath = BoardLogic.TrimToBeforeDestination(destTuple, pathContaingDestination);
if (!BoardLogic.IsPathClear(board, trimmedPath))
return result.SetMessage("path blocked");
break;
}
}
if (destPiece != null)
takenPiece = dest;
result.Success = true;
result.TakenPiece = takenPiece;
result.Moves = new[] { source + dest, additionalMove }.Where(x => x != null).ToArray();
return result;
}
public PlayerObject(PlayerTypeEnum type) : this()
{
PlayerType = type;
switch (type)
{
case PlayerTypeEnum.Fish:
VpIpMin = 38;
VpIpMax = 55;
PfrMin = 0;
PfrMax = 15;
AggMin = 0;
AggMax = 3;
ThreeBetMin = 0;
ThreeBetMax = 5;
WtsdMin = 18;
WtsdMax = 38;
WsdMin = 0;
WsdMax = 55;
WwsfMin = 0;
WwsfMax = 40;
break;
case PlayerTypeEnum.Gambler:
VpIpMin = 25;
VpIpMax = 40;
PfrMin = 15;
PfrMax = 30;
AggMin = 2.5;
AggMax = 8;
ThreeBetMin = 5;
ThreeBetMax = 18;
WtsdMin = 21;
WtsdMax = 26;
WsdMin = 48;
WsdMax = 57;
WwsfMin = 39;
WwsfMax = 48;
break;
case PlayerTypeEnum.Lag:
VpIpMin = 20;
VpIpMax = 25;
PfrMin = 17;
PfrMax = 23;
AggMin = 2.4;
AggMax = 4;
ThreeBetMin = 5;
ThreeBetMax = 8.8;
WtsdMin = 21;
WtsdMax = 26;
WsdMin = 48;
WsdMax = 57;
WwsfMin = 39;
WwsfMax = 48;
break;
case PlayerTypeEnum.Nit:
VpIpMin = 20;
VpIpMax = 25;
PfrMin = 17;
PfrMax = 23;
AggMin = 2.4;
AggMax = 4;
ThreeBetMin = 5;
ThreeBetMax = 8.8;
WtsdMin = 21;
WtsdMax = 26;
WsdMin = 48;
WsdMax = 57;
WwsfMin = 39;
WwsfMax = 48;
break;
case PlayerTypeEnum.Rock:
VpIpMin = 20;
VpIpMax = 25;
PfrMin = 17;
PfrMax = 23;
AggMin = 2.4;
AggMax = 4;
ThreeBetMin = 5;
ThreeBetMax = 8.8;
WtsdMin = 21;
WtsdMax = 26;
WsdMin = 48;
WsdMax = 57;
WwsfMin = 39;
WwsfMax = 48;
break;
case PlayerTypeEnum.Tag:
VpIpMin = 20;
VpIpMax = 25;
PfrMin = 17;
PfrMax = 23;
AggMin = 2.4;
AggMax = 4;
ThreeBetMin = 5;
ThreeBetMax = 8.8;
WtsdMin = 21;
WtsdMax = 26;
WsdMin = 48;
WsdMax = 57;
WwsfMin = 39;
WwsfMax = 48;
break;
case PlayerTypeEnum.Whale:
VpIpMin = 20;
VpIpMax = 25;
PfrMin = 17;
PfrMax = 23;
AggMin = 2.4;
AggMax = 4;
ThreeBetMin = 5;
ThreeBetMax = 8.8;
WtsdMin = 21;
WtsdMax = 26;
WsdMin = 48;
WsdMax = 57;
WwsfMin = 39;
WwsfMax = 48;
break;
}
}
protected static PlayerTypeEnum GetOppositePlayer(PlayerTypeEnum player)
{
return player == PlayerTypeEnum.White ? PlayerTypeEnum.Black : PlayerTypeEnum.White;
}
public void PrintBoard(ChessPiece[,] board, PlayerTypeEnum player, HashSet<string> potentialMoves)
{
potentialMoves = potentialMoves ?? new HashSet<string>();
if (player == PlayerTypeEnum.White)
{
for (int col = 0; col < 8; col++)
{
string file = NotationHelper.TranslateToFile(col);
Console.Write(" {0}", file);
}
Console.WriteLine();
for (int rank = 8; rank > 0; rank--)
{
Console.Write(rank);
for (char file = 'a'; file <= 'h'; file++)
{
PrintState(board, potentialMoves, rank, file);
}
Console.WriteLine();
}
for (int col = 0; col < 8; col++)
{
string file = NotationHelper.TranslateToFile(col);
Console.Write(" {0}", file);
}
}
else if (player == PlayerTypeEnum.Black)
{
for (int col = 7; col >= 0; col--)
{
string file = NotationHelper.TranslateToFile(col);
Console.Write(" {0}", file);
}
Console.WriteLine();
for (int rank = 1; rank <= 8; rank++)
{
Console.Write(rank);
for (char file = 'h'; file >= 'a'; file--)
{
PrintState(board, potentialMoves, rank, file);
}
Console.WriteLine();
}
for (int col = 7; col >= 0; col--)
{
string file = NotationHelper.TranslateToFile(col);
Console.Write(" {0}", file);
}
}
Console.WriteLine();
}
public ChessGame(ChessBoard b, PlayerTypeEnum player, Dictionary<PlayerTypeEnum, List<ChessPiece>> takenPieces)
: this(b, player, takenPieces, new TraditionalRulesOfChess())
{
}
public static bool HaveRightsOfAtLeast(this Citizen citizen, PlayerTypeEnum playerType)
{
return(citizen.GetPlayerType() >= playerType);
}
public ChessPiece[] GetTakenPiecesByPlayer(PlayerTypeEnum player)
{
return _takenPieces[player].Select(x => x.GetCopy()).ToArray();
}
private PlayerType(PlayerTypeEnum @enum)
{
Id = (int)@enum;
Name = @enum.ToString();
Description = @enum.GetDescription();
}
public Player(IMoveStrategy strategy, PlayerTypeEnum type)
{
this.Strategy = strategy;
this.Type = type;
}
public string GetKing(PlayerTypeEnum player)
{
List<string> locations = GetPiecesOfType(player, PieceTypeEnum.King);
return locations == null || locations.Count < 1 ? null : locations.First();
}
// Update is called once per frame
void Update()
{
// if (pcvr.DongGanState == 0) {
// return;
// }
if (DaoJiShiCtrl.GetInstance().GetIsPlayDaoJishi() ||
(!XkGameCtrl.IsActivePlayerOne && !XkGameCtrl.IsActivePlayerTwo))
{
// pcvr.CloseQiNangQian();
// pcvr.CloseQiNangHou();
return;
}
PlayerSt = PlayerTypeEnum.TanKe; //test.
float eulerAngleX = 0f;
float eulerAngleZ = 0f;
float offsetAngle = 0f;
switch (PlayerSt)
{
case PlayerTypeEnum.TanKe:
EulerAngle = transform.eulerAngles;
if (EulerAngle.x > 180f)
{
EulerAngle.x -= 360f;
}
if (EulerAngle.z > 180f)
{
EulerAngle.z -= 360f;
}
eulerAngleX = EulerAngle.x;
eulerAngleZ = EulerAngle.z;
offsetAngle = 0f;
if (Mathf.Abs(eulerAngleX) <= offsetAngle)
{
//前后气囊放气.
if (KeyQHQiNangState != 0)
{
QiNangStateTK[0] = 0;
QiNangStateTK[1] = 0;
KeyQHQiNangState = 0;
if (KeyZYQiNangState == 0)
{
pcvr.CloseQiNangQian();
pcvr.CloseQiNangHou();
}
}
}
else if (eulerAngleX < 0f)
{
//前气囊充气,后气囊放气.
if (KeyQHQiNangState != 1)
{
QiNangStateTK[0] = 1;
QiNangStateTK[1] = 0;
KeyQHQiNangState = 1;
pcvr.OpenQiNangQian();
pcvr.CloseQiNangHou(KeyZYQiNangState);
}
}
else if (eulerAngleX > 0f)
{
//后气囊充气,前气囊放气.
if (KeyQHQiNangState != 2)
{
QiNangStateTK[0] = 0;
QiNangStateTK[1] = 1;
KeyQHQiNangState = 2;
pcvr.OpenQiNangHou();
pcvr.CloseQiNangQian(KeyZYQiNangState);
}
}
if (Mathf.Abs(eulerAngleZ) <= offsetAngle)
{
//左右气囊放气.
if (KeyZYQiNangState != 0)
{
QiNangStateTK[2] = 0;
QiNangStateTK[3] = 0;
KeyZYQiNangState = 0;
if (KeyQHQiNangState == 0)
{
pcvr.CloseQiNangZuo();
pcvr.CloseQiNangYou();
}
}
}
else if (eulerAngleZ < 0f)
{
//左气囊充气,右气囊放气.
if (KeyZYQiNangState != 1)
{
QiNangStateTK[2] = 1;
QiNangStateTK[3] = 0;
KeyZYQiNangState = 1;
pcvr.OpenQiNangZuo();
pcvr.CloseQiNangYou(KeyQHQiNangState);
}
}
else if (eulerAngleZ > 0f)
{
//右气囊充气,左气囊放气.
if (KeyZYQiNangState != 2)
{
QiNangStateTK[2] = 0;
QiNangStateTK[3] = 1;
KeyZYQiNangState = 2;
pcvr.OpenQiNangYou();
pcvr.CloseQiNangZuo(KeyQHQiNangState);
}
}
break;
case PlayerTypeEnum.FeiJi:
EulerAngle = transform.eulerAngles;
if (EulerAngle.x > 180f)
{
EulerAngle.x -= 360f;
}
if (EulerAngle.z > 180f)
{
EulerAngle.z -= 360f;
}
eulerAngleX = EulerAngle.x;
eulerAngleZ = EulerAngle.z;
offsetAngle = 1f;
if (Mathf.Abs(eulerAngleX) <= offsetAngle)
{
//前后气囊放气.
QiNangStateFJ[0] = 0;
QiNangStateFJ[1] = 0;
}
else if (eulerAngleX < 0f)
{
//前气囊充气,后气囊放气.
QiNangStateFJ[0] = 1;
QiNangStateFJ[1] = 0;
}
else if (eulerAngleX > 0f)
{
//后气囊充气,前气囊放气.
QiNangStateFJ[0] = 0;
QiNangStateFJ[1] = 1;
}
if (Mathf.Abs(eulerAngleZ) <= offsetAngle)
{
//左右气囊放气.
QiNangStateFJ[2] = 0;
QiNangStateFJ[3] = 0;
}
else if (eulerAngleZ > 0f)
{
//右气囊充气,左气囊放气.
QiNangStateFJ[2] = 0;
QiNangStateFJ[3] = 1;
}
else if (eulerAngleZ < 0f)
{
//左气囊充气,右气囊放气.
QiNangStateFJ[2] = 1;
QiNangStateFJ[3] = 0;
}
break;
}
}
public List<string> GetPiecesForPlayer(PlayerTypeEnum player)
{
List<string> s = new List<string>();
for (int row = 0; row < 8; row++)
{
for (int col = 0; col < 8; col++)
{
ChessPiece p = _boardState[row, col];
if (p == null || p.Player != player)
continue;
string notation = NotationHelper.Translate(row, col);
s.Add(notation);
}
}
return s;
}
// Use this for initialization
void Start()
{
CameraObj = gameObject;
PlayerCamera = GetComponent <Camera>();
if (PlayerCamera != null)
{
PlayerCamera.targetTexture = null;
}
if (PlayerMainCamTmp != null && PlayerMainCamTmp.Length >= 2)
{
PlayerMainCameraTmp = new Camera[2];
if (PlayerMainCamTmp[0] != null)
{
PlayerMainCameraTmp[0] = PlayerMainCamTmp[0].GetComponent <Camera>();
// if (XkGameCtrl.GetInstance().IsOpenVR) {
// PlayerMainCamTmp[0].SetActive(false);
// }
}
if (PlayerMainCamTmp[1] != null)
{
PlayerMainCameraTmp[1] = PlayerMainCamTmp[1].GetComponent <Camera>();
// if (XkGameCtrl.GetInstance().IsOpenVR) {
// PlayerMainCamTmp[1].SetActive(false);
// }
}
}
CameraTran = transform;
PlayerScript = GetComponentInParent <XkPlayerCtrl>();
switch (PlayerScript.PlayerSt)
{
case PlayerTypeEnum.FeiJi:
_InstanceFeiJi = this;
PlayerSt = PlayerTypeEnum.FeiJi;
FeiJiCameraTan = transform;
if (!XkGameCtrl.IsTiaoGuoStartCartoon)
{
CameraObj.SetActive(false);
}
// else {
// CameraObj.SetActive(XkGameCtrl.GetInstance().IsOpenVR);
// }
break;
case PlayerTypeEnum.TanKe:
_InstanceTanKe = this;
PlayerSt = PlayerTypeEnum.TanKe;
TanKeCameraTan = transform;
CameraObj.SetActive(false);
break;
case PlayerTypeEnum.CartoonCamera:
_InstanceCartoon = this;
PlayerSt = PlayerTypeEnum.CartoonCamera;
if (XkGameCtrl.IsTiaoGuoStartCartoon)
{
CameraObj.SetActive(false);
}
break;
}
if (PlayerSt != PlayerTypeEnum.CartoonCamera)
{
XkGameCtrl.GetInstance().ChangeAudioListParent();
}
if (PlayerScript != null)
{
PlayerScript.SetPlayerCamera(this);
}
GameObject obj = new GameObject();
obj.name = "CameraParent";
CameraParent = obj.transform;
CameraParent.parent = CameraTran.parent;
CameraParent.localPosition = CameraTran.localPosition;
CameraParent.rotation = CameraTran.rotation;
CameraTran.parent = null;
if (PlayerSt != PlayerTypeEnum.CartoonCamera)
{
if (!XkGameCtrl.IsTiaoGuoStartCartoon)
{
SetEnableCamera(false);
}
if (XkGameCtrl.IsActivePlayerOne)
{
IndexPlayerNum = -1;
TestChangePlayerCamera();
}
else
{
IndexPlayerNum = 0;
TestChangePlayerCamera();
}
}
XKGlobalData.GetInstance().PlayGuanKaBeiJingAudio();
}
public void SetPlayerType(PlayerTypeEnum pt)
{
_playerTypeDropdown.value = (int)pt;
}
