public PowerUpTilesDto Use(PowerUpTilesDto powerUpTilesDto)
{
Debug.Log(powerUpTilesDto.TileIdToBeExploded);
int valueInTile = powerUpTilesDto.TileArray[powerUpTilesDto.TileIdToBeExploded].getVal();
int index = powerUpTilesDto.TileIdToBeExploded;
int gridSize = powerUpTilesDto.TileArray.Length;
powerUpTilesDto.TileArray[index].setVal(0);
if (powerUpTilesDto.Reverse == false)
{
while (valueInTile != 0)
{
index = (index + 1) % gridSize;
powerUpTilesDto.TileArray[index].setVal(powerUpTilesDto.TileArray[index].getVal() + 1);
valueInTile--;
}
}
else
{
while (valueInTile != 0)
{
if (index == 0)
{
index = gridSize - 1;
}
else
{
index = index - 1;
}
powerUpTilesDto.TileArray[index].setVal(powerUpTilesDto.TileArray[index].getVal() + 1);
valueInTile--;
}
}
return(powerUpTilesDto);
}
public PowerUpTilesDto Use(PowerUpTilesDto powerUpTilesDto)
{
inTile = gridArray[index];
gridArray[index] = 0;
if (!reverse)
{
while (inTile != 0)
{
index = (index + 1) % gridArray.Length;
gridArray[index]++;
inTile--;
}
}
else
{
while (inTile != 0)
{
if (index == 0)
{
index = gridArray.Length - 1;
}
else
{
index -= 1;
}
gridArray[index]++;
inTile--;
}
}
return(powerUpTilesDto);
}
public void UseSwapPowerUp()
{
// Debug.Log("swap called :" + reverse);
List <PowerUpBase> playerPowerUps;
if (turn == 1)
{
playerPowerUps = listPowerUp1.GetActivePowerUps();
}
else
{
playerPowerUps = listPowerUp2.GetActivePowerUps();
}
var swapPowerUp = playerPowerUps.FirstOrDefault(x => x.GetType().Equals("swap"));
PowerUpTilesDto powerUpTilesDto = getPowerUpDto(ScoreA: scoreValA, ScoreB: scoreValB, PreviousScoreA: preScoreValA, PreviousScoreB: preScoreValB);
powerUpTilesDto = swapPowerUp.Use(powerUpTilesDto);
if (turn == 1)
{
listPowerUp1.DisablePowerUp(swapPowerUp);
}
else
{
listPowerUp2.DisablePowerUp(swapPowerUp);
}
initializePowerUp(); //to disable used powerup
takeSnapShot(powerUpTilesDto);
EventSystem.current.SetSelectedGameObject(null);
}
public void UseReversePowerUp()
{
Debug.Log("reverse called :" + reverse);
List <PowerUpBase> playerPowerUps;
if (turn == 1)
{
playerPowerUps = listPowerUp1.GetActivePowerUps();
}
else
{
playerPowerUps = listPowerUp2.GetActivePowerUps();
}
var reversePowerUp = playerPowerUps.FirstOrDefault(x => x.GetType().Equals("reverse"));
PowerUpTilesDto powerUpTilesDto = getPowerUpDto();
powerUpTilesDto = reversePowerUp.Use(powerUpTilesDto);
reverse = powerUpTilesDto.Reverse;
if (turn == 1)
{
listPowerUp1.DisablePowerUp(reversePowerUp);
}
else
{
listPowerUp2.DisablePowerUp(reversePowerUp);
}
initializePowerUp(); //to disable used powerup
}
public void UseReversePowerUp()
{
Debug.Log("reverse called :" + reverse);
List <PowerUpBase> playerPowerUps;
if (turn == 1)
{
playerPowerUps = listPowerUp1.GetActivePowerUps();
}
else
{
playerPowerUps = listPowerUp2.GetActivePowerUps();
}
var reversePowerUp = playerPowerUps.FirstOrDefault(x => x.GetType().Equals("reverse"));
PowerUpTilesDto powerUpTilesDto = getPowerUpDto(ScoreA: scoreValA, ScoreB: scoreValB, PreviousScoreA: preScoreValA, PreviousScoreB: preScoreValB);
powerUpTilesDto = reversePowerUp.Use(powerUpTilesDto);
reverse = powerUpTilesDto.Reverse;
if (turn == 1)
{
listPowerUp1.DisablePowerUp(reversePowerUp);
}
else
{
listPowerUp2.DisablePowerUp(reversePowerUp);
}
usedPowerUpList.Append("reverse|");
initializePowerUp(); //to disable used powerup
EventSystem.current.SetSelectedGameObject(null);
}
void takeSnapShot(PowerUpTilesDto powerUpTilesDto)
{
preScoreValA = scoreValA;
preScoreValB = scoreValB;
for (int i = 0; i < tileArray.Length; i++)
{
int currentVal = powerUpTilesDto.TileArray[i].getVal();
previousTileArray[i].setVal(currentVal);
}
}
// grid[] is an old_array
// gridArray[] is a TileArray that it's gonna be update
public PowerUpTilesDto Use(PowerUpTilesDto powerUpTilesDto, int[] grid)
{
int size = powerUpTilesDto.TileArray.Length;
for (int i = 0, i < size i++)
{
gridArray[i] = grid[i];
}
return(powerUpTilesDto);
}
public PowerUpTilesDto Use(PowerUpTilesDto powerUpTilesDto)
{
powerUpTilesDto.TileArray[powerUpTilesDto.TileIdToBeBlocked].setBlock();
for (int i = 0; i < 10; i++)
{
Debug.Log("ID: " + i + " : " + powerUpTilesDto.TileArray[i].getIsBlocked());
}
return(powerUpTilesDto);
}
public PowerUpTilesDto Use(PowerUpTilesDto powerUpTilesDto)
{
int size = powerUpTilesDto.TileArray.Length;
for (int i = 0, j = size - 1; i < size / 2; i++, j--)
{
gridArray[i] += gridArray[j];
gridArray[j] = gridArray[i] - gridArray[j];
gridArray[i] = gridArray[i] - gridArray[j];
}
return(powerUpTilesDto);
}
private PowerUpTilesDto getPowerUpDto(int tileIdToBeBlocked = -1, int tileIdToBeExploded = -1)
{
PowerUpTilesDto powerUpTilesDto = new PowerUpTilesDto();
powerUpTilesDto.TileArray = new Tile[tileArray.Length];
tileArray.CopyTo(powerUpTilesDto.TileArray, 0);
powerUpTilesDto.PreviousTileArray = new Tile[tileArray.Length];
tileArray.CopyTo(powerUpTilesDto.PreviousTileArray, 0);
powerUpTilesDto.TileIdToBeBlocked = tileIdToBeBlocked;
powerUpTilesDto.TileIdToBeExploded = tileIdToBeExploded;
powerUpTilesDto.Reverse = reverse;
return(powerUpTilesDto);
}
public PowerUpTilesDto Use(PowerUpTilesDto powerUpTilesDto)
{
int size = powerUpTilesDto.TileArray.Length;
for (int i = 0, j = size - 1; i < size / 2; i++, j--)
{
var tempValue = powerUpTilesDto.TileArray[i].getVal();
powerUpTilesDto.TileArray[i].setVal(powerUpTilesDto.TileArray[j].getVal());
powerUpTilesDto.TileArray[j].setVal(tempValue);
}
return(powerUpTilesDto);
}
public void UseUndoPowerUp()
{
turn *= -1;
List <PowerUpBase> playerPowerUps;
if (turn == 1)
{
playerPowerUps = listPowerUp1.GetActivePowerUps();
}
else
{
playerPowerUps = listPowerUp2.GetActivePowerUps();
}
var undoPowerUp = playerPowerUps.FirstOrDefault(x => x.GetType().Equals("undo"));
PowerUpTilesDto powerUpTilesDto = getPowerUpDto(ScoreA: scoreValA, ScoreB: scoreValB, PreviousScoreA: preScoreValA, PreviousScoreB: preScoreValB);
powerUpTilesDto.PreviousTileArray = previousTileArray;
powerUpTilesDto = undoPowerUp.Use(powerUpTilesDto);
if (turn == 1)
{
listPowerUp1.DisablePowerUp(undoPowerUp);
}
else
{
listPowerUp2.DisablePowerUp(undoPowerUp);
}
scoreA.GetComponentInChildren <Text>().text = "ScoreA: " + powerUpTilesDto.ScoreA;
scoreB.GetComponentInChildren <Text>().text = "ScoreB: " + powerUpTilesDto.ScoreB;
scoreValA = powerUpTilesDto.ScoreA;
scoreValB = powerUpTilesDto.ScoreB;
// undoPop.transform.localPosition = new Vector3(0, -380, 0);
allPopUps.gameObject.SetActive(false);
undoSuccess = true;
undoCancel = true;
usedPowerUpList.Append("undo|");
// turn *= -1;
checkTurnPowerUp();
turnDisable();
checkWinCon();
initializePowerUp();
EventSystem.current.SetSelectedGameObject(null);
}
public void UseShieldPowerUp(int index)
{
try
{
tileArray[blockedIndex].setUnblock();
} catch (Exception e)
{
}
blockedIndex = index;
explodeSelect.gameObject.SetActive(false);
List <PowerUpBase> playerPowerUps;
if (turn == 1)
{
playerPowerUps = listPowerUp1.GetActivePowerUps();
}
else
{
playerPowerUps = listPowerUp2.GetActivePowerUps();
}
var shieldPowerUp = playerPowerUps.FirstOrDefault(x => x.GetType().Equals("shield"));
PowerUpTilesDto powerUpTilesDto = getPowerUpDto(index, -1, ScoreA: scoreValA, ScoreB: scoreValB, PreviousScoreA: preScoreValA, PreviousScoreB: preScoreValB);
powerUpTilesDto = shieldPowerUp.Use(powerUpTilesDto);
if (turn == 1)
{
listPowerUp1.DisablePowerUp(shieldPowerUp);
}
else
{
listPowerUp2.DisablePowerUp(shieldPowerUp);
}
usedPowerUpList.Append("shield|");
takeSnapShot(powerUpTilesDto);
initializePowerUp();
turn *= -1;
checkTurnPowerUp();
turnDisable();
checkWinCon();
shieldCancel = true;
shieldPowerUpInUse = false;
EventSystem.current.SetSelectedGameObject(null);
}
public void UseSwapPowerUp()
{
isPowerUpButtonClicked = true;
nullify_powerup = "swap";
if ((turn * -1 == 1 && apList[5].interactable == true) || (turn * -1 == -1 && bpList[5].interactable == true))
{
if (turn * -1 == 1)
{
nullTextA.gameObject.SetActive(true);
}
else
{
nullTextB.gameObject.SetActive(true);
}
time_counter = 0;
isCalledNullify = true;
}
else
{
// Debug.Log("swap called :" + reverse);
List <PowerUpBase> playerPowerUps;
if (turn == 1)
{
playerPowerUps = listPowerUp1.GetActivePowerUps();
}
else
{
playerPowerUps = listPowerUp2.GetActivePowerUps();
}
var swapPowerUp = playerPowerUps.FirstOrDefault(x => x.GetType().Equals("swap"));
PowerUpTilesDto powerUpTilesDto = getPowerUpDto(ScoreA: scoreValA, ScoreB: scoreValB, PreviousScoreA: preScoreValA, PreviousScoreB: preScoreValB);
powerUpTilesDto = swapPowerUp.Use(powerUpTilesDto);
// reverse = powerUpTilesDto.Reverse;
if (turn == 1)
{
listPowerUp1.DisablePowerUp(swapPowerUp);
}
else
{
listPowerUp2.DisablePowerUp(swapPowerUp);
}
takeSnapshot(powerUpTilesDto);
initializePowerUp(); //to disable used powerup
}
}
public PowerUpTilesDto Use(PowerUpTilesDto powerUpTilesDto)
{
for (int i = 0; i < tileStateArray.Length; i++)
{
if (i == index)
{
tileStateArray[i] = false;
}
else
{
tileStateArray[i] = true;
}
}
return(powerUpTilesDto);
}
public void UseExplodePowerUp(int indexToBeExploded)
{
turn *= -1;
explodeSelect.gameObject.SetActive(false);
List <PowerUpBase> playerPowerUps;
if (turn == 1)
{
playerPowerUps = listPowerUp1.GetActivePowerUps();
}
else
{
playerPowerUps = listPowerUp2.GetActivePowerUps();
}
var explodePowerUp = playerPowerUps.FirstOrDefault(x => x.GetType().Equals("explode"));
PowerUpTilesDto powerUpTilesDto = getPowerUpDto(-1, indexToBeExploded, ScoreA: scoreValA, ScoreB: scoreValB, PreviousScoreA: preScoreValA, PreviousScoreB: preScoreValB);
powerUpTilesDto = explodePowerUp.Use(powerUpTilesDto);
powerUpTilesDto.TileArray.CopyTo(tileArray, 0);
if (turn == 1)
{
listPowerUp1.DisablePowerUp(explodePowerUp);
}
else
{
listPowerUp2.DisablePowerUp(explodePowerUp);
}
usedPowerUpList.Append("explode|");
takeSnapShot(powerUpTilesDto);
initializePowerUp(); //to disable used powerup
enableTiles();
turn *= -1;
checkTurnPowerUp();
turnDisable();
checkWinCon();
explodePowerUpInUse = false;
EventSystem.current.SetSelectedGameObject(null);
}
public void initializeUndoPowerUp()
{
Debug.Log("undo Initialized");
isUndoClickedB = false;
isUndoClickedA = false;
List <PowerUpBase> playerPowerUps;
if (turn == 1)
{
playerPowerUps = listPowerUp1.GetActivePowerUps();
}
else
{
playerPowerUps = listPowerUp2.GetActivePowerUps();
}
var undoPowerUp = playerPowerUps.FirstOrDefault(x => x.GetType().Equals("undo"));
PowerUpTilesDto powerUpTilesDto = getPowerUpDto(ScoreA: scoreValA, ScoreB: scoreValB, PreviousScoreA: preScoreValA, PreviousScoreB: preScoreValB);
powerUpTilesDto.PreviousTileArray = previousTileArray;
powerUpTilesDto.TileArray = tileArray;
powerUpTilesDto = undoPowerUp.Use(powerUpTilesDto);
if (turn == 1)
{
listPowerUp1.DisablePowerUp(undoPowerUp);
}
else
{
listPowerUp2.DisablePowerUp(undoPowerUp);
}
initializePowerUp(); //to disable used powerup
scoreA.GetComponentInChildren <Text>().text = "ScoreA: " + powerUpTilesDto.ScoreA;
scoreB.GetComponentInChildren <Text>().text = "ScoreB: " + powerUpTilesDto.ScoreB;
scoreValA = powerUpTilesDto.ScoreA;
scoreValB = powerUpTilesDto.ScoreB;
changeTurn();
changeTurn();
}
/*public void isCheckBlockPowerUpAvailable()
* {
* List<PowerUpBase> playerPowerUps;
* if (turn == 1)
* {
* playerPowerUps = listPowerUp1.GetActivePowerUps();
* }
* else
* {
* playerPowerUps = listPowerUp2.GetActivePowerUps();
* }
* Debug.Log("Inside isCheckBlock" + playerPowerUps.FirstOrDefault(x => x.GetType().Equals("shield")));
* var checkBlockPowerUp = playerPowerUps.FirstOrDefault(x => x.GetType().Equals("shield"));
*
*
* if (checkBlockPowerUp != null)
* {
* initiateBlockPowerUp();
* }
*
* }*/
public void blockTheCell(int indexToBeBlocked)
{
List <PowerUpBase> playerPowerUps;
if (turn == 1)
{
playerPowerUps = listPowerUp1.GetActivePowerUps();
}
else
{
playerPowerUps = listPowerUp2.GetActivePowerUps();
}
var blockPowerUp = playerPowerUps.FirstOrDefault(x => x.GetType().Equals("shield"));
Debug.Log(blockPowerUp);
Debug.Log("Inside blockTheCell" + indexToBeBlocked);
PowerUpTilesDto powerUpTilesDto = getPowerUpDto(indexToBeBlocked, -1, ScoreA: scoreValA, ScoreB: scoreValB, PreviousScoreA: preScoreValA, PreviousScoreB: preScoreValB);
powerUpTilesDto = blockPowerUp.Use(powerUpTilesDto);
powerUpTilesDto.TileArray.CopyTo(tileArray, 0);
Debug.Log("entered blockTheCell");
if (turn == 1)
{
listPowerUp1.DisablePowerUp(blockPowerUp);
}
else
{
listPowerUp2.DisablePowerUp(blockPowerUp);
}
isBlockButtonClicked = false;
initializePowerUp(); //to disable used powerup
enableTiles();
turn *= -1;
turnDisable();
Debug.Log("Done with block cell.");
EventSystem.current.SetSelectedGameObject(null);
}
public PowerUpTilesDto Use(PowerUpTilesDto powerUpTilesDto)
{
Debug.Log(" in use fun A" + powerUpTilesDto.PreviousScoreA);
Debug.Log(" in use fun B" + powerUpTilesDto.PreviousScoreB);
int size = powerUpTilesDto.TileArray.Length;
for (int i = 0; i < size; i++)
{
int prevVal = powerUpTilesDto.PreviousTileArray[i].getVal();
powerUpTilesDto.TileArray[i].setVal(prevVal);
}
powerUpTilesDto.ScoreA = powerUpTilesDto.PreviousScoreA;
powerUpTilesDto.ScoreB = powerUpTilesDto.PreviousScoreB;
Debug.Log(" in use fun after A" + powerUpTilesDto.ScoreA);
Debug.Log(" in use fun after B" + powerUpTilesDto.ScoreB);
return(powerUpTilesDto);
}
public void UseExplodePowerUp(int indexToBeBlocked)
{
turn *= -1;
explodeSelect.gameObject.SetActive(false);
List <PowerUpBase> playerPowerUps;
if (turn == 1)
{
playerPowerUps = listPowerUp1.GetActivePowerUps();
}
else
{
playerPowerUps = listPowerUp2.GetActivePowerUps();
}
var explodePowerUp = playerPowerUps.FirstOrDefault(x => x.GetType().Equals("explode"));
PowerUpTilesDto powerUpTilesDto = getPowerUpDto(-1, indexToBeBlocked);
powerUpTilesDto = explodePowerUp.Use(powerUpTilesDto);
powerUpTilesDto.TileArray.CopyTo(tileArray, 0);
if (turn == 1)
{
listPowerUp1.DisablePowerUp(explodePowerUp);
}
else
{
listPowerUp2.DisablePowerUp(explodePowerUp);
}
initializePowerUp(); //to disable used powerup
enableTiles();
turn *= -1;
turnDisable();
explodePowerUpInUse = false;
EventSystem.current.SetSelectedGameObject(null);
}
// Update is called once per frame
void Update()
{
if (isCalledNullify)
{
time_counter += Time.deltaTime;
if (time_counter >= 5.0f)
{
Debug.Log(time_counter);
isCalledNullify = false;
time_counter = 0;
nullTextA.gameObject.SetActive(false);
nullTextB.gameObject.SetActive(false);
Debug.Log("isNullifyButtonClicked A : " + isNullifyButtonClickedA);
Debug.Log("isNullifyButtonClicked B : " + isNullifyButtonClickedB);
if (nullify_powerup == "explode")
{
//ExplodedPowerUpInitiated();
if ((turn == 1 && isNullifyButtonClickedB) || (turn == -1 && isNullifyButtonClickedA))
{
initializeNullifyPowerUp(nullify_powerup);
nullify_powerup = "";
isPowerUpButtonClicked = false;
}
else
{
nullify_powerup = "";
explodePowerUpInUse = true;
explodeSelect.gameObject.SetActive(true);
explodeSelect.text = "Select the tile to explode! BOOM!";
turn *= -1; //to explode opponent's tile
turnDisable();
isPowerUpButtonClicked = false;
}
}
else if (nullify_powerup == "swap")
{
if ((turn == 1 && isNullifyButtonClickedB) || (turn == -1 && isNullifyButtonClickedA))
{
initializeNullifyPowerUp(nullify_powerup);
nullify_powerup = "";
isPowerUpButtonClicked = false;
}
else
{
nullify_powerup = "";
// Debug.Log("swap called :" + reverse);
List <PowerUpBase> playerPowerUps;
if (turn == 1)
{
playerPowerUps = listPowerUp1.GetActivePowerUps();
}
else
{
playerPowerUps = listPowerUp2.GetActivePowerUps();
}
var swapPowerUp = playerPowerUps.FirstOrDefault(x => x.GetType().Equals("swap"));
PowerUpTilesDto powerUpTilesDto = getPowerUpDto(ScoreA: scoreValA, ScoreB: scoreValB, PreviousScoreA: preScoreValA, PreviousScoreB: preScoreValB);
powerUpTilesDto = swapPowerUp.Use(powerUpTilesDto);
// reverse = powerUpTilesDto.Reverse;
if (turn == 1)
{
listPowerUp1.DisablePowerUp(swapPowerUp);
}
else
{
listPowerUp2.DisablePowerUp(swapPowerUp);
}
takeSnapshot(powerUpTilesDto);
initializePowerUp(); //to disable used powerup
}
}
else if (nullify_powerup == "reverse")
{
if ((turn == 1 && isNullifyButtonClickedB) || (turn == -1 && isNullifyButtonClickedA))
{
initializeNullifyPowerUp(nullify_powerup);
nullify_powerup = "";
isPowerUpButtonClicked = false;
}
else
{
nullify_powerup = "";
Debug.Log("reverse called :" + reverse);
List <PowerUpBase> playerPowerUps;
if (turn == 1)
{
playerPowerUps = listPowerUp1.GetActivePowerUps();
}
else
{
playerPowerUps = listPowerUp2.GetActivePowerUps();
}
var reversePowerUp = playerPowerUps.FirstOrDefault(x => x.GetType().Equals("reverse"));
PowerUpTilesDto powerUpTilesDto = getPowerUpDto(ScoreA: scoreValA, ScoreB: scoreValB, PreviousScoreA: preScoreValA, PreviousScoreB: preScoreValB);
powerUpTilesDto = reversePowerUp.Use(powerUpTilesDto);
reverse = powerUpTilesDto.Reverse;
if (turn == 1)
{
listPowerUp1.DisablePowerUp(reversePowerUp);
}
else
{
listPowerUp2.DisablePowerUp(reversePowerUp);
}
initializePowerUp(); //to disable used powerup
}
}
}
}
if (isCalledBlock)
{
time_counter += Time.deltaTime;
if (time_counter >= 5.0f)
{
time_counter = 0;
isCalledBlock = false;
//undoTextA.gameObject.SetActive(false);
//undoTextB.gameObject.SetActive(false);
if (isBlockButtonClicked)
{
initiateBlockPowerUp();
}
else
{
changeTurn();
}
}
Debug.Log("Val: Logging inside Timer");
}
if (isCalledUndo)
{
time_counter += Time.deltaTime;
if (time_counter >= 5.0f)
{
isCalledUndo = false;
undoTextA.gameObject.SetActive(false);
undoTextB.gameObject.SetActive(false);
if ((isUndoClickedB && turn == -1) || (isUndoClickedA && turn == 1))
{
initializeUndoPowerUp();
}
else
{
//preScoreValA = scoreValA;
//preScoreValB = scoreValB;
//for (int i = 0; i < tileArray.Length; i++)
//{
// int currentVal = tileArray[i].getVal();
// previousTileArray[i].setVal(currentVal);
//}
changeTurn();
}
}
}
updateBoard();
handleReverseDirection();
// Checks if the game has a winner
if (!win)
{
if (turn == 1)
{
scoreA.color = new Color32(100, 221, 23, 255);
scoreB.color = Color.white;
}
else
{
scoreB.color = new Color32(100, 221, 23, 255);
scoreA.color = Color.white;
}
}
else
{
scoreA.color = Color.white;
scoreB.color = Color.white;
}
}
public PowerUpTilesDto Use(PowerUpTilesDto powerUpTilesDto)
{
powerUpTilesDto.Reverse = !powerUpTilesDto.Reverse;
return(powerUpTilesDto);
}
public PowerUpTilesDto Use(PowerUpTilesDto powerUpTilesDto)
{
return(powerUpTilesDto);
}
