public void SetDroneOwner(DroneBase drone, OWNERS owner)
{
Color droneColor = Color.yellow;
switch (owner)
{
case OWNERS.PLAYER:
droneColor = Color.green;
break;
case OWNERS.RAIDER:
droneColor = Color.red;
break;
case OWNERS.NEUTRAL:
droneColor = Color.white;
break;
}
foreach (Image image in images)
{
image.color = droneColor;
}
idText.color = droneColor;
UserDrone uDrone = drone.GetComponent <UserDrone>();
if (uDrone != null)
{
idText.text = uDrone.GetStringIdentifier();
}
}
public void Tick(DroneBase drone)
{
rotateCommand.SetTarget(drone.transform.position - drone.GetVelocity());
if (!rotateCommand.IsFinished(drone))
{
drone.FireThrusters(0.0f);
rotateCommand.Tick(drone);
return;
}
if (drone.velocity != Vector3.zero)
{
drone.FireThrusters(drone.thrusterForce);
// Zero velocity to avoid dealing with "drifting".
// This will lead to unexpected stops, but is far simpler to deal with.
if (Mathf.Abs(drone.velocity.magnitude) < 0.15)
{
drone.FireThrusters(0.0f);
drone.velocity = Vector3.zero;
drone.acceleration = Vector3.zero;
}
}
}
void Awake()
{
droneBase = GetComponent <DroneBase>();
droneBase.SetOwner(OWNERS.PLAYER);
minedResources = new ResourceSet();
id = nextId++;
}
public void Tick(DroneBase drone)
{
if (target == null)
{
return;
}
rotateCommand.SetTarget(target.transform.position);
Vector3 positionDiff = target.transform.position - drone.transform.position;
float positionDiffMag = positionDiff.magnitude;
if (!rotateCommand.IsFinished(drone))
{
rotateCommand.Tick(drone);
return;
}
float velocityMag = drone.velocity.magnitude;
float timeToIntercept = positionDiffMag / velocityMag;
float maxAcceleration = drone.thrusterForce / drone.weight;
float timeToSlow = drone.velocity.magnitude / maxAcceleration;
float timeToTarget = (positionDiffMag + radius + 10.0f) / drone.velocity.magnitude;
if (timeToSlow < timeToTarget)
{
drone.FireThrusters(drone.thrusterForce);
}
else
{
drone.FireThrusters(0.0f);
}
}
void updateTargetRotation(DroneBase drone)
{
Vector3 positionDiff = target - drone.transform.position;
// Update rotation
// https://answers.unity.com/questions/254130/how-do-i-rotate-an-object-towards-a-vector3-point.html
drone.targetRotation = Quaternion.LookRotation(positionDiff.normalized);
}
public void Tick(DroneBase drone)
{
if (command == 0)
{
command1.Tick(drone);
}
if (command == 1)
{
command2.Tick(drone);
}
}
/// Perform a tick
public void Tick(DroneBase drone)
{
if (uDrone == null)
{
return;
}
if (drone.HasStorageAvailable())
{
target.Mine(drone.damage, drone, uDrone);
}
}
public bool IsFinished(DroneBase drone)
{
if (command == 0 && command1.IsFinished(drone))
{
command += 1;
}
if (command == 1 && command2.IsFinished(drone))
{
command += 1;
}
return(command == 2);
}
public bool IsFinished(DroneBase drone)
{
if (target == null)
{
return(true);
}
Vector3 positionDiff = drone.transform.position - target.position;
float maxAcceleration = drone.thrusterForce / drone.weight;
return(Mathf.Abs(positionDiff.magnitude) < radius);
}
// Start is called before the first frame update
void Start()
{
DroneMgr.inst.RaiderDroneSpawned(this);
DroneBase drone = GetComponent <DroneBase>();
if (drone != null)
{
drone.SetOwner(OWNERS.RAIDER);
}
DroneStatSet droneStats = new DroneStatSet();
droneStats.Health = 100;
drone.SetDroneStats(droneStats);
}
public void RaiderDroneDestroyed(RaiderDrone destroyed)
{
raiderDrones.Remove(destroyed);
DroneBase db = destroyed.GetComponent <DroneBase>();
if (db != null)
{
allDrones.Remove(db);
}
if (raiderWarning && raiderDrones.Count <= 0)
{
raiderWarning = false;
raiderAlarm.Stop();
}
}
public void RaiderDroneSpawned(RaiderDrone newDrone)
{
if (!raiderDrones.Contains(newDrone))
{
raiderDrones.Add(newDrone);
DroneBase db = newDrone.GetComponent <DroneBase>();
if (db != null)
{
allDrones.Add(db);
}
if (!raiderWarning)
{
raiderWarning = true;
raiderAlarm.Play();
}
}
}
public void UserDroneSpawned(UserDrone newDrone)
{
if (!userDrones.Contains(newDrone))
{
userDrones.Add(newDrone);
droneList.DroneSpawned(newDrone);
DroneBase db = newDrone.GetComponent <DroneBase>();
if (db != null)
{
allDrones.Add(db);
}
if (offeringEscape)
{
offeringEscape = false;
quickEscape.gameObject.SetActive(false);
}
}
}
/// Try to mine this asteroid
public void Mine(float power, DroneBase drone, UserDrone uDrone)
{
if (uDrone == null)
{
return;
}
if (Resources.Iron > 0.0f || Resources.Copper > 0.0f || Resources.Uranium > 0.0f || Resources.Copper > 0.0f)
{
float ironMined = Mathf.Clamp(power * resourceRatios.Iron, 0.0f, Resources.Iron);
float copperMined = Mathf.Clamp(power * resourceRatios.Copper, 0.0f, Resources.Copper);
float uraniumMined = Mathf.Clamp(power * resourceRatios.Uranium, 0.0f, Resources.Uranium);
float iceMined = Mathf.Clamp(power * resourceRatios.Ice, 0.0f, Resources.Ice);
// TODO: The player currently gains some extra resources from each "mine" op
// since the iron levels in an asteroid can go below zero. Fix this.
/*GameMgr.inst.Resources.Iron += ironMined;
* GameMgr.inst.Resources.Copper += copperMined;
* GameMgr.inst.Resources.Uranium += uraniumMined;
* GameMgr.inst.Resources.Ice += iceMined;*/
uDrone.minedResources.Iron += ironMined;
uDrone.minedResources.Copper += copperMined;
uDrone.minedResources.Uranium += uraniumMined;
uDrone.minedResources.Ice += iceMined;
drone.AddResourcesStored(ironMined + copperMined + uraniumMined + iceMined);
Resources.Iron -= ironMined;
Resources.Copper -= copperMined;
Resources.Uranium -= uraniumMined;
Resources.Ice -= iceMined;
}
if (IsEmpty())
{
AsteroidMgr.inst.AsteroidDestroyed(this);
gameObject.GetComponent <Fracture>().FractureObject();
}
}
public void DroneDestroyed(DroneBase drone)
{
UserDrone userDrone = drone.GetComponent <UserDrone>();
RaiderDrone raiderDrone = drone.GetComponent <RaiderDrone>();
if (userDrone != null && raiderDrone != null)
{
Debug.LogWarning("A drone was destroyed with both a UserDrone and RaiderDrone script.");
}
if (userDrone != null)
{
UserDroneDestroyed(userDrone);
}
else if (raiderDrone != null)
{
RaiderDroneDestroyed(raiderDrone);
}
else
{
Debug.LogWarning("A drone was destroyed without a UserDrone and RaiderDrone script.");
}
}
public void UserDroneDestroyed(UserDrone destroyed)
{
if (userDrones.Contains(destroyed))
{
userDrones.Remove(destroyed);
droneList.DroneDestroyed(destroyed);
DroneBase db = destroyed.GetComponent <DroneBase>();
if (db != null)
{
allDrones.Remove(db);
}
if (userDrones.Count <= 0)
{
if (quickEscape != null)
{
quickEscape.gameObject.SetActive(true);
}
offeringEscape = true;
}
}
}
void FixedUpdate()
{
List <DroneBase> activeDrones = DroneMgr.inst.GetAllDrones();
List <Asteroid> activeRoids = AsteroidMgr.inst.GetAsteroids();
if (droneIcons.Count != activeDrones.Count)
{
while (droneIcons.Count < activeDrones.Count)
{
GameObject obj = Instantiate(droneBogie);
obj.transform.SetParent(radarPanel);
RectTransform rectTransform = obj.GetComponent <RectTransform>();
rectTransform.localPosition = Vector3.zero;
obj.transform.localScale = Vector3.one;
droneIcons.Add(obj.GetComponent <Bogie>());
}
if (droneIcons.Count > activeDrones.Count)
{
for (int i = activeDrones.Count; i < droneIcons.Count; i++)
{
Destroy(droneIcons[i].gameObject);
}
droneIcons.RemoveRange(activeDrones.Count, (droneIcons.Count - activeDrones.Count));
}
for (int i = 0; i < droneIcons.Count; i++)
{
DroneBase drone = activeDrones[i];
Bogie bogie = droneIcons[i];
bogie.SetDroneOwner(drone, drone.GetOwner());
}
}
if (roidIcons.Count != activeRoids.Count)
{
while (roidIcons.Count < activeRoids.Count)
{
GameObject obj = Instantiate(asteroidBogie);
obj.transform.SetParent(radarPanel);
RectTransform rectTransform = obj.GetComponent <RectTransform>();
rectTransform.localPosition = Vector3.zero;
obj.transform.localScale = Vector3.one / 2.0f;
roidIcons.Add(obj);
}
if (roidIcons.Count > activeRoids.Count)
{
for (int i = activeRoids.Count; i < roidIcons.Count; i++)
{
Destroy(roidIcons[i].gameObject);
}
roidIcons.RemoveRange(activeRoids.Count, (roidIcons.Count - activeRoids.Count));
}
}
for (int i = 0; i < droneIcons.Count; i++)
{
DroneBase drone = activeDrones[i];
Bogie bogie = droneIcons[i];
float distance = Vector3.Distance(drone.transform.position, sensor.transform.position);
distance = Mathf.Clamp((distance / radarRange), 0.0f, 1.0f);
// -90 to 90 on the XZ axis, relative to the "reverse" direction (-Z)
Vector3 toVector = sensor.transform.InverseTransformPoint(drone.transform.position);
toVector.y = 0;
float angle = Vector3.SignedAngle(-Vector3.forward, toVector, Vector3.up);
angle = Mathf.Clamp(angle, -90, 90);
angle *= Mathf.Deg2Rad;
RectTransform rect = bogie.GetComponent <RectTransform>();
float posX = Mathf.Sin(angle) * distance * (width / 2);
float posY = Mathf.Cos(angle) * distance * height;
rect.anchoredPosition = new Vector2(posX, posY);
Vector3 relVector = sensor.transform.InverseTransformDirection(drone.transform.forward);
bogie.UpdateDroneDirection(-Vector3.SignedAngle(-Vector3.forward, relVector, Vector3.up));
}
for (int i = 0; i < roidIcons.Count; i++)
{
Asteroid asteroid = activeRoids[i];
GameObject roid = roidIcons[i];
float distance = Vector3.Distance(asteroid.transform.position, sensor.transform.position);
distance = Mathf.Clamp((distance / radarRange), 0.0f, 1.0f);
Vector3 toVector = sensor.transform.InverseTransformPoint(asteroid.transform.position);
toVector.y = 0;
float angle = Vector3.SignedAngle(-Vector3.forward, toVector, Vector3.up);
angle = Mathf.Clamp(angle, -90, 90);
angle *= Mathf.Deg2Rad;
RectTransform rect = roid.GetComponent <RectTransform>();
float posX = Mathf.Sin(angle) * distance * (width * 4);
float posY = Mathf.Cos(angle) * distance * height;
posX = Mathf.Clamp(posX, -width / 2, width / 2);
rect.anchoredPosition = new Vector2(posX, posY);
}
}
public bool IsFinished(DroneBase drone)
{
return(command1.IsFinished(drone) && command2.IsFinished(drone));
}
public void Tick(DroneBase drone)
{
command1.Tick(drone);
command2.Tick(drone);
}
/// Whether this is done executing.
public bool IsFinished(DroneBase drone)
{
updateTargetRotation(drone);
return(drone.isAtTargetRotation());
}
public PursueTargetToRadiusCommand(DroneBase target)
{
this.target = target;
rotateCommand = new RotateToPointCommand(target.transform.position);
}
/// Whether this is done executing.
public bool IsFinished(DroneBase drone)
{
return(target.IsEmpty());
}
/// Perform a tick
public void Tick(DroneBase drone)
{
updateTargetRotation(drone);
}
public bool IsFinished(DroneBase drone)
{
return(drone.velocity == Vector3.zero);
}
void Awake()
{
droneBase = GetComponent <DroneBase>();
}
public bool IsFinished(DroneBase drone)
{
return(target == null);
}
public ZeroVelocityCommand(DroneBase drone)
{
rotateCommand = new RotateToPointCommand(drone.transform.position - drone.GetVelocity());
}
