// Use this for initialization
void Awake()
{
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(gameObject);
}
#if UNITY_EDITOR
//Sets this to not be destroyed when reloading scene
if (Application.isEditor && EditorApplication.isPlaying)
{
#endif
DontDestroyOnLoad(gameObject);
#if UNITY_EDITOR
}
#endif
targets = new List <Transform>();
updateCameras();
}
public void ExitCombat()
{
NeverdawnCamera.HideGrid(1.0f);
_combatController.ExitCombat();
_gameState = GameState.Exploration;
}
internal void StartCombat(Character attacker)
{
UIAnnouncement.Announce("Fight!", 2.0f);
NeverdawnCamera.ShowGrid(2.0f);
_gameState = GameState.Combat;
_combatController.PrepareCombat(_explorationController.controllers, attacker);
}
protected override void OnInitializeCursor()
{
NeverdawnCamera.AddTargetLerped(targetTransform);
meshFilter = GetComponent <MeshFilter>();
root = character.transform.position + character.transform.TransformDirection(projectileSpawn);
inputVector = character.transform.forward * minPower;
inputAngle = Mathf.PI / 4.0f;
updateCursor();
}
public static void DestroyGame()
{
PlayerInventory.Clear();
NeverdawnCamera.Destroy();
EventController.ClearEvents();
foreach (AvatarController controller in activeControllers)
{
Destroy(controller.gameObject);
}
activeControllers.Clear();
}
private void updateCurrentControllers()
{
currentTurnControllers.Clear();
Character character = currentCombatGroup[turnIndex];
// find the next living character
while (!character.isAlive)
{
turnIndex = NeverdawnUtility.RepeatIndex(turnIndex + 1, currentCombatGroup.Count);
character = currentCombatGroup[turnIndex];
}
// fetch all characters in the party in the following sequence
if (character.IsInPlayerParty)
{
while (character.IsInPlayerParty)
{
// find the current controller or an auxiliary controller
NeverdawnCharacterController controller = character.controller;
if (!controller)
{
controller = findControllerForCharacter(character);
}
// collect the controllers and try to add more characters
if (!currentTurnControllers.Contains(controller))
{
controller.character = character;
currentTurnControllers.Add(controller);
turnIndex = NeverdawnUtility.RepeatIndex(turnIndex + 1, currentCombatGroup.Count);
character = currentCombatGroup[turnIndex];
}
else
{
break;
}
}
}
else
{
currentTurnControllers.Add(character.controller);
turnIndex = NeverdawnUtility.RepeatIndex(turnIndex + 1, currentCombatGroup.Count);
}
NeverdawnCamera.Clear();
currentTurnControllers.ForEach(c => NeverdawnCamera.AddTargetLerped(c.character.cachedTransform));
}
protected override void OnInitializeCursor()
{
NeverdawnCamera.AddTargetLerped(targetTransform);
agent = targetTransform.GetComponent <NavMeshAgent>();
meshFilter = GetComponent <MeshFilter>();
navMeshPath = new NavMeshPath();
meshRenderer = GetComponent <MeshRenderer>();
NavMeshAnimator walker = character.GetComponentInChildren <NavMeshAnimator>();
turnSpeed = 0.5f * walker.turnSpeed;
root = character.position;
agent.Warp(root);
createGradient();
}
private void createAvatarController(InputModule module)
{
AvatarController controller = GameObject.Instantiate(avatarControllerPrefab);
controller.inputModule = module;
controller.transform.SetParent(avatarControllerParent);
controller.color = playerColors[controllers.Count];
controller.character = GameController.instance.party.GetNextCharacter();
if (controller.character)
{
controller.characterMenu = UICharacterMenus.GetMenu(controller.character);
controller.preferredCharacterId = controller.character.id;
NeverdawnCamera.AddTargetLerped(controller.character.transform);
}
controllers.Add(controller);
}
private IEnumerator loadGame(SerializableGame data, float delay = 0.0f)
{
yield return(new WaitForSeconds(delay));
_currentGame = data;
AsyncOperation async = SceneManager.LoadSceneAsync(data.currentScene);
while (!async.isDone)
{
_loadingScreen.SetProgress(Mathf.Clamp01(async.progress / 0.9f));
yield return(null);
}
_generalGuiPage.Show();
_loadingScreen.Hide(1.0f);
NeverdawnCamera.HideGrid();
yield return(new WaitForSeconds(1.0f));
}
internal void ExitCombat()
{
foreach (Character character in currentCombatGroup)
{
if (character.isAlive)
{
character.LeaveCombatStance();
}
}
NeverdawnCamera.Clear();
foreach (AvatarController controller in _controllers)
{
controller.character = Frame.FindComponentById <Character>(controller.preferredCharacterId);
NeverdawnCamera.AddTargetLerped(controller.character.transform);
}
GameController.instance.party.StoreUnused();
}
internal void Initialize(SerializableGame game)
{
foreach (InputModule module in DeviceController.inputModules)
{
if (!moduleInUse(module))
{
createAvatarController(module);
}
}
foreach (AvatarController controller in controllers)
{
if (controller.character == null)
{
controller.character = GameController.instance.party[controller.preferredCharacterId];
if (controller.character != null)
{
controller.character.solid.Show();
controller.character.GetComponentInChildren <NavMeshAnimator>().Reset();
NeverdawnCamera.AddTargetLerped(controller.character.transform);
}
else
{
Debug.LogWarning("A character was lost during scene transition");
return;
}
}
}
foreach (AvatarController controller in controllers)
{
controller.character.position = game.currentPosition.ToVector3();
controller.character.eulerAngles = game.currentRotation.ToVector3();
}
DeviceController.onModuleActivated -= createAvatarController;
DeviceController.onModuleActivated += createAvatarController;
}
public void UpdateExplorationControls()
{
if (character != null)
{
if (currentAbility != null)
{
updateAbility();
return;
}
if (inputModule.GetAxisUp(NeverdawnInputAxis.Trigger, NeverdawnInputAxisDirection.Positive))
{
if (quickSlotsPage != null)
{
quickSlotsPage = null;
characterMenu.Close();
}
}
if (inputModule.GetAxisDown(NeverdawnInputAxis.Trigger, NeverdawnInputAxisDirection.Positive))
{
if (character.isIdle)
{
quickSlotsPage = Instantiate(UIFactory.uiQuickMenuQuickSlotsPrefab);
quickSlotsPage.abilities = character.quickCastAbilities;
characterMenu.Open(quickSlotsPage);
}
}
if (characterMenu.isOpen)
{
if (inputModule.GetButtonDown(NeverdawnInputButton.Cancel))
{
characterMenu.GoBack();
}
return;
}
// DEBUG LVL UP
if (inputModule.GetButtonDown(NeverdawnInputButton.Info))
{
character.LevelUp();
}
// Start pressed
if (inputModule.GetButtonDown(NeverdawnInputButton.Start))
{
if (character.isIdle)
{
characterMenu.NavigateInto(Instantiate(UIFactory.uiQuickMenuStartPrefab));
}
}
//Select pressed
if (inputModule.GetButtonDown(NeverdawnInputButton.Settings))
{
if (character.isIdle)
{
GameController.instance.PauseGame();
}
}
// Confirm pressed
if (inputModule.GetButtonDown(NeverdawnInputButton.Confirm))
{
if (character.isIdle)
{
if (currentInteractable != null)
{
UIQuickMenuInteractable page = Instantiate(UIFactory.uiQuickMenuInteractionCollectionPrefab);
page.SetInteractionCollection(currentInteractable);
characterMenu.NavigateInto(page);
}
}
else
{
character.currentAction.ActionConfirm();
}
}
// Cancel pressed
if (inputModule.GetButtonDown(NeverdawnInputButton.Cancel))
{
if (!character.isIdle)
{
character.currentAction.ActionCancel();
}
else
{
characterMenu.NavigateInto(Instantiate(UIFactory.uiQuickMenuStartPrefab));
}
}
// Switch character pressed
if (inputModule.GetButtonDown(NeverdawnInputButton.SwitchCharacter))
{
if (character.isIdle)
{
NeverdawnCamera.RemoveTargetLerped(characterTransform);
Character nextCharacter = GameController.instance.party.GetNextCharacter(this);
if (nextCharacter != null)
{
character = nextCharacter;
preferredCharacterId = nextCharacter.id;
}
NeverdawnCamera.AddTargetLerped(characterTransform);
// UINeverdawnParty.UpdateView();
characterMenu = UICharacterMenus.GetMenu(character);
}
}
// Movement
if (character.isIdle)
{
Vector3 input = inputModule.normalizedDirection;
smoothedInput = Vector3.RotateTowards(smoothedInput, input, Time.deltaTime * _inputSmoothing, 1.0f);
// Get player input
Vector2 fwdTurn = NeverdawnUtility.InputToForwardTurn(characterTransform, smoothedInput, 2.0f);
// Rotate the player
characterTransform.Rotate(Vector3.up, fwdTurn.y * Time.deltaTime * characterNavMeshAnimator.turnSpeed);
// Find target position
Vector3 targetPosition = characterTransform.position + characterNavMeshAnimator.moveSpeed * fwdTurn.x * characterTransform.forward * Time.deltaTime;
NavMeshHit hit;
// Check for valid position
if (!NavMesh.Raycast(characterTransform.position, targetPosition, out hit, NavMesh.AllAreas))
{
characterTransform.position = hit.position;
}
else
{
if (NavMesh.SamplePosition(targetPosition, out hit, 0.1f, NavMesh.AllAreas))
{
characterTransform.position = hit.position;
}
}
RaycastHit rayHit;
// experimental: stick to ground
if (Physics.Raycast(characterTransform.position, Vector3.down, out rayHit, 0.5f, 1 << 9))
{
characterTransform.position = rayHit.point;
}
}
// Find closest interaction
Collider[] colliders = Physics.OverlapSphere(character.transform.position, 1.0f, 1 << 10);
float minDistance = float.MaxValue;
Interactable closestHandle = null;
for (int i = 0; i < colliders.Length; i++)
{
float distance = Vector3.Distance(colliders[i].transform.position, character.transform.position);
Interactable handle = colliders[i].GetComponentInParent <Interactable>();
if (distance < minDistance && handle != null && handle.enabled)
{
closestHandle = handle;
minDistance = distance;
}
}
if (closestHandle != null)
{
updateInteraction(closestHandle);
}
else
{
updateInteraction(null);
}
}
}
void OnDestroy()
{
NeverdawnCamera.RemoveTargetLerped(targetTransform);
}
public override void UpdateCombatControls()
{
if (GameController.state == GameState.Combat)
{
if (character.isIdle)
{
if (obstacle.enabled)
{
obstacle.enabled = false;
return;
}
if (character.remainingActions > 0)
{
RangedAttackAbility rangedAttack = character.GetCastableAbilities <RangedAttackAbility>()
.OrderByDescending(m => m.threatRating).FirstOrDefault();
if (rangedAttack != null)
{
target = CharacterUtils.GetClosestCharacter(GameController.instance.party, character.position);
if (target != null)
{
NeverdawnCamera.AddTargetLerped(target.transform);
hasFallback = false;
float distance = Vector3.Distance(character.position, target.position);
if (distance > rangedAttack.weapon.estimatedRange + character.remainingSteps)
{
if (character.remainingSteps > 0.0f)
{
character.PushAction(new CharacterNavigateToAction(target.position, character.remainingSteps, false,
rangedAttack.weapon.estimatedRange - 0.1f));
}
else
{
GameController.instance.combatController.EndTurn(this);
return;
}
}
else
{
// Get positions and sort by strategic value (furthest away from target!)
List <Vector3> positions = sampleSurroundings(20, character.remainingSteps);
positions = positions.OrderByDescending(p => Vector3.Distance(p, target.position)).ToList();
// No position found yet!
bool hasPosition = false;
Vector3 targetPosition = Vector3.negativeInfinity;
Vector3 targetVelocity = Vector3.negativeInfinity;
Vector3 force;
foreach (Vector3 position in positions)
{
Vector3 direction = target.position - position;
direction.y = 0.0f;
direction.Normalize();
launchTransform.position = position;
launchTransform.forward = direction;
Vector3 launchPosition = launchTransform.TransformPoint(rangedAttack.weapon.projectileSpawn);
if (tryHitTarget(rangedAttack, launchPosition, target.frame, out force, 5))
{
targetPosition = position;
targetVelocity = force;
hasPosition = true;
break;
}
}
if (hasPosition)
{
rangedAttack.targetVelocity = targetVelocity;
rangedAttack.caster = character;
character.PushAction(new CharacterNavigateToAction(targetPosition, character.remainingSteps, false));
character.PushAction(rangedAttack.Prepare());
character.PushAction(rangedAttack.Cast());
}
else
{
if (hasFallback)
{
rangedAttack.targetVelocity = fallBackVelocity;
rangedAttack.caster = character;
character.PushAction(new CharacterNavigateToAction(fallbackPosition, character.remainingSteps, false));
character.PushAction(rangedAttack.Prepare());
character.PushAction(rangedAttack.Cast());
}
else
{
GameController.instance.combatController.EndTurn(this);
}
}
}
}
else
{
GameController.instance.combatController.EndTurn(this);
}
}
else
{
EndCombatTurn();
}
}
else
{
if (target)
{
NeverdawnCamera.RemoveTargetLerped(target.transform);
}
EndCombatTurn();
}
}
}
if (character.isIdle)
{
if (!obstacle.enabled)
{
obstacle.enabled = true;
}
}
}
