public static bool FkeyHasChanged(SchemaChanges changes, SubObjectState <FkeyType, FkeyType.State> current)
{
if (current == null)
{
return(true);
}
var desired = changes.Desired.Get(current);
// The foreign key doesn't exist in the desired schema at all
if (desired == null)
{
return(true);
}
// The destination table has changed
if (desired.State.ToTable != current.State.ToTable)
{
return(true);
}
// Either the from or to table might need to be dropped entirely to reorder fields
if (FieldType.IsFieldReorderPossiblyNeeded(changes, current.ParentIdentifier) ||
FieldType.IsFieldReorderPossiblyNeeded(changes, current.State.ToTable))
{
return(true);
}
// It's changed from cascading to not or vice versa
if (desired.State.IsCascadeDelete != current.State.IsCascadeDelete)
{
return(true);
}
// The sequence of field name pairs don't match
if (!Enumerable.SequenceEqual(desired.State.Joins, current.State.Joins, FieldPair.GetComparer(changes.DbDriver)))
{
return(true);
}
// Any of the fields in either table are changing
if (current.State.Joins.Any(field =>
FieldType.FieldHasChanged(changes, current.ParentIdentifier, FieldType.Identifier(field.FromFieldName)) ||
FieldType.FieldHasChanged(changes, current.State.ToTable, FieldType.Identifier(field.ToFieldName))))
{
return(true);
}
// The unique index on the destination table that corresponds to the destination fields is changing
var ukey = UniqueIndexType.ChildrenFrom(changes.Current, current.State.ToTable)
.SingleOrDefault(key => new HashSet <Identifier>(key.State.IndexState.Fields).SetEquals(from field in current.State.Joins
select FieldType.Identifier(field.ToFieldName)));
if (ukey != null && UniqueIndexType.IndexHasChanged(changes, ukey))
{
return(true);
}
return(false);
}
public void ReturnToHand()
{
Debug.Log("deselecting defend card" + card);
transform.SetParent(originalCardHolder);
//Debug.Log(1);
transform.position = originalCardHolder.position;
//Debug.Log(2);
GameManager.gm.defendCards.Remove(fp);
//Debug.Log(3);
fp.defend = null;
fp = null;
GameManager.gm.UpdateActionButtons();
//Debug.Log(40);
}
public bool CanDefend(FieldPair fp, Card def)
{
if (phase != 1 || fp.defend != null)
{
return(false);
}
Card atk = fp.attack;
if (atk.Equals(trump))
{
return(false);
}
if (def.Equals(trump))
{
return(true);
}
if (atk.cardValue == trump.cardValue)
{
return(false);
}
if (atk.cardSuit == trump.cardSuit)
{
if (def.EqualValue(trump))
{
return(true);
}
if (def.cardSuit == trump.cardSuit)
{
return(def.Difference(atk) > 0);
}
return(false);
}
if (def.cardSuit == trump.cardSuit || def.cardValue == trump.cardValue)
{
return(true);
}
return(atk.cardSuit == def.cardSuit && def.Difference(atk) > 0);
}
public void OnPointerUp(PointerEventData eventData)
{
if (played)
{
return;
}
clicked = !scrolling && !dragged;
//Debug.Log("UP" + dragged + " " + scrolling + " " + clicked);
if (inHand)
{
hand.movementType = ScrollRect.MovementType.Elastic;
hand = null;
}
scrolling = false;
mouseDown = false;
if (dragged)
{
if (originalCardHolder.tag == "Hand")
{
//transform.position = or;
if (cardHolder)
{
if (cardHolder.tag == "DefendField")
{
int fpID = cardHolder.transform.GetSiblingIndex();
fp = GameManager.gm.field[fpID];
if (GameManager.gm.defender == GameManager.gm.myTurn && GameManager.gm.CanDefend(fp, card))
{
if (selected)
{
selected = false;
GameManager.gm.selected.Remove(card);
}
Debug.Log("CAN DEFEND");
transform.SetParent(cardHolder);
transform.position = cardHolder.position;
fp.defend = card;
GameManager.gm.defendCards.Add(fp);
GameManager.gm.UpdateActionButtons();
//GameManager.gm.defendCards.Add(card);
}
else
{
fp = null;
Debug.Log("CANT");
transform.SetParent(originalCardHolder);
transform.position = originalPosition;
}
}
else
{
Debug.Log("WHAT IS THIS");
}
}
else
{
transform.SetParent(originalCardHolder);
transform.position = originalPosition;
}
}
cardHolder = null;
//transform.i
}
dragged = false;
}
private void AddCardsToAttackField(int player, List <Card> cards)
{
//Debug.Log("ADDING CARDS");
// If I am attacking, remove selected cards from my hand to the attack field
if (player == myTurn)
{
foreach (Card c in cards)
{
for (int i = 0; i < myCardsContainer.transform.childCount; i++)
{
Debug.Log(i + " " + myCardsContainer.transform.childCount);
Transform cardHolder = myCardsContainer.transform.GetChild(i);
if (cardHolder.childCount > 0)
{
CardUI cUI = cardHolder.GetChild(0).GetComponent <CardUI>();
if (c.Equals(cUI.card))
{
// Debug.Log("PLAYED " + cUI.card.ToString());
cUI.transform.SetParent(attackField.transform);
cUI.played = true;
Destroy(cardHolder.gameObject);
//i--;
break;
}
}
}
}
}
//foreach(Card c in playerOrder[player].hand)
// {
// Debug.Log(Card.CARDS[c]);
//}
// Add a card holder for each card added to the attack field
foreach (Card c in cards)
{
//Debug.Log("spawn" + Card.CARDS[c]);
FieldPair fp = new FieldPair();
fp.attack = c;
field.Add(fp);
// If player adding cards to field is not me, create a new card UI
if (player != myTurn)
{
GameObject cardObj = CreateCardUI(c);//Instantiate(cardPrefab);
CardUI cui = cardObj.transform.GetComponent <CardUI>();
//cui.card = c;
cui.played = true;
cardObj.transform.SetParent(attackField.transform);
cardObj.transform.localScale = new Vector3(1, 1, 1);
//cardObj.transform.GetChild(0).GetComponent<Text>().text = Card.CARDS[c];
}
GameObject cardHolder = Instantiate(cardHolderPrefab);
cardHolder.transform.SetParent(defendField.transform);
cardHolder.tag = "DefendField";
cardHolder.transform.localScale = new Vector3(1, 1, 1);
if (player == myTurn)
{
playerOrder[player].hand.Remove(c);
}
else
{
foreach (Card cc in playerOrder[player].hand)
{
if (cc.Equals(c))
{
playerOrder[player].hand.Remove(cc);
break;
}
}
}
}
}
public bool Defend(int player, Card def, FieldPair fieldCard)
{
if (player != defender || !CanDefend(fieldCard, def))
{
return(false);
}
fieldCard.defend = def;
hasDefended = true;
if (myTurn == defender)
{
for (int i = 0; i < defendField.transform.childCount; i++)
{
Transform cardHolder = defendField.transform.GetChild(i);
if (cardHolder.childCount == 1)
{
CardUI cui = cardHolder.GetChild(0).GetComponent <CardUI>();
if (cui.card.Equals(def))
{
cui.played = true;
break;
}
}
}
for (int i = 0; i < myCardsContainer.transform.childCount; i++)
{
if (myCardsContainer.transform.GetChild(i).childCount == 0)
{
Destroy(myCardsContainer.transform.GetChild(i).gameObject);
}
}
//playerOrder[player].hand.Remove(def);
}
else
{
for (int i = 0; i < attackField.transform.childCount; i++)
{
//Transform cardHolder = defendField.transform.GetChild(i)
CardUI cui = attackField.transform.GetChild(i).GetComponent <CardUI>();
if (cui.card.Equals(fieldCard.attack))
{
GameObject defCardUI = CreateCardUI(def);//Instantiate(cardPrefab);
//defCardUI.transform.GetComponent<CardUI>().card = def;
defCardUI.transform.GetComponent <CardUI>().played = true;
defCardUI.transform.SetParent(defendField.transform.GetChild(i));
defCardUI.transform.localScale = new Vector3(1, 1, 1);
//defCardUI.transform.GetChild(0).GetComponent<Text>().text = Card.CARDS[def];
defCardUI.transform.position = defCardUI.transform.parent.position;
break;
}
}
// playerOrder[player].hand.Remove(playerOrder[player].hand[0]);
}
if (player == myTurn)
{
playerOrder[player].hand.Remove(def);
}
else
{
foreach (Card cc in playerOrder[player].hand)
{
if (cc.Equals(def))
{
playerOrder[player].hand.Remove(cc);
break;
}
}
}
if (HasFinishedGame(player))
{
Debug.Log("WOO WIN" + playerOrder[player].playerName);
StartCoroutine("EndGame");
}
//if (player == myTurn)
//else
UpdateGameUI();
UpdateOtherPlayerUI(player);
UpdateActionButtons();
StartCoroutine("EndBattleBtn");
return(true);
}
