Selection of scripts forming the core of interacting with the cards in your hand
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
using System.Collections; | |
using System.Collections.Generic; | |
using UnityEngine; | |
public class CardSlotHolder : MonoBehaviour { | |
public enum SlotType { EMPTY, GENERIC, GRABBAG}; | |
public SlotType typeOfSlot; | |
public bool shouldSpawnCard = true; | |
public SingleCard cardHeld; | |
//Add reference to enemy | |
public CardSlotManager manager; | |
public bool isAdditionType; | |
public GameObject GenericToSpawn; | |
int difficulty = 0; | |
private void Start() { | |
difficulty = Random.Range(1, 3); | |
} | |
private void Update() { | |
if(typeOfSlot == SlotType.GENERIC && shouldSpawnCard && cardHeld == null) { | |
shouldSpawnCard = false; | |
StartCoroutine(ReloadCard()); | |
} | |
} | |
IEnumerator ReloadCard() { | |
for (int i = 0; i < 3; i++) { | |
yield return new WaitForFixedUpdate(); | |
} | |
if (!isAdditionType && !manager.isGraveyard) { | |
GetComponent<BoxCollider>().enabled = false; | |
GenericToSpawn.GetComponent<SingleCard>().cardValue = difficulty; | |
GameObject generalMinusCard = Instantiate(GenericToSpawn, transform.position, Quaternion.identity, transform); | |
generalMinusCard.GetComponent<DragTransform>().SlotIn(transform); | |
shouldSpawnCard = true; | |
} | |
} | |
public void GrabCardsFromBag() { | |
StartCoroutine(LoadGrabBagCard()); | |
} | |
IEnumerator LoadGrabBagCard() { | |
for (int i = 0; i < 3; i++) { | |
yield return new WaitForFixedUpdate(); | |
} | |
SingleCard cardFromGrabBag = manager.GetDeckManager().GetGrabBagCard(); | |
GameObject generalMinusCard = Instantiate(GenericToSpawn, transform.position, Quaternion.identity, transform); | |
generalMinusCard.GetComponent<SingleCard>().SetValues(cardFromGrabBag, generalMinusCard, this); | |
generalMinusCard.GetComponent<SingleCard>().isGrabBagCard = true; | |
generalMinusCard.GetComponent<DragTransform>().SlotIn(transform); | |
generalMinusCard.GetComponent<BoxCollider2D>().enabled = true; | |
} | |
public void SetCard(GameObject newCard) { | |
SingleCard tempCard = newCard.GetComponent<SingleCard>(); | |
if (cardHeld != null) { | |
if(tempCard != cardHeld) { | |
cardHeld.GetComponent<DragTransform>().Expunge(); | |
} | |
} | |
cardHeld = tempCard; | |
if(manager) | |
manager.SlotUpdated(gameObject); | |
//Tell the enemy reference to check if all cards are filled | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
using System.Collections; | |
using System.Collections.Generic; | |
using UnityEngine; | |
public class CardSlotManager : MonoBehaviour { | |
public bool isGraveyard = false; | |
[Tooltip("+, -")] | |
public GameObject[] slotTypes; | |
[Tooltip("+, -")] | |
public GameObject[] symbolTypes; | |
public List<GameObject> equation; | |
public AnimationCurve customCombineLerp; | |
public AnimationCurve attackAnimCurve; | |
public AnimationCurve healAnimCurve; | |
public AnimationCurve slowAnimCurve; | |
public AnimationCurve rotateAnimCurve; | |
public GameObject flash; | |
public GameObject freshNewCard; | |
public PlayerHealthBar PHB; | |
Deck deckManager; | |
AudioSource SFXbox; | |
[Tooltip("Diamond, Heart, Spade, Club")] | |
public AudioClip[] effectSounds; | |
// Start is called before the first frame update | |
void Start() { | |
SFXbox = GetComponent<AudioSource>(); | |
deckManager = FindObjectOfType<Deck>(); | |
for (int i = 0; i < equation.Count; i += 2) { | |
CardSlotHolder currentHolder = equation[i].GetComponent<CardSlotHolder>(); | |
if (currentHolder) { | |
currentHolder.manager = this; | |
} | |
} | |
} | |
public bool debugTesting = false; | |
private void Update() { | |
if (debugTesting) { | |
debugTesting = false; | |
GenerateSlots(true); | |
} | |
} | |
//Generate Slots Randomly | |
public void GenerateSlots() { | |
GenerateSlots(-1, -1); | |
} | |
//numSlotsToMake is -1, choose randomly | |
//isSubtraction: 0 == false, 1 == true, -1 == random | |
public void GenerateSlots(int numSlotsToMake, int isSubtraction) { | |
if (equation.Count > 0) { | |
foreach (GameObject go in equation) { | |
Destroy(go); | |
} | |
} | |
equation.Clear(); | |
//Choose randomly | |
if (numSlotsToMake == -1) { | |
numSlotsToMake = Random.Range(1, 3); | |
} | |
GameObject initialSlot = Instantiate(slotTypes[0], transform); | |
equation.Add(initialSlot); | |
initialSlot.GetComponent<CardSlotHolder>().manager = this; | |
//Creates the slots | |
for (int i = 1; i < numSlotsToMake; i++) { | |
if (isSubtraction == -1) { | |
isSubtraction = Random.Range(0, 2); | |
} | |
GameObject tempCardSlot = Instantiate(slotTypes[isSubtraction], transform); | |
tempCardSlot.GetComponent<CardSlotHolder>().manager = this; | |
equation.Add(tempCardSlot); | |
} | |
//Adds the symbols between each slot | |
for (int index = 1; index < equation.Count; index++) { | |
for (int type = 0; type < slotTypes.Length; type++) { | |
if (equation[index].GetComponent<CardSlotHolder>().isAdditionType == slotTypes[type].GetComponent<CardSlotHolder>().isAdditionType) { | |
GameObject tempSymbol = Instantiate(symbolTypes[type], transform); | |
equation.Insert(index, tempSymbol); | |
index++; | |
break; | |
} | |
} | |
} | |
//Sets every object to the correct distances | |
int indexCenter = equation.Count / 2; | |
for (int i = 0; i < equation.Count; i++) { | |
equation[i].transform.localPosition = new Vector3(2 * (i - indexCenter), 0, 1); | |
} | |
} | |
/// <summary> | |
/// Generates Card Slots for an enemy that is actually the shopkeeper | |
/// </summary> | |
/// <param name="isShopGenertaion"></param> | |
public void GenerateSlots(bool isShopGenertaion) { | |
if (equation.Count > 0) { | |
foreach (GameObject go in equation) { | |
Destroy(go); | |
} | |
} | |
equation.Clear(); | |
//Choose randomly | |
int numSlotsToMake = 3; | |
GameObject initialSlot = Instantiate(slotTypes[2], transform); | |
equation.Add(initialSlot); | |
initialSlot.GetComponent<CardSlotHolder>().manager = this; | |
//Creates the slots | |
for (int i = 1; i < numSlotsToMake; i++) { | |
GameObject tempCardSlot = Instantiate(slotTypes[0], transform); | |
tempCardSlot.GetComponent<CardSlotHolder>().manager = this; | |
equation.Add(tempCardSlot); | |
} | |
//Sets every object to the correct distances | |
int indexCenter = equation.Count / 2; | |
for (int i = 0; i < equation.Count; i++) { | |
equation[i].transform.localPosition = new Vector3(2 * (i - indexCenter), 0, 1); | |
equation[i].GetComponent<CardSlotHolder>().GrabCardsFromBag(); | |
} | |
FindObjectOfType<ShoppingCart>().ShoppingTime(); | |
} | |
public Deck GetDeckManager() { return deckManager; } | |
public void SlotUpdated(GameObject CSH) { | |
for(int i =0; i < equation.Count; i+= 2) { | |
if(equation[i] == CSH) { | |
continue; | |
} | |
else if(CSH.GetComponent<CardSlotHolder>().cardHeld == equation[i].GetComponent<CardSlotHolder>().cardHeld ) { | |
equation[i].GetComponent<CardSlotHolder>().cardHeld = null; | |
} | |
} | |
if (CheckIfFull()) { | |
// | |
//Do math | |
// | |
int totalValue = equation[0].GetComponent<CardSlotHolder>().cardHeld.cardValue; | |
CardDisplay.Suit currentSuit = equation[0].GetComponent<CardSlotHolder>().cardHeld.cardSuit; | |
for (int i = 1; i < equation.Count; i += 2) { | |
if (equation[i].tag == symbolTypes[0].tag) { | |
totalValue += equation[i + 1].GetComponent<CardSlotHolder>().cardHeld.cardValue; | |
} | |
else { | |
totalValue -= equation[i + 1].GetComponent<CardSlotHolder>().cardHeld.cardValue; | |
} | |
} | |
for(int i = 0; i < equation.Count; i++) { | |
if(equation[i].tag != symbolTypes[0].tag && equation[i].tag != symbolTypes[1].tag) { | |
equation[i].GetComponent<CardSlotHolder>().cardHeld.GetComponent<BoxCollider2D>().enabled = false; | |
} | |
} | |
if(totalValue >= 10) { | |
totalValue = 10; | |
} | |
StartCoroutine(CombineCards(totalValue, currentSuit)); | |
} | |
} | |
float timeToPushCardsTogether = 0.5f; | |
IEnumerator CombineCards(int value, CardDisplay.Suit suit) { | |
float timeSinceStart = 0f; | |
SingleCard firstCard = equation[0].GetComponent<CardSlotHolder>().cardHeld; | |
//Move cards together | |
if (equation.Count > 2) { | |
while (timeSinceStart < timeToPushCardsTogether) { | |
yield return null; | |
timeSinceStart += Time.deltaTime; | |
for (int i = 0; i < equation.Count; i += 2) { | |
Transform currentTrans = equation[i].GetComponent<CardSlotHolder>().cardHeld.transform; | |
currentTrans.position = Vector2.Lerp(equation[i].transform.position, equation[1].transform.position, customCombineLerp.Evaluate(timeSinceStart / timeToPushCardsTogether)); | |
} | |
} | |
} | |
//When they get close, make a white circle that overtakes the cards | |
//The circle "flashes" (lerps big and then small) | |
GameObject combineFlash; | |
if (equation.Count > 2) { | |
combineFlash = Instantiate(flash, equation[1].transform.position, Quaternion.identity); | |
} | |
else { | |
combineFlash = Instantiate(flash, equation[0].transform.position, Quaternion.identity); | |
} | |
combineFlash.transform.localScale = new Vector3(0, 0, 0); | |
timeSinceStart = 0; | |
float timeToExpand = 0.2f; | |
while (timeSinceStart < timeToExpand) { | |
yield return null; | |
timeSinceStart += Time.deltaTime; | |
combineFlash.transform.localScale = Vector3.Lerp(new Vector3(0, 0, 0), new Vector3(4, 4, 4), customCombineLerp.Evaluate(timeSinceStart / timeToExpand)); | |
} | |
GameObject cardToAnimate = null; | |
// | |
//Instantiate the new card | |
if (!isGraveyard) { | |
GameObject newCard = Instantiate(freshNewCard, equation[equation.Count / 2].transform.position, Quaternion.identity); | |
newCard.transform.localScale = equation[0].transform.localScale; | |
SingleCard tempCard = new SingleCard(value, (int)suit); | |
newCard.GetComponent<SingleCard>().SetValues(tempCard, newCard); | |
yield return new WaitForFixedUpdate(); | |
newCard.GetComponent<SingleCard>().SetSortingValue(5, true); | |
newCard.GetComponent<BoxCollider2D>().enabled = false; | |
cardToAnimate = newCard; | |
if(equation.Count > 2) { | |
deckManager.AddGrabBagCard(tempCard); | |
} | |
Destroy(newCard, timeSinceStart + 2f); | |
} | |
// | |
//Delete the other cards | |
for (int i = 0; i < equation.Count; i += 2) { | |
deckManager.CardPlayed(equation[i].GetComponent<CardSlotHolder>().cardHeld); | |
} | |
// | |
//Make flash effect go away | |
while (timeSinceStart > 0) { | |
yield return null; | |
timeSinceStart -= Time.deltaTime; | |
combineFlash.transform.localScale = Vector3.Lerp(new Vector3(0, 0, 0), new Vector3(4, 4, 4), customCombineLerp.Evaluate(timeSinceStart / timeToExpand)); | |
} | |
Destroy(combineFlash); | |
// | |
//Effect takes place | |
// | |
if (!isGraveyard) { | |
Vector3 initPos = cardToAnimate.transform.position; | |
Vector3 initScale = cardToAnimate.transform.localScale; | |
Vector3 targetPos; | |
timeSinceStart = 0f; | |
// | |
//Blank Card | |
if (value <= 0) { | |
timeSinceStart = 0f; | |
combineFlash = Instantiate(flash, cardToAnimate.transform.position, Quaternion.identity); | |
combineFlash.transform.localScale = new Vector3(0, 0, 0); | |
while (timeSinceStart < timeToExpand) { | |
yield return null; | |
timeSinceStart += Time.deltaTime; | |
combineFlash.transform.localScale = Vector3.Lerp(new Vector3(0, 0, 0), new Vector3(4, 4, 4), customCombineLerp.Evaluate(timeSinceStart / timeToExpand)); | |
} | |
//Delete the blank cards | |
Destroy(cardToAnimate); | |
//Make flash effect go away | |
while (timeSinceStart > 0) { | |
yield return null; | |
timeSinceStart -= Time.deltaTime; | |
combineFlash.transform.localScale = Vector3.Lerp(new Vector3(0, 0, 0), new Vector3(4, 4, 4), customCombineLerp.Evaluate(timeSinceStart / timeToExpand)); | |
} | |
int numCardsToDraw = equation.Count / 2 + 1; | |
for (int i = 0; i < equation.Count; i++) { | |
if(equation[i].tag == "-" && equation[i+1].GetComponent<CardSlotHolder>().shouldSpawnCard) { | |
numCardsToDraw--; | |
} | |
} | |
for (int i = 0; i < numCardsToDraw; i++) { | |
deckManager.DrawCard(); | |
} | |
yield break; | |
} | |
// | |
//Diamonds Hurt Red Enemies | |
// | |
if (suit == CardDisplay.Suit.DIAMOND) { | |
StartCoroutine(AttackAnimation(cardToAnimate, true)); | |
} | |
// | |
//Spades Hurt Black Enemies | |
// | |
else if (suit == CardDisplay.Suit.SPADE) { | |
StartCoroutine(AttackAnimation(cardToAnimate, false)); | |
} | |
// | |
//Hearts Heal the player | |
// | |
else if (suit == CardDisplay.Suit.HEART) { | |
targetPos = initPos; | |
targetPos.y = -10; | |
Vector3 tempVector = new Vector3(0, 0, 0); | |
Vector3 travelVector = targetPos - initPos; | |
PHB.HealDamage(value); | |
while (timeSinceStart < 1.5f) { | |
yield return null; | |
timeSinceStart += Time.deltaTime; | |
tempVector = healAnimCurve.Evaluate(timeSinceStart / 2f) * travelVector; | |
cardToAnimate.transform.position = initPos + tempVector; | |
cardToAnimate.transform.localScale = new Vector3(rotateAnimCurve.Evaluate(timeSinceStart / 1.5f) * initScale.x, | |
initScale.y, initScale.z); | |
} | |
} | |
// | |
//Clubs slow the enemy | |
// | |
else if (suit == CardDisplay.Suit.CLUB) { | |
targetPos = initPos; | |
targetPos.y = 6; | |
Vector3 tempVector = new Vector3(0, 0, 0); | |
Vector3 travelVector = targetPos - initPos; | |
EnemySpawner.instance.currentEnemy.GetComponent<Enemy>().SlowEffect(value); | |
while (timeSinceStart < 1.5f) { | |
yield return null; | |
timeSinceStart += Time.deltaTime; | |
tempVector = healAnimCurve.Evaluate(timeSinceStart / 2f) * travelVector; | |
cardToAnimate.transform.position = initPos + tempVector; | |
cardToAnimate.transform.localScale = new Vector3(rotateAnimCurve.Evaluate(timeSinceStart / 1.5f) * initScale.x, | |
initScale.y, initScale.z); | |
} | |
} | |
} | |
else { | |
deckManager.StopAllCoroutines(); | |
deckManager.DrawCard(); | |
} | |
} | |
IEnumerator AttackAnimation(GameObject cardToAnimate, bool isDiamondAttack) { | |
float timeSinceStart = 0f; | |
Vector3 initPos = cardToAnimate.transform.position; | |
Vector3 targetPos; | |
int value = cardToAnimate.GetComponent<SingleCard>().cardValue; | |
targetPos = initPos; | |
targetPos.y = 6; | |
Vector3 tempVector = new Vector3(0, 0, 0); | |
Vector3 travelVector = targetPos - initPos; | |
if (EnemySpawner.instance.currentEnemy == null) { | |
yield break; | |
} | |
Enemy enemyScript = EnemySpawner.instance.currentEnemy.GetComponent<Enemy>(); | |
enemyScript.GetHit(value, isDiamondAttack); | |
if (isDiamondAttack && enemyScript.isRed | |
|| !isDiamondAttack && !enemyScript.isRed) { | |
SFXbox.clip = effectSounds[2]; | |
SFXbox.Play(); | |
while (timeSinceStart < 1.5f) { | |
yield return null; | |
timeSinceStart += Time.deltaTime; | |
tempVector = attackAnimCurve.Evaluate(timeSinceStart / 2f) * travelVector; | |
cardToAnimate.transform.position = initPos + tempVector; | |
} | |
} | |
else { | |
SFXbox.clip = effectSounds[1]; | |
SFXbox.Play(); | |
float deflectAmount = Random.Range(30f, 70f); | |
//Debug.Log(deflectAmount); | |
deflectAmount *= (Random.Range(0, 2) % 2 == 0) ? 1 : -1; | |
float startX = cardToAnimate.transform.position.x; | |
float deflectStartTime = 0f; | |
while (timeSinceStart < 1.5f) { | |
yield return null; | |
timeSinceStart += Time.deltaTime; | |
tempVector = attackAnimCurve.Evaluate(timeSinceStart / 2f) * travelVector; | |
if (cardToAnimate.transform.position.y >= 1) { | |
if (deflectStartTime < 0.01) { | |
deflectStartTime = timeSinceStart; | |
//Play sound | |
SFXbox.clip = effectSounds[0]; | |
SFXbox.Play(); | |
} | |
float newXPos = Mathf.Lerp(startX, startX + deflectAmount, | |
(timeSinceStart - deflectStartTime) / (1.15f - deflectStartTime)); | |
tempVector.x = newXPos; | |
} | |
cardToAnimate.transform.position = initPos + tempVector; | |
} | |
//Debug.Log(cardToAnimate.transform.position); | |
} | |
} | |
public bool CheckIfFull() { | |
for (int i = 0; i < equation.Count; i += 2) { | |
CardSlotHolder currentSlot = equation[i].GetComponent<CardSlotHolder>(); | |
if (currentSlot.cardHeld == null) { | |
return false; | |
} | |
if(currentSlot.typeOfSlot == CardSlotHolder.SlotType.GRABBAG) { | |
return false; | |
} | |
} | |
return true; | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
using System.Collections; | |
using System.Collections.Generic; | |
using UnityEngine; | |
using UnityEngine.SceneManagement; | |
using TMPro; | |
public class Deck : MonoBehaviour { | |
public GameObject card; | |
public GameObject cardGhosts; | |
public Vector3[] newCardSpawnLocations; | |
public int handSize = 3; | |
public AnimationCurve customSlideAnimation; | |
[Tooltip("The Cards in Your Deck")] | |
public List<SingleCard> cardPool; | |
[Tooltip("The Cards in Hand")] | |
public List<SingleCard> cardsInHand; | |
public List<GameObject> handCardObjects; | |
[Tooltip("The Cards in Your Graveyard")] | |
public List<SingleCard> discardPool; | |
public List<SingleCard> grabBagPool; | |
public GameObject goodbyeParticle; | |
public TextMeshPro deckCount; | |
public TextMeshPro discardCount; | |
public bool loadingNewCard = false; | |
public bool currentlyShopping = false; | |
AudioSource shuffleSFX; | |
// Start is called before the first frame update | |
void Start() { | |
cardPool = new List<SingleCard>(); | |
cardsInHand = new List<SingleCard>(); | |
discardPool = new List<SingleCard>(); | |
shuffleSFX = GetComponent<AudioSource>(); | |
// | |
//Generates the deck here | |
//Hearts and Clubs | |
for (int suit = 1; suit < 4; suit += 2) { | |
for (int value = 1; value < 5; value++) { | |
SingleCard tempCard = new SingleCard(value, suit); | |
cardPool.Add(tempCard); | |
} | |
} | |
//Diamonds and Spades | |
for (int numSets = 0; numSets < 2; numSets++) { | |
for (int suit = 0; suit < 4; suit += 2) { | |
for (int value = 1; value < 5; value++) { | |
SingleCard tempCard = new SingleCard(value, suit); | |
cardPool.Add(tempCard); | |
} | |
} | |
} | |
//cardPool.Add(new SingleCard(4, CardDisplay.Suit.CURSE)); | |
//cardPool.Add(new SingleCard(4, CardDisplay.Suit.BLESS)); | |
//Draw the starting hand | |
for (int i = 0; i < handSize; i++) { | |
DrawCard(); | |
} | |
} | |
float timeCountDown = 2f; | |
// Update is called once per frame | |
void Update() { | |
//Death Reset | |
if (Time.timeScale == 0 && Input.anyKeyDown) { | |
SceneManager.LoadScene(1); | |
Time.timeScale = 1f; | |
} | |
//Shuffle test | |
if (Input.GetKeyDown(KeyCode.Alpha9)) { | |
discardPool.AddRange(cardPool); | |
cardPool.Clear(); | |
UpdateNumCardsEachZone(); | |
StartCoroutine(BackendDraw()); | |
} | |
} | |
public void UpdateNumCardsEachZone() { | |
deckCount.text = cardPool.Count + ""; | |
discardCount.text = discardPool.Count + ""; | |
} | |
/// <summary> | |
/// Draw multiple cards at once | |
/// </summary> | |
/// <param name="numCardsToDraw"> The number of cards to draw at once</param> | |
public void DrawCards(int numCardsToDraw) { | |
for (int i = 0; i < numCardsToDraw; i++) { | |
DrawCard(); | |
} | |
} | |
/// <summary> | |
/// Call this function to draw ONE card | |
/// </summary> | |
public void DrawCard() { | |
loadingNewCard = true; | |
StartCoroutine(BackendDraw()); | |
} | |
public void NaturalDraw() { | |
loadingNewCard = true; | |
StartCoroutine(BackendDraw()); | |
} | |
IEnumerator BackendDraw() { | |
if (cardPool.Count == 0) { | |
//If you still don't have a deck, just give up | |
if (discardPool.Count == 0) { | |
yield break; | |
} | |
cardPool.AddRange(discardPool); | |
shuffleSFX.Play(); | |
yield return StartCoroutine(ShuffleEffect()); | |
} | |
while(currentlyShopping) { | |
yield return null; | |
} | |
//Remove a random card from the deck | |
int drawnCardIndex = Random.Range(0, cardPool.Count); | |
SingleCard newCard = cardPool[drawnCardIndex]; | |
cardPool.RemoveAt(drawnCardIndex); | |
UpdateNumCardsEachZone(); | |
//Add that card to the hand pile | |
cardsInHand.Add(newCard); | |
//Instantiate a single card object | |
GameObject newCardObject = Instantiate(card, newCardSpawnLocations[0], Quaternion.Euler(0, 0, 45), transform); | |
newCardObject.GetComponent<SingleCard>().SetValues(newCard, newCardObject); | |
newCard.SetValues(newCardObject); | |
handCardObjects.Add(newCardObject); | |
//Push in from the bottom on left most side | |
StartCoroutine(slideInNewCard(newCardObject)); | |
} | |
IEnumerator ShuffleEffect() { | |
float timeSinceStart = 0f; | |
float timeForEffect = shuffleSFX.clip.length * .9f; | |
int numGhostsToSpawn = discardPool.Count; | |
discardPool.Clear(); | |
float timeBetweenEachGhost = (timeForEffect / 2f) / numGhostsToSpawn; | |
List<GameObject> ghostsAlreadySpawned = new List<GameObject>(); | |
int numGhostsSpawned = 0; | |
//Actual start of shuffle effect | |
while (timeSinceStart < timeForEffect) { | |
timeSinceStart += Time.deltaTime; | |
yield return null; | |
if (numGhostsSpawned < numGhostsToSpawn) { | |
if (numGhostsSpawned * timeBetweenEachGhost < timeSinceStart) { | |
//Spawn a Ghost | |
GameObject newGhost = Instantiate(cardGhosts, discardCount.transform.position, Quaternion.identity, transform); | |
numGhostsSpawned++; | |
Destroy(newGhost, timeForEffect - timeSinceStart + .1f); | |
ghostsAlreadySpawned.Add(newGhost); | |
} | |
} | |
for (int i = 0; i < ghostsAlreadySpawned.Count; i++) { | |
float xPos = Mathf.Lerp( | |
7.4f, -7.4f, | |
customSlideAnimation.Evaluate( | |
(timeSinceStart - i * timeBetweenEachGhost) / (timeForEffect / 2)) | |
); | |
float yPos = -0.04565f * Mathf.Pow(xPos, 2) - 2f; | |
ghostsAlreadySpawned[i].transform.position = new Vector3(xPos, yPos, 0); | |
} | |
} | |
//Cleanup | |
ghostsAlreadySpawned.Clear(); | |
} | |
public void AddGrabBagCard(SingleCard cardToAdd) { | |
grabBagPool.Add(cardToAdd); | |
} | |
public SingleCard GetGrabBagCard() { | |
if(grabBagPool.Count >= 1) { | |
int index = Random.Range(0, grabBagPool.Count); | |
SingleCard card = grabBagPool[index]; | |
grabBagPool.RemoveAt(index); | |
return card; | |
} | |
else { | |
int suit = Random.Range(0, 4); | |
int value = Random.Range(1, 4); | |
return new SingleCard(value, (CardDisplay.Suit)suit); | |
} | |
} | |
/// <summary> | |
/// Moves parameters and cards from zone to zone. Does NOT call an effect. | |
/// </summary> | |
/// <param name="cardThatWasPlayed">The SingleCard script attached to the played card</param> | |
public void CardPlayed(SingleCard cardThatWasPlayed) { | |
for (int i = 0; i < cardsInHand.Count; i++) { | |
if (cardThatWasPlayed.gameObject == handCardObjects[i]) { | |
handCardObjects[i].GetComponent<BoxCollider2D>().enabled = false; | |
//Move the card to a new zone | |
discardPool.Add(cardsInHand[i]); | |
cardsInHand.RemoveAt(i); | |
UpdateNumCardsEachZone(); | |
//Create the discard particle | |
Instantiate(goodbyeParticle, handCardObjects[i].transform.position, Quaternion.identity); | |
handCardObjects.RemoveAt(i); | |
Destroy(cardThatWasPlayed.gameObject); | |
//Shift the cards around | |
StartCoroutine(AdjustAllCardPositions()); | |
return; | |
} | |
} | |
Destroy(cardThatWasPlayed.gameObject); | |
} | |
public float timeToSlideInNew = 1f; | |
/// <summary> | |
/// Moves a new card from off screen into the hand | |
/// </summary> | |
/// <param name="newestCard">The object of the new card</param> | |
/// <returns></returns> | |
IEnumerator slideInNewCard(GameObject newestCard) { | |
yield return new WaitForFixedUpdate(); | |
while (currentlyShopping) { | |
yield return null; | |
} | |
//Adjust the render order to display properly | |
for (int cardIndex = 0; cardIndex < cardsInHand.Count; cardIndex++) { | |
handCardObjects[cardIndex].GetComponent<SingleCard>().SetSortingValue(-2 * cardIndex, true); | |
} | |
//Set new card location according to theoretical arch | |
Vector3 newCardLocation = new Vector3(-8, 0, 10); | |
newCardLocation.y = -0.05f * Mathf.Pow(newCardLocation.x, 2) - 4f; | |
newestCard.transform.position = newCardLocation; | |
newestCard.GetComponent<SingleCard>().RefreshJumpingValues(); | |
StartCoroutine(AdjustAllCardPositions()); | |
} | |
public float timeToAdjustAllCards = 1f; | |
/// <summary> | |
/// Adjust the location of all cards in hand to the correct positions | |
/// </summary> | |
/// <returns></returns> | |
IEnumerator AdjustAllCardPositions() { | |
float timeSinceStart = 0f; | |
while (currentlyShopping) { | |
yield return null; | |
} | |
while (timeSinceStart < timeToAdjustAllCards) { | |
yield return null; | |
for (int cardIndex = 0; cardIndex < cardsInHand.Count; cardIndex++) { | |
float targetXPos = 0; | |
//Calculate the target position for the current card | |
if (cardsInHand.Count == 2) { | |
targetXPos = 2 - (cardIndex * 4f / (cardsInHand.Count - 1f)); | |
} | |
else if (cardsInHand.Count > 2) { | |
targetXPos = 4 - (cardIndex * 8f / (cardsInHand.Count - 1f)); | |
} | |
float targetYPos = EvaluateHandEquation(targetXPos); | |
if (!handCardObjects[cardIndex]) { | |
continue; | |
} | |
Transform currentCardTrans = handCardObjects[cardIndex].transform; | |
// | |
//Only sets values for cards not in slot & Not being held | |
if (!handCardObjects[cardIndex].GetComponent<DragTransform>().inSlot && | |
!handCardObjects[cardIndex].GetComponent<DragTransform>().dragging) { | |
//Moves and rotates cards appropriately | |
Vector3 startingPos = handCardObjects[cardIndex].GetComponent<SingleCard>().startingPos; | |
float currentXPos = Mathf.Lerp(startingPos.x, targetXPos, customSlideAnimation.Evaluate(timeSinceStart / timeToAdjustAllCards)); | |
float currentYPos = EvaluateHandEquation(currentXPos); | |
currentCardTrans.position = new Vector3(currentXPos, currentYPos, 2 * cardIndex); | |
float angle = Mathf.Lerp(20, -20, (currentXPos + 4) / 8); | |
if (angle < 0) { | |
angle += 360; | |
} | |
currentCardTrans.rotation = Quaternion.Euler(0, 0, angle); | |
} | |
} | |
timeSinceStart += Time.deltaTime; | |
} | |
//Update Reset Positions | |
for (int cardIndex = 0; cardIndex < cardsInHand.Count; cardIndex++) { | |
if (!handCardObjects[cardIndex].GetComponent<DragTransform>().inSlot && | |
!handCardObjects[cardIndex].GetComponent<DragTransform>().dragging) { | |
handCardObjects[cardIndex].GetComponent<SingleCard>().RefreshJumpingValues(); | |
} | |
else { | |
float targetXPos = 0; | |
if (cardsInHand.Count == 2) { | |
targetXPos = 2 - (cardIndex * 4f / (cardsInHand.Count - 1f)); | |
} | |
else if (cardsInHand.Count > 2) { | |
targetXPos = 4 - (cardIndex * 8f / (cardsInHand.Count - 1f)); | |
} | |
float targetYPos = EvaluateHandEquation(targetXPos); | |
float angle = Mathf.Lerp(20, -20, (targetXPos + 4) / 8); | |
if (angle < 0) { | |
angle += 360; | |
} | |
handCardObjects[cardIndex].GetComponent<SingleCard>().RefreshJumpingValues(new Vector3(targetXPos, targetYPos, 2 * cardIndex), Quaternion.Euler(0, 0, angle)); | |
} | |
} | |
loadingNewCard = false; | |
} | |
public float EvaluateHandEquation(float xAxis) { | |
return -0.05f * Mathf.Pow(xAxis, 2) - 4f; | |
} | |
} | |
/* | |
* Old alternative method of adding new cards | |
Slide new card in from directly below | |
//Slide in according to the animation curve | |
while (timeSinceStart < timeToSlideInNew) { | |
yield return null; | |
newestCard.transform.position = Vector3.Lerp(newCardSpawnLocations[0], newCardSpawnLocations[1], customSlideAnimation.Evaluate(timeSinceStart / timeToSlideInNew)); | |
timeSinceStart += Time.deltaTime; | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
using System.Collections; | |
using System.Collections.Generic; | |
using UnityEngine; | |
public class SingleCard : MonoBehaviour { | |
public bool debugTesting = false; | |
public bool isGrabBagCard = false; | |
public int cardValue; | |
public CardDisplay.Suit cardSuit; | |
[Tooltip("1,2,3,4,5")] | |
public GameObject[] valueDisplayPrefabs; | |
CardDisplay ownDisplay; | |
GameObject ownDisplayObject; | |
public Transform currentTrans; | |
SpriteRenderer renderBox; | |
AudioSource SFXbox; | |
public AudioClip[] dealSounds; | |
public Vector3 startingPos; | |
public Quaternion startingRotation; | |
public int startingLevel; | |
public CardSlotHolder GrabBagHolder; | |
public SingleCard(int outsideValue, int outsideSuit) { | |
cardValue = outsideValue; | |
cardSuit = (CardDisplay.Suit)outsideSuit; | |
} | |
public SingleCard(int outsideValue, CardDisplay.Suit outsideSuit) { | |
cardValue = outsideValue; | |
cardSuit = outsideSuit; | |
} | |
// Start is called before the first frame update | |
void Start() { | |
renderBox = GetComponent<SpriteRenderer>(); | |
ResetDisplay(); | |
SFXbox = GetComponent<AudioSource>(); | |
SFXbox.clip = dealSounds[Random.Range(0, dealSounds.Length)]; | |
SFXbox.Play(); | |
} | |
// Update is called once per frame | |
void Update() { | |
if (debugTesting) { | |
debugTesting = false; | |
RandomDisplay(); | |
} | |
} | |
void RandomDisplay() { | |
cardValue = Random.Range(6, 8); | |
cardSuit = (CardDisplay.Suit)Random.Range(4, 7); | |
ResetDisplay(); | |
} | |
public void ResetDisplay() { | |
if (cardValue <= 0) { | |
if (ownDisplayObject) { | |
Destroy(ownDisplayObject); | |
} | |
ownDisplayObject = null; | |
return; | |
} | |
if (ownDisplayObject) { | |
Destroy(ownDisplayObject); | |
} | |
if(cardValue >= 10) { | |
cardValue = 10; | |
} | |
ownDisplayObject = Instantiate(valueDisplayPrefabs[cardValue - 1], transform.position + new Vector3(0, 0, -1), transform.rotation, transform); | |
ownDisplay = ownDisplayObject.GetComponent<CardDisplay>(); | |
ownDisplay.currentSuit = cardSuit; | |
ownDisplay.resetDisplay(); | |
} | |
public void SetValues(GameObject otherObject) { | |
currentTrans = otherObject.transform; | |
} | |
public void SetValues(SingleCard otherCard, GameObject otherObject) { | |
cardValue = otherCard.cardValue; | |
cardSuit = otherCard.cardSuit; | |
currentTrans = otherObject.transform; | |
ResetDisplay(); | |
} | |
public void SetValues(SingleCard otherCard, GameObject otherObject, CardSlotHolder CSH) { | |
SetValues(otherCard, otherObject); | |
GrabBagHolder = CSH; | |
} | |
public void SetSortingValue(int newSortingLevel, bool isMovingUp) { | |
StartCoroutine(LateSetSorting(newSortingLevel, isMovingUp)); | |
} | |
IEnumerator LateSetSorting(int newSortingLevel, bool isMovingUp) { | |
if (isMovingUp) { | |
yield return new WaitForFixedUpdate(); | |
if (ownDisplay) { | |
ownDisplay.layerOrder = newSortingLevel + 1; | |
ownDisplay.resetDisplay(); | |
} | |
yield return new WaitForFixedUpdate(); | |
yield return new WaitForFixedUpdate(); | |
renderBox.sortingOrder = newSortingLevel; | |
} | |
else { | |
yield return new WaitForFixedUpdate(); | |
renderBox.sortingOrder = newSortingLevel; | |
yield return new WaitForFixedUpdate(); | |
yield return new WaitForFixedUpdate(); | |
if (ownDisplay) { | |
ownDisplay.layerOrder = newSortingLevel + 1; | |
ownDisplay.resetDisplay(); | |
} | |
} | |
} | |
public void RefreshJumpingValues() { | |
startingPos = currentTrans.position; | |
startingRotation = currentTrans.rotation; | |
startingLevel = currentTrans.GetComponent<SpriteRenderer>().sortingOrder; | |
} | |
public void RefreshJumpingValues(Vector3 position, Quaternion rotation) { | |
startingPos = position; | |
startingRotation = rotation; | |
} | |
bool isInProgress = false; | |
bool inProgressState = false; | |
void OnMouseEnter() { | |
//Lerp position to y = -3.5 | |
//set z rotation to 0 | |
//set sorting value to 2 | |
DragTransform DT = GetComponent<DragTransform>(); | |
if (DT.IsDragging() || DT.inSlot) { | |
return; | |
} | |
StopAllCoroutines(); | |
AnimationCancel(); | |
StartCoroutine(HoverMoveUp(true)); | |
} | |
void OnMouseExit() { | |
// | |
//Check to see if dragging is true | |
//If so, do nothing | |
//Otherwise, trigger the lerp back to correct position | |
// | |
DragTransform DT = GetComponent<DragTransform>(); | |
if (DT.IsDragging() || DT.inSlot) { | |
return; | |
} | |
StopAllCoroutines(); | |
AnimationCancel(); | |
StartCoroutine(HoverMoveUp(false)); | |
} | |
void AnimationCancel() { | |
StopAllCoroutines(); | |
if (isInProgress) { | |
if (inProgressState) { | |
transform.position = new Vector3(startingPos.x, -3.5f, startingPos.z); | |
transform.rotation = Quaternion.identity; | |
} | |
else { | |
transform.position = startingPos; | |
transform.rotation = startingRotation; | |
} | |
SetSortingValue((inProgressState) ? 2 : startingLevel, inProgressState); | |
} | |
} | |
public float timeToMoveSpots = 0.5f; | |
IEnumerator HoverMoveUp(bool isMovingUp) { | |
isInProgress = true; | |
inProgressState = isMovingUp; | |
float timeSinceStart = (isMovingUp) ? 0f : timeToMoveSpots; | |
while ((isMovingUp && timeSinceStart < timeToMoveSpots) || (!isMovingUp && timeSinceStart > 0)) { | |
yield return null; | |
transform.position = Vector3.Lerp(startingPos, new Vector3(startingPos.x, -3.5f, startingPos.z), timeSinceStart / timeToMoveSpots); | |
transform.rotation = Quaternion.Slerp(startingRotation, Quaternion.identity, timeSinceStart / timeToMoveSpots); | |
timeSinceStart += (isMovingUp) ? Time.deltaTime : -1 * Time.deltaTime; | |
} | |
yield return LateSetSorting((isMovingUp) ? 2 : startingLevel, isMovingUp); | |
isInProgress = false; | |
} | |
public override string ToString() { | |
return cardValue + " of " + cardSuit + "s"; | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment