private void Awake()
{
round = 1;
SetPlayerActive(false);
Instance = this;
uiMng.PlayRoundStart();
}
private void Awake()
{
Instance = this;
cam = Camera.main;
m_camTp = cam.transform.position;
aSrc = GetComponent <AudioSource>();
}
private void UpdatePanel()
{
nextLesson.interactable = true;
prevLesson.interactable = true;
if (GameMng.selectedLessonIndex == 1)
{
prevLesson.interactable = false;
}
if (GameMng.selectedLessonIndex == GameMng.GetLastOpenLesson(GameMng.selectedCategory))
{
nextLesson.interactable = false;
}
lessonNumber.text = 3 + " / " + GameMng.selectedLessonIndex.ToString();
lessonScore.text = GameMng.GetLessonBestScore(GameMng.selectedCategory, GameMng.selectedLessonIndex) + "/" + 30;
List <ScoreHistory> scoreList = Setting.GetHistory(GameMng.selectedCategory.ToString(), GameMng.selectedLessonIndex);
List <int> valueList = new List <int>();
valueList.Add(0);
foreach (var item in scoreList)
{
valueList.Add(item.score);
}
graph.ShowGraph(valueList, GraphVisualType.LineGraph);
}
private IEnumerator ShowStart()
{
string s1, s2;
if (currentQType == QType.Practice)
{
s1 = GameMng.selectedCategory.ToString();
s2 = "lesson " + GameMng.GetLessonNumberString();
}
else
{
s2 = GameMng.selectedExam.examTitle;
s1 = "Exam";
}
yield return(new WaitForSeconds(1));
startPanel.Show(s1, s2);
yield return(new WaitForSeconds(2));
if (currentQType == QType.Exam)
{
examTime = (int)(QuestionList.Count * 15f);
timerPanel.SetTimer(0, 0, 0, examTime);
timerPanel.OnTimerDoneEvent += TimerPanel_OnTimerDoneEvent;
}
ShowNextQuestion();
}
public void Setup()
{
// Shuffle deck
List <CardDesc> shuffledDeck = new List <CardDesc>(playerDeck.cards);
ShuffleDeck(shuffledDeck);
deck.Add(shuffledDeck);
hp = GameMng.GetRules().maxHealth;
energy = 0;
UpdateStats();
// Set me as active player, so I can draw cards
activePlayer = true;
for (int i = 0; i < GameMng.GetRules().startCardsOnHand; i++)
{
DrawCard(deck);
// So we don't exceed the draw limit
drawCount = 0;
}
activePlayer = false;
}
/// <summary>
/// Back to general chat
/// </summary>
/// <param name="user"></param>
/// <param name="opponent"></param>
public void BackToChat(string user, string opponent)
{
if (!string.IsNullOrEmpty(user) && !string.IsNullOrEmpty(opponent))
{
try
{
GameMng.DeleteGame(user, opponent);
GameMng.DeleteHowToFirst(user, opponent);
if (_callback.ContainsKey(user))
{
_callback[user].BackToChatFromServer(user, opponent);
}
if (_callback.ContainsKey(opponent))
{
_callback[opponent].BackToChatFromServer(opponent, user);
}
}
catch (Exception ex)
{
_callback[user].RecieveError(ex.Message);
_callback[opponent].RecieveError(ex.Message);
}
}
}
public void RunAttack(Card card)
{
int attackPower = card.GetAttackPower();
Player otherPlayer = GameMng.GetOtherPlayer(this);
otherPlayer.DealDamage(this, attackPower);
}
public void RunAction(Card card)
{
if (currentCard == null)
{
return;
}
if (currentCard.desc.IsValidTarget(this, card))
{
// This is a valid target
currentCard.desc.CastSpell(this, currentCard, card);
// Destroy this card
hand.Remove(currentCard);
graveyard.Add(currentCard.desc);
Destroy(currentCard.gameObject);
// Clear the playfield
playArea.ClearCreatures();
GameMng.GetOtherPlayer(this).playArea.ClearCreatures();
// Disable target mode
targetType = CardDesc.TargetType.None;
}
}
public void StartHowToFirst(string user, string opponent)
{
if (!string.IsNullOrEmpty(user) && !string.IsNullOrEmpty(opponent))
{
try
{
if (_callback.ContainsKey(user))
{
if (_callback.ContainsKey(opponent))
{
GameMng.AddHowToFirst(user, opponent);
_callback[user].StartHowToFirstFromServer(user, opponent);
_callback[opponent].StartHowToFirstFromServer(opponent, user);
}
else if (opponent == "autoPlayer")
{
GameMng.AddHowToFirst(user, opponent);
_callback[user].StartHowToFirstFromServer(user, opponent);
}
}
}
catch (Exception ex)
{
_callback[user].RecieveError(ex.Message);
_callback[opponent].RecieveError(ex.Message);
}
}
}
public void GetGameTable(string user, string opponent)
{
if (!string.IsNullOrEmpty(user) && !string.IsNullOrEmpty(opponent))
{
try
{
if (_callback.ContainsKey(user))
{
var game = GameMng.GetGame(user, opponent);
var gameTable = GameMng.GetGameTableForSend(user, opponent);
if (gameTable != null)
{
var whiteCheckers = gameTable[0];
var blackCheckers = gameTable[1];
var barCheckers = gameTable[2];
_callback[user].UpdateTable(user, opponent, whiteCheckers, blackCheckers, barCheckers);
if (_callback.ContainsKey(opponent))
{
_callback[opponent].UpdateTable(opponent, user, whiteCheckers, blackCheckers, barCheckers);
}
}
}
}
catch (Exception ex)
{
_callback[user].RecieveError(ex.Message);
_callback[opponent].RecieveError(ex.Message);
}
}
}
private void OnTap(Card card)
{
if (GameMng.GetActivePlayer() != player)
{
return;
}
if (card.tapped)
{
return;
}
// Only creatures can be tapped
if (card.desc.type != CardDesc.Type.Creature)
{
return;
}
card.Tap();
if (GameMng.GetRules().attackOnTap)
{
player.RunAttack(card);
}
}
private void Start()
{
if (GameManager == null)
{
GameManager = GameObject.Find("_GameManager");
}
GMng = GameManager.GetComponent <GameMng>();
}
public override void OnStartClient()
{
base.OnStartClient();
string _netId = GetComponent <NetworkIdentity>().netId.ToString();
Player _player = GetComponent <Player>();
GameMng.RegisterPlayer(_netId, _player);
}
private IEnumerator CheckMaxCorrectInRow()
{
if (correctInRow > GameMng.GetMaxCorrectInRow())
{
GameMng.SetMaxCorrectInRow(correctInRow);
}
yield return(0);
}
/// <summary>
/// Computer Player Logic
/// </summary>
/// <param name="computer">name of comp player</param>
/// <param name="opponent">name of user player</param>
/// <param name="diceNumbers">number of dice</param>
public void MoveCheckerAuto(string computer, string opponent)
{
if (_callback.ContainsKey(opponent))
{
var game = GameMng.GetGame(computer, opponent);
if (game == null)
{
return;
}
var diceNumbers = game.DiceLogic.GetRandomDices();
if (diceNumbers[0] == diceNumbers[1])
{
diceNumbers.AddRange(diceNumbers);
}
_callback[opponent].RecieveRoll(Player.autoPlayer.ToString(), diceNumbers);
bool result = false;
try
{
foreach (var number in diceNumbers)
{
result = GameMng.CheckersMoovingLogicAuto(computer, opponent, number);
if (result)
{
var gameTable = GameMng.GetGameTableForSend(computer, opponent);
if (gameTable != null)
{
var whiteCheckers = gameTable[0];
var blackCheckers = gameTable[1];
var barCheckers = gameTable[2];
_callback[opponent].UpdateTable(opponent, computer, whiteCheckers, blackCheckers, barCheckers);
}
}
if (GameMng.IsGameOver(opponent, computer))
{
_callback[opponent].GameOverFromServer(opponent, computer, false);
GameMng.DeleteGame(computer, opponent);
}
}
if (_callback.ContainsKey(opponent))
{
_callback[opponent].SetMasterFromServer(opponent, computer);
}
}
catch (Exception ex)
{
_callback[opponent].RecieveError(ex.Message);
return;
}
}
}
private void CheckOpenNextLesson()
{
int currentLessonIndex = GameMng.selectedLessonIndex;
if (currentLessonIndex < 3)
{
GameMng.SetLastOpenLesson(GameMng.selectedCategory, currentLessonIndex + 1);
}
}
public bool IsDoneExcelent()
{
if (GameMng.GetExamBestScore(examTitle) == examQuestions * 3)
{
return(true);
}
return(false);
}
public void RollHowFirstComp(string user, string computer)
{
if (!string.IsNullOrEmpty(user) && !string.IsNullOrEmpty(computer))
{
var callback = OperationContext.Current.GetCallbackChannel <IClientCallback>();
var arrayResult = GameMng.RollHowFirst(user, computer);
var number1 = int.Parse(arrayResult[0]);
var number2 = int.Parse(arrayResult[1]);
int[] resultToSend = new int[2];
resultToSend[0] = (number1 == 0) ? 1 : number1;
resultToSend[1] = (number2 == 0) ? 1 : number2;
//Send to User result of first roll
_callback[user].RecieveRollHowFirst(user, computer, resultToSend);
//Computer rolling
arrayResult = GameMng.RollHowFirst(computer, user);
number1 = int.Parse(arrayResult[0]);
number2 = int.Parse(arrayResult[1]);
resultToSend = new int[2];
resultToSend[0] = (number1 == 0) ? 1 : number1;
resultToSend[1] = (number2 == 0) ? 1 : number2;
//Send to User result of second roll
_callback[user].RecieveRollHowFirst(user, computer, resultToSend);
if (arrayResult[2] != string.Empty)
{
var winnerName = arrayResult[2];
if (winnerName == user)
{
_callback[user].CloseHowToFirstFromServer(user, computer, true);
GameMng.DeleteHowToFirst(user, computer);
GameMng.AddGame(user, computer);
}
else
{
_callback[user].CloseHowToFirstFromServer(user, computer, false);
GameMng.DeleteHowToFirst(user, computer);
GameMng.AddGame(computer, user);
//MoveCheckerAuto(computer, user);
}
}
else
{
if (number1 == number2)
{
_callback[user].GameInfoUpdateFromServer(computer, "The numbers are equals. Try again");
}
}
}
}
private void Awake()
{
if (instance != null)
{
Destroy(gameObject);
return;
}
instance = this;
}
public void OnPlay(Player player)
{
if ((type == Type.Energy) && (GameMng.GetRules().energyOnDrop))
{
player.ChangeEnergy(energyAmmount);
}
// Pay the cost
player.ChangeEnergy(-cost);
}
void OnTriggerEnter(Collider other)
{
if (other.transform.tag == "Enemy") // Use enemy tag for Traps-objekts as well
{
Die();
}
if (other.transform.tag == "Goal")
{
GameMng.CompleteLevel();
}
}
private void CheckIsOpen()
{
if (GameMng.GetLastOpenLesson(myCategory.questionType) == 0)
{
myButton.interactable = false;
}
else
{
myButton.interactable = true;
}
}
private void Awake()
{
if (m_instance)
{
Destroy(gameObject);
}
else
{
m_instance = this;
}
DontDestroyOnLoad(gameObject);
}
void Awake()
{
Score = 0;
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(gameObject);
}
}
private void MessegeBox_OnOkButtonClickEvent()
{
if (GameMng.GetDiamondNumber() >= GameMng.selectedExam.examDiamondPrice)
{
GameMng.Instance.RemoveDiamond(GameMng.selectedExam.examDiamondPrice);
myPanel.Hide();
GameMng.Instance.ShowExam();
}
else
{
Setting.MessegeBox.SetMessege("الماس کافی نداری");
}
}
public void ClickedCard()
{
// Check if we're on a targeting mode
Player activePlayer = GameMng.GetActivePlayer();
if (activePlayer.IsTargeting())
{
activePlayer.RunAction(this);
return;
}
OnClick?.Invoke(this);
}
/// <summary>
/// Generates random numbers in dice range
/// </summary>
/// <param name="user">user name</param>
/// <param name="opponent">opponent name</param>
public void Roll(string user, string opponent)
{
if (!string.IsNullOrEmpty(user) && !string.IsNullOrEmpty(opponent))
{
var game = GameMng.GetGame(user, opponent);
if (game == null)
{
return;
}
var diceLogic = new DiceLogic(_rand);
var diceNumbers = diceLogic.GetRandomDices();
var callback = OperationContext.Current.GetCallbackChannel <IClientCallback>();
try
{
if (_callback.ContainsKey(user))
{
if (diceNumbers[0] == diceNumbers[1])
{
game.DoubleDice = new DoubleDice(user, opponent);
_callback[user].GameInfoUpdateFromServer(opponent, "You have the double.\nMove twice please.");
if (_callback.ContainsKey(opponent))
{
_callback[opponent].GameInfoUpdateFromServer(user, "Your opponent has the double.\nWait please.");
}
}
else
{
game.DifferentDice = new DifferentDice(user, opponent);
}
if (_callback.ContainsKey(opponent))
{
_callback[opponent].RecieveRoll(user, diceNumbers);
}
_callback[user].RecieveRoll(opponent, diceNumbers);
}
}
catch (Exception ex)
{
callback.RecieveError(ex.Message);
if (_callback.ContainsKey(opponent))
{
_callback[opponent].RecieveError(ex.Message);
}
}
}
}
void Awake()
{
Animator = this.GetComponent <Animator>();
if (this.name == "Transitions")
{
DontDestroyOnLoad(this);
}
GameObject Manager = GameObject.Find("ManagerHolder");
GM = Manager.GetComponent <GameMng>();
Controler = Manager.GetComponent <UIControler>();
}
public void CalculateScore()
{
int score = GameMng.GetCategoryScore(myCategory.questionType);
totalScoreText.text = score + "/" + "100";
if (score == 100)
{
flagImage.gameObject.SetActive(true);
}
else
{
flagImage.gameObject.SetActive(false);
}
}
void CalculateGainedScore()
{
score = 0;
for (int i = 0; i < examCategorys; i++)
{
score += GameMng.GetCategoryScore((QuestionType)i);
}
if (score >= MinScore2Open())
{
isOpen = true;
}
examScoreText.text = score.ToString() + " / " + MinScore2Open().ToString();
}
