//Shooting States
private void ShootClosestTarget(RobotControls controls)
{
StopMovement(controls);
currentTarget = _closestEnemy;
_ShootVector = TargetPrediction(currentTarget, controls);
_canShoot = true;
}
private void HideBehindTeammate(RobotControls controls)
{
Vector3 hidingDir = _closestTeammate.currentPosition - _closestEnemy.currentPosition;
_MoveVector = hidingDir.normalized * 2 + _closestTeammate.currentPosition;
_canMove = true;
}
void SetVisibleRobots(RobotControls controls)
{
CheckForVisibility(controls);
UpdateClosestEnemy(controls);
UpdateClosestTeammate(controls);
_allVisibleRobots = visibleTeamMates.Concat(visibleEnemies).ToList();
}
private void ShootBallOwner(RobotControls controls)
{
StopMovement(controls);
currentTarget = _ballOwner;
_ShootVector = TargetPrediction(currentTarget, controls);
_canShoot = true;
}
void CheckWhichTeamHasBall(RobotControls controls)
{
var allVisibleRobots = visibleTeamMates.Concat(visibleEnemies);
foreach (var robot in allVisibleRobots)
{
if (robot.currentPosition.x == _ball.x && robot.currentPosition.z == _ball.z)
{
if (robot.team == controls.myself.team)
{
_teammateHasBall = true;
_enemyHasBall = false;
if (robot.id == controls.myself.id)
{
_hasBall = true;
}
else
{
_hasBall = false;
}
}
else
{
_teammateHasBall = false;
_enemyHasBall = true;
_hasBall = false;
}
}
}
}
private void CoverTeammate(RobotControls controls, SubjectiveRobot teammate)
{
Vector3 reltiveEnemyDir = _closestEnemy.currentPosition - teammate.currentPosition;
_MoveVector = reltiveEnemyDir.normalized * 2 + teammate.currentPosition;
_canMove = true;
}
public override void UpdateMovement(RobotControls controls)
{
if (controls.myself.currentHealth < 50 && _noclosestHealth == false)
{
controls.goTo(_closestHealth.currentPickupPosition);
}
else
{
if (Vector3.Distance(controls.myself.currentPosition, controls.updateBall) < 2f)
{
if (_noclosestPickup == false)
{
controls.goTo(_closestPickup.currentPickupPosition);
}
else
{
controls.goTo(_closestTeammate.currentPosition);
}
}
else
{
controls.goTo(controls.updateBall);
}
}
}
public override void UpdateAttack(RobotControls controls)
{
if (_hasBall)
{
return;
}
_currentCooldown += Time.deltaTime;
if (_currentCooldown < _cooldown)
{
return;
}
var _relativeDistance = _closestEnemy.currentPosition - controls.myself.currentPosition;
if (_relativeDistance.magnitude > 3)
{
return;
}
Attack(_closestEnemy, controls);
_currentCooldown = 0;
}
/// <summary>
/// This method calculates Vector3 where projectile should be launced in order to hit the intended target;
/// </summary>
private Vector3 TargetPrediction(SubjectiveRobot target, RobotControls controls)
{
float coolDown = 0.5f;
float coolDownVar = coolDown;
Vector3 predictionPoint;
Vector3 startPoint = target.currentPosition;
if (coolDownVar > 0)
{
coolDown -= Time.deltaTime;
return(new Vector3(0, 0, 0));
}
else
{
Vector3 endPoint = target.currentPosition;
Vector3 targetMovementVector = endPoint - startPoint;
targetSpeed = targetMovementVector.magnitude / coolDown;
Vector3 distanceVector = endPoint - controls.myself.currentPosition;
float distance = distanceVector.magnitude;
float projection = Vector3.Project(targetMovementVector, distanceVector).magnitude;
float timeToReach;
timeToReach = (float)Math.Sqrt((Math.Pow(distance + projection, 2) + (Math.Pow(targetSpeed, 2) - Math.Pow(projection, 2))) / Math.Pow(projectileSpeed, 2));
predictionPoint = targetMovementVector / (coolDown * timeToReach);
return(new Vector3(predictionPoint.x, controls.myself.currentPosition.y, predictionPoint.z));
}
}
public override void UpdateBallPass(RobotControls controls)
{
if (_canPassBall)
{
controls.passBall(_PassBallVector);
_canPassBall = false;
}
}
public override void UpdateAttack(RobotControls controls)
{
if (_canShoot)
{
controls.attack(_ShootVector);
_canShoot = false;
}
}
private void GoFromRobot(RobotControls controls, SubjectiveRobot robot)
{
Vector3 moveDir = controls.myself.currentPosition - robot.currentPosition;
//_MoveVector = moveDir.normalized + controls.myself.currentPosition;
_MoveVector = moveDir;
_canMove = true;
}
public override void UpdateMovement(RobotControls controls)
{
if (_canMove)
{
controls.goTo(_MoveVector);
_canMove = false;
}
}
public override void UpdateData(RobotControls controls)
{
CheckForVisibility(controls);
UpdateClosestEnemy(controls);
UpdateClosestTeammate(controls);
CheckPickups(controls);
CheckBallOwnership(controls);
UpdateBehaviour(controls);
}
private void KillBallOwner(RobotControls controls)
{
CheckForVisibility(controls);
UpdateClosestEnemy(controls);
UpdateClosestTeammate(controls);
if (controls.reload < 0.3)
{
ShootBallOwner(controls);
}
}
public void TragectoryPrediction(RobotControls controls, SubjectiveRobot?target)
{
if (target != null && target.Value.isSeen)
{
float tTimeElapsed = 0;
float pSpeed = 10;
float tSpeed = 0;
float pRatio = 0;
float tRatio = 0;
float tPosX = 0;
Vector3 tPosA = Vector3.zero;
Vector3 tPosB = Vector3.zero;
Vector3 tPos = Vector3.zero;
Vector3 tDistanceTraveled = Vector3.zero;
Vector3 tmDistance = Vector3.zero;
if (controls.reload <= .5)
{
if (tTimeElapsed == 0)
{
tPosA = target.Value.currentPosition;
Debug.Log("tPosA: " + tPosA);
tTimeElapsed += Time.deltaTime;
}
else if (tTimeElapsed > 0 && tTimeElapsed < .5)
{
tTimeElapsed += Time.deltaTime;
Debug.Log("tTimeElapsed: " + tTimeElapsed);
}
else if (tTimeElapsed >= .5)
{
tTimeElapsed = 0;
tPosB = target.Value.currentPosition;
Debug.Log("tPosB: " + tPosB);
tDistanceTraveled = tPosB - tPosA;
Debug.Log("tDistanceTraveled: " + tDistanceTraveled);
tmDistance = tPosB - controls.myself.currentPosition;
tSpeed = tDistanceTraveled.magnitude / tTimeElapsed;
pRatio = pSpeed / tSpeed;
Debug.Log("tSpeed: " + tSpeed);
tRatio = tSpeed / pSpeed;
Debug.Log("pSpeed: " + pSpeed);
tPosX = (-pRatio + Mathf.Sqrt(pRatio * pRatio - 4 * tRatio * tmDistance.magnitude)) / 2 * tRatio;
Debug.Log("tPosX: " + tPosX);
tPos = new Vector3(Mathf.Abs(tPosX), 2 * controls.myself.currentPosition.y, Mathf.Abs(tPosX * pRatio));
}
Debug.Log("tPos: " + tPos);
// controls.attack(tPos);
controls.attack(target.Value.currentPosition);
}
}
}
//Checks who owns the ball
private void CheckBallOwnership(RobotControls controls)
{
_currentBallPosition = controls.updateBall;
_iHaveBall = false;
_ballCaptured = false;
_ballOwnerUnknown = false;
foreach (SubjectiveRobot robot in controls.archiveRobots)
{
if (robot.team == controls.myself.team)
{
if (Vector3.Distance(robot.currentPosition, _currentBallPosition) < 1.3f)
{
_ballCaptured = true;
_ballOwner = robot;
_enemyTeamHasTheBall = false;
if (robot.id == controls.myself.id)
{
Debug.Log("I Have the ball");
_iHaveBall = true;
}
else
{
Debug.Log($"My teammate, {_ballOwner} has the ball");
_iHaveBall = false;
}
}
}
else
{
if (robot.isSeen)
{
if (Vector3.Distance(robot.currentPosition, _currentBallPosition) < 1.3f)
{
_ballCaptured = true;
_ballOwner = robot;
_enemyTeamHasTheBall = true;
Debug.Log($"My enemy, {_ballOwner} has the ball");
}
}
else
{
if (_currentBallPosition != _lastBallPosition)
{
_ballCaptured = true;
_enemyTeamHasTheBall = true;
_ballOwnerUnknown = true;
Debug.Log($"Unknown enemy has the ball");
}
}
}
}
_lastBallPosition = _currentBallPosition;
}
public override void UpdateBallPass(RobotControls controls)
{
if (controls.myself.currentHealth < 40 && Vector3.Distance(controls.myself.currentPosition, controls.updateBall) < 1.5f)
{
controls.passBall(_closestTeammate.currentPosition);
}
else
{
return;
}
}
public override void UpdateMovement(RobotControls controls)
{
if (_hasBall)
{
var relativeDistance = _closestEnemy.currentPosition - controls.myself.currentPosition;
controls.goTo(controls.myself.currentPosition - relativeDistance);
}
else
{
controls.goTo(_ball);
}
}
public override void UpdateBallPass(RobotControls controls)
{
if (!_hasBall)
{
return;
}
if (controls.myself.currentHealth < 30)
{
controls.passBall(_closestTeammate.currentPosition);
}
}
public SubjectiveRobot?GetSeenRobotTarget(RobotControls controls, Vector3 startPos, bool alliesOpponents, bool closestFurthest)
{
SubjectiveRobot?target = null;
float minDistance = Mathf.Infinity;
float maxDistance = 0;
if (controls.archiveRobots.Count > 1)
{
foreach (SubjectiveRobot robot in controls.archiveRobots)
{
Vector3 diff = robot.currentPosition - startPos;
float curDistance = diff.sqrMagnitude;
if (robot.isSeen && robot.id != controls.myself.id)
{
if (alliesOpponents && robot.team == controls.myself.team)
{
if (closestFurthest && curDistance < minDistance)
{
target = robot;
minDistance = curDistance;
}
if (!closestFurthest && curDistance > maxDistance)
{
target = robot;
maxDistance = curDistance;
}
}
if (!alliesOpponents && robot.team != controls.myself.team)
{
if (closestFurthest && curDistance < minDistance)
{
target = robot;
minDistance = curDistance;
}
if (!closestFurthest && curDistance > maxDistance)
{
target = robot;
maxDistance = curDistance;
}
}
}
}
}
if (target != null)
{
return(target.Value);
}
else
{
return(null);
}
}
protected void UpdateClosestPickup(RobotControls controls)
{
SubjectivePickup?closestPickup;
SubjectivePickup?closestHealth;
closestPickup = null;
closestHealth = null;
float distanceMin = 1000f;
if (controls.updatePickup.Count > 0)
{
foreach (SubjectivePickup pickup in controls.updatePickup)
{
if (pickup.ofType == "Health")
{
if (Vector3.Distance(pickup.currentPickupPosition, controls.myself.currentPosition) < distanceMin)
{
distanceMin = Vector3.Distance(pickup.currentPickupPosition, controls.myself.currentPosition);
closestHealth = pickup;
}
}
else
{
if (Vector3.Distance(pickup.currentPickupPosition, controls.myself.currentPosition) < distanceMin)
{
distanceMin = Vector3.Distance(pickup.currentPickupPosition, controls.myself.currentPosition);
closestPickup = pickup;
}
}
}
}
if (closestHealth.HasValue)
{
_closestHealth = closestHealth.Value;
_noclosestHealth = false;
}
else
{
_noclosestHealth = true;
}
if (closestPickup.HasValue)
{
_closestPickup = closestPickup.Value;
_noclosestPickup = false;
}
else
{
_noclosestPickup = true;
}
}
private void KillClosestEnemy(RobotControls controls)
{
CheckForVisibility(controls);
UpdateClosestEnemy(controls);
UpdateClosestTeammate(controls);
if (visibleEnemies.Count > 0)
{
if (controls.reload <= 0.3)
{
ShootClosestTarget(controls);
}
}
}
private void ApproachOwner(RobotControls controls)
{
CheckForVisibility(controls);
UpdateClosestEnemy(controls);
UpdateClosestTeammate(controls);
if (Vector3.Distance(controls.myself.currentPosition, _ballOwner.currentPosition) > 4f)
{
GoForRobot(controls, _ballOwner);
}
else
{
StopMovement(controls);
}
}
private void SpeedOrBall(RobotControls controls)
{
CheckForVisibility(controls);
UpdateClosestEnemy(controls);
UpdateClosestTeammate(controls);
if (_closestSpeed != null)
{
if (Vector3.Distance(controls.myself.currentPosition, _closestSpeed) < (Vector3.Distance(controls.myself.currentPosition, controls.updateBall) / 3f) && !_haveSpeed)
{
GoForSpeed(controls);
}
else
{
GoForBall(controls);
}
}
}
private void GoForHealth(RobotControls controls)
{
_MoveVector = _closestHealth;
_canMove = true;
if (Vector3.Distance(_closestHealth, controls.myself.currentPosition) > 3)
{
foreach (SubjectivePickup pickup in controls.updatePickup)
{
if (pickup.currentPickupPosition == _closestHealth)
{
if (Vector3.Distance(_closestHealth, controls.myself.currentPosition) < 0.25f)
{
_recentlyHealed = true;
}
}
}
}
}
private void GoForInvuln(RobotControls controls)
{
_MoveVector = _closestInvuln;
_canMove = true;
if (Vector3.Distance(_closestInvuln, controls.myself.currentPosition) > 3)
{
foreach (SubjectivePickup pickup in controls.updatePickup)
{
if (pickup.currentPickupPosition == _closestInvuln)
{
if (Vector3.Distance(_closestInvuln, controls.myself.currentPosition) < 0.25f)
{
_haveInvuln = true;
}
}
}
}
}
private void ProtectOrApproach(RobotControls controls)
{
CheckForVisibility(controls);
UpdateClosestEnemy(controls);
UpdateClosestTeammate(controls);
if (visibleEnemies.Count > 0)
{
CoverTeammate(controls, _ballOwner);
}
else
{
if (Vector3.Distance(controls.myself.currentPosition, _ballOwner.currentPosition) < 3)
{
GoForRobot(controls, _ballOwner);
}
else
{
StopMovement(controls);
}
}
}
public SubjectivePickup?GetClosestPowerup(RobotControls controls, Vector3 startPos)
{
SubjectivePickup?powerupTarget = null;
float minDistance = Mathf.Infinity;
if (controls.updatePickup.Count > 0)
{
foreach (SubjectivePickup pickup in controls.updatePickup)
{
Vector3 diff = pickup.currentPickupPosition - startPos;
float curDistance = diff.sqrMagnitude;
if (curDistance < minDistance)
{
powerupTarget = pickup;
minDistance = curDistance;
}
if (pickup.currentPickupPosition != powerupPos1 && pickup.currentPickupPosition != powerupPos2 &&
pickup.currentPickupPosition != powerupPos3 && pickup.currentPickupPosition != powerupPos4)
{
if (powerupPos1 == Vector3.zero)
{
powerupPos1 = pickup.currentPickupPosition;
}
else if (powerupPos2 == Vector3.zero)
{
powerupPos2 = pickup.currentPickupPosition;
}
else if (powerupPos3 == Vector3.zero)
{
powerupPos3 = pickup.currentPickupPosition;
}
else if (powerupPos4 == Vector3.zero)
{
powerupPos4 = pickup.currentPickupPosition;
}
}
}
}
return(powerupTarget);
}
public override void UpdateAttack(RobotControls controls)
{
if (_noClosestEnemy == false)
{
Cooldowntime -= Time.deltaTime;
if (Cooldowntime > Cooldown)
{
return;
}
var EnemyDistance = _closestEnemy.currentPosition - controls.myself.currentPosition;
if (EnemyDistance.magnitude > 5)
{
return;
}
controls.attack(_closestEnemy.currentPosition);
Cooldowntime = 0.5f;
}
else
{
return;
}
}
