void TurnEnd(int pawnID, int progress)
{
var pawn = Pawns.Get(pawnID);
coroutines.StopAll();
if (PhotonNetwork.IsMasterClient)
{
if (pawn.CurrentElement == Grid.Last)
{
Core.Match.End(pawn);
}
else
{
PawnIndex = ClampToPlayerIndex(PawnIndex + 1);
}
}
else
{
pawn.SyncProgress(progress);
}
pawn.Land();
if (OnTurnEnd != null)
{
OnTurnEnd(pawn, progress);
}
if (PhotonNetwork.IsMasterClient)
{
photonView.RPC(nameof(TurnInitiation), RpcTarget.All, Pawns[PawnIndex].ID);
}
}
protected void DecrementJobPriority(WorkTypeDef work, bool toggle)
{
bool min = Pawns.All(p => (p.workSettings.GetPriority(work) == 0 || (p.story == null || p.story.WorkTypeIsDisabled(work))));
foreach (Pawn p in Pawns)
{
if (!(p.story == null || p.story.WorkTypeIsDisabled(work)))
{
int cur = p.workSettings.GetPriority(work);
if (!toggle && cur > 0 && cur < 4)
{
p.workSettings.SetPriority(work, cur + 1);
}
if (cur == 4 || (toggle && cur == 1))
{
p.workSettings.SetPriority(work, 0);
if (toggle)
{
SoundDefOf.CheckboxTurnedOff.PlayOneShotOnCamera();
}
}
if (min && toggle)
{
p.workSettings.SetPriority(work, 3);
SoundDefOf.CheckboxTurnedOn.PlayOneShotOnCamera();
}
}
}
}
/// <summary>
/// Gathers the player pawns from this node.
/// </summary>
/// <param name="playerIdP">The player identifier.</param>
/// <returns>the player's pawns from this node.</returns>
protected List <Pawn> GatherPlayerPawns(Int32 playerIdP)
{
List <Pawn> _playerPawns = Pawns.FindAll(_playerPawn => _playerPawn.PawnID == playerIdP);
Pawns.RemoveAll(_playerPawn => _playerPawn.PawnID == playerIdP);
return(_playerPawns);
}
protected override void BuildPawnList()
{
Pawns.Clear();
IEnumerable <Pawn> sorted;
switch (OrderBy)
{
case Order.Work:
sorted = from p in Find.ListerPawns.FreeColonists
orderby(p.story == null || p.story.WorkTypeIsDisabled(_workOrder)),
p.skills.AverageOfRelevantSkillsFor(_workOrder) descending
select p;
break;
case Order.Name:
sorted = from p in Find.ListerPawns.FreeColonists
orderby p.LabelCap ascending
select p;
break;
default:
sorted = Find.ListerPawns.FreeColonists;
break;
}
Pawns = sorted.ToList();
if (_asc && Pawns.Count > 1)
{
Pawns.Reverse();
}
}
protected void IncrementJobPriority(WorkTypeDef work, bool toggle)
{
int start = toggle ? 3 : 4;
bool max = Pawns.All(p => (p.workSettings.GetPriority(work) == 1 || (p.story == null || p.story.WorkTypeIsDisabled(work))));
foreach (Pawn t in Pawns)
{
if (!(t.story == null || t.story.WorkTypeIsDisabled(work)))
{
int cur = t.workSettings.GetPriority(work);
if (cur > 1)
{
t.workSettings.SetPriority(work, cur - 1);
}
if (cur == 0)
{
if (toggle)
{
SoundDefOf.CheckboxTurnedOn.PlayOneShotOnCamera();
}
t.workSettings.SetPriority(work, start);
}
if (toggle && max)
{
SoundDefOf.CheckboxTurnedOff.PlayOneShotOnCamera();
t.workSettings.SetPriority(work, 0);
}
}
}
}
public void Play(int i, int j)
{
if (i >= 3 || j >= 3)
{
Console.WriteLine("Illegal Move, trey again");
return;
}
if (_board[i, j] == Pawns.E && i < 3 && j < 3)
{
_board[i, j] = _turn;
}
else
{
Console.WriteLine("Spot taken, try again");
return;
}
_winner = CheckBoard();
if (_winner != Pawns.E)
{
IsGameOver = true;
return;
}
_turn = _turn == Pawns.X? Pawns.O : Pawns.X;
}
void RollRPC(int pawnID, int roll)
{
var pawn = Pawns.Get(pawnID);
if (Pawns.IsLocal(pawn))
{
Core.Dice.Interactable = false;
}
else
{
Core.Dice.Value = roll;
}
if (PhotonNetwork.IsMasterClient)
{
if (pawn != Pawns[PawnIndex])
{
Debug.LogWarning("Pawn: " + pawn.name + " Threw dice when it wasn't their turn, ignoring");
return;
}
if (InTurn)
{
Debug.LogWarning("Pawn: " + pawn.name + " Threw dice mid-turn, ignoring");
return;
}
photonView.RPC(nameof(TurnStart), RpcTarget.All, pawn.ID, pawn.Progress, roll);
}
}
private void ReplaceBoard(SaveData _data)
{
BlackPlayer.Reset();
WhitePlayer.Reset();
Pawns.Clear();
int number = 0;
foreach (var color in _data.Pawns)
{
if (color == PawnColor.Black)
{
Pawns.Add(new Pawn(BlackPlayer, number));
}
else if (color == PawnColor.White)
{
Pawns.Add(new Pawn(WhitePlayer, number));
}
else
{
Pawns.Add(new Pawn(null, number));
}
number++;
}
BlackPlayer.Time = _data.BlackTime;
WhitePlayer.Time = _data.WhiteTime;
CurrentPlayer = WhitePlayer;
if (_data.CurrentPlayer == PawnColor.Black)
{
CurrentPlayer = BlackPlayer;
}
GetLegalMove(CurrentPlayer);
UpdateScore();
}
/// <summary>
/// List pawns for current node
/// </summary>
/// <returns>List of pawn types</returns>
public List <String> ListPawns()
{
List <String> retList = new List <String>();
Pawns.ForEach(pawn => retList.Add(pawn.ToString()));
return(retList);
}
void OnCreatedRoom()
{
Network.Callbacks.Matchmaking.CreatedRoomEvent -= OnCreatedRoom;
Pawns.OnAdd += OnPlayersAdd;
Pawns.Spawn(Pawn.Player);
Pawns.Spawn(Pawn.AI);
}
public override void OnOpen()
{
base.OnOpen();
if ((specificSocialTabForPawn == null || !Pawns.Contains(specificSocialTabForPawn)) && Pawns.Any())
{
specificSocialTabForPawn = Pawns[0];
}
}
public void ResetPawns()
{
this.Pawns.Clear();
foreach (var x in Enumerable.Range(1, 3))
{
Pawns.Add(new Pawn(x, this.Color));
}
this.Steps = 0;
}
public List <Point> GetOccupiedPoints()
{
List <Point> occupiedPoints =
Actors.Select(actor => actor.Position).ToList();
occupiedPoints.AddRange(Pawns.Select(pawn => pawn.Position));
return(occupiedPoints);
}
public void AddPawn(Pawn pawn)
{
if (Pawns.Count == 3)
{
return;
}
Pawns.Add(pawn);
}
public void ClearPawns()
{
foreach (Pawn pawn in Pawns)
{
GameObject.Destroy(pawn.gameObject);
}
Pawns.Clear();
}
private void DrawCounts(Rect rect)
{
Text.Anchor = TextAnchor.UpperRight;
Text.Font = GameFont.Tiny;
GUI.color = Color.grey;
Widgets.Label(rect, "AnimalTab.XofYShown".Translate(Pawns.Count(), AllPawns.Count()));
GUI.color = Color.white;
Text.Font = GameFont.Medium;
Text.Anchor = TextAnchor.UpperLeft;
}
public bool PlaceNewPawn(Pawn pawn)
{
if (Tiles[pawn.Position.x, pawn.Position.y].Occupied() == false)
{
Pawns.Add(pawn);
Tiles[pawn.Position.x, pawn.Position.y].Pawn = pawn;
return(true);
}
return(false);
}
public void add_or_remove_piece(bool add, Piece p)
{
if (Pawns.IndexOf(p) == -1)
{
Pawns.Remove(p);
}
else
{
MajorPieces.Remove(p);
}
}
public void Initialize()
{
// filling dummy files collection
_dummies = new Pawns();
_dummies.ReadDirectory(ConstantsPR.SourceOldPath, false);
_dummies.ReadDirectory(ConstantsPR.SourceNewPath, true);
// empty both test folders
_dummies.EmptyDirectory(ConstantsPR.TestSourcePath);
_dummies.EmptyDirectory(ConstantsPR.TestTargetPath);
}
void TurnInitiation(int pawnID)
{
var pawn = Pawns.Get(pawnID);
Core.Dice.Interactable = Pawns.IsLocal(pawn);
if (OnTurnInitiation != null)
{
OnTurnInitiation(pawn);
}
}
public override void Draw(SpriteBatch spriteBatch, Matrix parentTransform)
{
Matrix globalTransform = LocalTransform * parentTransform;
Tiles.ForEach(t => t.Draw(spriteBatch, globalTransform));
Pawns.ForEach(p => p.Draw(spriteBatch, globalTransform));
IsManeuvering = false;
IsMainThrustFiring = false;
IsPortThrustFiring = false;
IsStarboardThrustFiring = false;
}
public void Initialize()
{
_dummies = new Pawns();
_dummies.ReadDirectory(ConstantsPR.SourceOldPath, false);
_dummies.ReadDirectory(ConstantsPR.SourceNewPath, true);
// empty both test folders
_dummies.EmptyDirectory(ConstantsPR.TestSourcePath);
_dummies.EmptyDirectory(ConstantsPR.TestTargetPath);
_action = new DeployAction(ConstantsPR.TestSourcePath, ConstantsPR.TestTargetPath, null, null, false);
}
void TurnStart(int pawnID, int progress, int roll)
{
var pawn = Pawns.Get(pawnID);
var target = Grid.Get(Grid[progress], roll);
coroutines.Start(Procedure(pawn, Grid[progress], target));
if (OnTurnStart != null)
{
OnTurnStart(pawn, progress, roll);
}
}
public Player(string Color)
{
this.Color = Color;
this.Pawns = new List <Pawn>()
{
};
this.Score = 0;
this.Steps = 0;
foreach (var x in Enumerable.Range(1, 3))
{
Pawns.Add(new Pawn(x, this.Color));
}
}
public void startTabChess()
{
Cor cor = Cor.Branca;
Peca peca = new Pawns(cor);
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
if (i == 7 || i == 0)
{
if (j == 0 || j == 7)
{
peca = new Rooks(cor);
}
else if (j == 1 || j == 6)
{
peca = new Horse(cor);
}
else if (j == 2 || j == 5)
{
peca = new Bishops(cor);
}
else if (j == 3)
{
peca = new Queen(cor);
}
else
{
peca = new King(cor);
}
}
else
{
peca = new Pawns(cor);
}
tabuleiro.pecas[i, j] = peca;
peca.posicao = new Position(i, j);
if (j == 7)
{
if (i == 1)
{
cor = Cor.Preta;
i = 5;
}
}
}
}
}
public override void Update(GameTime gameTime, Matrix parentTransform)
{
float deltaTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
HandleInput(deltaTime);
DetectCollisions();
// Continue rotation until turn rate reaches zero to simulate slowing
if (_currentTurnRate > 0)
{
RotateClockwise(deltaTime);
}
else if (_currentTurnRate < 0)
{
RotateCounterClockwise(deltaTime);
}
Velocity += _acceleration * deltaTime;
// Cap velocity to max velocity
if (Velocity.LengthSquared() > MaxVelocity * MaxVelocity)
{
Velocity.Normalize();
Velocity *= MaxVelocity;
}
_acceleration.X = 0;
_acceleration.Y = 0;
Position += Velocity * deltaTime;
WorldPosition = Position;
if (!IsManeuvering)
{
if (_currentTurnRate != 0)
{
SlowDownManueveringThrust();
}
}
Tiles.ForEach(t => t.Update(gameTime, LocalTransform));
Pawns.ForEach(p => p.Update(gameTime, LocalTransform));
if (MainGame.IsDebugging && MainGame.Ship == this)
{
MainGame.Instance.ShipDebugEntries["Position"] = $"{Math.Round(Position.X)}, {Math.Round(Position.Y)}";
MainGame.Instance.ShipDebugEntries["Velocity"] = $"{Math.Round(Velocity.X)}, {Math.Round(Velocity.Y)}";
MainGame.Instance.ShipDebugEntries["Heading"] = $"{Math.Round(Heading, 2)}";
MainGame.Instance.ShipDebugEntries["Velocity Heading"] = $"{Math.Round(Velocity.ToAngle(), 2)}";
MainGame.Instance.ShipDebugEntries["World Tile"] = $"{Math.Floor(Position.X / MainGame.WorldTileSize)}, {Math.Floor(Position.Y / MainGame.WorldTileSize)}";
MainGame.Instance.ShipDebugEntries["Current Turn Rate"] = $"{Math.Round(_currentTurnRate, 2)}";
}
}
//Przemieszczenie piona
private void MovePawns(int x, int y)
{
if (allowedMoves[x, y])
{
Pawns[selectedPawns.CurentX, selectedPawns.CurentY] = null;
selectedPawns.transform.position = GetTitleCenter(x, y);
selectedPawns.SetPosition(x, y);
Pawns[x, y] = selectedPawns;
isWhiteTure = !isWhiteTure;
StartTime = Time.time;
}
BoardSquareLights.Instance.HidenSquareLights();
selectedPawns = null;
}
//Wybranie danego piona
private void SelectPawns(int x, int y)
{
if (Pawns[x, y] == null)
{
return;
}
if (Pawns[x, y].isWhite != isWhiteTure)
{
return;
}
allowedMoves = Pawns[x, y].PosibleMove();
selectedPawns = Pawns[x, y];
BoardSquareLights.Instance.SquareLightAllowedMoves(allowedMoves);
}
IEnumerator Start()
{
yield return(new WaitForEndOfFrame());
Network.Init();
Grid.Init();
Pawns.Init();
Turns.Init();
Match.Init();
Menu.Init();
Mode.Init();
PhotonNetwork.GameVersion = Application.version;
}
public Player(string name, ColorType color)
{
this.Name = name;
this.Color = color;
this.PawnsAtHome = PlayerConstants.InitPawnsAtHome;
this.PawnsEscaped = PlayerConstants.InitPawnsEscaped;
this.StepsLeft = 0;
this.Home = new Home(color);
this.Pawns = new List <Pawn>();
for (int i = 0; i < PlayerConstants.PawnsPerPlayer; i++)
{
Pawns.Add(new Pawn(Color, i));
}
}
private static Boolean KawigiEdit_RunTest(int testNum, string[] p0, Boolean hasAnswer, int p1)
{
Console.Write("Test " + testNum + ": [" + "{");
for (int i = 0; p0.Length > i; ++i) {
if (i > 0) {
Console.Write(",");
}
Console.Write("\"" + p0[i] + "\"");
}
Console.Write("}");
Console.WriteLine("]");
Pawns obj;
int answer;
obj = new Pawns();
DateTime startTime = DateTime.Now;
answer = obj.pawnsAttack(p0);
DateTime endTime = DateTime.Now;
Boolean res;
res = true;
Console.WriteLine("Time: " + (endTime - startTime).TotalSeconds + " seconds");
if (hasAnswer) {
Console.WriteLine("Desired answer:");
Console.WriteLine("\t" + p1);
}
Console.WriteLine("Your answer:");
Console.WriteLine("\t" + answer);
if (hasAnswer) {
res = answer == p1;
}
if (!res) {
Console.WriteLine("DOESN'T MATCH!!!!");
} else if ((endTime - startTime).TotalSeconds >= 2) {
Console.WriteLine("FAIL the timeout");
res = false;
} else if (hasAnswer) {
Console.WriteLine("Match :-)");
} else {
Console.WriteLine("OK, but is it right?");
}
Console.WriteLine("");
return res;
}
