public void CreateLocalPlayer(LudoType playerType, string playerName, BoardPlayer boardPlayer, BoardPlayerUI boardPlayerUI)
{
var player = new LocalPlayer(playerType, playerName, boardPlayer, boardPlayerUI);
rulesManager.AddPlayer(player);
players.Add(player);
}
public int GetOuterPathTileNo(PlayerType playerType, int tilesTraveled, int tiles = 0)
{
int startingTileNo = GetStartingTileNo(playerType);
int tilesReached = CalculateOuterPathTileNo(startingTileNo, tilesTraveled + tiles);
return(tilesReached);
}
public Vector2 GetInnerTilePosition(PlayerType playerType, int tileIndex)
{
int row = TileManager.Instance.GetInnerTileRowNo(playerType, tileIndex);
int col = TileManager.Instance.GetInnerTileColNo(playerType, tileIndex);
return(tile_0_0.transform.position + new Vector3(col * tileWidth, row * tileHeight, 0));
}
// Temp disabled, waiting for server implementation
/*public*/
private void CreateOnlinePlayer(LudoType playerType)
{
var player = new OnlinePlayer(playerType);
//rulesManager.AddPlayer(player);
players.Add(player);
}
public BoardPlayer CreatePlayer(LudoType playerType)
{
BoardPlayer player = new BoardPlayer(playerType);
boardPlayers.Add(new BoardPlayerInfo(player, playerType, 0)); // TODO update starting tile use tile manager
return(player);
}
public Vector2 GetNextTilePosition(PlayerType playerType, int tilesTraveled)
{
if (TileManager.Instance.IsInnerTile(tilesTraveled + 1))
{
return(GetNextInnerTilePosition(playerType, tilesTraveled));
}
return(GetTilePosition(TileManager.Instance.GetNextOuterPathTileNo(playerType, tilesTraveled)));
}
public void InitTwoPlayerBoard(LudoType bottomPlayerType, string player1Name, string player2Name)
{
RotateBoard(bottomPlayerType);
UpdatePlayerName(0, player1Name);
DisablePlayer(1);
UpdatePlayerName(2, player2Name);
DisablePlayer(3);
}
private void CreateLocalPlayer(LudoType playerType, string playerName)
{
BoardPlayerUI boardPlayerUI = boardUI.GetPlayer(playerType);
BoardPlayer boardPlayer = board.CreatePlayer(playerType);
boardPlayerUI.SetUITileManager(uiTileManager);
playerManager.CreateLocalPlayer(playerType, playerName, boardPlayer, boardPlayerUI);
}
private void InitPawns(PlayerType playerType)
{
for (int i = 0; i < pawns.Length; i++)
{
pawns[i].Init(playerType, new PawnUIID(i));
slots[i].PutPawnInSlot(pawns[i]);
}
}
public LocalPlayer(LudoType playerType, string playerName, BoardPlayer boardPlayer, BoardPlayerUI boardPlayerUI)
{
playerBoardType = playerType;
this.playerName = playerName;
playerOriginalType = playerType;
this.boardPlayer = boardPlayer;
this.boardPlayerUI = boardPlayerUI;
InitPawnData();
}
public int ConvertTileNoToTilesTraveled(PlayerType playerType, int tileNo)
{
int startingTileNo = GetStartingTileNo(playerType);
if (tileNo >= startingTileNo)
{
return(tileNo - startingTileNo + 1);
}
return(Constants.Tiles.TotalTilesInOuterPath - startingTileNo + tileNo);
}
private void CreateBoardWithPawnSelected(LudoType pawn)
{
LudoType player1Type = pawn;
LudoType player2Type = (LudoType)(((int)pawn + 2) % (int)LudoType.END);
Debugger.Log("PlayerSelectedPawn player1Type:" + player1Type + " player2Type:" + player2Type);
CreateTwoPlayerBoard(player1Type, player2Type, "You", "Opponent");
TileManager.Instance.SetBottomLeftPlayer(player1Type);
gameState = GameState.InitGameBoard;
}
public BoardPlayerUI GetPlayer(LudoType playerType)
{
foreach (var player in boardPlayers)
{
if (player.playerType == playerType)
{
return(player);
}
}
return(null);
}
public int GetInnerTileRowNo(PlayerType playerType, int innerTileIndex)
{
int row = GetOuterPathRowNo(GetStartingInnerTileNo(playerType));
switch (GetPlayerIndex(playerType))
{
case 0: row += innerTileIndex; break; // Bottom player
case 2: row -= innerTileIndex; break; // Top Player
}
return(row);
}
public int GetInnerTileColNo(PlayerType playerType, int innerTileIndex)
{
int col = GetOuterPathColNo(GetStartingInnerTileNo(playerType));
switch (GetPlayerIndex(playerType))
{
case 1: col += innerTileIndex; break; // Left Player
case 3: col -= innerTileIndex; break; // Right Player
}
return(col);
}
private void UpdatePlayers(LudoType bottomLeftPlayer)
{
LudoType playerType = bottomLeftPlayer;
for (int i = 0; i < boardPlayers.Length; i++)
{
boardPlayers[i].Init(playerType);
playerType++;
if (playerType == LudoType.END)
{
playerType = 0;
}
}
}
public Vector2 GetStartingTilePositionFor(PlayerType playerType)
{
switch (TileManager.Instance.GetPlayerIndex(playerType))
{
case 0: return(GetBottomLeftPlayerStartingTile());
case 1: return(GetTopLeftPlayerStartingTile());
case 2: return(GetTopRightPlayerStartingTile());
case 3: return(GetBottomRightPlayerStartingTile());
}
return(Vector2.zero);
}
public int GetPlayerIndex(PlayerType playerType)
{
// Consider BottomLeftPlayer:2
// PlayerType:2 => 2 - 2 = 0
// PlayerType:3 => 3 - 2 = 1
// PlayerType:0 => 0 - 2 = -2 => 4 - 2 = 2
// PlayerType:1 => 1 - 2 = -1 => 4 - 1 = 3
int player = (int)playerType - (int)bottomLeftPlayer;
if (player < 0)
{
player += (int)PlayerType.END;
}
return(player);
}
private Vector2 GetNextInnerTilePosition(PlayerType playerType, int tilesTraveled, int tiles = 1)
{
int noOfInnerTilesReached = tilesTraveled + tiles - Constants.Tiles.InnerTileStarting;
Vector2 startingInnerTilePosition = GetTilePosition(TileManager.Instance.GetStartingInnerTileNo(playerType));
switch (TileManager.Instance.GetPlayerIndex(playerType))
{
case 0: return(GetPositionToTop(startingInnerTilePosition, noOfInnerTilesReached)); // Go up from first inner tile
case 1: return(GetPositionToRight(startingInnerTilePosition, noOfInnerTilesReached)); // Go right from first inner tile
case 2: return(GetPositionToBottom(startingInnerTilePosition, noOfInnerTilesReached)); // Go bottom from first inner tile
case 3: return(GetPositionToLeft(startingInnerTilePosition, noOfInnerTilesReached)); // Go left from first inner tile
}
return(Vector2.zero);
}
private void InternalRotateBoard(LudoType boardType)
{
this.boardType = boardType;
Debugger.Log("Rotate Board : " + boardType);
switch (boardType)
{
case LudoType.Blue:
board.transform.SetPositionAndRotation(board.transform.position, Quaternion.AngleAxis(0, new Vector3(0, 0, 1)));
break;
case LudoType.Yellow:
board.transform.SetPositionAndRotation(board.transform.position, Quaternion.AngleAxis(90, new Vector3(0, 0, 1)));
break;
case LudoType.Red:
board.transform.SetPositionAndRotation(board.transform.position, Quaternion.AngleAxis(180, new Vector3(0, 0, 1)));
break;
case LudoType.Green:
board.transform.SetPositionAndRotation(board.transform.position, Quaternion.AngleAxis(270, new Vector3(0, 0, 1)));
break;
}
UpdatePlayers(boardType);
}
public BoardPlayer(LudoType playerType)
{
PlayerType = playerType;
CreatePawns();
}
public OnlinePlayer(LudoType playerType)
{
playerBoardType = playerType;
// Player Original type is retrived from server connection
}
public int GetStartingTileNo(PlayerType playerType) => Constants.Tiles.StartingTilesNo[GetPlayerIndex(playerType)];
public int GetNextOuterPathTileNo(PlayerType playerType, int tilesTraveled) => GetOuterPathTileNo(playerType, tilesTraveled, 1);
private void CreateTwoPlayerBoard(LudoType player1Type, LudoType player2Type, string player1Name, string player2Name)
{
boardUI.InitTwoPlayerBoard(player1Type, player1Name, player2Name);
CreateLocalPlayer(player1Type, player1Name);
CreateLocalPlayer(player2Type, player2Name);
}
public int GetStartingInnerTileNo(PlayerType playerType) => CalculateOuterPathTileNo(GetStartingTileNo(playerType), Constants.Tiles.InnerTileStarting);
public void RotateBoard(LudoType boardType)
{
InternalRotateBoard(boardType);
}
public BoardPlayerInfo(BoardPlayer player, LudoType playerType, int startingTile)
{
this.player = player;
this.playerType = playerType;
this.startingTile = startingTile;
}
public void Init(PlayerType playerType)
{
InitPawns(playerType);
this.playerType = playerType;
}
// Start is called before the first frame update
void Start()
{
playerType = PlayerType.Red;
HideDice();
}
