// button that logs player in
public void Button_Login()
{
ServerResponse response = UserRequestLibrary.LoginRequest(m_NameText, m_PasswordText);
// if response is positive, save name and password, and load next scene
if (response.ResponseType == EServerResponseType.OK)
{
// save name and password
PlayerData.playerName = m_NameText.text.Remove(m_NameText.text.Length - 1);
PlayerData.playerPassword = m_PasswordText.text.Remove(m_PasswordText.text.Length - 1);
LoginBanner.gameObject.SetActive(true);
LoginBannerText.text = response.Text;
StartCoroutine(LoadStoryScene());
return;
}
// if response is error, print out error message
if (response.ResponseType == EServerResponseType.ERROR)
{
LoginBanner.gameObject.SetActive(true);
LoginBannerText.text = response.Text;
Invoke("DisableLoginBanner", 2.0f);
return;
}
}
// check if player unlocked a character
string CheckForCharacterUnlock()
{
// check if there are any chars that can be unlocked
if (m_CharactersThatCanBeUnlocked.Count <= 0)
{
UIControllerBattle.get.m_UnlockedCharacterIcon.sprite = UIControllerBattle.get.m_CharacterSpritesDict["NotUnlocked"];
return("You've already unlocked all characters in this Level!");
}
// if there are any
else
{
// check if a character is going to be unlocked
System.Random rand = new System.Random();
int unlockChance = rand.Next(0, 100);
// player missed chance to unlock character
if (unlockChance < 50)
{
UIControllerBattle.get.m_UnlockedCharacterIcon.sprite = UIControllerBattle.get.m_CharacterSpritesDict["NotUnlocked"];
return("Nobody joined your team this time. Try again another time!");
}
// player hit chance to unlock character
else
{
// calculate which character should be unlocked
int characterIndex = rand.Next(0, m_CharactersThatCanBeUnlocked.Count);
// Unlock character for player
ServerResponse responseDelServer = UserRequestLibrary.UnlockCharacterForUser(m_CharactersThatCanBeUnlocked[characterIndex].m_CharacterName);
UIControllerBattle.get.m_UnlockedCharacterIcon.sprite = UIControllerBattle.get.m_CharacterSpritesDict[m_CharactersThatCanBeUnlocked[characterIndex].m_CharacterName];
return($"The {m_CharactersThatCanBeUnlocked[characterIndex].m_CharacterName} joined your team!");
}
}
}
public void Login()
{
// Set IP to the current ip text if not empty
if (m_NewIPText.text == "")
{
return;
}
PlayerData.IP = m_NewIPText.text.Remove(m_NewIPText.text.Length - 1);
ServerResponse sr = UserRequestLibrary.LoginRequest(m_NameText, m_PasswordText);
// if response is positive, save name and password, and load next scene
if (sr.ResponseType == EServerResponseType.OK)
{
// save name and password
PlayerData.playerName = m_NameText.text.Remove(m_NameText.text.Length - 1);
PlayerData.playerPassword = m_PasswordText.text.Remove(m_PasswordText.text.Length - 1);
LoginBanner.gameObject.SetActive(true);
LoginBannerText.text = sr.Text;
StartCoroutine(LoadMainScene());
return;
}
// if response is error, print out error message
if (sr.ResponseType == EServerResponseType.ERROR)
{
LoginBanner.gameObject.SetActive(true);
LoginBannerText.text = sr.Text;
Invoke("DisableLoginBanner", 2.0f);
return;
}
}
// get current character stats from database
public void GetStats()
{
ServerResponse sr = UserRequestLibrary.GetCharacterStatsRequest(m_CharacterName);
m_ExperienceGained = sr.Characters[0].Experience;
m_Level = sr.Characters[0].Level;
m_UnlockStatus = sr.Characters[0].UnlockStatus;
}
// gets the saved stepdata from database
public void GetSavedSteps()
{
ServerResponse sr = UserRequestLibrary.GetResourcesRequest();
m_currentStepTracker = sr.Resources.StepCounter;
ResourcesWindow.get.m_StepCounterText.text = ((int)m_currentStepTracker).ToString();
}
// button function to create a new account
public void Button_CreateAccount()
{
ServerResponse response = UserRequestLibrary.CreateAccountRequest(m_NameText, m_PasswordText);
// log the response to the player
CreateAccountBanner.gameObject.SetActive(true);
CreateAccountBannerText.text = response.Text;
Invoke("DisableCreateAccountBanner", 2.0f);
return;
}
// gets this character values from the database
public void GetStats()
{
ServerResponse response = UserRequestLibrary.GetCurrentCharStats(m_CharacterName);
m_AttackDamage = response.Characters[0].AttackDamage;
m_Defense = response.Characters[0].Defense;
m_Health = response.Characters[0].HP;
m_UnlockStatus = response.Characters[0].UnlockStatus;
m_Level = response.Characters[0].Level;
}
void SpawnEnemyTeam()
{
ServerResponse response = UserRequestLibrary.GetLevelData(PlayerData.LastSelectedLevel);
// spawn enemies that are deposited in the database
for (int i = 0; i < response.LevelData.Enemies.Count; i++)
{
// spawn enemy at the correct enemy spawnpoint
GameObject go = Instantiate(m_CharacterDict[response.LevelData.Enemies[i].Name], m_EnemySpawnpoints[i]);
Character EnemyReference = go.GetComponent <Character>();
// if it is the first spawned, set as last selected enemy
if (i == 0)
{
m_LastSelectedEnemy = EnemyReference;
}
// set character spawned to enemy team
EnemyReference.m_TeamStatus = "Enemy";
// set character values got from database
EnemyReference.m_AttackDamage = response.LevelData.Enemies[i].AttackDamage;
EnemyReference.m_Defense = response.LevelData.Enemies[i].Defense;
EnemyReference.m_Health = response.LevelData.Enemies[i].HP;
// save enemy in enemy list
m_Enemies.Add(EnemyReference);
// bottom chars should overlap top chars
if (i > 0 && i % 2 != 0)
{
go.GetComponent <SpriteRenderer>().sortingOrder = 11;
}
else
{
go.GetComponent <SpriteRenderer>().sortingOrder = 10;
}
}
// check which characters the player can unlock
foreach (var charToBeUnlocked in m_Enemies)
{
// get current status character in database
ServerResponse sr = UserRequestLibrary.GetCurrentCharStats(charToBeUnlocked.m_CharacterName);
// if character has not unlocked the character yet
if (sr.Characters[0].UnlockStatus == 0)
{
// add it to the list of characters that can be unlocked
m_CharactersThatCanBeUnlocked.Add(charToBeUnlocked);
}
}
}
// returns true if level is already unlocked
// false otherwhise
public void GetLevelStatus()
{
ServerResponse response = UserRequestLibrary.GetLevelStatusForUser(m_LevelID);
if (response.LevelStatus.UnlockStatus == 1)
{
m_IsUnlocked = true;
return;
}
m_IsUnlocked = false;
}
// saves the accumulated steps from player in the database
public void UpdateStepsInDatabase()
{
ServerResponse sr = UserRequestLibrary.GetResourcesRequest();
if (m_locationTrackable)
{
BA_Praxis_Library.Resources res = new BA_Praxis_Library.Resources()
{
StepCounter = (int)m_currentStepTracker,
AncientMaterial = sr.Resources.AncientMaterial,
ChaosMaterial = sr.Resources.ChaosMaterial,
DarkMaterial = sr.Resources.DarkMaterial,
NatureMaterial = sr.Resources.NatureMaterial,
NeutralMaterial = sr.Resources.NeutralMaterial
};
sr = UserRequestLibrary.UpdateResourcesRequest(res);
}
}
// tries to start the gps location system
private IEnumerator StartGPSLocationService()
{
if (!Input.location.isEnabledByUser)
{
m_IsGPSEnabled.text = "User has not enabled GPS";
yield break;
}
Input.location.Start();
int maxWait = 20;
while (Input.location.status == LocationServiceStatus.Initializing && maxWait > 0)
{
yield return(new WaitForSeconds(1));
maxWait--;
}
if (maxWait <= 0)
{
m_IsGPSEnabled.text = "Timed out";
yield break;
}
if (Input.location.status == LocationServiceStatus.Failed)
{
m_IsGPSEnabled.text = "Unable to get device location";
yield break;
}
m_Latitude_Latest = Input.location.lastData.latitude;
m_Longitude_Latest = Input.location.lastData.longitude;
m_locationTrackable = true;
ServerResponse sr = UserRequestLibrary.GetResourcesRequest();
m_currentStepTracker = sr.Resources.StepCounter;
m_IsGPSEnabled.text = "GPS active";
}
public static void UpdateResourcesForCurrentSelectedCharacter(int materialsGained)
{
int currentCharID = PlayerData.currentSelectedCharacter;
ServerResponse sr = UserRequestLibrary.GetResourcesRequest();
Resources resources = sr.Resources;
// if character is adventurer
if (currentCharID == 0)
{
resources.NeutralMaterial += materialsGained;
}
// if character is bandit | red ogre | werewolf
else if (currentCharID == 1 || currentCharID == 5 || currentCharID == 9)
{
resources.DarkMaterial += materialsGained;
}
// if character is golem | satyr | yeti
else if (currentCharID == 2 || currentCharID == 6 || currentCharID == 10)
{
resources.AncientMaterial += materialsGained;
}
// if character is wasp | rat | mandrake
else if (currentCharID == 8 || currentCharID == 4 || currentCharID == 3)
{
resources.NatureMaterial += materialsGained;
}
// if character is shade
else if (currentCharID == 7)
{
resources.ChaosMaterial += materialsGained;
}
UserRequestLibrary.UpdateResourcesRequest(resources);
}
// upgrade character in database
public ServerResponse UpgradeCharacter()
{
return(UserRequestLibrary.UpgradeCharacterRequest(m_CharacterName));
}
// unlocks this character in the database so it can be used ingame
public void UnlockCharacter()
{
ServerResponse response = UserRequestLibrary.UnlockCharacterForUser(m_CharacterName);
}
public static void UpdateExperience(int _expToAdd)
{
int currentCharID = PlayerData.currentSelectedCharacter;
string characterName = "";
switch (currentCharID)
{
case 0:
characterName = "Adventurer";
break;
case 1:
characterName = "Bandit";
break;
case 2:
characterName = "Golem";
break;
case 3:
characterName = "Mandrake";
break;
case 4:
characterName = "Rat";
break;
case 5:
characterName = "Red Ogre";
break;
case 6:
characterName = "Satyr";
break;
case 7:
characterName = "Shade";
break;
case 8:
characterName = "Wasp";
break;
case 9:
characterName = "Werewolf";
break;
case 10:
characterName = "Yeti";
break;
default:
break;
}
// get current stats from database
ServerResponse sr = UserRequestLibrary.GetCharacterStatsRequest(characterName);
// copy stats
BA_Praxis_Library.Character charTMP = sr.Characters[0];
//set name
charTMP.Name = characterName;
// add experience
charTMP.Experience += _expToAdd;
// update experience
UserRequestLibrary.UpdateExperience(charTMP);
}
// handles the complete battle
// first: player attacks chosen enemy
// then: enemy attacks random team member
// lastly: reset all battle states
private void HandleRound()
{
// check if player has won
if (m_Enemies.Count <= 0)
{
ResetBattlePhase();
UIControllerBattle.get.m_AttackButton.gameObject.SetActive(false);
UIControllerBattle.get.m_HelperMenuButton.gameObject.SetActive(false);
// Activate the ending screen
UIControllerBattle.get.m_EndingScreen.gameObject.SetActive(true);
string tmp = CheckForCharacterUnlock();
UIControllerBattle.get.m_EndingText.text = "You won!\n" + tmp;
if (PlayerData.LastSelectedLevel < 5)
{
ServerResponse sr = UserRequestLibrary.UnlockLevelForUser(PlayerData.LastSelectedLevel + 1);
}
return;
}
// if player lost
if (m_Team.Count <= 0)
{
ResetBattlePhase();
UIControllerBattle.get.m_AttackButton.gameObject.SetActive(false);
UIControllerBattle.get.m_HelperMenuButton.gameObject.SetActive(false);
// Activate the ending screen
UIControllerBattle.get.m_EndingScreen.gameObject.SetActive(true);
UIControllerBattle.get.m_EndingText.text = "You lost.. try again with a better team!";
return;
}
// round start
if (!m_roundInitialized)
{
// get gameobject of current team member
m_teamMember = m_LastSelectedTeamMember.gameObject;
// save last position of team member
m_teamMemberLastPos = m_teamMember.transform.position;
// get animator
m_teamMemberAnimator = m_teamMember.GetComponent <Animator>();
// attacker should overlap attacked
// save original sorting layer
m_teamMemberSpriteLayer = m_teamMember.GetComponent <SpriteRenderer>().sortingOrder;
m_teamMember.GetComponent <SpriteRenderer>().sortingOrder = 15;
// get gameobject of current enemy
m_enemyTarget = m_LastSelectedEnemy.gameObject;
// get animator
m_enemyTargetAnimator = m_enemyTarget.GetComponent <Animator>();
// let enemy sprite be under player sprite
// save original sorting layer
m_enemyTargetSpriteLayer = m_enemyTarget.GetComponent <SpriteRenderer>().sortingOrder;
m_enemyTarget.GetComponent <SpriteRenderer>().sortingOrder = 14;
// direction where team member is headed
m_direction = m_enemyTarget.transform.position - m_teamMember.transform.position;
m_direction.Normalize();
// round start done
m_roundInitialized = true;
// run animation
m_teamMemberAnimator.SetBool("IsRunning", true);
}
// player attack turn
else if (!m_PlayerAttacked)
{
// if is not playing animation
if (m_teamMemberAnimator != null && !m_teamMemberAnimator.GetBool("IsAttacking"))
{
// if enemy was reached, attack
if (m_teamMember.transform.position.x >= m_enemyTarget.transform.position.x - 1.5f)
{
m_teamMemberAnimator.SetBool("IsAttacking", true);
m_enemyTargetAnimator.SetTrigger("IsHurt");
}
// if enemy was not reached yet, return, so position can be updated
else
{
// move towards enemy
m_teamMember.transform.position += m_direction * m_MoveSpeed * Time.deltaTime;
return;
}
}
// if already is playing animation | wait for animation event to be called
else
{
return;
}
}
// player moves back to original position
else if (!m_playerMoveBack)
{
// if player has returned to his original position
if (m_teamMember.transform.position.x <= m_teamMemberLastPos.x)
{
m_teamMember.GetComponent <Animator>().SetBool("IsRunning", false);
// Reset Sprite Layers
m_teamMember.GetComponent <SpriteRenderer>().sortingOrder = m_teamMemberSpriteLayer;
m_enemyTarget.GetComponent <SpriteRenderer>().sortingOrder = m_enemyTargetSpriteLayer;
m_playerMoveBack = true;
}
// if not move backwards
else
{
m_teamMember.transform.position -= m_direction * m_MoveSpeed * Time.deltaTime;
return;
}
}
// check if enemy dead
else if (m_LastSelectedEnemy.m_Health <= 0)
{
if (m_enemyTargetAnimator != null && !m_enemyTargetAnimator.GetBool("IsDead"))
{
m_enemyTargetAnimator.SetBool("IsDead", true);
}
return;
}
// enemy chooses a target to attack
else if (!m_enemyTargetChoosen)
{
// choose a random target from the remaining team members
// Remember: Random.Next(inclusive, exclusive)
System.Random rand = new System.Random();
m_enemy_ChosenTeamPlayerTarget = m_Team[rand.Next(0, m_Team.Count)];
System.Random random = new System.Random();
m_enemyAttackerCharacter = m_Enemies[random.Next(0, m_Enemies.Count)];
// save spritelayer order for chosen target
m_enemy_ChosenTeamPlayerTargetSpriteLayer = m_enemy_ChosenTeamPlayerTarget.GetComponent <SpriteRenderer>().sortingOrder;
m_enemy_ChosenTeamPlayerTarget.GetComponent <SpriteRenderer>().sortingOrder = 14;
m_enemy_ChosenTeamPlayerTargetAnimator = m_enemy_ChosenTeamPlayerTarget.GetComponent <Animator>();
// get gameobject of current enemy
m_enemyAttacker = m_enemyAttackerCharacter.gameObject;
// save last position of current enemy
m_enemyAttackerLastPos = m_enemyAttacker.transform.position;
// get animator
m_enemyAttackerAnimator = m_enemyAttacker.GetComponent <Animator>();
// let enemy sprite be over player sprite
// save original sorting layer
m_enemyAttackerSpriteLayer = m_enemyAttacker.GetComponent <SpriteRenderer>().sortingOrder;
m_enemyAttacker.GetComponent <SpriteRenderer>().sortingOrder = 15;
// direction where enemy attacker is headed
m_direction = m_enemy_ChosenTeamPlayerTarget.transform.position - m_enemyAttacker.transform.position;
m_direction.Normalize();
m_enemyAttacker.GetComponent <Animator>().SetBool("IsRunning", true);
m_enemyTargetChoosen = true;
}
// enemy is attacking
else if (!m_EnemyAttacked)
{
// if is not playing animation
if (m_enemyAttackerAnimator != null && !m_enemyAttackerAnimator.GetBool("IsAttacking"))
{
// if player was reached, attack
if (m_enemyAttacker.transform.position.x <= m_enemy_ChosenTeamPlayerTarget.transform.position.x + 1.5f)
{
m_enemyAttackerAnimator.SetBool("IsAttacking", true);
m_enemy_ChosenTeamPlayerTargetAnimator.SetTrigger("IsHurt");
}
// if enemy was not reached yet, return, so position can be updated
else
{
// move towards enemy
m_enemyAttacker.transform.position += m_direction * m_MoveSpeed * Time.deltaTime;
return;
}
}
// if already is playing animation | wait for animation event to be called
else
{
return;
}
}
// enemy moves back to original position
else if (!m_enemyMoveBack)
{
// if player has returned to his original position
if (m_enemyAttacker.transform.position.x >= m_enemyAttackerLastPos.x)
{
m_enemyAttacker.GetComponent <Animator>().SetBool("IsRunning", false);
// Reset Sprite Layers
m_enemy_ChosenTeamPlayerTarget.GetComponent <SpriteRenderer>().sortingOrder = m_enemy_ChosenTeamPlayerTargetSpriteLayer;
m_enemyAttacker.GetComponent <SpriteRenderer>().sortingOrder = m_enemyAttackerSpriteLayer;
m_enemyMoveBack = true;
}
// if not move backwards
else
{
m_enemyAttacker.transform.position -= m_direction * m_MoveSpeed * Time.deltaTime;
return;
}
}
// team member targeted by enemy dead
else if (m_enemy_ChosenTeamPlayerTarget.m_Health <= 0)
{
if (m_enemy_ChosenTeamPlayerTargetAnimator != null && !m_enemy_ChosenTeamPlayerTargetAnimator.GetBool("IsDead"))
{
m_enemy_ChosenTeamPlayerTargetAnimator.SetBool("IsDead", true);
}
return;
}
// round finished
else
{
ResetBattlePhase();
}
}
