private int GetCountToNextLegalRotation(HackCard hackcard, int startingRotation = 0)
{
FindAndStoreAdjacentSquares();
// We check all four rotations for a match and allow placing the square if there are any
// If there are, we return the number of rotations necessary for later processing
// If there are none, we return -1
// Starting rotation is set to 1 if we want to find the next legal rotation and skip 'no rotation'
for (int rotations = startingRotation; rotations < 4; rotations++)
{
string rotatedLeftCircuit = hackcard.GetLeftCircuit();
string rotatedTopCircuit = hackcard.GetTopCircuit();
string rotatedRightCircuit = hackcard.GetRightCircuit();
string rotatedBottomCircuit = hackcard.GetBottomCircuit();
for (int i = 0; i < rotations; i++)
{
string previousLeftCircuit = rotatedLeftCircuit;
rotatedLeftCircuit = rotatedBottomCircuit;
rotatedBottomCircuit = rotatedRightCircuit;
rotatedRightCircuit = rotatedTopCircuit;
rotatedTopCircuit = previousLeftCircuit;
}
bool isCurrentRotationLegal = CheckRotation(rotatedLeftCircuit, rotatedTopCircuit, rotatedRightCircuit, rotatedBottomCircuit);
if (isCurrentRotationLegal)
{
return(rotations);
}
}
return(-1);
}
public void KeepOrDiscardFromTopXCards(List <int> idsToKeep, List <int> idsToDiscard, int amountOfCards)
{
int currentIndex = 0;
// save the current card so we can see if it changes or not
HackCard currentTopCard = cards[0];
// loop through the top X cards to check the lists for their ids
for (int i = 0; i < amountOfCards; i++)
{
int currentCardId = cards[currentIndex].GetCardId();
if (idsToKeep.Contains(currentCardId))
{
currentIndex++;
idsToKeep.Remove(currentCardId);
}
else if (idsToDiscard.Contains(currentCardId))
{
hackDiscard.AddCardToDiscard(cards[currentIndex]);
cards.RemoveAt(currentIndex);
idsToDiscard.Remove(currentCardId);
}
}
if (cards[0] != currentTopCard)
{
ClearTemporaryCardModifications();
SetTopCard();
}
SetTextFieldCount();
}
public bool AttachCardToSquare(HackCard hackCard, string[] tempCircuitConnections)
{
int timesToRotate = GetCountToNextLegalRotation(hackCard);
if (timesToRotate != -1)
{
HackCard newHackCard = Instantiate(hackCard, new Vector2(hackholder.transform.position.x, hackholder.transform.position.y), Quaternion.identity);
newHackCard.SetModifiedCircuit(tempCircuitConnections);
newHackCard.transform.SetParent(hackholder.transform);
newHackCard.transform.localScale = new Vector3(1, 1, 1);
newHackCard.SetGridSquareHolder(this);
for (int i = 0; i < timesToRotate; i++)
{
RotateCardNinetyDegrees(newHackCard);
newHackCard.RotateCircuitsAndSpikesNinetyDegrees();
}
HackBattleData hackBattleData = FindObjectOfType <HackBattleData>();
hackBattleData.SetStateToCardUI();
newHackCard.SetupUI(GetCountToPreviousLegalRotation(newHackCard, 1), GetCountToNextLegalRotation(newHackCard, 1));
attachedHackCard = newHackCard;
UpdateSecurityRating();
return(true);
}
else
{
return(false);
}
}
private void RotateCardNinetyDegrees(HackCard cardToRotate)
{
// Variables must be shifted one to the right (eg left => top, top => right, right => bottom, bottom => left)
// this must be done for circuits AND spikes
cardToRotate.transform.Find("Card").gameObject.transform.Rotate(0, 0, 270);
//cardToRotate.transform.Rotate(0, 0, 270);
}
private int GetCountToPreviousLegalRotation(HackCard hackcard, int startingRotation = 0)
{
FindAndStoreAdjacentSquares();
for (int rotations = startingRotation; rotations < 4; rotations++)
{
string rotatedLeftCircuit = hackcard.GetLeftCircuit();
string rotatedTopCircuit = hackcard.GetTopCircuit();
string rotatedRightCircuit = hackcard.GetRightCircuit();
string rotatedBottomCircuit = hackcard.GetBottomCircuit();
for (int i = 0; i < rotations; i++)
{
string previousLeftCircuit = rotatedLeftCircuit;
rotatedLeftCircuit = rotatedTopCircuit;
rotatedTopCircuit = rotatedRightCircuit;
rotatedRightCircuit = rotatedBottomCircuit;
rotatedBottomCircuit = previousLeftCircuit;
}
bool isCurrentRotationLegal = CheckRotation(rotatedLeftCircuit, rotatedTopCircuit, rotatedRightCircuit, rotatedBottomCircuit);
if (isCurrentRotationLegal)
{
return(rotations);
}
}
return(-1);
}
private void SetPreviousCardAndModifiers()
{
previousTopHackCard = cards[0];
prevTempLeftCircuit = tempLeftCircuit;
prevTempTopCircuit = tempTopCircuit;
prevTempRightCircuit = tempRightCircuit;
prevtempBottomCircuit = tempBottomCircuit;
}
public HackCard GetCardById(int cardId)
{
string paddedCardId = "" + cardId.ToString("000");
string imagePath = "CardPrefabs/HackPlayer/HackCard" + paddedCardId;
HackCard newHackCard = Resources.Load <HackCard>(imagePath);
return(newHackCard);
}
public bool DoesSquareHaveCard()
{
HackCard attachedCard = GetComponentInChildren <HackCard>();
if (attachedCard)
{
return(true);
}
return(false);
}
public void ToggleToHackCard()
{
runnerMode = false;
cardBattleContextHolder.SetActive(false);
cardHackContextHolder.SetActive(true);
string paddedCardId = "" + card.GetCardId().ToString("000");
string imagePath = "CardPrefabs/HackPlayer/HackCard" + paddedCardId;
HackCard newHackCard = Resources.Load <HackCard>(imagePath);
hackCard = newHackCard;
cardHackImage.sprite = hackCard.GetCardImage();
SetupSpikes(hackCard);
}
private void CreateCardOption(HackCard card, int counter)
{
float imageOffset = cardWidth;
contentWidth += cardWidth;
if (counter > 0)
{
imageOffset += cardWidth / 4;
contentWidth += cardWidth / 4;
}
imageOffset *= counter;
HackDummyTile newDummyCard = Instantiate(hackDummyTile, new Vector2(transform.position.x + imageOffset, transform.position.y), Quaternion.identity);
newDummyCard.transform.SetParent(tileHolder.transform);
newDummyCard.SetupDummyTile(card);
tileOptions.Add(newDummyCard);
}
public void AddConnectionsToActiveCard(int number, string color)
{
HackCard topCard = cards[0];
// in circuit array: 0 = left, 1 = top, 2 = right, 3 = bottom
string[] circuits = { topCard.GetLeftCircuit(), topCard.GetTopCircuit(), topCard.GetRightCircuit(), topCard.GetBottomCircuit() };
List <int> emptyColorIndices = new List <int>();
List <int> differentColorIndices = new List <int>();
List <int> sameColorIndices = new List <int>();
for (int i = 0; i < circuits.Length; i++)
{
if (circuits[i] == color)
{
sameColorIndices.Add(i);
}
else if (circuits[i] == "none")
{
emptyColorIndices.Add(i);
}
else
{
differentColorIndices.Add(i);
}
}
for (int i = 0; i < number; i++)
{
if (emptyColorIndices.Count > 0)
{
int indexToUse = Random.Range(0, emptyColorIndices.Count);
SetTemporaryCircuit(emptyColorIndices[indexToUse], color);
emptyColorIndices.RemoveAt(indexToUse);
}
else if (differentColorIndices.Count > 0)
{
int indexToUse = Random.Range(0, differentColorIndices.Count);
SetTemporaryCircuit(differentColorIndices[indexToUse], color);
differentColorIndices.RemoveAt(indexToUse);
}
}
SetTopCard();
}
private void SetupSpikes(HackCard hackCard)
{
string emptyImagePath = "CardParts/Circuits/EMPTYCIRCUIT";
if (hackCard.GetTopLeftSpike().GetSpikeColor() != "none")
{
string topLeftSpikePath = "CardParts/Spikes/" + hackCard.GetTopLeftSpike().GetSpikeColor().ToUpper() + "-UPLEFT";
topLeftSpikeImage.sprite = Resources.Load <Sprite>(topLeftSpikePath);
}
else
{
topLeftSpikeImage.sprite = Resources.Load <Sprite>(emptyImagePath);
}
if (hackCard.GetTopRightSpike().GetSpikeColor() != "none")
{
string topRightSpikePath = "CardParts/Spikes/" + hackCard.GetTopRightSpike().GetSpikeColor().ToUpper() + "-UPRIGHT";
topRightSpikeImage.sprite = Resources.Load <Sprite>(topRightSpikePath);
}
else
{
topRightSpikeImage.sprite = Resources.Load <Sprite>(emptyImagePath);
}
if (hackCard.GetBottomLeftSpike().GetSpikeColor() != "none")
{
string bottomLeftSpikePath = "CardParts/Spikes/" + hackCard.GetBottomLeftSpike().GetSpikeColor().ToUpper() + "-BOTTOMLEFT";
bottomLeftSpikeImage.sprite = Resources.Load <Sprite>(bottomLeftSpikePath);
}
else
{
bottomLeftSpikeImage.sprite = Resources.Load <Sprite>(emptyImagePath);
}
if (hackCard.GetbottomRightSpike().GetSpikeColor() != "none")
{
string bottomRightSpikePath = "CardParts/Spikes/" + hackCard.GetbottomRightSpike().GetSpikeColor().ToUpper() + "-BOTTOMRIGHT";
bottomRightSpikeImage.sprite = Resources.Load <Sprite>(bottomRightSpikePath);
}
else
{
bottomRightSpikeImage.sprite = Resources.Load <Sprite>(emptyImagePath);
}
}
public void ReAttachTopCardFromDiscard(HackCard cardFromDiscard)
{
// TODO: THIS NEEDS TO GET THE TOP CARD FROM DISCARD, NOT THE PREVIOUSLY PLAYED CARD
// TODO: THIS IS BAD!!!!!!
// reattaching from discard works differently and the animation is handled by the discard
// pile, so we need a separate method
if (cards.Count > 0)
{
ShiftAllCardsDownOneInOrder();
cards[0] = cardFromDiscard;
ReSetPrevModifiers();
}
else
{
cards.Add(cardFromDiscard);
ReSetPrevModifiers();
}
SetTopCard();
SetTextFieldCount();
}
public void SetupCardSample(
HackCard newHackCard,
Card newCard,
Sprite topLeftSpikeImage,
Sprite topRightSpikeImage,
Sprite bottomLeftSpikeImage,
Sprite bottomRightSpikeImage
)
{
runnerCard.SetActive(false);
hackerCard.SetActive(true);
hackCard = newHackCard;
card = newCard;
hackerCardImage.sprite = hackCard.GetCardImage();
hackerCardLeftCircuit.sprite = card.GetLeftCircuitImage();
hackerCardTopCircuit.sprite = card.GetTopCircuitImage();
hackerCardRightCircuit.sprite = card.GetRightCircuitImage();
hackerCardBottomCircuit.sprite = card.GetBottomCircuitImage();
topLeftSpike.sprite = topLeftSpikeImage;
topRightSpike.sprite = topRightSpikeImage;
bottomLeftSpike.sprite = bottomLeftSpikeImage;
bottomRightSpike.sprite = bottomRightSpikeImage;
}
public void SetTopCard()
{
Image[] imageHolders = GetComponentsInChildren <Image>();
AllSpikeImages allSpikeImages = FindObjectOfType <AllSpikeImages>();
if (cards.Count == 0)
{
foreach (Image image in imageHolders)
{
image.sprite = allSpikeImages.GetEmptyImage();
}
}
else
{
HackCard topCard = cards[0];
foreach (Image image in imageHolders)
{
switch (image.name)
{
case "HackDeckCardBack":
image.sprite = allSpikeImages.GetCardBack();
break;
case "LeftCircuit":
string color;
if (tempLeftCircuit != null)
{
color = tempLeftCircuit;
}
else
{
color = topCard.GetLeftCircuit();
}
Sprite currentImage = allSpikeImages.GetCircuitImageByColorAndDirection(color, "left");
image.sprite = currentImage;
break;
case "TopCircuit":
if (tempTopCircuit != null)
{
color = tempTopCircuit;
}
else
{
color = topCard.GetTopCircuit();
}
currentImage = allSpikeImages.GetCircuitImageByColorAndDirection(color, "top");
image.sprite = currentImage;
break;
case "RightCircuit":
if (tempRightCircuit != null)
{
color = tempRightCircuit;
}
else
{
color = topCard.GetRightCircuit();
}
currentImage = allSpikeImages.GetCircuitImageByColorAndDirection(color, "right");
image.sprite = currentImage;
break;
case "DownCircuit":
if (tempBottomCircuit != null)
{
color = tempBottomCircuit;
}
else
{
color = topCard.GetBottomCircuit();
}
currentImage = allSpikeImages.GetCircuitImageByColorAndDirection(color, "bottom");
image.sprite = currentImage;
break;
case "TopLeftSpike":
Spike currentspike = topCard.GetTopLeftSpike();
string state = currentspike.GetSpikeState();
color = currentspike.GetSpikeColor();
currentImage = allSpikeImages.GetSpikebyColorCornerAndState(color, "topleft", state);
image.sprite = currentImage;
break;
case "TopRightSpike":
currentspike = topCard.GetTopRightSpike();
state = currentspike.GetSpikeState();
color = currentspike.GetSpikeColor();
currentImage = allSpikeImages.GetSpikebyColorCornerAndState(color, "topright", state);
image.sprite = currentImage;
break;
case "BottomLeftSpike":
currentspike = topCard.GetBottomLeftSpike();
state = currentspike.GetSpikeState();
color = currentspike.GetSpikeColor();
currentImage = allSpikeImages.GetSpikebyColorCornerAndState(color, "bottomleft", state);
image.sprite = currentImage;
break;
case "BottomRightSpike":
currentspike = topCard.GetbottomRightSpike();
state = currentspike.GetSpikeState();
color = currentspike.GetSpikeColor();
currentImage = allSpikeImages.GetSpikebyColorCornerAndState(color, "bottomright", state);
image.sprite = currentImage;
break;
case "CardImage":
image.sprite = topCard.GetCardImage();
break;
}
}
}
}
public void SetPreviousTopHackCard(HackCard card)
{
previousTopHackCard = card;
}
public void SetupDummyTile(HackCard card)
{
Image[] images = GetComponentsInChildren <Image>();
id = card.GetCardId();
foreach (Image image in images)
{
switch (image.name)
{
case "LeftCircuit":
circuitLeft = card.GetImageByGameObjectName("Left");
if (circuitLeft != null)
{
image.sprite = circuitLeft;
}
else
{
image.sprite = emptyImageSprite;
}
break;
case "TopCircuit":
circuitTop = card.GetImageByGameObjectName("Up");
if (circuitTop != null)
{
image.sprite = circuitTop;
}
else
{
image.sprite = emptyImageSprite;
}
break;
case "RightCircuit":
circuitRight = card.GetImageByGameObjectName("Right");
if (circuitRight != null)
{
image.sprite = circuitRight;
}
else
{
image.sprite = emptyImageSprite;
}
break;
case "DownCircuit":
circuitDown = card.GetImageByGameObjectName("Down");
if (circuitDown != null)
{
image.sprite = circuitDown;
}
else
{
image.sprite = emptyImageSprite;
}
break;
case "TopLeftSpike":
spikeTopLeft = card.GetImageByGameObjectName("TopLeft");
if (spikeTopLeft != null)
{
image.sprite = spikeTopLeft;
}
else
{
image.sprite = emptyImageSprite;
}
break;
case "TopRightSpike":
spikeTopRight = card.GetImageByGameObjectName("TopRight");
if (spikeTopRight != null)
{
image.sprite = spikeTopRight;
}
else
{
image.sprite = emptyImageSprite;
}
break;
case "BottomLeftSpike":
spikeBottomLeft = card.GetImageByGameObjectName("BottomLeft");
if (spikeBottomLeft != null)
{
image.sprite = spikeBottomLeft;
}
else
{
image.sprite = emptyImageSprite;
}
break;
case "BottomRightSpike":
spikeBottomRight = card.GetImageByGameObjectName("BottomRight");
if (spikeBottomRight != null)
{
image.sprite = spikeBottomRight;
}
else
{
image.sprite = emptyImageSprite;
}
break;
case "FrontImage":
cardImage = card.GetImageByGameObjectName("Image");
if (cardImage != null)
{
image.sprite = cardImage;
}
else
{
image.sprite = emptyImageSprite;
}
break;
case "Selected":
selectedImage = image;
break;
}
}
}
public void AddCardToDiscard(HackCard card)
{
cards.Add(card);
SetTopCard();
UpdateTextFieldCounter();
}
