IEnumerator NetworkActivate(int player, IndividualCard myCard)
{
myCard.SelectCard();
myCard.cardType = 15;
myCard.isPoison = true;
myCard.selectedEffect = (GameObject)Instantiate(selectPrefab, myCard.transform.position, Quaternion.identity);
yield return(new WaitForSeconds(GS.a.powerUpSettings.poison_activeTime));
if (network_scoreboard [player] != null)
{
network_scoreboard [player].GetComponent <DisableAndDestroy> ().Engage();
}
network_scoreboard [player] = null;
myCard.UnSelectCard();
}
public void Activate(IndividualCard myCard)
{
if (isChecking)
{
return;
}
//check if we have done the first round
int i = 0;
if (mem_Cards [0] != null || mem_Cards[1] != null)
{
i = 2;
}
//select the card the player chose
SelectCard(myCard, i);
//select a random card
SelectRandomCard(i + 1);
if (i == 0)
{
if (mem_Cards [0].cardType == mem_Cards [1].cardType)
{
isChecking = true;
Invoke("CheckCards", GS.a.powerUpSettings.earth_checkSpeed);
}
else
{
LocalPlayerController.s.canSelect = true;
}
}
else
{
isChecking = true;
Invoke("CheckCards", GS.a.powerUpSettings.earth_checkSpeed);
}
if (counter >= GS.a.powerUpSettings.earth_activeCount)
{
Disable();
}
}
public override IEnumerator MainLoop()
{
yield return(new WaitForSeconds(0.5f));
IndividualCard curTarget = null;
List <IndividualCard> myCards;
while (true)
{
do
{
myCards = GetRandomizedMoveableCardList();
yield return(new WaitForSeconds(0.5f));
} while (myCards.Count == 0);
curTarget = GetRandomizedMoveableCardList()[0];
yield return(MoveToPosition(curTarget));
if (!Select(curTarget))
{
Denied();
}
yield return(new WaitForSeconds(selectWaitTime));
if (curTarget == null)
{
yield return(new WaitForSeconds(reactionTime));
continue;
}
while (curTarget.cBase != GS.a.cardSet.matchedCard)
{
Activate(curTarget);
ScoreBoardManager.s.AddScore(DataHandler.s.myPlayerInteger, 0, -1, true);
yield return(new WaitForSeconds(periodicAttackTime));
}
Die(false);
}
}
public void ReceiveNPCAction(int x, int y, int index, ActionType action, int data)
{
IndividualCard card = null;
try {
if (x != -1 && y != -1)
{
card = CardHandler.s.allCards[x, y];
}
} catch {
DataLogger.LogError("ReceiveNPCAction couldnt find the card " + x.ToString() + "-" + y.ToString());
}
try {
NPCBase myNPC = null;
if (action != ActionType.Spawn)
{
myNPC = ActiveNPCS[index];
}
switch (action)
{
case ActionType.Spawn:
DataLogger.LogError("Customs NPCs are not implemented to spawn yet! Spawning default level npc");
myNPC = SpawnNPCAtLocation(card, GS.a.myNPCPrefab);
ActiveNPCS.SetIndex(index, myNPC);
break;
case ActionType.Die:
case ActionType.SelectCard:
case ActionType.Activate:
case ActionType.GoToPos:
myNPC.ReceiveNPCAction(card, action, data);
break;
default:
DataLogger.LogError("Unrecognized power up action PUF");
break;
}
} catch (System.Exception e) {
DataLogger.LogError(this.name, e);
}
}
public void ReceiveAction(int player, int x, int y, PowerUpManager.ActionType action)
{
try {
switch (action)
{
case PowerUpManager.ActionType.Enable:
network_scoreboard [player] = (GameObject)Instantiate(scoreboardPrefab, ScoreBoardManager.s.scoreBoards [player].transform);
network_scoreboard [player].transform.ResetTransformation();
break;
case PowerUpManager.ActionType.Activate:
IndividualCard myCard = CardHandler.s.allCards [x, y];
Instantiate(activatePrefab, myCard.transform.position, Quaternion.identity);
break;
case PowerUpManager.ActionType.SelectCard:
IndividualCard myCard2 = CardHandler.s.allCards [x, y];
if (myCard2.isSelectable)
{
myCard2.SelectCard();
}
else
{
DataHandler.s.NetworkCorrection(myCard2);
}
break;
case PowerUpManager.ActionType.Disable:
if (network_scoreboard [player] != null)
{
network_scoreboard [player].GetComponent <DisableAndDestroy> ().Engage();
}
network_scoreboard [player] = null;
break;
default:
DataLogger.LogError("Unrecognized power up action PUF");
break;
}
} catch (System.Exception e) {
DataLogger.LogError(this.name, e);
}
}
public override void SetUp(int playerID, bool isPowerUp, IndividualCard card1, IndividualCard card2)
{
/*if (card1.cBase.score == 0) {
* Destroy (gameObject);
* return;
* }*/
//print ("Trying to spawn and align effect: " + name);
AlignBetweenCards(card1, card2, AlignMode.position);
unifier1.transform.position = card1.transform.position - Vector3.forward * 0.1f;
unifier2.transform.position = card2.transform.position - Vector3.forward * 0.1f;
float deltaUnifier = Mathf.Abs((card1.transform.position - card2.transform.position).magnitude) / 2f;
aUnifier = 2 * deltaUnifier / (uniTimer * uniTimer);
vUnifier = 0;
List <Transform> targets = new List <Transform> ();
if (!isPowerUp)
{
targets.Add(ScoreBoardManager.s.scoreGetTargets[playerID]);
}
else
{
targets.Add(ScoreBoardManager.s.powerGetTargets[0]);
targets.Add(ScoreBoardManager.s.powerGetTargets[0]);
}
target = targets[Random.Range(0, targets.Count)];
float deltax = target.position.x - transform.position.x;
float deltay = target.position.y - transform.position.y;
vx = deltax * xMul;
vy = deltay * yMul;
ax = 2 * (deltax - (vx * timer)) / (timer * timer);
ay = 2 * (deltay - (vy * timer)) / (timer * timer);
StartCoroutine(Move());
}
IEnumerator NetworkDisable(int player, IndividualCard myCard)
{
myCard.SelectCard();
Instantiate(activatePrefab, myCard.transform.position, Quaternion.identity);
myCard.selectedEffect = (GameObject)Instantiate(selectPrefab, myCard.transform.position, Quaternion.identity);
yield return(new WaitForSeconds(GS.a.powerUpSettings.poison_checkSpeed / 4f));
for (int i = 0; i < GS.a.powerUpSettings.poison_damage; i++)
{
GameObject exp = (GameObject)Instantiate(scoreLowerExplosionPrefab, ScoreBoardManager.s.scoreBoards [player].transform);
exp.transform.ResetTransformation();
yield return(new WaitForSeconds((GS.a.powerUpSettings.poison_checkSpeed / 2f) / (float)GS.a.powerUpSettings.poison_damage));
}
yield return(new WaitForSeconds(GS.a.powerUpSettings.poison_checkSpeed / 4f));
myCard.PoisonMatch();
}
static void SpawnEffectBetweenCards(GameObject fx, int playerID, IndividualCard card1, IndividualCard card2, Color effectColor)
{
if (card1.cBase.effectColor.a <= 0.5f)
{
card1.cBase.effectColor = PowerUpManager.s.dragonColors[0];
}
if (fx != null)
{
GameObject myFx = Instantiate(fx);
if (myFx.GetComponent <BetweenCardsEffect> () != null)
{
myFx.GetComponent <BetweenCardsEffect> ().SetUp(playerID, card1.cBase.isPowerUpRelated, card1, card2);
}
if (myFx.GetComponent <ElementalTypeSpriteColorChanger> () != null)
{
myFx.GetComponent <ElementalTypeSpriteColorChanger> ().ChangeColor(card1.cBase.effectColor);
}
}
}
IEnumerator _Activate(IndividualCard myCard, int _power, float _amount)
{
activateEffect.transform.localScale = new Vector3(-((_power - 1f) / 1.9f), 1f + ((_power - 1.5f) / 7f), 1);
yield return(new WaitForSeconds(0.1f));
for (int i = 0; i < _power; i++)
{
Select(GetLineSequence(myCard, i, _power));
yield return(new WaitForSeconds(0.03f));
}
CheckCards(0.4f + (0.02f * _power));
amount--;
if (amount <= 0)
{
Disable();
}
}
protected IEnumerator MoveToPosition(IndividualCard to)
{
if (to == null)
{
yield return(null);
}
else
{
if (DataHandler.s.myPlayerInteger == 0)
{
SendNPCAction(to.x, to.y, NPCManager.ActionType.GoToPos, -1);
}
if (selectionHintEffect != null)
{
Instantiate(selectionHintEffect, to.transform.position, selectionHintEffect.transform.rotation);
}
yield return(MoveToPositionCoroutine(to));
}
}
IEnumerator NetworkNetherRoutine(int _power, float _amount)
{
//----------------------new
//GameObject netherEffect = (GameObject)Instantiate (netherEffectPrefab, Vector3.zero, Quaternion.identity);
//yield return new WaitForSeconds (netherActiveTime);
//----------------------new
int gridSizeX = CardHandler.s.allCards.GetLength(0);
int gridSizeY = CardHandler.s.allCards.GetLength(1);
for (int y = 0; y < gridSizeY; y++)
{
//----------------------old
IndividualCard NetherPos = CardHandler.s.allCards[0, y];
GameObject netherEffect = (GameObject)Instantiate(netherEffectPrefab, NetherPos.transform.position, Quaternion.identity);
//----------------------old
for (int x = 0; x < gridSizeX; x++)
{
IndividualCard myCardS = CardHandler.s.allCards[x, y];
if (myCardS.cBase == null)
{
GameObject netherGetEffect = (GameObject)Instantiate(getEffectPrefab, myCardS.transform.position - Vector3.forward, Quaternion.identity);
//myCardS.cardType = 5;
//myCardS.cardType = 0;
yield return(new WaitForSeconds(0.01f));
}
else
{
//myCardS.JustRotate ();
myCardS.NetherReset();
}
yield return(new WaitForSeconds(0.005f));
}
yield return(new WaitForSeconds(0.05f));
}
yield return(null);
}
//-----------------------------------------------------------------------------------------------Helper Functions
IEnumerator SelectSquareCards(IndividualCard center)
{
Instantiate(activatePrefab, center.transform.position, Quaternion.identity);
//yield return new WaitForSeconds (effectActiveTime);
int gridSizeX = CardHandler.s.allCards.GetLength(0);
int gridSizeY = CardHandler.s.allCards.GetLength(1);
//get cards
int leftLimit = (int)Mathf.Clamp(center.x - 1, 0, gridSizeX - 1);
int rightLimit = (int)Mathf.Clamp(center.x + 1, 0, gridSizeX - 1);
int downLimit = (int)Mathf.Clamp(center.y - 1, 0, gridSizeY - 1);
int upLimit = (int)Mathf.Clamp(center.y + 1, 0, gridSizeY - 1);
int n = 0;
for (int i = leftLimit; i <= rightLimit; i++)
{
for (int m = downLimit; m <= upLimit; m++)
{
IndividualCard myCardS = CardHandler.s.allCards [i, m];
if (myCardS.cardType != 0)
{
if (myCardS.isSelectable)
{
SelectCard(myCardS, n);
n++;
yield return(new WaitForSeconds(0.05f));
}
}
}
}
yield return(new WaitForSeconds(0.3f));
CheckCards();
}
IEnumerator _Activate(IndividualCard myCard, int _power, float _amount)
{
yield return(new WaitForSeconds(0.1f));
for (int i = 0; i < _power; i++)
{
Select(GetAreaSequence(myCard, i, _power));
if (i % 4 == 0)
{
yield return(new WaitForSeconds(0.03f));
}
}
CheckCards(0.4f + (0.02f * _power));
amount--;
if (amount <= 0)
{
Disable();
}
}
NPCBase SpawnNPCAtLocation(IndividualCard myCard, NPCBase myNPCPrefab)
{
if (myNPCPrefab == null)
{
DataLogger.LogError("Trying to spawn null npc");
return(null);
}
NPCBase myNPC = Instantiate(myNPCPrefab.gameObject, npcSpawnPos.position, Quaternion.identity).GetComponent <NPCBase> ();
myNPC.transform.localScale = new Vector3(1, 1, 1) * GS.a.gridSettings.scaleMultiplier;
myNPC.Spawn(myCard);
if (DataHandler.s.myPlayerInteger == 0)
{
ActiveNPCS.Add(myNPC);
SendNPCAction(myCard.x, myCard.y, myNPC.GetComponent <NPCBase> (), ActionType.Spawn, -1);
}
return(myNPC);
}
IEnumerator MoveOneSpot(IndividualCard from, IndividualCard to)
{
//Vector3 startPos = from.transform.position + cardOffset;
Vector3 endPos = to.transform.position + cardOffset;
while (Vector3.Distance(transform.position, endPos) > 0.01f)
{
if (!isStunned)
{
transform.position = Vector3.Lerp(transform.position, endPos, Time.deltaTime * 20f);
}
yield return(null);
}
transform.position = endPos;
from.myOccupants.Remove(this);
to.myOccupants.Add(this);
myCurrentOccupation = to;
yield return(null);
}
IEnumerator MoveToStartPos(IndividualCard myCard)
{
//come back to this sometime to comment this section please!
transform.position = myCard.transform.position + cardOffset + cardOffset + cardOffset + startingPositionOffset;
Vector3 endPos = myCard.transform.position + cardOffset;
while (Vector3.Distance(transform.position, endPos) > 0.01f)
{
transform.position = Vector3.Lerp(transform.position, endPos, Time.deltaTime * 10f);
yield return(null);
}
transform.position = endPos;
myCurrentOccupation = myCard;
if (DataHandler.s.myPlayerInteger == 0)
{
StartCoroutine(MainLoop());
}
}
public override IEnumerator MainLoop()
{
yield return(new WaitForSeconds(0.5f));
IndividualCard curTarget = null;
while (true)
{
List <IndividualCard> allCards = GetAllCards();
RandFuncs.Shuffle(allCards);
foreach (IndividualCard card in allCards)
{
if (card.currentSelectingPlayer != -1)
{
curTarget = card;
break;
}
}
if (curTarget == null)
{
yield return(new WaitForSeconds(reactionTime));
continue;
}
yield return(MoveToPosition(curTarget));
while (curTarget.currentSelectingPlayer != -1)
{
Activate(curTarget);
ScoreBoardManager.s.AddScore(curTarget.currentSelectingPlayer, 0, -1, true);
yield return(new WaitForSeconds(periodicAttackTime));
}
yield return(new WaitForSeconds(reactionTime));
}
}
public void ReceiveEnemyPowerUpActions(int player, int x, int y, PUpTypes type, int id, int power, float amount, ActionType action)
{
IndividualCard card = null;
try {
if (x != -1 && y != -1)
{
card = CardHandler.s.allCards[x, y];
}
} catch {
DataLogger.LogError("ReceiveEnemyPowerUpActions couldnt find the card " + x.ToString() + "-" + y.ToString());
}
if (type == PUpTypes.equipment)
{
equipmentPUps[id].ReceiveAction(player, card, power, amount, action);
}
else
{
potionPUps[id].ReceiveAction(player, card, power, amount, action);
}
}
IEnumerator _Activate(IndividualCard myCard)
{
SendAction(myCard.x, myCard.y, PowerUpManager.ActionType.Activate);
myCard.SelectCard();
myCard.cardType = 15;
myCard.isPoison = true;
myCard.selectedEffect = (GameObject)Instantiate(selectPrefab, myCard.transform.position, Quaternion.identity);
indicator.GetComponent <DisableAndDestroy> ().Engage();
indicator = null;
LocalPlayerController.s.PowerUpMode(false);
PowerUpManager.s.canActivatePowerUp = true;
LocalPlayerController.s.canSelect = true;
yield return(new WaitForSeconds(GS.a.powerUpSettings.poison_activeTime));
myCard.UnSelectCard();
}
/*Vector3 DefPos;
* IEnumerator FloatAround () {
* DefPos = transform.position;
*
* int random = Random.Range (0, 10000);
*
* yield return new WaitForSeconds (Random.Range(0, 2f));
*
* while (true) {
* Vector3 goToPos = Random.insideUnitSphere/5f + DefPos;
* //Vector3 goToPos = new Vector3 (temp.x, temp.y, DefPos.z) + DefPos;
*
* float timer = Random.Range(1f,3f);
* float driftSpeed = Random.Range (0.01f, 0.05f);
* //print ("Card going to: " + goToPos.ToString());
* while (timer > 0) {
* transform.position = Vector3.MoveTowards (transform.position, goToPos, driftSpeed * Time.deltaTime);
* timer -= Time.deltaTime;
* yield return null;
* }
* yield return null;
* }
* }*/
public void SetOpenState(bool state)
{
aud = GetComponent <AudioPlayer> ();
card = GetComponent <IndividualCard> ();
isOpen = state;
if (!isMatched)
{
InstantSetAlphaStates();
StopAllCoroutines();
if (isOpen)
{
aud.OpenSound();
StartCoroutine(RotateTo(openRotation, openTime));
}
else
{
aud.CloseSound();
StartCoroutine(RotateTo(closeRotation, openTime));
}
}
}
IEnumerator _ChoosePoisonCard(int myPlayerinteger, IndividualCard myCard)
{
bool temp = true;
if (myPlayerinteger == DataHandler.s.myPlayerInteger)
{
//LocalPlayerController.s.canSelect = false;
//temp = PowerUpManager.s.canActivatePowerUp;
//PowerUpManager.s.canActivatePowerUp = false;
}
myCard.SelectCard();
Instantiate(activatePrefab, myCard.transform.position, Quaternion.identity);
myCard.selectedEffect = (GameObject)Instantiate(selectPrefab, myCard.transform.position, Quaternion.identity);
myCard.isPoison = false;
print("poison coroutine started");
yield return(new WaitForSeconds(GS.a.powerUpSettings.poison_checkSpeed / 4f));
for (int i = 0; i < GS.a.powerUpSettings.poison_damage; i++)
{
ScoreBoardManager.s.AddScore(myPlayerinteger, 0, -1, false);
GameObject exp = (GameObject)Instantiate(scoreLowerExplosionPrefab, ScoreBoardManager.s.scoreBoards [myPlayerinteger].transform);
exp.transform.ResetTransformation();
yield return(new WaitForSeconds((GS.a.powerUpSettings.poison_checkSpeed / 2f) / (float)GS.a.powerUpSettings.poison_damage));
}
yield return(new WaitForSeconds(GS.a.powerUpSettings.poison_checkSpeed / 4f));
if (myPlayerinteger == DataHandler.s.myPlayerInteger)
{
//LocalPlayerController.s.canSelect = true;
//PowerUpManager.s.canActivatePowerUp = temp;
}
myCard.PoisonMatch();
}
protected void Select(IndividualCard card)
{
if (card == null)
{
return;
}
if (card.isOccupied)
{
card.KillOccupants();
}
if (card.isSelectable)
{
card.SelectCard(-1);
SendAction(card.x, card.y, power, amount, PowerUpManager.ActionType.SelectCard);
mem_Cards.Add(card);
if (selectPrefab != null)
{
card.selectedEffect = (GameObject)Instantiate(selectPrefab, card.transform.position, Quaternion.identity);
}
}
}
IEnumerator DeadlyPoisonCard(int myPlayerinteger, IndividualCard myCard, DeadlyRoutineHolder holder)
{
myCard.SelectCard(myPlayerinteger);
float timer = myCard.cBase.poisonAmount;
GameObject myEffect = Instantiate(deadlyPoisonEffect, myCard.transform.position, Quaternion.identity);
myEffect.GetComponent <DeadlyPoisonEffect> ().SetUp(timer);
holder.effect = myEffect;
yield return(new WaitForSeconds(timer));
LocalPlayerController.s.canSelect = false;
GameObjectiveMaster.s.isGamePlaying = false;
Instantiate(deadlyPoisonExplodeEffect, myCard.transform.position, Quaternion.identity);
yield return(new WaitForSeconds(1f));
GameObjectiveMaster.s.EndGame(GameObjectiveMaster.s.WinnerID(false));
yield return(null);
}
//Area Sequence
/*
* 6 4 8
* 3 1 2
* 9 5 7
*/
protected IndividualCard GetAreaSequence(IndividualCard start, int areaId, int power)
{
int xLength = CardHandler.s.allCards.GetLength(0);
int yLength = CardHandler.s.allCards.GetLength(1);
int xOffset = 0;
int yOffset = 0;
switch (areaId + 1)
{
case 1:
//do nothing as this is the middle
break;
case 2:
xOffset = 1;
break;
case 3:
xOffset = -1;
break;
case 4:
yOffset = 1;
break;
case 5:
yOffset = -1;
break;
case 6:
xOffset = -1;
yOffset = 1;
break;
case 7:
xOffset = 1;
yOffset = -1;
break;
case 8:
xOffset = 1;
yOffset = 1;
break;
case 9:
xOffset = -1;
yOffset = -1;
break;
}
if ((xLength > start.x + xOffset && start.x + xOffset >= 0) &&
(yLength > start.y + yOffset && start.y + yOffset >= 0))
{
return(CardHandler.s.allCards[start.x + xOffset, start.y + yOffset]);
}
else
{
return(null);
}
}
/// <summary>
/// Dont use this method unless necessary, CheckCards will automatically unselect for you
/// </summary>
/// <param name="card"></param>
protected void UnSelect(IndividualCard card)
{
card.UnSelectCard();
DataHandler.s.SendPlayerAction(card.x, card.y, CardHandler.CardActions.UnSelect);
}
IEnumerator MoveToPositionCoroutine(IndividualCard to)
{
if (to == null)
{
yield return(new WaitForSeconds(1f));
}
to.isTargeted = true;
int distanceX = to.x - myCurrentOccupation.x;
int distanceY = to.y - myCurrentOccupation.y;
int distance = Mathf.Abs(distanceX) + Mathf.Abs(distanceY);
while (distance > 0)
{
int xOff = 0;
int yOff = 0;
if (distanceY > 0)
{
yOff = 1;
}
else if (distanceY < 0)
{
yOff = -1;
}
if (distanceX > 0)
{
xOff = 1;
}
else if (distanceX < 0)
{
xOff = -1;
}
if (Mathf.Abs(xOff) + Mathf.Abs(yOff) == 2)
{
if (Random.value > 0.5f)
{
xOff = 0;
}
else
{
yOff = 0;
}
}
if (Mathf.Abs(xOff) + Mathf.Abs(yOff) == 0)
{
break;
}
IndividualCard targetCard = CardHandler.s.allCards[myCurrentOccupation.x + xOff, myCurrentOccupation.y + yOff];
yield return(MoveOneSpot(myCurrentOccupation, targetCard));
distanceX = to.x - myCurrentOccupation.x;
distanceY = to.y - myCurrentOccupation.y;
distance = Mathf.Abs(distanceX) + Mathf.Abs(distanceY);
yield return(new WaitForSeconds(movementSpeed));
}
//moving finsihed
yield return(new WaitForSeconds(selectWaitTime));
}
public override void Activate(IndividualCard myCard)
{
base.Activate(myCard);
StartCoroutine(_Activate(myCard, power, amount));
}
// Use this for initialization
public override void SetUp(int playerID, bool isPowerUp, IndividualCard card1, IndividualCard card2)
{
Color myColor = card1.cBase.effectColor;
if (myColor.a <= 0.5f)
{
myColor = PowerUpManager.s.dragonColors[0];
}
//-----------------------------lightning bolt
Vector3[] places = new Vector3[2];
places[0] = card1.transform.position + (-Vector3.forward);
places[1] = card2.transform.position + (-Vector3.forward);
GetComponentInChildren <LineRenderer> ().startColor = myColor;
GetComponentInChildren <LineRenderer> ().endColor = myColor;
GetComponentInChildren <DigitalRuby.LightningBolt.LightningBoltScript> ().StartPosition = places[0];
GetComponentInChildren <DigitalRuby.LightningBolt.LightningBoltScript> ().EndPosition = places[1];
//-----------------------------particle attractor
if (card1.cBase.score != 0)
{
List <Transform> targets = new List <Transform> ();
if (!isPowerUp)
{
targets.Add(ScoreBoardManager.s.scoreGetTargets[playerID]);
}
else
{
targets.Add(ScoreBoardManager.s.powerGetTargets[0]);
targets.Add(ScoreBoardManager.s.powerGetTargets[1]);
}
foreach (ParticleSystem part in GetComponentsInChildren <ParticleSystem> ())
{
part.startColor = myColor;
}
try {
int n = 0;
foreach (particleAttractorLinear att in GetComponentsInChildren <particleAttractorLinear> ())
{
if (targets[n] == null)
{
n = IncrementN(n, targets);
}
if (targets[n] == null)
{
DataLogger.LogError("Trying to set null match effect target!");
}
att.target = targets[n];
n = IncrementN(n, targets);
}
} catch (System.Exception e) {
DataLogger.LogError("Cant set match effect target " + e.Message);
}
particles[0].transform.position = places[0];
particles[1].transform.position = places[1];
}
else
{
Destroy(particles[0].gameObject);
Destroy(particles[1].gameObject);
}
}
IEnumerator _Activate(IndividualCard myCard, float n)
{
yield return(new WaitForSeconds(n == 0 ? 0.7f : 0.4f));
Select(myCard);
}
public void Activate(IndividualCard myCard, float n)
{
base.Activate(myCard);
StartCoroutine(_Activate(myCard, n));
}
