public void ChangeBackToGameplay()
{
if (player == null)
{
player = storyManager.GetPlayerCharacter();
}
try
{
player.transform.position = currentPlayerPosition;
player.transform.rotation = currentPlayerRotation;
player.gameObject.SetActive(false);
player.ResetFighterValues();
}
catch (Exception) { }
cam.transform.position = currentCamPosition;
cam.transform.rotation = currentCamRotation;
pedestal.SetActive(false);
gameplayUI.SetActive(true);
mainMenuUI.SetActive(false);
storyManager.ResetDecisions();
cam.ResetSpotlight();
ResetUI();
}
public void ContinueGame()
{
StoryGameSave save = GameManager.INSTANCE.profile.GetStoryGameSave();
startSet = save.startSet;
pathPlayerTook = save.playerPath;
classID = save.classID;
player = starterClasses[classID].Init(transform.parent, Vector3.zero, Quaternion.identity);
Destroy(starterModels[0].transform.parent.gameObject);
playerLifebar.SetFighter(player);
player.SetLifebar(playerLifebar);
player.gameObject.SetActive(false);
characterChosen = true;
player.SetLevel(save.level);
player.SetAttributes(save.playerAttributes);
player.SetUnlockedAttacks(save.unlockedAttacks);
player.SetStat(Stat.STR, save.strength);
player.SetStat(Stat.DEX, save.dexterity);
player.SetStat(Stat.INT, save.intelligence);
player.SetStat(Stat.FTH, save.faith);
player.SetStat(Stat.LCK, save.luck);
player.SetSkillPoints(save.skillPoints);
startChapter = save.currentChapter;
startSituationID = save.currentSituation;
ChangeChapter(save.currentChapter, save.currentSituation);
}
public void Init(PlayerMove attack, TextMeshProUGUI description, DCPlayer player)
{
this.player = player;
this.attack = attack;
this.description = description;
buttonDescription.text = attack.name;
}
public int EnhanceDuration(DCPlayer player, int duration)
{
(string _, int strength) = player.GetStat(Stat.STR);
(string _, int dexterity) = player.GetStat(Stat.DEX);
(string _, int intelligence) = player.GetStat(Stat.INT);
(string _, int faith) = player.GetStat(Stat.FTH);
(string _, int luck) = player.GetStat(Stat.LCK);
return(Mathf.RoundToInt(((float)STR * (float)DEX * (float)INT * (float)FTH * (float)LCK
* strength * dexterity * intelligence * faith * luck) / Mathf.Pow(BattleManager.maxSkillLevel * (float)Scaling.S, 2) *
duration));
}
void OnReceived(IAsyncResult result)
{
// this is what had been passed into BeginReceive as the second parameter:
UdpClient socket = result.AsyncState as UdpClient;
// points towards whoever had sent the message:
IPEndPoint source = new IPEndPoint(0, 0);
// get the actual message and fill out the source:
byte[] message = socket.EndReceive(result, ref source);
// do what you'd like with `message` here:
string returnData = Encoding.ASCII.GetString(message);
Debug.Log("Got this: " + returnData);
latestMessage = JsonUtility.FromJson <Message>(returnData);
try{
switch (latestMessage.cmd)
{
case commands.NEW_CLIENT:
NPlayer = JsonUtility.FromJson <NewPlayer>(returnData);
Joined = true;
break;
case commands.UPDATE:
lastestGameState = JsonUtility.FromJson <GameState>(returnData);
break;
case commands.DISCONNECT:
DCP = JsonUtility.FromJson <DCPlayer>(returnData);
break;
case commands.OLD_CLIENT:
connectedPlayers = JsonUtility.FromJson <EveryPlayer>(returnData);
break;
default:
Debug.Log("Error");
break;
}
}
catch (Exception e) {
Debug.Log(e.ToString());
}
// schedule the next receive operation once reading is done:
socket.BeginReceive(new AsyncCallback(OnReceived), socket);
}
public void ChangeToMainMenu()
{
if (player == null)
{
player = storyManager.GetPlayerCharacter();
}
if (player == null)
{
return;
}
player.DisableAgent(true);
cam.SetSpotlight(50, 1.5f);
currentPlayerPosition = player.transform.position;
currentCamPosition = cam.transform.position;
currentPlayerRotation = player.transform.rotation;
currentCamRotation = cam.transform.rotation;
player.transform.position = playerTransformInMainMenu.position;
player.transform.rotation = playerTransformInMainMenu.rotation;
cam.transform.position = camTransformInMainMenu.position;
cam.transform.rotation = camTransformInMainMenu.rotation;
player.gameObject.SetActive(true);
player.ResetFighterValues();
pedestal.SetActive(true);
mainMenuUI.SetActive(true);
gameplayUI.SetActive(false);
if (!perksAndMovesSet)// needed for first time in main menu
{
foreach (PlayerMove move in player.GetAllMoves())
{
Instantiate(skillPrefab, scrollPanel.transform).
Init(this, unlockButton, move).gameObject.SetActive(true);
}
foreach (Perk perk in player.GetAllPerks())
{
Instantiate(skillPrefab, scrollPanel.transform).
Init(this, unlockButton, perk).gameObject.SetActive(true);
}
perksAndMovesSet = true;
}
}
private void Update()
{
if (player == null)
{
player = storyManager.GetPlayerCharacter();
}
if (player == null)
{
return;
}
else
{
(string name, int value) = player.GetStat(stat);
text.text = $"{name}\n{value}";
}
}
private void Update()
{
if (player == null)
{
player = storyManager.GetPlayerCharacter();
if (player == null)
{
return;
}
else
{
unlockButton.SetPlayer(player);
mainMenuButton.SetActive(true);
}
}
classLabel.text = player.GetClass();
levelLabel.text = $"{player.GetLevel()}";
skillLabel.text = $"{player.GetSkillPoints()}";
}
GetAttackInfo(DCPlayer player, bool preview = false)
{
(string _, int STR) = player.GetStat(Stat.STR);
(string _, int DEX) = player.GetStat(Stat.DEX);
(string _, int INT) = player.GetStat(Stat.INT);
(string _, int FTH) = player.GetStat(Stat.FTH);
(string _, int LCK) = player.GetStat(Stat.LCK);
(Scaling[] scalings, float damageMultiplier, float critMultiplier,
float statusProbability, List <Status> statuses) = Perk.ApplyAttackPerks(player.GetActivePerks(), this);
Scaling newSTR = scalings[0];
Scaling newDEX = scalings[1];
Scaling newINT = scalings[2];
Scaling newFTH = scalings[3];
Scaling newLCK = scalings[4];
float luck = (float)newLCK * LCK / BattleManager.maxSkillLevel;
float scaling = (preview ? 1f : Random.Range(0.9f, 1.1f)) + ((float)newSTR * STR + (float)newDEX * DEX +
(float)newINT * INT + (float)newFTH * FTH + (float)newLCK * LCK) /
(BattleManager.maxSkillLevel * (float)Scaling.C * 4);
if (status != Status.None)
{
statusProbability += luck;
for (int i = 0; i < timesStatusApplied; i++)
{
if (statusProbability > Random.Range(0f, 1f) || preview)
{
statuses.Add(status);
}
}
}
scaling *= damageMultiplier;
scaling *= luck > Random.Range(0, 1f) && !preview ? critMultiplier : 1f;
return(healthDamage * scaling, staminaDamage *scaling, manaDamage *scaling, statuses, statusProbability, luck);
}
public void SetPlayer(DCPlayer player)
{
this.player = player;
}
/// <summary>
/// method, that handles current situation
/// </summary>
/// <param name="id">id of current situation</param>
/// <param name="distanceToWalk">distance that needs to be walked</param>
/// <param name="startBattle">true, if battle should start</param>
/// <returns></returns>
private IEnumerator WaitTillDistanceWalked(int id, double distanceToWalk,
bool startBattle)
{
if (startBattle)
{
yield return(new WaitUntil(() => battleManager.BattleOver));
}
// do some "walking"
if (!turnOffWalkingRequirement && distanceToWalk > 0)
{
textWhenWalking.gameObject.SetActive(true);
decisionsPanel.gameObject.SetActive(false);
currentSituation.gameObject.SetActive(false);
if (!startSet)
{
textWhenWalking.SetStart(manager.profile.GetDistanceTraveled(), distanceToWalk);
startSet = true;
}
yield return(new WaitUntil(() => distanceToWalk - textWhenWalking.Distance <= 0));
startSet = false;
textWhenWalking.gameObject.SetActive(false);
decisionsPanel.gameObject.SetActive(true);
currentSituation.gameObject.SetActive(true);
}
// flush current options
decisionsPanel.Flush();
// set new id for current situation
currentSituationID = id;
Situation current = chapters[currentChapterID].situations[currentSituationID];
currentSituation.text = current.description;
CharacterSelection charSel = current as CharacterSelection;
Navigation navi = current as Navigation;
Dialogue dialogue = current as Dialogue;
GameOverSituation gameOver = current as GameOverSituation;
if (!characterChosen && !(current is CharacterSelection))
{
for (int i = 0; i < starterModels.Length; i++)
{
if (starterModels[i].isActiveAndEnabled)
{
player = starterClasses[i].Init(transform.parent, Vector3.zero, Quaternion.identity);
classID = i;
}
}
Destroy(starterModels[0].transform.parent.gameObject);
playerLifebar.SetFighter(player);
player.SetLifebar(playerLifebar);
player.gameObject.SetActive(false);
characterChosen = true;
}
if (charSel == null && navi != null)
{
foreach (NextPoint info in (current as Navigation).options)
{
InstantiateDecision(info);
}
}
if (dialogue != null)
{
foreach (DialogueOption info in dialogue.options)
{
InstantiateDecision(info);
}
for (int i = 0; i < dialogue.enemies.Length; i++)
{
Enemy enemy = Instantiate(dialogue.enemies[i], dialogue.enemyPosition[i],
Quaternion.Euler(dialogue.enemyRotation[i]));
battleManager.AddEnemy(enemy);
}
}
if (charSel != null)
{
for (int i = 0; i < starterModels.Length; i++)
{
starterModels[i].gameObject.SetActive(i == charSel.classID);
}
foreach (NextPoint info in (current as Navigation).options)
{
InstantiateDecision(info);
}
}
if (current.flushDeadEnemies)
{
foreach (GameObject gameObject in destroyOnSituationChange)
{
Destroy(gameObject);
}
destroyOnSituationChange = new List <GameObject>();
}
if (current.important)
{
PlotPoint plotPoint = new PlotPoint();
plotPoint.chapter = currentChapterID;
plotPoint.situation = currentSituationID;
pathPlayerTook.Add(plotPoint);
}
if (gameOver != null)
{
if (gameOver.vfx != null)
{
ParticleSystem gameOverVFX = Instantiate(gameOver.vfx, player.transform.position,
player.transform.rotation, transform);
gameOverVFX.Play();
}
yield return(new WaitForSeconds(3f));
SceneManager.LoadScene(4);
}
if (dialogue == null || dialogue.dialogueStart)
{
cam.UpdateCamPositionAndRotation(current.camPosition, Quaternion.Euler(current.camRotation));
cam.SetSpotlight(current.spotlightRange);
}
try
{
foreach (int i in current.activateGameObject)
{
toggleableObjects[i].gameObject.SetActive(true);
}
foreach (int i in current.deactivateGameObject)
{
toggleableObjects[i].gameObject.SetActive(false);
}
}
catch (NullReferenceException) { }
}
// Update is called once per frame
void Update()
{
if (attackQueue == null)
{
attackQueue = new Queue <Fighter>();
}
if (player == null)
{
player = manager.GetPlayerCharacter();
}
if (player == null)
{
return;
}
if (pause)
{
player.IsFighting = false;
if (enemies == null)
{
return;
}
foreach (Enemy enemy in enemies)
{
enemy.IsFighting = false;
}
}
else
{
player.IsFighting = true;
foreach (Enemy enemy in enemies)
{
enemy.IsFighting = true;
}
}
if (AllEnemiesDead() && !someoneIsAttacking)
{
cam.ChangeToFirstPerson();
pause = true;
}
if (AllEnemiesDead() && !someoneIsAttacking && cam.PositionSet)
{
HandleBattleOver();
pause = true;
}
if (player != null && player.IsDead())
{
StartCoroutine(DoDeathCam(1.5f));
}
if (!someoneIsAttacking && attackQueue.Count > 0 && !BattleOver)
{
currentAttacker = attackQueue.Dequeue();
if (!currentAttacker.IsDead())
{
SomeoneGotHit = false;
someoneIsAttacking = true;
foreach (Enemy enemy in enemies)
{
enemy.PauseInitiativeTimer(true);
}
player.PauseInitiativeTimer(true);
if (currentAttacker == player)
{
attackOptionsPanel.Flush();
foreach (PlayerMove attack in player.GetAvailableMoves())
{
Instantiate(attackOptionPrefab, attackOptionsPanel.transform).
Init(attack, description, player);
}
player.Attack();
}
else
{
currentAttacker.Attack();
}
}
}
}
public (string STR, string DEX, string INT, string FTH, string LCK, float critMultiplier) GetScalingInfo(DCPlayer player)
{
(Scaling[] scalings, float _, float critMultiplier, float _, List <Status> _) = Perk.ApplyAttackPerks(player.GetActivePerks(), this);
return(ScalingToString(scalings[0]), ScalingToString(scalings[1]), ScalingToString(scalings[2]),
ScalingToString(scalings[3]), ScalingToString(scalings[4]), critMultiplier);
}
public void SetPlayerPosition(DCPlayer player)
{
this.player = player;
}
