private void ActivateSelectedCommand()
{
activePlayer = playerUnitsReadyToSelectCommand.Dequeue();
// Fill out the command with the current targets,
// and send it back through the actor so that actor can update state.
foreach (ActorCombatController target in currentTargets)
{
selectedCommand.AddTarget(target);
}
activePlayer.RegisterCommand(selectedCommand);
// Mark selection and active player as null so we can move to next player.
selectedCommand = null;
activePlayer = null;
currentTargets.Clear();
}
public void DisplayInstructions()
{
if (player == null)
{
player = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerCombatController>();
}
instructionsPanel.SetActive(!instructionsPanel.activeInHierarchy);
if (instructionsPanel.activeInHierarchy)
{
Time.timeScale = 0;
player.enabled = false;
}
else
{
Time.timeScale = 1;
player.enabled = true;
}
}
private PlayerCombatController NextPlayer(TargetChangeDirection change)
{
float currentY = lastSinglePlayerCombatTarget.transform.position.y;
float ny = currentY;
PlayerCombatController nextPlayer = null;
switch (change)
{
case TargetChangeDirection.Up:
foreach (PlayerCombatController player in battleController.playerActors)
{
float ey = player.transform.position.y;
if (ey > currentY && (ey > ny || ny == currentY))
{
ny = ey;
nextPlayer = player;
}
}
if (nextPlayer == null)
{
nextPlayer = BottomPlayer();
}
return(nextPlayer);
case TargetChangeDirection.Down:
foreach (PlayerCombatController player in battleController.playerActors)
{
float ey = player.transform.position.y;
if (ey < currentY && (ey < ny || ny == currentY))
{
ny = ey;
nextPlayer = player;
}
}
if (nextPlayer == null)
{
nextPlayer = TopPlayer();
}
return(nextPlayer);
default:
throw new System.ArgumentException("Unhandled switch case [" + change.ToString() + "]");
}
}
// Update is called once per frame
void Update()
{
CheckFinished();
activePlayer = null;
if (playerUnitsReadyToSelectCommand.Count > 0)
{
activePlayer = playerUnitsReadyToSelectCommand.Peek();
}
if (activePlayer != null)
{
if (selectedCommand != null)
{
ManageTargetSelectionInput();
// Update targets based on current command targets identified
UpdateTargetSelection();
if (Input.GetButtonDown("UseAction"))
{
// Command is selected; player is done with prep and can be dequeued.
ActivateSelectedCommand();
}
}
else
{
if (Input.GetButtonDown("Cancel"))
{
// Dequeue the top ready player and put them at the back of the line.
playerUnitsReadyToSelectCommand.Enqueue(playerUnitsReadyToSelectCommand.Dequeue());
}
}
}
foreach (ActorCombatController actor in fingerPointers.Keys)
{
fingerPointers[actor].SetActive(false);
}
foreach (ActorCombatController actor in currentTargets)
{
fingerPointers[actor].SetActive(true);
}
}
private void LoadPlayer(int id, PlayerClass playerClass)
{
switch (playerClass)
{
case PlayerClass.Knight:
{
Player.CreatePlayer(id, 3, 1, 1, 1);
PlayerExplorationController explorationController = Instantiate(ResourceUtility.GetPrefab <PlayerExplorationController>("KnightE"));
explorationController.Initialize(id);
playerExplorationControllers[id] = explorationController;
PlayerCombatController combatController = Instantiate(ResourceUtility.GetPrefab <PlayerCombatController>("KnightC"));
combatController.Initialize(id);
playerCombatControllers[id] = combatController;
}
break;
case PlayerClass.Heavy:
{
Player.CreatePlayer(id, 6, 2, 1, 1);
PlayerExplorationController explorationController = Instantiate(ResourceUtility.GetPrefab <PlayerExplorationController>("HeavyE"));
explorationController.Initialize(id);
playerExplorationControllers[id] = explorationController;
PlayerCombatController combatController = Instantiate(ResourceUtility.GetPrefab <PlayerCombatController>("HeavyC"));
combatController.Initialize(id);
playerCombatControllers[id] = combatController;
}
break;
case PlayerClass.Nurse:
{
Player.CreatePlayer(id, 2, 1, 1, 1);
PlayerExplorationController explorationController = Instantiate(ResourceUtility.GetPrefab <PlayerExplorationController>("NurseE"));
explorationController.Initialize(id);
playerExplorationControllers[id] = explorationController;
PlayerCombatController combatController = Instantiate(ResourceUtility.GetPrefab <PlayerCombatController>("NurseC"));
combatController.Initialize(id);
playerCombatControllers[id] = combatController;
}
break;
}
}
private void Awake()
{
movementController = GetComponent <PlayerMovementController>();
combatController = GetComponent <PlayerCombatController>();
rigidBody = GetComponent <Rigidbody>();
// Input setup
controls = new InputMaster();
controls.Player.Enable();
// Movement
controls.Player.Steering.performed += ctx => Steering(ctx.ReadValue <float>());
controls.Player.AcceleratePress.performed += _ => accelInput = 1.0f;
controls.Player.AccelerateRelease.performed += _ => accelInput = 0.0f;
controls.Player.JumpPress.performed += _ => { movementController.Jump(moveInput); movementController.UpdateJumpInput(true); };
controls.Player.JumpRelease.performed += _ => movementController.UpdateJumpInput(false);
controls.Player.BrakePress.performed += _ => movementController.brakingState.Active = true;
controls.Player.BrakeRelease.performed += _ => movementController.brakingState.Active = false;
controls.Player.DriftPress.performed += _ => movementController.driftingState.Active = true;
controls.Player.DriftRelease.performed += _ => movementController.driftingState.Active = false;
controls.Player.Grind.performed += _ => { movementController.grindingState.TryGrind(); };
controls.Player.BoostPress.performed += _ => boostInput = 1.0f;
controls.Player.BoostRelease.performed += _ => boostInput = 0.0f;
controls.Player.Movement.performed += ctx => moveInput = ctx.ReadValue <Vector2>();
// Combat
controls.Player.Attack.performed += _ => combatController.BasicAttack();
// Interact
controls.Player.Interact.performed += _ => npc.Interact();
controls.Conversation.Accept.performed += _ => npc.Accept();
controls.Conversation.Decline.performed += _ => npc.Decline();
// Cursor
//Cursor.visible = false;
//Cursor.lockState = CursorLockMode.Locked;
}
public void Trigger(PlayerCombatController playerController)
{
if (!triggered && gameObject.activeInHierarchy)
{
gameObject.SetActive(false);
triggered = true;
switch (type)
{
case LootType.Weapon:
WeaponManager._instance.equipWeapon(playerController, (WeaponType)id, level);
break;
case LootType.Potion:
playerController.Avatar.ApplyHealing(DataTableManager.singleton.GetItemData(id).Attributes);
break;
}
Destroy(gameObject);
}
}
public void equipWeapon(PlayerCombatController player, WeaponType type, int level)
{
var defaultPos = Weapons[(int)type].transform.localPosition;
var defaultRot = Weapons[(int)type].transform.rotation;
var temp = Instantiate(Weapons[(int)type]);
temp.transform.parent = player.weaponHolder;
temp.transform.localPosition = defaultPos;
temp.transform.rotation = defaultRot;
if (player.transform.localScale.x < 0)
{
if (temp.transform.eulerAngles.z == 0)
{
temp.transform.eulerAngles = new Vector3(0, 180, 0);
}
else
{
temp.transform.eulerAngles = new Vector3(0, 0, 360 - temp.transform.eulerAngles.z);
}
}
temp.GetComponent <Weapon>().type = type;
temp.GetComponent <Weapon>().AcquireWeapon(level);
}
private void Awake()
{
CameraCenterController = cam.GetComponent <CameraCenterController>();
CombatUIManager = combatUI.GetComponent <CombatUIManager>();
PlayerCombatController = player.GetComponent <PlayerCombatController>();
}
private void Start()
{
panel.SetActive(false);
playerScript = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerController>();
PC = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerCombatController>();
}
public void PlayerUnitReadyToSelectCommand(PlayerCombatController playerUnit)
{
playerUnitsReadyToSelectCommand.Enqueue(playerUnit);
}
private void Start()
{
anim = GetComponent <Animator>();
player = transform.parent.parent.parent.GetComponent <PlayerCombatController>();
}
public CombatState(PlayerMovementController controller, PlayerCombatController combatController)
{
_controller = controller;
_combatController = combatController;
_exitWhenFinished = false;
}
public void UpdateHealthDisplay(PlayerCombatController cmbtCtrl)
{
currentStatsTextElement.text =
$"Health: {cmbtCtrl.CurrentHealth.ToString("0")}/{cmbtCtrl.MaxHealth.ToString("0")}\n" +
$"Consumable Charges: {cmbtCtrl.CurrentConsumableCharges}/{cmbtCtrl.MaxConsumableCharges}";
}
public override void Initialize(params object[] args)
{
player = (PlayerCombatController)args[0];
}
private void Awake()
{
// Gets the player PlayerMovementController & PlayerCombatController
m_movementController = GetComponent <PlayerMovementController>();
m_combatController = GetComponent <PlayerCombatController>();
}
public IdleState(PlayerCombatController controller)
{
_controller = controller;
}
public void AttackPlayer(PlayerCombatController target)
{
target.TakeDamage(AttackPoints);
Debug.Log(this + " says: \"attack!\"");
}
private void Awake()
{
controller = GetComponent<CharacterController2D>();
combatController = GetComponent<PlayerCombatController>();
animator = GetComponent<Animator>();
}
public override void Refresh(params object[] args)
{
player = (PlayerCombatController)args[0];
}
// Start is called before the first frame update
void Start()
{
playerCombatController = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerCombatController>();
cooldownTime = playerCombatController.GetRangedAttackCooldown();
cooldownFinished = true;
}
// Use this for initialization
void Start()
{
playerPos = transform.parent.transform;
player = transform.parent.parent.GetComponent <PlayerCombatController> ();
}
private void Awake()
{
combatController = GetComponent <PlayerCombatController>();
}
private void ManageTargetSelectionInput()
{
switch (selectedCommand.currentTargetSelection)
{
case CommandBase.Target.ALL_ALLIES:
// Left: previous target option
// Right/Up/Down: Nothing
if (Input.GetButtonDown("MoveLeft"))
{
selectedCommand.currentTargetIndex--;
}
break;
case CommandBase.Target.SELECTED_ALLY:
// Left: previous target option
// Right: next target option
// Up/Down: Toggle targets
if (Input.GetButtonDown("MoveLeft"))
{
selectedCommand.currentTargetIndex--;
}
if (Input.GetButtonDown("MoveRight"))
{
selectedCommand.currentTargetIndex++;
}
if (Input.GetButtonDown("MoveUp"))
{
lastSinglePlayerCombatTarget = NextPlayer(TargetChangeDirection.Up);
}
if (Input.GetButtonDown("MoveDown"))
{
lastSinglePlayerCombatTarget = NextPlayer(TargetChangeDirection.Down);
}
break;
case CommandBase.Target.SELF:
// As SELECTED_ALLY but Up/Down does nothing
if (Input.GetButtonDown("MoveLeft"))
{
selectedCommand.currentTargetIndex--;
}
if (Input.GetButtonDown("MoveRight"))
{
selectedCommand.currentTargetIndex++;
}
break;
case CommandBase.Target.SELECTED_ENEMY:
// Left: Previous single enemy target if one available, or previous target option otherwise
// Right: Next single enemy target if one availalbe, or next target option otherwise
// Up/Down: Vertical toggle on targets (wraparound possible)
if (Input.GetButtonDown("MoveLeft"))
{
EnemyCombatController nextEnemy = NextEnemy(TargetChangeDirection.Left);
if (nextEnemy == null)
{
selectedCommand.currentTargetIndex--;
}
else
{
lastSingleEnemyCombatTarget = nextEnemy;
}
}
if (Input.GetButtonDown("MoveRight"))
{
EnemyCombatController nextEnemy = NextEnemy(TargetChangeDirection.Right);
if (nextEnemy == null)
{
selectedCommand.currentTargetIndex++;
}
else
{
lastSingleEnemyCombatTarget = nextEnemy;
}
}
if (Input.GetButtonDown("MoveUp"))
{
lastSingleEnemyCombatTarget = NextEnemy(TargetChangeDirection.Up);
}
if (Input.GetButtonDown("MoveDown"))
{
lastSingleEnemyCombatTarget = NextEnemy(TargetChangeDirection.Down);
}
break;
case CommandBase.Target.ALL_ENEMIES:
// Right: Next target option
// Left/Up/Down: Nothing
if (Input.GetButtonDown("MoveRight"))
{
selectedCommand.currentTargetIndex++;
}
break;
case CommandBase.Target.RANDOM_ENEMY:
// No input to handle
// This should never apply here; if RANDOM_ENEMY is in the list,
// it should be alone, and a random enemy should be selected instead
break;
}
}
private void Start()
{
playerStats = GetComponent <PlayerStats>();
playerCombat = transform.GetComponent <PlayerCombatController>();
}
protected virtual void Awake()
{
WalkingSpeed = 4;
MovementController = new PlayerMovementController(gameObject, WalkingSpeed, GroundCheck);
CombatController = new PlayerCombatController(gameObject, MaxLife);
}
private void Start()
{
combatController = GetComponent <PlayerCombatController>();
}
public SimpleAttackState(PlayerCombatController controller)
{
_controller = controller;
_currentTime = 0;
_enemyHitList = new List <EnemyBlackboard>();
}
private void Start()
{
player = gameObject.GetComponentInParent <PlayerCombatController>();
}
private void Start()
{
_combat = GetComponent <PlayerCombatController>();
_anim = gameObject.GetComponentInChildren <Animator>();
}
