public bool Attack(SquadControl targetSquad, bool usePrimary)
{
if (!CanAttack)
{
Debug.Log(transform.name + " has no way to attack");
return(false);
}
Transform mySquad = unitControl.Squad.transform;
Vector3 offsetFromSquad = targetSquad.transform.position - mySquad.position;
float heading = Vector3.Angle(offsetFromSquad.normalized, mySquad.forward) *
Mathf.Sign(Vector3.Dot(offsetFromSquad.normalized, mySquad.right));
int attackDir = Mathf.RoundToInt(heading / 90);
bool attackAttempted = false;
if (offsetFromSquad.magnitude < (GameManager.instance.GridSize * 1.1f))
{
attackAttempted = TryMeleeAttack(usePrimary ? primaryWeapon : secondaryWeapon, targetSquad, attackDir);
}
if (!attackAttempted)
{
attackAttempted = TryAttackRanged(usePrimary ? primaryWeapon: secondaryWeapon, targetSquad, attackDir);
}
if (!attackAttempted)
{
unitControl.AttackComplete();
}
return(attackAttempted);
}
public void RemoveEnemySquad(SquadControl oldSquad)
{
if (enemySquads.Contains(oldSquad))
{
enemySquads.Remove(oldSquad);
}
}
public void SquadTurnComplete(SquadControl squad)
{
if (squad == PlayerSquad)
{
foreach (SquadControl enemySquad in enemySquads)
{
enemySquad.StartTurn();
}
}
else if (enemySquads.Contains(squad))
{
bool allDone = true;
foreach (SquadControl enemySquad in enemySquads)
{
if (enemySquad.UnitsAreBusy)
{
allDone = false;
}
}
if (allDone)
{
PlayerSquad.StartTurn();
}
}
}
public void SquadSelected(SquadControl selectedSquad)
{
if (selectedSquad.squadType == SquadControl.SquadType.Enemy)
{
squad.Attack(selectedSquad);
}
}
public void Init()
{
gameManager = GameManager.instance;
gameObject.tag = "Unit";
gameObject.layer = LayerMask.NameToLayer("Units");
animator = GetComponent <Animator>();
unitMover = gameObject.AddComponent <UnitMover>();
unitAttack = gameObject.AddComponent <UnitAttack>();
//navAgent = gameObject.AddComponent<NavMeshAgent>();
TeamName = teamName;
AddWeapon(TempPrimaryWeapon);
if (!TempSecondaryWeapon.Equals(""))
{
AddWeapon(TempSecondaryWeapon);
}
if (!squad && teamName.Equals("Player"))
{
squad = gameManager.PlayerSquad;
}
if (!squad)
{
Debug.Log(transform.name + " has no squad");
}
UnitId = squad.AddUnit(this);
animator.SetFloat("AnimOffset", (float)UnitId / 4.0f);
transform.position = SquadPosition;
transform.rotation = squad.transform.rotation;
CapsuleCollider collision = gameObject.AddComponent <CapsuleCollider>();
collision.radius = 0.5f;
collision.height = 2.0f;
collision.center = new Vector3(0.0f, 1.0f, 0.0f);
hitPoint = maxHits;
RagdollConfig ragdollConfig = gameObject.AddComponent <RagdollConfigCombot>();
if (ragdollConfig)
{
ragdollControl = ragdollConfig.Init();
}
}
public void Attack(SquadControl targetSquad)
{
if (IsAttacking)
{
return;
}
ReCenterPosition();
hasAttacked = true;
StartCoroutine(StartAttack(targetSquad));
}
public void Should_set_on_expected_direction_when_only_one_robot_moves(string inputList, string expectedOutput)
{
//Given
var mockOutput = new Mock <IOutput>();
var roverSquadControl = new SquadControl(mockOutput.Object);
var input = inputList.Split('\n').ToList();
//When
roverSquadControl.SendCommand(input);
//Then
mockOutput.Verify(output => output.Debug(It.Is <string>(outputValue => outputValue == expectedOutput)));
}
void LateUpdate()
{
if (!squad)
{
squad = gameManager.PlayerSquad;
}
if (moveTimer >= 0)
{
moveTimer += Time.deltaTime / squad.MoveDuration;
float amount = cameraMove.Evaluate(moveTimer);
transform.position = Vector3.Lerp(startPos, endPos, amount);
if (moveTimer > 1)
{
moveTimer = -1;
}
}
}
IEnumerator StartAttack(SquadControl targetSquad)
{
int[] normalOrder = new int[6] {
0, 1, 2, 3, 1, 0
};
int[] mixedOrder = new int[6] {
1, 0, 3, 2, 1, 0
};
int[] order = Random.value > 0.5f ? normalOrder : mixedOrder;
for (int i = 0; i < 6; i++)
{
UnitControl unit = units[order[i]];
if (unit && unit.Attack(targetSquad, (i < 4)))
{
yield return(new WaitForSeconds(0.5f));
}
}
}
public SquadControl[] FindEnemiesAtPosition(Vector3 pos, SquadControl.SquadType squadType)
{
List <SquadControl> squads = new List <SquadControl>();
LayerMask enemyMask = 1 << LayerMask.NameToLayer("Squads");
LayerMask playerMask = 1 << LayerMask.NameToLayer("Player");
pos.y += 1.0f;
for (int i = 0; i < 4; i++)
{
Vector3 dir = Quaternion.AngleAxis(90 * i, Vector3.up) * (Vector3.forward * GridSize);
Collider[] hits = Physics.OverlapSphere(pos + dir, 1.0f, enemyMask | playerMask);
if (hits.Length > 0)
{
SquadControl enemySquad = hits[0].transform.GetComponent <SquadControl>();
if (enemySquad)
{
if ((squadType == SquadControl.SquadType.Enemy && enemySquad.squadType == SquadControl.SquadType.Player) ||
(squadType == SquadControl.SquadType.Player && enemySquad.squadType == SquadControl.SquadType.Enemy) ||
(squadType == SquadControl.SquadType.Enemy && enemySquad.squadType == SquadControl.SquadType.Friendly) ||
(squadType == SquadControl.SquadType.Friendly && enemySquad.squadType == SquadControl.SquadType.Enemy))
{
squads.Add(enemySquad);
}
}
Debug.DrawRay(pos + dir, Vector3.up, Color.green, 5);
}
else
{
Debug.DrawRay(pos + dir, Vector3.up, Color.red, 5);
}
}
return(squads.ToArray());
}
public void TakeTurn()
{
SquadControl[] possibleMeleeTargets = squad.GetAttackTargets();
bool playerVisible = CanSeePlayer();
int directionToPlayer = 0;
if (playerVisible)
{
directionToPlayer = GetOrthagonalDirection(gameManager.PlayerSquad.transform);
}
bool shouldMove = false;
Vector3 moveDirection = Vector3.zero;
bool shouldRotate = false;
int rotateDirection = 0;
bool shouldAttack = false;
SquadControl attackTarget = null;
switch (currentState)
{
case AIState.Waiting:
if (possibleMeleeTargets.Length > 0)
{
ChangeState(AIState.Chasing);
shouldAttack = true;
attackTarget = possibleMeleeTargets[0];
}
if (playerVisible)
{
ChangeState(AIState.Chasing);
}
break;
case AIState.Patrolling:
break;
case AIState.Chasing:
Debug.Log("directionToPlayer: " + directionToPlayer);
if (!playerVisible && possibleMeleeTargets.Length == 0)
{
ChangeState(AIState.Waiting);
}
if (possibleMeleeTargets.Length > 0)
{
Debug.Log("Should Attack");
shouldAttack = true;
attackTarget = possibleMeleeTargets[0];
}
else if (directionToPlayer < 0.1f)
{
shouldMove = true;
moveDirection = transform.forward;
}
else
{
shouldRotate = true;
rotateDirection = Mathf.Clamp(directionToPlayer, -1, 1);
}
break;
}
if (shouldAttack)
{
Debug.Log(transform.name + " is Attacking");
squad.Attack(attackTarget);
}
else if (shouldMove)
{
Debug.Log(transform.name + " is Moving");
squad.Move(moveDirection);
}
else if (shouldRotate)
{
Debug.Log(transform.name + " is Rotating");
squad.Rotate(rotateDirection);
}
else
{
Debug.Log(transform.name + " is Passing");
squad.CompleteTurn();
}
}
void Start()
{
squad = gameObject.GetComponent <SquadControl>();
gameManager = GameManager.instance;
}
public void SetSquad(SquadControl newSquad)
{
squad = newSquad;
}
public bool Attack(SquadControl targetSquad)
{
return(Attack(targetSquad, true));
}
public void AddFrientlySquad(SquadControl newSquad)
{
friendlySquads.Add(newSquad);
}
public void AddEnemySquad(SquadControl newSquad)
{
enemySquads.Add(newSquad);
}
static void Main()
{
var squadControl = new SquadControl(new ConsoleOutput(false));
squadControl.SendCommand(FromConsoleInput().ToList());
}
void Update()
{
if (!squad)
{
squad = gameManager.PlayerSquad;
}
if (squad && !squad.IsWaitingForTurn)
{
Vector2 touchPos = (GvrController.TouchPos * 2) - Vector2.one;
if (GvrController.TouchDown)
{
swipeTimer = swipeTime;
swipeStart = touchPos;
}
if (swipeTimer > 0)
{
swipeTimer -= Time.deltaTime;
}
if (Input.GetKeyDown(KeyCode.W))
{
int offset = GetDirectionOffset();
if (offset == 0)
{
squad.Move(squad.transform.forward);
}
else
{
squad.Rotate(GetDirectionOffset());
}
}
if (Input.GetKeyDown(KeyCode.S))
{
squad.Move(-squad.transform.forward);
}
if (Input.GetKeyDown(KeyCode.A))
{
squad.Move(-squad.transform.right);
}
if (Input.GetKeyDown(KeyCode.D))
{
squad.Move(squad.transform.right);
}
if (Input.GetKeyDown(KeyCode.Q))
{
squad.Rotate(-1);
}
if (Input.GetKeyDown(KeyCode.E))
{
squad.Rotate(1);
}
if (swipeTimer > 0 && GvrController.TouchUp)
{
float horizontalDistance = touchPos.x - swipeStart.x;
float verticleDistance = touchPos.y - swipeStart.y;
if (Mathf.Abs(horizontalDistance) > 0.5f || Mathf.Abs(verticleDistance) > 0.5f)
{
Vector3 direction = Vector3.zero;
if (Mathf.Abs(horizontalDistance) > Mathf.Abs(verticleDistance))
{
direction = horizontalDistance < 0 ? -squad.transform.right : squad.transform.right;
}
else
{
direction = verticleDistance < 0 ? squad.transform.forward : -squad.transform.forward;
}
int offset = GetDirectionOffset();
if (offset == 0)
{
squad.Move(direction);
}
else
{
squad.Rotate(GetDirectionOffset());
}
}
}
}
}
void Start()
{
gameManager = GameManager.instance;
squad = gameManager.PlayerSquad;
}
public bool Attack(SquadControl targetSquad, bool usePrimary)
{
isAttacking = true;
return(unitAttack.Attack(targetSquad, usePrimary));
}
bool TryAttackRanged(Weapon weapon, SquadControl targetSquad, int direction)
{
return(false);
}
bool TryMeleeAttack(Weapon weapon, SquadControl target, int direction)
{
if (!weapon)
{
return(false);
}
bool attackedUsingReach = false;
bool attackDodged = false;
bool needsToAdvance = false;
string attackResult = "";
int attackDirection = direction;
UnitControl victim = null;
//check forward
Vector3 dir = Quaternion.AngleAxis(90 * direction, Vector3.up) * (transform.forward * 3);
Vector3 forwardPos = unitControl.SquadPosition + dir;
victim = CheckForTarget(forwardPos);
// secondary attack if direction is forward;
if (weapon.isSecondary)
{
if (victim)
{
animator.SetTrigger("AttackSecondary");
weapon.StartAttack();
lastAttackTarget = victim;
lastWeaponUsed = weapon;
return(true);
}
Debug.Log("No Target for Secondary");
return(false);
}
//check forward with reach
if (!victim && weapon.hasReach)
{
dir = Quaternion.AngleAxis(90 * direction, Vector3.up) * (transform.forward * 2);
victim = CheckForTarget(forwardPos + dir);
if (victim)
{
attackedUsingReach = true;
}
}
//Special attacks if attacking forward
if (direction == 0)
{
//no special attacks from the backrow
if (!victim)
{
float distanceForMe = Vector3.Distance(unitControl.SquadPosition, target.transform.position);
float distanceForSquad = Vector3.Distance(unitControl.Squad.transform.position, target.transform.position);
if (distanceForMe > distanceForSquad)
{
return(false);
}
}
// advance and check right
if (!victim)
{
dir = Quaternion.AngleAxis(90 * -1, Vector3.up) * (transform.forward * 2);
victim = CheckForTarget(forwardPos + dir);
attackDirection = -1;
needsToAdvance = true;
}
// advance and check left
if (!victim)
{
dir = Quaternion.AngleAxis(90 * 1, Vector3.up) * (transform.forward * 2);
victim = CheckForTarget(forwardPos + dir);
attackDirection = 1;
needsToAdvance = true;
}
// advance and check forward
if (!victim)
{
dir = (transform.forward * 2);
victim = CheckForTarget(forwardPos + dir);
attackDirection = 0;
needsToAdvance = true;
}
}
if (victim)
{
animator.SetInteger("AttackDirection", attackDirection);
if (needsToAdvance)
{
animator.SetTrigger("Advance");
}
if (attackedUsingReach)
{
animator.SetTrigger("UseReachAttack");
}
//find if attack hits
float attackRoll = Random.value;
attackRoll += unitControl.AttackBonus;
attackRoll += weapon.AttackBonus;
attackRoll -= unitControl.ParryBonus;
float victimOffset = Vector3.Dot(victim.transform.forward,
Quaternion.AngleAxis(90 * attackDirection, Vector3.up) * transform.forward);
if (victimOffset > -0.75)
{
attackResult = "Primary";
}
else if (attackRoll > 0.5f || attackedUsingReach)
{
attackResult = "Primary";
if (victim.DodgeBonus > Random.value)
{
attackDodged = true;
victim.DodgeAttack(attackDirection);
}
}
else
{
attackResult = "Blocked";
victim.BlockAttack(attackDirection);
}
if (!needsToAdvance && !attackedUsingReach)
{
animator.SetTrigger("Attack" + attackResult);
}
weapon.StartAttack();
lastAttackTarget = attackDodged ? null : victim;
lastWeaponUsed = weapon;
return(true);
}
return(false);
}
