// +++ constructor ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public PlayerFigure(PlayerColors playerColor, int index = 0, int offSet = 0)
{
Index = index;
Color = playerColor;
MovePoints = -1;
GameBoardLocation = -1;
}
public CheckMovesResult CheckRule(PlayerColors playerColor, List <PlayerFigure> playerFigures, int diceValue)
{
CheckMovesResult result = null;
// no player figure is on the game field which means no player figure has movepoint score between 0 and up to 40
var numberOfFiguresOnBoard = nvp_RuleHelper.CountPlayersOnBoard(playerColor, playerFigures);
// at least on player figure is in the house
var numberOfPlayerInTheHouse = nvp_RuleHelper.CountPlayersInHouse(playerColor, playerFigures);
// general rule
if (numberOfPlayerInTheHouse == 0 || diceValue < 6)
{
return(_nextRule.CheckRule(playerColor, playerFigures, diceValue));
}
result = new CheckMovesResult(true, true, "nvp_Rule_6_all_in_house_class: move out");
// get figure to move
var pf = playerFigures.Single(x => x.Index == 0 && x.Color == playerColor);
// enlist the move for display
result.PossibleMoves = new List <PlayerMove>();
var move = new PlayerMove();
move.Color = playerColor;
move.Index = nvp_RuleHelper.GetNextFigureToLeaveHouse(playerColor, playerFigures).Index;
move.MovePoints = 0;
move.GameBoardLocation = pf.OffSet;
result.PossibleMoves.Add(move);
return(result);
}
public void SetTeam(int team)
{
m_Team = team;
//change outline
m_Mesh.materials[2].SetColor("_OutlineColor", m_TeamManager.GetTeamColor(m_Team));
//Set character color
PlayerColors playerColors = new PlayerColors();
m_SkinColor = playerColors.playerColorList[m_Id];
m_Mesh.material.color = m_SkinColor;
//Set character color skin
if (m_Team == 1)
{
//Get the Correct texture for team 1
var mat = m_Mesh.materials[3].GetTexture("_MainTex");
//Set the correct texture to the one that will show in-game
m_Mesh.materials[1].SetTexture("_MainTex", mat);
}
//Set the texture of the correct team also to the skin 1== builder, 2 == lucha
if (m_SkinId != 0) //3
{
m_Mesh.materials[0].SetTexture("_MainTex", m_Mesh.materials[1].GetTexture("_MainTex"));
}
//else
//{
// m_Mesh.materials[0].SetTexture("_MainTex", m_Mesh.materials[1].GetTexture("_MainTex"));
//}
Respawn(false, true, false);
}
public CheckMovesResult CheckRule(PlayerColors playerColor, List <PlayerFigure> playerFigures, int diceNumber)
{
if (nvp_RuleHelper.IsFieldOccupiedByOwnFigure(playerColor, playerFigures, 0))
{
if (nvp_RuleHelper.CanExitStart(playerColor, playerFigures, diceNumber))
{
var pf = nvp_RuleHelper.GetPlayerFigureOnField(playerColor, playerFigures, 0);
var result = new CheckMovesResult(true, false, "");
var pm = new PlayerMove();
pm.Color = playerColor;
pm.Index = pf.Index;
pm.MovePoints = diceNumber;
result.PossibleMoves = new List <PlayerMove>();
result.PossibleMoves.Add(pm);
return(result);
}
else
{
var result = new CheckMovesResult(false, false, "");
return(result);
}
}
else
{
return(_nextRule.CheckRule(playerColor, playerFigures, diceNumber));
}
}
public void GetPlayerColor()
{
// Gets random color from list to start
var max = Enum.GetValues(typeof(PlayerColors)).Length;
_playerColor = (PlayerColors) new Random().Next(0, max - 1);
}
public Player(PlayerColors playerColor)
{
this.playerColor = playerColor;
this.tanks = new Tank[3] {
new EmptyTankSlot(), new EmptyTankSlot(), new EmptyTankSlot()
};
}
private void OnBuildColorsReceived(ulong sender, BuildColorMessage message)
{
if (Network.IsClient)
{
var player = MyAPIGateway.Session.LocalHumanPlayer;
if (player != null && player.SteamUserId == message.SteamId && message.BuildColors != null && message.BuildColors.Any())
{
player.BuildColorSlots = message.BuildColors;
_lastColorsSend.Clear();
_lastColorsSend.AddRange(player.BuildColorSlots);
}
}
else if (Network.IsServer)
{
var playerColor = new PlayerColors {
Id = message.SteamId, Colors = MyAPIGateway.Utilities.SerializeToBinary(message.BuildColors)
};
if (Settings.Colors.Contains(playerColor))
{
Settings.Colors.Remove(playerColor);
}
Settings.Colors.Add(playerColor);
}
}
// Returns an array of size 3. Each index corresponds to a tank
// and holds an integer for it's health. If that index is an
// empty tank slot, the health will be -9999.
public int[] getHealthForPlayerTanks(PlayerColors player)
{
int[] health = new int[3];
Tank[] tanks;
const int emptyTankSlotHealth = -9999;
if (player == PlayerColors.Red)
{
tanks = player1.getPlayerTanks();
}
else
{
tanks = player2.getPlayerTanks();
}
for (int i = 0; i < 3; i++)
{
if (tanks[i] is EmptyTankSlot)
{
health[i] = emptyTankSlotHealth;
}
else
{
health[i] = tanks[i].getHealth();
}
}
return(health);
}
public CheckMovesResult CheckRules(string diceRoll)
{
PlayerColors playerColor = PlayerColors.red;
if (diceRoll.Contains("r"))
{
playerColor = PlayerColors.red;
}
if (diceRoll.Contains("y"))
{
playerColor = PlayerColors.yellow;
}
if (diceRoll.Contains("b"))
{
playerColor = PlayerColors.black;
}
if (diceRoll.Contains("g"))
{
playerColor = PlayerColors.green;
}
var diceValue = Convert.ToInt32(diceRoll.Substring(1, 1));
return(_gameboard.CheckPossiblePlayerMoves(playerColor, diceValue));
}
void AddPlayerColor(PlayerColors color)
{
int offset = 0;
if (color == PlayerColors.black)
{
offset = 10;
}
if (color == PlayerColors.yellow)
{
offset = 20;
}
if (color == PlayerColors.green)
{
offset = 30;
}
for (int i = 0, n = 4; i < n; i++)
{
playerFigures.Add(
new PlayerFigure(color, i, offset)
);
}
}
public PlayerInfo(XboxController ID, PlayerColors playerColors)
{
IsAlive = true;
PlayerID = ID;
CurrentColor = playerColors;
Scores = new List <ScoreInformation>();
}
public bool playerHasValidAttack(PlayerColors player, CoordinateSet playerCoordinates)
{
Tank playerTank;
Tank[] enemyTanks;
if (player == PlayerColors.Red)
{
playerTank = player1.getPlayerTankByCoordinates(playerCoordinates);
enemyTanks = player2.getPlayerTanks();
}
else
{
playerTank = player2.getPlayerTankByCoordinates(playerCoordinates);
enemyTanks = player1.getPlayerTanks();
}
for (int i = 0; i < 3; i++)
{
if (enemyTanks[i] is EmptyTankSlot)
{
continue;
}
if (checkValidAttack(player, playerCoordinates, enemyTanks[i].getCoordinates(), false))
{
return(true);
}
}
return(false);
}
private void GetPlayers()
{
StartCoroutine(Network.GetRequest(URL.GetPlayers, response =>
{
response = "{\"otherPlayers\":" + response + "}";
Players = JsonUtility.FromJson <Players>(response);
var index = 0;
foreach (var player in _playersScoreboard)
{
Debug.Log(Players.otherPlayers[index].player);
if (Players.otherPlayers[index].player == ThisPlayerID)
{
ThisPlayerPlayerColor = (PlayerColors)index;
_myPlayer.UpdateColor(ThisPlayerPlayerColor);
index++;
}
Players.otherPlayers[index].Color = (PlayerColors)index;
player.InitViews(Players.otherPlayers[index]);
index++;
}
UpdateTurn(22);
}, URL.Headers()));
}
public string[] getPlayerPowerups(PlayerColors player)
{
string[] powerups = new string[3];
Tank[] tanks;
if (player == PlayerColors.Red)
{
tanks = player1.getPlayerTanks();
}
else
{
tanks = player2.getPlayerTanks();
}
for (int i = 0; i < 3; i++)
{
if (tanks[i] is EmptyTankSlot)
{
powerups[i] = "Nothing";
continue;
}
powerups[i] = tanks[i].getPowerupAsString();
}
return(powerups);
}
void PreviousColor()
{
if (LogFilter.Debug)
{
Debug.Log("CHANGE COLOR PREVIOUS");
}
CmdUpdatePlayerColor(PlayerColors.PreviousColor(playerColor));
}
protected override void OnDisabled()
{
base.OnDisabled();
GameEvents.onVesselCreate.Remove(PlayerColorEvents.SetVesselOrbitColor);
SystemsContainer.Get <LockSystem>().UnregisterAcquireHook(PlayerColorEvents.OnLockAcquire);
SystemsContainer.Get <LockSystem>().UnregisterReleaseHook(PlayerColorEvents.OnLockRelease);
PlayerColors.Clear();
}
public override void OnDisabled()
{
base.OnDisabled();
GameEvents.onVesselCreate.Remove(PlayerColorEvents.SetVesselOrbitColor);
LockSystem.Singleton.UnregisterAcquireHook(PlayerColorEvents.OnLockAcquire);
LockSystem.Singleton.UnregisterReleaseHook(PlayerColorEvents.OnLockRelease);
PlayerColors.Clear();
}
/// <summary>
/// Sets up a new bomb
/// </summary>
/// <param name="gridPosition">Position of the bomb in grid coordinates</param>
/// <param name="timer">Explosion timer, 0 if manually triggered</param>
/// <param name="range">Range of the bomb explosion</param>
/// <param name="ownerColor">Color of the owner</param>
public Bomb(Point gridPosition, int timer, int range, PlayerColors ownerColor)
{
Position = gridPosition;
_timer = timer;
_setupTime = DateTime.Now;
_ownerColor = ownerColor;
Range = range;
}
/**
* Callback that is getting called when player presses interaction key near interactable
*/
public override void Interact(int playerId)
{
PlayerColor newPlayerColor = PlayerColors.SwitchToRandomColor(playerId);
playersManager.clients[playerId].basePlayer.colorable.ChangeColor(newPlayerColor);
Logger.LogEvent(SharedLoggerSection.PlayerColors, $"Changed player {playerId} color to {Helpers.GetEnumName(newPlayerColor)}");
}
void NextColor()
{
if (LogFilter.Debug)
{
Debug.Log("CHANGE COLOR NEXT");
}
CmdUpdatePlayerColor(PlayerColors.NextColor(playerColor));
}
public static int CountPlayersInHouse(PlayerColors playerColor, List <PlayerFigure> playerFigures)
{
int count = playerFigures.Count(
x => x.MovePoints < 0 &&
x.Color == playerColor);
return(count);
}
// +++ constructor ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public PlayerFigure(PlayerColors playerColor, int index = 0, int offSet = 0)
{
Index = index;
Color = playerColor;
LocalPosition = -1;
WorldPosition = -1;
WorldOffset = offSet;
}
public PlayerFigure(PlayerColors playerColor, int index, int localPosition, int worldPosition, int offset = 0)
{
Color = playerColor;
Index = index;
LocalPosition = localPosition;
WorldPosition = worldPosition;
WorldOffset = offset;
}
public static int CountPlayersInHouse(PlayerColors playerColor, List <PlayerFigure> playerFigures)
{
int count = playerFigures.Count(x =>
x.LocalPosition < 0 &&
x.Color == playerColor);
return(count);
}
public static int CountPlayersOnBoard(PlayerColors playerColor, List <PlayerFigure> playerFigures)
{
int count = playerFigures.Count(
x => x.MovePoints >= 0 &&
x.MovePoints <= 40 &&
x.Color == playerColor);
return(count);
}
public void SetUITankParts(Image[] tankParts, PlayerColors color)
{
tankParts[(int)TankParts.BODY].color = playerBodyColors[(int)color];
tankParts[(int)TankParts.LIGHT].color = playerLightColors[(int)color];
tankParts[(int)TankParts.SHADOW].color = playerShadowColors[(int)color];
tankParts[(int)TankParts.WHEEL_BODY].color = playerBodyColors[(int)color];
tankParts[(int)TankParts.WHEEL_LIGHT].color = playerLightColors[(int)color];
tankParts[(int)TankParts.WHEEL_SHADOW].color = playerShadowColors[(int)color];
}
// +++ public Methods +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public CheckMovesResult CheckPossiblePlayerMoves(PlayerColors playerColor, int diceValue)
{
var defaultResult = new CheckMovesResult();
defaultResult.PlayerColor = playerColor;
defaultResult.DiceValue = diceValue;
defaultResult.PlayerFigures = playerFigures;
return(_ruleChain[0].CheckRule(defaultResult));
}
public static int CountPlayersOnBoard(PlayerColors playerColor, List <PlayerFigure> playerFigures)
{
int count = playerFigures.Count(x =>
x.LocalPosition >= 0 &&
x.LocalPosition <= 40 &&
x.Color == playerColor);
return(count);
}
public static List <PlayerFigure> GetFiguresOnBoardByColor(PlayerColors playerColor, List <PlayerFigure> playerfigures, int diceValue)
{
var list = playerfigures.Where(x =>
x.Color == playerColor &&
x.LocalPosition > 0 &&
x.LocalPosition + diceValue < 45).ToList();
return(list);
}
protected override void OnDisabled()
{
base.OnDisabled();
GameEvents.onVesselCreate.Remove(PlayerColorEvents.OnVesselCreated);
GameEvents.OnMapEntered.Remove(PlayerColorEvents.MapEntered);
LockEvent.onLockAcquireUnityThread.Remove(PlayerColorEvents.OnLockAcquire);
LockEvent.onLockReleaseUnityThread.Remove(PlayerColorEvents.OnLockRelease);
PlayerColors.Clear();
}
private static Color GetPrimaryColor(PlayerColors color)
{
switch (color)
{
case PlayerColors.PLAYERCOLOR_BLACK: return CreateColor(1, 0.13, 0.13, 0.13);
case PlayerColors.PLAYERCOLOR_BLUE: return CreateColor(1, 0.21, 0.40, 1.00);
case PlayerColors.PLAYERCOLOR_BROWN: return CreateColor(1, 0.39, 0.24, 0.00);
case PlayerColors.PLAYERCOLOR_CYAN: return CreateColor(1, 0.07, 0.80, 0.96);
case PlayerColors.PLAYERCOLOR_LIGHT_BLUE: return CreateColor(1, 0.5, 0.70, 1);
case PlayerColors.PLAYERCOLOR_DARK_BLUE: return CreateColor(1, 0.16, 0.00, 0.64);
case PlayerColors.PLAYERCOLOR_DARK_CYAN: return CreateColor(1, 0.00, 0.54, 0.55);
case PlayerColors.PLAYERCOLOR_LIGHT_GREEN: return CreateColor(1, 0.5, 1, 0.50);
case PlayerColors.PLAYERCOLOR_MIDDLE_GREEN: return CreateColor(1, 0.204, 0.576, 0.00);
case PlayerColors.PLAYERCOLOR_DARK_GREEN: return CreateColor(1, 0.00, 0.39, 0.00);
case PlayerColors.PLAYERCOLOR_DARK_DARK_GREEN: return CreateColor(1, 0.00, 0.27, 0.00);
case PlayerColors.PLAYERCOLOR_DARK_PINK: return CreateColor(1, 0.69, 0.00, 0.38);
case PlayerColors.PLAYERCOLOR_DARK_PURPLE: return CreateColor(1, 0.45, 0.00, 0.49);
case PlayerColors.PLAYERCOLOR_DARK_RED: return CreateColor(1, 0.62, 0.00, 0.00);
case PlayerColors.PLAYERCOLOR_DARK_YELLOW: return CreateColor(1, 0.97, 0.75, 0.0);
case PlayerColors.PLAYERCOLOR_DARK_GRAY: return CreateColor(1, 0.369, 0.369, 0.369);
case PlayerColors.PLAYERCOLOR_GRAY: return CreateColor(1, 0.7, 0.7, 0.7);
case PlayerColors.PLAYERCOLOR_GREEN: return CreateColor(1, 0.49, 0.88, 0.00);
case PlayerColors.PLAYERCOLOR_ORANGE: return CreateColor(1, 0.99, 0.35, 0.0);
case PlayerColors.PLAYERCOLOR_PEACH: return CreateColor(1, 0.60 , 0.49, 0.0);
case PlayerColors.PLAYERCOLOR_PINK: return CreateColor(1, 0.98 , 0.67, 0.49);
case PlayerColors.PLAYERCOLOR_PURPLE: return CreateColor(1, 0.77, 0.34, 1.00);
case PlayerColors.PLAYERCOLOR_RED: return CreateColor(1, 0.86, 0.02, 0.02);
case PlayerColors.PLAYERCOLOR_WHITE: return CreateColor(1, 0.90, 0.90, 0.90);
case PlayerColors.PLAYERCOLOR_YELLOW: return CreateColor(1, 1.00, 1.00, 0.17);
case PlayerColors.PLAYERCOLOR_LIGHT_YELLOW: return CreateColor(1, 1, 1, 0.5);
case PlayerColors.PLAYERCOLOR_LIGHT_PURPLE: return CreateColor(1, 0.7, 0.6, 1);
case PlayerColors.PLAYERCOLOR_LIGHT_ORANGE: return CreateColor(1, 0.90, 0.65, 0.32);
case PlayerColors.PLAYERCOLOR_MIDDLE_PURPLE: return CreateColor(1, 0.675, 0.118, 0.725);
case PlayerColors.PLAYERCOLOR_GOLDENROD: return CreateColor(1, 0.871, 0.624, 0);
case PlayerColors.PLAYERCOLOR_DARK_LEMON: return CreateColor(1, 0.847, 0.792, 0.039);
case PlayerColors.PLAYERCOLOR_MIDDLE_BLUE: return CreateColor(1, 0, 0.220, 0.914);
case PlayerColors.PLAYERCOLOR_MIDDLE_CYAN: return CreateColor(1, 0, 0.639, 0.710);
case PlayerColors.PLAYERCOLOR_MAROON: return CreateColor(1, 0.514, 0.2, 0.157);
case PlayerColors.PLAYERCOLOR_LIGHT_BROWN: return CreateColor(1, 0.518, 0.345, 0.075);
case PlayerColors.PLAYERCOLOR_DARK_ORANGE: return CreateColor(1, 0.878, 0.235, 0);
case PlayerColors.PLAYERCOLOR_PALE_RED: return CreateColor(1, 0.780, 0.282, 0.239);
case PlayerColors.PLAYERCOLOR_DARK_INDIGO: return CreateColor(1, 0.306, 0.020, 0.835);
case PlayerColors.PLAYERCOLOR_PALE_ORANGE: return CreateColor(1, 0.863, 0.471, 0.149);
case PlayerColors.PLAYERCOLOR_LIGHT_BLACK: return CreateColor(1, 0.251, 0.251, 0.251);
case PlayerColors.NONE:
default:
return CreateColor(1, 0, 0, 0);
}
}
