public async Task <IActionResult> Edit(int id, [Bind("PositionID,PositionDescription")] PlayerPositions playerPositions)
{
if (id != playerPositions.PositionID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(playerPositions);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PlayerPositionsExists(playerPositions.PositionID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(playerPositions));
}
public void ChangeRounds()
{
preRoundTime = 3;
gameTime = 60;
breakTime = 10;
trainTime = 15;
if (isRoundStart)
{
PlayerPositions playerPos = GetComponent <PlayerPositions>();
playerPos.ResetFightPosition();
preRound = true;
gameUI.alpha = 1;
breakUI.alpha = 0;
trainUI.alpha = 0;
}
if (isBreakStart)
{
gameUI.alpha = 0;
trainUI.alpha = 0;
}
if (isTrainingStart)
{
gameUI.alpha = 0;
breakUI.alpha = 0;
trainUI.alpha = 1;
}
}
public void UpdatePlayerPosition(IPlayer player)
{
var newList = PlayerPositions.Where(x => x.Id != player.Id).ToList();
newList.Add(player);
PlayerPositions = newList;
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// Window initilization
Window.AllowUserResizing = false;
Window.Title = "S******d";
// Device manager initilization
deviceManager.IsFullScreen = false;
deviceManager.PreferredBackBufferHeight = 768;
deviceManager.PreferredBackBufferWidth = 1024;
deviceManager.ApplyChanges();
// Game initilization
Configuration.Init(this.Content);
GameCursor.Init();
GameCursor.CustomMouse = true;
Deck.Init();
Button.Init(GraphicsDevice);
TextField.Init(GraphicsDevice);
PlayerPositions.Init(GraphicsDevice);
// Screen initilization
Screens.ScreenManager.AddScreen(new Menu(GraphicsDevice));
Screens.ScreenManager.AddScreen(new GameBoard(GraphicsDevice));
Screens.ScreenManager.AddScreen(new SetupLocal(GraphicsDevice));
Screens.ScreenManager.AddScreen(new SetupMultiplayer(GraphicsDevice));
Screens.ScreenManager.GotoScreen("menu");
this.TargetElapsedTime = TimeSpan.FromSeconds(1.0f / FPS);
base.Initialize();
}
public Player(byte pSpeed, byte pPrecision, byte pDuel, PlayerPositions pPosition)
{
Name = GetRandomName();
Speed = pSpeed;
Precision = pPrecision;
Duel = pDuel;
Position = pPosition;
}
public Player(string pName, byte pSpeed, byte pPrecision, byte pDuel, PlayerPositions pPosition)
{
Name = pName;
Speed = pSpeed;
Precision = pPrecision;
Duel = pDuel;
Position = pPosition;
}
public AvailablePlayerAction(PlayerActions playerAction, PlayerPositions currentPosition, PlayerPositions playerPosition, Tile actionOnTile, IEnumerable <Meld> melds)
{
PlayerAction = playerAction;
CurrentPosition = currentPosition;
PlayerPosition = playerPosition;
ActionOnTile = actionOnTile;
Melds = melds;
Priority = GetPriority();
}
public static int GetBetween(this PlayerPositions playerPosition, PlayerPositions currentPlayerPosition)
{
var between = (int)playerPosition - (int)currentPlayerPosition;
if (between < 0)
{
between += 4;
}
return(between);
}
public async Task <IActionResult> Create([Bind("PositionID,PositionDescription")] PlayerPositions playerPositions)
{
if (ModelState.IsValid)
{
_context.Add(playerPositions);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(playerPositions));
}
public HistoryMove MoveCheckerToNewPlace(int currentCol
, int currentRow
, int nextCol
, int nextRow
, bool convertBackToChecker = false)
{
CheckerModel checker = PlayerPositions.Single(x => x.Column == currentCol && x.Row == currentRow);
IEnumerable <LinkedList <CheckerModel> > availablePaths = CalculateAvailablePaths();
LinkedList <CheckerModel> path = availablePaths.Where(x => x.Last.Value.Column == nextCol && x.Last.Value.Row == nextRow).OrderByDescending(x => x.Count).FirstOrDefault();
bool isConvertedToQueen = false;
if (ShouldConvertToQueenByPathDuringTaking(path))
{
checker.BecomeAQueen();
isConvertedToQueen = true;
}
CheckerModel newPosition = _dataProvider.GetElementAtPosition(nextCol, nextRow);
CheckerModel oldPositionedChecker = _dataProvider.GetElementAtPosition(currentCol, currentRow);
if (convertBackToChecker)
{
oldPositionedChecker.DowngradeToChecker();
}
if (_pathCalculator.IsMoveToucheBoard(newPosition))
{
oldPositionedChecker.BecomeAQueen();
isConvertedToQueen = true;
}
_dataProvider.StartTrackChanges();
List <CheckerModel> itemsToTake = GetToTakeCheckers(availablePaths, nextCol, nextRow, checker);
var historyMove = new HistoryMove(isConvertedToQueen);
foreach (CheckerModel checkerElement in itemsToTake)
{
var element = new CheckerModel(checkerElement.Column, checkerElement.Row, PieceType.Checker, Side.Empty);
historyMove.DeletedList.Add(new KeyValuePair <CheckerModel, CheckerModel>(checkerElement.Clone(), element.Clone()));
_dataProvider.MoveCheckerToNewPosition(element, checkerElement.Column, checkerElement.Row);
}
historyMove.MovedFromTo = new KeyValuePair <CheckerModel, CheckerModel>(oldPositionedChecker.Clone(), newPosition.Clone());
_dataProvider.MoveCheckerToNewPosition(oldPositionedChecker, nextCol, nextRow);
_dataProvider.StopTrackChanges();
return(historyMove);
}
public static PlayerPositions GetNextPosition(this PlayerPositions positions)
{
switch (positions)
{
case PlayerPositions.East:
return(PlayerPositions.North);
case PlayerPositions.North:
return(PlayerPositions.West);
case PlayerPositions.West:
return(PlayerPositions.South);
case PlayerPositions.South:
return(PlayerPositions.East);
default:
throw new Exception("PlayerPosition not found");
}
}
public void Join(Player player)
{
if (!IsBusy)
{
if (Players.Count < 4)
{
foreach (PlayerPositions direction in Enum.GetValues(typeof(PlayerPositions)))
{
if (Players.All(q => q.PlayerPosition != direction))
{
player.SetDirection(direction);
if (Players.Count == 0)
{
player.IsDealer = true;
_currentPlayerPosition = direction;
}
Players.Add(player);
player.PlayerWinable += PlayerOnPlayerWinable;
player.PlayerActionable += PlayerOnPlayerActionable;
player.PlayerInitalWin += PlayerOnPlayerInitalWin;
player.PlayerAction += PlayerOnPlayerAction;
break;
}
}
}
if (Players.Count == 4)
{
IsBusy = true;
Reset();
if (GameStarted != null)
{
GameStarted(this, null);
}
}
}
}
private void NotificationFromDataAdapter(List <CheckerModel> added, List <CheckerModel> deleted, List <CheckerModel> modified)
{
var addedForPlayer = new List <CheckerModel>();
foreach (var addedModel in added.Where(x => x.Side == Side))
{
PlayerPositions.Add(addedModel);
addedForPlayer.Add(addedModel);
}
var deletedFromForPlayer = new List <CheckerModel>();
foreach (var deletedModel in deleted.Where(x => x.Side == Side))
{
CheckerModel toRemove = PlayerPositions.Single(x => x.Column == deletedModel.Column && x.Row == deletedModel.Row);
PlayerPositions.Remove(toRemove);
deletedFromForPlayer.Add(toRemove);
}
modified = modified.Where(x => x.Side == Side).ToList();
NotificationAction?.Invoke(addedForPlayer, deletedFromForPlayer, modified);
}
public PlayerPositions InsertPlayerPosition(PlayerPositions playerPosition)
{
return(_servicePlayerPosition.Insert(playerPosition));
}
public void AddPlayerPosition(IPlayer player)
{
PlayerPositions.Add(player);
}
public void Clear()
{
PlayerPositions.Clear();
Hits.Clear();
Hearts.Clear();
}
public int GetPossibleMovementsCount()
{
return(PlayerPositions.Sum(position => position.PossibleMovementElements.Count));
}
public int GetQueensCount()
{
int counter = PlayerPositions.Count(playerPosition => playerPosition.Type == PieceType.Queen);
return(counter);
}
private Player GetPlayer(PlayerPositions position)
{
return(Players.FirstOrDefault(q => q.PlayerPosition == position));
}
public int GetSimpleCheckersCount()
{
int counter = PlayerPositions.Count(playerPosition => playerPosition.Type == PieceType.Checker);
return(counter);
}
public void SetDirection(PlayerPositions positions)
{
PlayerPosition = positions;
}
