/// <summary> Called when requested for trade player danied request. </summary>
static internal void ReceiveTradeReqDenial(PlayerInGame requestedTradePIG)
{
GameObject info = Instantiate(singleton.info);
info.GetComponent <Info>().Initialize(requestedTradePIG.nickName + " refused to trade!");
ReceiveInfo(info);
}
internal override IEnumerator EffectOnUse()
{
PlayerInGame fightingPlayer = gameManager.playersObjects[gameManager.activePlayerIndex].GetComponent <PlayerInGame>();
//Debug.Log("Monster in fight: " + this.gameObject);
if (CustomNetManager.singleton.isServerBusy)
{
yield return(new WaitUntil(() => !CustomNetManager.singleton.isServerBusy));
}
CustomNetManager.singleton.isServerBusy = true;
gameManager.fightInProggres = true;
gameManager.fightingPlayerNetId = fightingPlayer.netId;
gameManager.ServerUpdateFightingPlayersLevel();
gameManager.fightingMonstersLevel = ((MonsterValue)cardValues).level;
gameManager.readyPlayers = 0;
yield return(new WaitForEndOfFrame());
RpcInitiateFight();
yield return(new WaitForEndOfFrame());
CustomNetManager.singleton.isServerBusy = false;
yield return(ServerActivateCard());
}
public ActionResult CancelCollectingGems(int id, int playerInGameId)
{
Game game = db.Games.Find(id);
if (game == null)
{
return(HttpNotFound());
}
PlayerInGame playerInGame = db.PlayerInGames.Find(playerInGameId);
PlayerInGame tableInGame = game.TableInGame;
db.Logs.Add(new Log(User.Identity.Name, Log.System, id, String.Format("Player cancel collecting gems in game {0}.", game.Name)));
tableInGame.ResourceGreen += playerInGame.TakeGreen;
playerInGame.TakeGreen = 0;
tableInGame.ResourceWhite += playerInGame.TakeWhite;
playerInGame.TakeWhite = 0;
tableInGame.ResourceBlue += playerInGame.TakeBlue;
playerInGame.TakeBlue = 0;
tableInGame.ResourceBlack += playerInGame.TakeBlack;
playerInGame.TakeBlack = 0;
tableInGame.ResourceRed += playerInGame.TakeRed;
playerInGame.TakeRed = 0;
db.SaveChanges();
return(RedirectToAction("Details", new { id = id }));
}
public ActionResult TakeCollectedGems(int id, int playerInGameId)
{
Game game = db.Games.Find(id);
if (game == null)
{
return(HttpNotFound());
}
PlayerInGame playerInGame = db.PlayerInGames.Find(playerInGameId);
db.Logs.Add(new Log(User.Identity.Name, Log.GameLog, id, String.Format("Player {0} has taken {1} green, {2} white, {3} blue, {4} black, {5} red gems in game {6}.", playerInGame.Name, playerInGame.TakeGreen, playerInGame.TakeWhite, playerInGame.TakeBlue, playerInGame.TakeBlack, playerInGame.TakeRed, game.Name)));
playerInGame.ResourceGreen += playerInGame.TakeGreen;
playerInGame.TakeGreen = 0;
playerInGame.ResourceWhite += playerInGame.TakeWhite;
playerInGame.TakeWhite = 0;
playerInGame.ResourceBlue += playerInGame.TakeBlue;
playerInGame.TakeBlue = 0;
playerInGame.ResourceBlack += playerInGame.TakeBlack;
playerInGame.TakeBlack = 0;
playerInGame.ResourceRed += playerInGame.TakeRed;
playerInGame.TakeRed = 0;
db.SaveChanges();
SetNextPlayer(playerInGameId);
return(RedirectToAction("Details", new { id = id }));
}
private void ReserveCard(CardInGame cardInGame, PlayerInGame playerInGame)
{
TransferGem(cardInGame.PlayerInGame, playerInGame, 1, Gem.gold);
cardInGame.PlayerInGameId = playerInGame.Id;
cardInGame.IsOnTable = false;
db.SaveChanges();
}
internal override IEnumerator EffectOnUse()
{
yield return(base.EffectOnUse());
PlayerInGame player = ClientScene.FindLocalObject(targetNetId).GetComponent <PlayerInGame>(); // Finding player locally via theirs "NetworkInstanceId"
if (CustomNetManager.singleton.isServerBusy)
{
yield return(new WaitUntil(() => !CustomNetManager.singleton.isServerBusy));
}
CustomNetManager.singleton.isServerBusy = true;
EqItemSlot eqSlot = player.equipment.GetChild((int)(cardValues as EquipmentValue).eqPart).GetComponentInChildren <EqItemSlot>();
if (eqSlot.heldItem != null)
{
RpcSwitchEq(targetNetId);
}
else
{
RpcEquip(targetNetId);
}
yield return(new WaitUntil(() => player.equippedItems.Contains(this.gameObject)));
yield return(new WaitForEndOfFrame());
ServerOnEquip();
yield return(new WaitForEndOfFrame());
gameManager.ServerUpdateFightingPlayersLevel();
CustomNetManager.singleton.isServerBusy = false;
}
void RpcEquip(NetworkInstanceId targetNetId)
{
PlayerInGame player = ClientScene.FindLocalObject(targetNetId).GetComponent <PlayerInGame>(); // Finding player locally via its "NetworkInstanceId"
player.ClientEquip(this.gameObject);
gameManager.cardsUsageQueue.Remove(gameObject);
}
void ServerGetExcited()
{
PlayerInGame fightingPlayer = ClientScene.FindLocalObject(targetNetId).GetComponent <PlayerInGame>();
cardValues.level = 5;
foreach (var item in fightingPlayer.equippedItems)
{
if (item.GetComponent <EquipmentCard>().cardValues.name.Contains("Glass"))
{
(cardValues as MonsterValue).treasuresCount += 1;
cardValues.level += 5;
}
}
if (gameManager.helpingPlayerNetId != NetworkInstanceId.Invalid)
{
fightingPlayer = ClientScene.FindLocalObject(gameManager.helpingPlayerNetId).GetComponent <PlayerInGame>();
foreach (var item in fightingPlayer.equippedItems)
{
if (item.GetComponent <EquipmentCard>().cardValues.name.Contains("Glass"))
{
(cardValues as MonsterValue).treasuresCount += 1;
cardValues.level += 5;
}
}
}
}
static void ReceivePlayer(PlayerInGame playerScript)
{
GameObject playerStats = Instantiate(playerScript.opponentStatsUIPrefab);
GameManager.singleton.StartCoroutine(playerStats.GetComponent <PlayerStats>().Initialize(playerScript));
ReceiveObjectToChoose(playerStats);
}
public ActionResult DeleteConfirmed(int id)
{
PlayerInGame playerInGame = db.PlayerInGames.Find(id);
db.PlayerInGames.Remove(playerInGame);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public IActionResult JoinGame(string gameId, string playerId, string password)
{
var game = _context.Games.Include(x => x.Host).SingleOrDefault(x => x.Id == gameId);
if (game == null)
{
return(NotFound("Game not found / wrong game Id"));
}
var player = _context.Players.Find(playerId);
if (player == null)
{
return(NotFound("Player not found / wrong player Id"));
}
var playerInGame = _context.PlayersInGame.Include(x => x.Game).Include(x => x.Player)
.Where(x => x.GameId == gameId).Any(x => x.PlayerId == playerId);
if (playerInGame)
{
return(Ok("You are already in the game"));
}
if (password != game.Password)
{
return(BadRequest("Wrong password, try again!"));
}
var playerJoin = new PlayerInGame {
PlayerId = player.Id, Game = game, Player = player, JoinTime = DateTime.Now
};
_context.Add(playerJoin);
_context.SaveChanges();
var playerData = _context.PlayersData.Include(x => x.Player).SingleOrDefault(x => x.PlayerId == playerId);
if (playerData == null)
{
playerData = new PlayerData {
PlayerId = playerId, Player = player, CurrentState = EnumList.State.START_ON_HOLD, TimeStamp = DateTime.Now
};
_context.Add(playerData);
_context.SaveChanges();
}
else
{
playerData.CurrentState = _context.PlayersData.Include(x => x.Player).SingleOrDefault(x => x.PlayerId == game.HostId)
.CurrentState == EnumList.State.START_ON_HOLD ? EnumList.State.START_ON_HOLD : EnumList.State.AROUND;
_context.Update(playerData);
_context.SaveChanges();
}
return(Ok("Game Joined -- you will be on hold while the other players join"));
}
private void SetFirstKilled(PlayerInGame p)
{
if (p.Game.FirstKilled != null)
{
p.Game.FirstKilled.Player.PriorityPoints += 0.5;
}
p.Game.FirstKilled = p;
p.Game.FirstKilled.Player.PriorityPoints -= 0.5;
}
private List <Card> cardToInstante = new List <Card>(); // pile with the 52 cards
// Use this for initialization
void Start()
{
playersInGame = new List <PlayerInGame>();
PlayerInGame casinoPlayer = new PlayerInGame("Dealer", 0, -1, false);
playersInGame.Add(casinoPlayer);
initialCardsToDeal = new List <GameObject>();
currentCard = 0;
extraCardRequest = false;
}
public void OnDrop(PointerEventData eventData)
{
Draggable draggable = eventData.pointerDrag.GetComponent <Draggable>();
if (draggable != null)
{
Draggable.FreePlaceholder();
PlayerInGame.SellCard(eventData.pointerDrag.gameObject);
}
}
// Use this for initialization
void Start()
{
obj = GameObject.Find("PlayerVal").GetComponent <PlayerInGame>();
controllers = FindObjectOfType <ControllerPoll>();
for (int i = 0; i < 4; i++)
{
selectSprites[i] = GameObject.Find("Player" + (i + 1) + "Select").GetComponent <SpriteRenderer>();
unselectSprites[i] = GameObject.Find("Player" + (i + 1) + "Unselect").GetComponent <SpriteRenderer>();
}
}
public void CreatePlayerInGame(Player player, Game game, int score)
{
try
{
PlayerInGame playerInGame = new PlayerInGame(player, game, score);
ec.PlayersInGame.Add(playerInGame);
ec.SaveChanges();
}
catch
{
}
}
public PlayerInGame GetPlayerInGame(Player player, Game game)
{
try
{
PlayerInGame pig = ec.PlayersInGame.Find(player, game);
return(pig);
}
catch
{
return(null);
}
}
public ActionResult Edit([Bind(Include = "Id,ResourceGreen,ResourceWhite,ResourceBlue,ResourceBlack,ResourceRed,ResourceGold,IsWiner,GameId,PlayerId")] PlayerInGame playerInGame)
{
if (ModelState.IsValid)
{
db.Entry(playerInGame).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.GameId = new SelectList(db.Games, "Id", "Name", playerInGame.GameId);
ViewBag.PlayerId = new SelectList(db.Players, "Id", "UserName", playerInGame.PlayerId);
return(View(playerInGame));
}
internal static void ReceiveFightingPlayersToChoose()
{
PlayerInGame fightingplayer = ClientScene.FindLocalObject(GameManager.singleton.fightingPlayerNetId).GetComponent <PlayerInGame>();
ReceivePlayer(fightingplayer);
if (GameManager.singleton.helpingPlayerNetId != NetworkInstanceId.Invalid)
{
fightingplayer = ClientScene.FindLocalObject(GameManager.singleton.helpingPlayerNetId).GetComponent <PlayerInGame>();
ReceivePlayer(fightingplayer);
}
}
internal override void UseCard()
{
PlayerInGame localPlayer = PlayerInGame.localPlayerInGame;
// If target can be chosen
if (choosable)
{
//Debug.Log("Putting choosable card on table");
transform.SetParent(localPlayer.handContent);
// Storing card to use it upon choosing target
localPlayer.storedObject = this.gameObject;
switch (target)
{
case Target.Player:
ChoicePanel.PrepareToReceiveObjects(ChoicePanelTitle.ChoosePlayerTarget);
ChoicePanel.ReceivePlayersToChoose();
break;
case Target.Monster:
if (TableDropZone.singleton.transform.GetComponentsInChildren <MonsterCard>().Length > 1) // If there are multiple monsters in battle
{
ChoicePanel.PrepareToReceiveObjects(ChoicePanelTitle.ChooseMonsterToBuff);
foreach (var monster in TableDropZone.singleton.transform.GetComponent <TableDropZone>().BorrowMonsterCards())
{
ChoicePanel.ReceiveObjectToChoose(monster); // Create placeholders of monsters on table and send monsters to choice panel
}
}
else
{
localPlayer.UseStoredCardOnTarget(gameManager.fightingMonsters[0].GetComponent <Card>().GetNetId()); // Apply Buff to only Monster in battle
}
break;
case Target.Any:
ChoicePanel.PrepareToReceiveObjects(ChoicePanelTitle.ChooseFightingTarget);
foreach (var monster in TableDropZone.singleton.transform.GetComponent <TableDropZone>().BorrowMonsterCards())
{
ChoicePanel.ReceiveObjectToChoose(monster);
}
ChoicePanel.ReceiveFightingPlayersToChoose();
break;
default:
break;
}
}
else
{
localPlayer.UseCardOnLocalPlayer(this.netId);
}
}
private PlayerInGame GetCurrentPlayer(int player)
{
PlayerInGame tmp = new PlayerInGame();
foreach (PlayerInGame tmpPlayer in playersInGame)
{
if (tmpPlayer.PlayerPosition == player)
{
tmp = tmpPlayer;
}
}
return(tmp);
}
internal override IEnumerator EffectOnUse()
{
yield return(base.EffectOnUse());
if (gameManager.fightInProggres)
{
gameManager.ServerEndFight(false);
}
else
{
yield return(PlayerInGame.ServerDiscardCard(this.netId));
}
}
public ActionResult TakeGem(int id, int gemId, int playerInGameId)
{
Game game = db.Games.Find(id);
if (game == null)
{
return(HttpNotFound());
}
PlayerInGame playerInGame = db.PlayerInGames.Find(playerInGameId);
PlayerInGame tableInGame = game.TableInGame;
if (playerInGame.CanCollect(gemId))
{
switch (gemId)
{
case Gem.green:
++playerInGame.TakeGreen;
--tableInGame.ResourceGreen;
break;
case Gem.white:
++playerInGame.TakeWhite;
--tableInGame.ResourceWhite;
break;
case Gem.blue:
++playerInGame.TakeBlue;
--tableInGame.ResourceBlue;
break;
case Gem.black:
++playerInGame.TakeBlack;
--tableInGame.ResourceBlack;
break;
case Gem.red:
++playerInGame.TakeRed;
--tableInGame.ResourceRed;
break;
}
db.Logs.Add(new Log(User.Identity.Name, Log.System, id, String.Format("Player {0} has collected gem {1} in game {2}.", playerInGame.Name, gemId, game.Name)));
}
else
{
db.Logs.Add(new Log(User.Identity.Name, Log.Warning, id, String.Format("Player {0} cannot take more gem {1} in game.", playerInGame.Name, gemId, game.Name)));
}
db.SaveChanges();
return(RedirectToAction("Details", new { id = id }));
}
// GET: PlayerInGames/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
PlayerInGame playerInGame = db.PlayerInGames.Find(id);
if (playerInGame == null)
{
return(HttpNotFound());
}
return(View(playerInGame));
}
/// <summary>
/// Function transfer @amount gems from @fromPlayerInGame to @toPlayerInGame.
/// </summary>
/// <param name="fromPlayerInGame"></param>
/// <param name="toPlayerInGame"></param>
/// <param name="amount"></param>
/// <param name="gemId"></param>
/// <returns>
/// Returns number of gems which have not been tranfered, because @fromPlayerInGame has not enough gems.
/// In other words. Returns the difference between @amount to transfer and transferred amount in fact.
/// </returns>
private int TransferGem(PlayerInGame fromPlayerInGame, PlayerInGame toPlayerInGame, int amount, int gemId)
{
if (amount <= 0)
{
return(0);
}
int transferAmount = 0;
switch (gemId)
{
case Gem.green:
transferAmount = Math.Min(amount, fromPlayerInGame.ResourceGreen);
fromPlayerInGame.ResourceGreen -= transferAmount;
toPlayerInGame.ResourceGreen += transferAmount;
break;
case Gem.white:
transferAmount = Math.Min(amount, fromPlayerInGame.ResourceWhite);
fromPlayerInGame.ResourceWhite -= transferAmount;
toPlayerInGame.ResourceWhite += transferAmount;
break;
case Gem.blue:
transferAmount = Math.Min(amount, fromPlayerInGame.ResourceBlue);
fromPlayerInGame.ResourceBlue -= transferAmount;
toPlayerInGame.ResourceBlue += transferAmount;
break;
case Gem.black:
transferAmount = Math.Min(amount, fromPlayerInGame.ResourceBlack);
fromPlayerInGame.ResourceBlack -= transferAmount;
toPlayerInGame.ResourceBlack += transferAmount;
break;
case Gem.red:
transferAmount = Math.Min(amount, fromPlayerInGame.ResourceRed);
fromPlayerInGame.ResourceRed -= transferAmount;
toPlayerInGame.ResourceRed += transferAmount;
break;
case Gem.gold:
transferAmount = Math.Min(amount, fromPlayerInGame.ResourceGold);
fromPlayerInGame.ResourceGold -= transferAmount;
toPlayerInGame.ResourceGold += transferAmount;
break;
}
db.Logs.Add(new Log(User.Identity.Name, Log.System, toPlayerInGame.GameId, String.Format("{0} gems {1} has been transferred from {2} to {3} in game {4}.", transferAmount, gemId, fromPlayerInGame.Name, toPlayerInGame.Name, fromPlayerInGame.Game.Name)));
db.SaveChanges();
return(amount - transferAmount);
}
public ActionResult ChangeReserving(int id)
{
Game game = db.Games.Find(id);
if (game == null)
{
return(HttpNotFound());
}
PlayerInGame currentPlayer = GetCurrentPlayerInGame(id);
currentPlayer.IsReserving = !currentPlayer.IsReserving;
db.SaveChanges();
db.Logs.Add(new Log(User.Identity.Name, Log.System, id, String.Format("Player {0} wants to {1} cards in game {2}.", currentPlayer.Name, currentPlayer.IsReserving ? "reserve" : "buy", game.Name)));
return(RedirectToAction("Details", new { id = id }));
}
// GET: PlayerInGames/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
PlayerInGame playerInGame = db.PlayerInGames.Find(id);
if (playerInGame == null)
{
return(HttpNotFound());
}
ViewBag.GameId = new SelectList(db.Games, "Id", "Name", playerInGame.GameId);
ViewBag.PlayerId = new SelectList(db.Players, "Id", "UserName", playerInGame.PlayerId);
return(View(playerInGame));
}
/// <summary> Called when players gets Trade Request. </summary>
static internal void ReceiveTradeRequestInfo(PlayerInGame requestingTradePIG)
{
// Preventing creation of duplicate requests from same player.
foreach (InfoTradeRequest tradeRequest in infoPanelContent.GetComponentsInChildren <InfoTradeRequest>())
{
if (tradeRequest.RequestingTradePIG == requestingTradePIG)
{
return;
}
}
GameObject infoTR = Instantiate(singleton.infoTradeRequest);
infoTR.GetComponent <InfoTradeRequest>().Initialize(requestingTradePIG);
ReceiveInfo(infoTR);
}
static internal IEnumerator ReceiveServicedCard(GameObject card, NetworkInstanceId ownerNetId, NetworkInstanceId targetNetId)
{
//Debug.Log("targetNetId - " + targetNetId);
card.GetComponent <Draggable>().ClientSlide(cardServicePlaceholder);
// Check if card has a target
if (targetNetId != NetworkInstanceId.Invalid)
{
GameObject targetGO = ClientScene.FindLocalObject(targetNetId);
MonoBehaviour targetScript = null;
// Check if target is player or monster
if (targetScript = targetGO.GetComponent <MonsterCard>())
{
cardTargetObject = Instantiate(targetGO, cardTargetPlaceholder);
//Debug.Log("cardTargetObject - " + cardTargetObject);
yield return(new WaitForEndOfFrame());
(cardTargetObject.transform as RectTransform).localPosition = Vector3.zero;
}
else if (targetScript = targetGO.GetComponent <PlayerInGame>())
{
cardTargetObject = Instantiate((targetScript as PlayerInGame).opponentStatsUIPrefab);
singleton.StartCoroutine(
cardTargetObject.GetComponent <PlayerStats>()
.Initialize(targetScript as PlayerInGame));
cardTargetObject.transform.SetParent(cardTargetPlaceholder, false);
}
}
else
{
cardTargetObject = Instantiate(singleton.cardNoTargetObject);
cardTargetObject.transform.SetParent(cardTargetPlaceholder, false);
}
// Get Owner object, copy its Stats UI and place it in Onwer Placeholder
cardOwnerObject = ClientScene.FindLocalObject(ownerNetId);
PlayerInGame ownerScript = cardOwnerObject.GetComponent <PlayerInGame>();
cardOwnerObject = Instantiate(ownerScript.opponentStatsUIPrefab);
singleton.StartCoroutine(cardOwnerObject.GetComponent <PlayerStats>().Initialize(ownerScript));
cardOwnerObject.transform.SetParent(cardOnwersPlaceholder, false);
yield return(null);
}
/// <summary> Checking if player can start a fight. </summary>
internal override void UseCard()
{
PlayerInGame localPlayer = PlayerInGame.localPlayerInGame;
if (gameManager.turnPhase != TurnPhase.Search || gameManager.fightInProggres || !localPlayer.hasTurn || gameManager.foughtInThisRound)
{
InfoPanel.AlertCannotUseCard();
// Return card to hand
StartCoroutine(
GetComponent <Draggable>()
.ClientSlideWithNewPlaceholder(PlayerInGame.localPlayerInGame.handContent)
);
return;
}
localPlayer.UseCardOnLocalPlayer(this.netId);
}
private void SaveplayerInGame( List<Player> playersList , ListView listviewTeam , string checkBoxName1 , string checkBoxName2 , string checkBoxName3 , Game game )
{
Dictionary<string , string> plInGameDict;
List<CheckBox> bestPlayer;
List<CheckBox> yellowCard;
List<CheckBox> redCard;
plInGameDict = new Dictionary<string , string>();
bestPlayer = GetSpecifiedCheckBoxes( listviewTeam , checkBoxName1 );
yellowCard = GetSpecifiedCheckBoxes( listviewTeam , checkBoxName2 );
redCard = GetSpecifiedCheckBoxes( listviewTeam , checkBoxName3 );
for ( int i = 0 ; i < playersList.Count ; i++ )
{
var plInGame = new PlayerInGame( playersList[ i ] , bestPlayer[ i ].IsChecked.Value , yellowCard[ i ].IsChecked.Value , redCard[ i ].IsChecked.Value , game );
plInGameDict = plInGame.ConvertInstanceToDictionary();
client.Insert( plInGameDict , Middleware.VolleyballService.TablesNames.PlayerInGames );
}
}
