private void SpawnPowerUp()
{
float perc = Random.Range(0, 99);
if (perc > 60 && !CheckBoardFull())
{
int rand_x = Random.Range(-2, 2);
int rand_y = Random.Range(-2, 2);
if (!GameBoardMatrix.row[rand_y + 2].column[rand_x + 2] && !GameBoardMatrix.row[rand_y + 2].pColumn[rand_x + 2])
{
var up = Instantiate(PowerHolder, transform).GetComponent <PowerHolder>();
up.transform.localPosition = new Vector2(rand_x, rand_y);
up.MyPower = PowerUp[Random.Range(0, PowerUp.Length)];
up.ChangeSprite();
GameBoardMatrix.row[rand_y + 2].pColumn[rand_x + 2] = up;
string[] data = new string[]
{
ProjectConstants.message_spawnPowerUp,
up.MyPower.powerType.ToString(),
(rand_y).ToString(),
(rand_x).ToString()
};
GPGController.SendByteMessage(GPGBytePackager.CreatePackage(data),
GPGController.GetOpponentId());
}
}
}
public void UpdateCharge(int value)
{
if (Charge - value > 0)
{
Charge -= value;
string[] data = new string[]
{
ProjectConstants.message_chargeUpdate,
Charge.ToString()
};
GPGController.SendByteMessage(GPGBytePackager.CreatePackage(data),
GPGController.GetOpponentId());
}
else if (Charge - value >= GameManager.GetGameManager.Limit)
{
Charge = GameManager.GetGameManager.Limit;
}
else
{
Charge = 0;
_pieceLimit.rectTransform.sizeDelta = new Vector2(64, 0);
GameManager.GetGameManager.FinishGame();
string[] data = new string[]
{
ProjectConstants.message_chargeUpdate,
Charge.ToString()
};
GPGController.SendByteMessage(GPGBytePackager.CreatePackage(data),
GPGController.GetOpponentId());
return;
}
_pieceLimit.rectTransform.sizeDelta = new Vector2(64, height - (limitPerc * value));
height -= (limitPerc * value);
}
public static int OpCall()
{
LevelManager.GetLevelManager.ToggleLight(myTurn);
if (YourBet == 0 && OpBet == 0)
{
OpBet += TableBet;
LevelManager.GetLevelManager.BetEventText(GPGController.GetOpponentName() + " called " + TableBet);
LevelManager.GetLevelManager.BetText();
myTurn = true;
return(TableBet);
}
else if (YourBet > OpBet)
{
int difference = YourBet - OpBet;
OpBet += difference;
LevelManager.GetLevelManager.BetText();
LevelManager.GetLevelManager.BetEventText(GPGController.GetOpponentName() + " called " + difference);
myTurn = true;
if (IsSatisfied())
{
LevelManager.GetLevelManager.BetEventText("Game is starting".ToUpper());
var msg = new string[]
{
ProjectConstants.message_satisfied
};
GPGController.SendByteMessage(GPGBytePackager.CreatePackage(msg), GPGController.GetOpponentId());
LevelManager.GetLevelManager.LoadOnlineGame();
}
return(difference);
}
return(0);
}
void Start()
{
#if UNITY_ANDROID
Social.Active = new UnityEngine.SocialPlatforms.GPGSocial();
#elif UNITY_IPHONE
GameCenterPlatform.ShowDefaultAchievementCompletionBanner(true);
StartCoroutine(GPGController.checkConnection());
#endif
StartCoroutine(GPGController.signIn());
}
public void StartTimer()
{
_animator.SetTrigger("TimerStart");
string[] data = new string[]
{
ProjectConstants.message_updateTime,
PlayerTime.ToString()
};
GPGController.SendByteMessage(GPGBytePackager.CreatePackage(data),
GPGController.GetOpponentId());
}
public static void showLeaderBoards()
{
if (Social.localUser.authenticated)
{
Social.ShowLeaderboardUI();
}
else
{
instance.StartCoroutine(GPGController.signIn());
}
}
public static void MagnetizingRow()
{
MagnetizedTileCount++;
if (MagnetizedTileCount == ProjectConstants.MagnetizedRow_TierOne)
{
GPGController.UnlockAchievement(GPGSIds.achievement_attractive_gameplay);
}
if (MagnetizedTileCount == ProjectConstants.MagnetizedRow_TierTwo)
{
GPGController.UnlockAchievement(GPGSIds.achievement_magnetize);
}
}
public static void CollectingTiles()
{
CollectedTileCount++;
if (CollectedTileCount == ProjectConstants.CollectRow_TierOne)
{
GPGController.UnlockAchievement(GPGSIds.achievement_whole_row);
}
if (CollectedTileCount == ProjectConstants.CollectRow_TierTwo)
{
GPGController.UnlockAchievement(GPGSIds.achievement_a_fine_addition);
}
}
public static void PowerUpCounter()
{
PowerUpUseCount++;
if (PowerUpUseCount == ProjectConstants.PowerUpUse_TierOne)
{
GPGController.UnlockAchievement(GPGSIds.achievement_opportunist);
}
else if (PowerUpUseCount == ProjectConstants.PowerUpUse_TierTwo)
{
GPGController.UnlockAchievement(GPGSIds.achievement_power);
}
else if (PowerUpUseCount == ProjectConstants.PowerUpUse_TierThree)
{
GPGController.UnlockAchievement(GPGSIds.achievement_unlimited_power);
}
}
public static int CallAndIncrease(int increaseAmount)
{
if (!myTurn)
{
return(0);
}
LevelManager.GetLevelManager.ToggleLight(myTurn);
myTurn = false;
if ((YourBet == 0 && OpBet == 0) &&
ProjectConstants.userCredit - TableBet - increaseAmount > 0)
{
YourBet += TableBet;
ProjectConstants.userCredit -= TableBet;
YourBet += increaseAmount;
ProjectConstants.userCredit -= increaseAmount;
var data = new string[]
{
ProjectConstants.message_bet,
increaseAmount.ToString()
};
GPGController.SendByteMessage(GPGBytePackager.CreatePackage(data),
GPGController.GetOpponentId());
LevelManager.GetLevelManager.BetEventText("You called " + TableBet);
LevelManager.GetLevelManager.BetText();
}
else if ((YourBet < OpBet) &&
ProjectConstants.userCredit - (OpBet - YourBet) - increaseAmount > 0)
{
int difference = OpBet - YourBet;
YourBet += difference;
ProjectConstants.userCredit -= difference;
YourBet += increaseAmount;
ProjectConstants.userCredit -= increaseAmount;
var data = new string[]
{
ProjectConstants.message_bet,
increaseAmount.ToString()
};
GPGController.SendByteMessage(GPGBytePackager.CreatePackage(data),
GPGController.GetOpponentId());
LevelManager.GetLevelManager.BetEventText("You called " + difference);
LevelManager.GetLevelManager.BetText();
}
return(increaseAmount);
}
private void Start()
{
BetText();
OnlineStatusPanel.SetActive(false);
BetPanel.SetActive(false);
AdController.ConnectAds();
if (!GPGController.IsAuthenticated())
{
GPGController.GetGpgController.LoginToGPG();
}
Limit = timeLimit = scoreLimit = pieceLimit = 30;
if (GetLevelManager == null)
{
GetLevelManager = this;
}
SetDevicePrefs();
RemainingCreditsText.text = ProjectConstants.userCredit.ToString();
}
/// <summary>
/// Saves the score.
/// </summary>
/// <param name="score">Score.</param>
public static void saveScore(float score)
{
float _value = loadScore();
Debug.Log(_value + "::" + score);
if (score >= _value)
{
SaveSystem.saveFloat(GameTimeController.BEST_TIME_KEY, score);
GPGController.instance.StartCoroutine(GPGController.submitScore(score));
GameObject.Find("T").GetComponent <TextMesh>().text = "submit";
}
else
{
GameObject.Find("T").GetComponent <TextMesh>().text = "Denied";
}
}
private void OnLevelWasLoaded(int level)
{
_manager = GameManager.GetGameManager;
if (level == 1)
{
_manager.Limit = Limit;
_manager.LimitType = (int)Type;
}
if (!GPGController.IsAuthenticated())
{
GPGController.GetGpgController.LoginToGPG();
}
if (isOnline)
{
GPGController.GetGpgController.AssignTurns();
_manager.SetSecondNonPlayable();
_manager.isOnline = isOnline;
}
}
public static void WinLoseAchievements(bool isVictory, bool isScore)
{
PowerUpUseCount = 0;
if (isVictory)
{
LosesInARow = 0;
if (isScore)
{
GPGController.UnlockAchievement(GPGSIds.achievement_scoring_up);
}
else
{
GPGController.UnlockAchievement(GPGSIds.achievement_durable_batteries);
}
GPGController.IncrementAchievement(GPGSIds.achievement_winner_of_the_internet, 20);
GPGController.IncrementAchievement(GPGSIds.achievement_champion_of_the_internet, 10);
WinsInARow++;
if (WinsInARow == ProjectConstants.WinRowLimit_TierOne)
{
GPGController.UnlockAchievement(GPGSIds.achievement_gamer);
}
else if (WinsInARow == ProjectConstants.WinRowLimit_TierTwo)
{
GPGController.UnlockAchievement(GPGSIds.achievement_esports_player);
}
}
else
{
WinsInARow = 0;
LosesInARow++;
if (LosesInARow == ProjectConstants.LoseRowLimit_TierOne)
{
GPGController.UnlockAchievement(GPGSIds.achievement_loser);
}
else if (LosesInARow == ProjectConstants.LoseRowLimit_TierTwo)
{
GPGController.UnlockAchievement(GPGSIds.achievement_pathetic);
}
}
}
private void SetNumberIndex(Number number, Number spawned)
{
if (number.TurnNumber == 1)
{
for (int i = 0; i < PlayerOneNumbers.Length; i++)
{
if (PlayerOneNumbers[i] == number)
{
PlayerOneNumbers[i] = spawned;
AnimateDoor(1, i);
if (isOnline)
{
string[] data = new string[]
{
ProjectConstants.message_spawnTile,
spawned.MyNumber.ToString(),
i.ToString()
};
GPGController.SendByteMessage(GPGBytePackager.CreatePackage(data),
GPGController.GetOpponentId());
}
break;
}
}
}
else if (number.TurnNumber == 2)
{
for (int i = 0; i < PlayerTwoNumbers.Length; i++)
{
if (PlayerTwoNumbers[i] == number)
{
PlayerTwoNumbers[i] = spawned;
AnimateDoor(2, i);
break;
}
}
}
}
public static int OpCallAndIncrease(int increaseAmount)
{
LevelManager.GetLevelManager.ToggleLight(myTurn);
int difference = 0;
if (OpBet == 0 && YourBet == 0)
{
OpBet += TableBet;
}
else if (OpBet < YourBet)
{
difference = YourBet - OpBet;
OpBet += difference;
}
OpBet += increaseAmount;
myTurn = true;
LevelManager.GetLevelManager.BetText();
LevelManager.GetLevelManager.BetEventText(GPGController.GetOpponentName() +
" called " + difference + " and increased the bet by " + increaseAmount);
return(increaseAmount);
}
public bool UpdateMatrix(int pos_x, int pos_y, Number card)
{
if (BoardHandler.GameBoardMatrix.row[pos_y].column[pos_x] != null)
{
return(false);
}
if (isOnline)
{
string[] data = new string[]
{
ProjectConstants.message_played,
pos_x.ToString(),
pos_y.ToString(),
card.MyNumber.ToString()
};
GPGController.SendByteMessage(GPGBytePackager.CreatePackage(data),
GPGController.GetOpponentId());
}
BoardHandler.GameBoardMatrix.row[pos_y].column[pos_x] = card;
BoardHandler.GivePower(pos_x, pos_y, card);
ControlMatrix(pos_x, pos_y, card.MyNumber);
return(true);
}
private void SetDevicePrefs()
{
if (!PlayerPrefs.HasKey("Credit"))
{
PlayerPrefs.SetInt("Credit", 500);
}
if (!PlayerPrefs.HasKey("Muted"))
{
PlayerPrefs.SetInt("Muted", 0);
}
if (!PlayerPrefs.HasKey("Tutorial"))
{
PlayerPrefs.SetInt("Tutorial", 0);
}
if (PlayerPrefs.GetInt("Tutorial") == 0)
{
LoadLevel(ProjectConstants.Tutorial);
return;
}
else
{
GPGController.UnlockAchievement(GPGSIds.achievement_welcome);
}
}
private static void playSynchronization()
{
int _value = SaveSystem.loadInt(GameTimeController.BEST_TIME_KEY);
GPGController.instance.StartCoroutine(GPGController.submitScore(_value));
}
public void ShowAchievements()
{
GPGController.ShowAchievements();
}
public void WaitingRoomClose()
{
GPGController.LeaveRoom();
LevelManager.GetLevelManager.WaitingPanelClosed();
LevelManager.GetLevelManager.UpdateOnlineStatusText("CANCELLING");
}
void Awake()
{
instance = GameObject.Find(this.gameObject.name).GetComponent <GPGController>();
}
public void LoadLevelWithoutBanner(string level)
{
GPGController.LeaveRoom();
SceneManager.LoadSceneAsync(level);
}
