void Scout()
{
missile.Rotate(desiredHeading, Time.deltaTime);
LateralCorrection();
if (transform.InverseTransformVector(gameObject.GetComponent <Rigidbody2D>().velocity).y > scoutSpeed + 0.5f)
{
missile.ThrustBackward(0.33f);
}
else if (transform.InverseTransformVector(gameObject.GetComponent <Rigidbody2D>().velocity).y < scoutSpeed - 0.5f)
{
missile.ThrustForward(0.33f);
}
// Exit scout when target found by radar
if (targetObject != null)
{
if (targetObject.GetComponent <ShipController>() != null)
{
if (targetObject.GetComponent <ShipController>().radar.teamSide != missile.radar.teamSide)
{
missileState = MissileState.locked;
stateChanging = true;
}
}
}
}
// Update is called once per frame
void FixedUpdate()
{
if (FindObjectOfType <Player>() != null)
{
target = FindObjectOfType <Player>().transform;
}
if (target != null)
{
float dist = Vector3.Distance(target.position, transform.position);
if (dist >= in_range_distance)
{
missile_state = MissileState.NOT_INRANGE;
}
else
{
missile_state = MissileState.IN_RANGE;
}
if (missile_state == MissileState.NOT_INRANGE)
{
CrashToPlayer();
}
if (missile_state == MissileState.IN_RANGE)
{
InRangeBehaviour();
}
}
}
void Loiter()
{
LateralCorrection();
if (transform.InverseTransformVector(gameObject.GetComponent <Rigidbody2D>().velocity).y > 0.01f)
{
missile.ThrustBackward(0.2f);
}
else if (transform.InverseTransformVector(gameObject.GetComponent <Rigidbody2D>().velocity).y < -0.05f)
{
missile.ThrustForward(0.2f);
}
desiredHeading = desiredHeading + 50 * Time.deltaTime;
if (desiredHeading > 360)
{
desiredHeading = 0;
}
missile.Rotate(desiredHeading, Time.deltaTime);
if (targetObject != null)
{
// Debug.Log("Target found");
if (targetObject.GetComponent <ShipController>() != null)
{
if (targetObject.GetComponent <ShipController>().radar.teamSide != missile.radar.teamSide)
{
missileState = MissileState.locked;
stateChanging = true;
}
}
}
}
protected override void UpdateCore()
{
switch (State)
{
case MissileState.Lauched:
if (Range > 0)
{
Location.Y += Direction;
Range--;
if (Range == 0)
{
State = MissileState.OutOfRange;
}
}
break;
case MissileState.Exploding:
if (explosion.Length > 0)
{
buffer[0, 0] = Brick.From(ColorConsole.CharMap[explosion[explosion.Length - 1]]);
Array.Resize(ref explosion, explosion.Length - 1);
}
else
{
State = MissileState.OutOfRange;
}
break;
}
}
public CoreCannonMissileState GetMissileState(MissileState state)
{
CoreCannonMissileState pShipMissileState = null;
switch (state)
{
case CoreCannonManager.MissileState.Ready:
pShipMissileState = this.pReadyState;
break;
case CoreCannonManager.MissileState.MissileFlying:
pShipMissileState = this.pMissileFlyingState;
break;
case CoreCannonManager.MissileState.End:
pShipMissileState = this.pEndState;
break;
default:
Debug.Assert(false);
break;
}
return(pShipMissileState);
}
internal MissileAIUpdate(GameObject gameObject, MissileAIUpdateModuleData moduleData)
: base(gameObject, moduleData)
{
_moduleData = moduleData;
_state = MissileState.Inactive;
}
private void Update()
{
if (state == MissileState.Ready)
{
}
if (state == MissileState.Launch)
{
timer -= Time.deltaTime;
if (timer <= 0)
{
Trail.SetActive(true);
state = MissileState.Follow;
}
}
if (state == MissileState.Follow)
{
}
if (state != MissileState.Launch && state != MissileState.Ready)
{
transform.rotation = Quaternion.Euler(0, 0, Vector2.SignedAngle(new Vector2(0, 1), rig2d.velocity));
}
lifeTimer -= Time.deltaTime;
if (lifeTimer <= 0)
{
FinishWork();
}
}
public void Launch()//launches the missile, starting the flight sequence
{
missileTrail.GetComponent <TrailRenderer>().enabled = true;
state = MissileState.LAUNCHED;
missileBody.SetActive(true);
missileWings.SetActive(true);
transform.parent = null;
}
public void Launch(GameObject lastObject, GameObject forward)
{
LaunchBase = lastObject;
Target = forward;
this.gameObject.GetComponent <SphereCollider>().enabled = false;
GetComponent <Light>().enabled = false;
missileState = MissileState.Launching;
}
private void Explode()//puts missile back in object pool
{
body.isKinematic = true;
state = MissileState.WAITING;
StartCoroutine(TrailLinger());
missileBody.SetActive(false);
missileWings.SetActive(false);
missileExplosion.GetComponent <ParticleSystem>().Play();
seconds = 0;
}
IEnumerator TrailLinger()
{
yield return(new WaitForSeconds(trailLength));
state = MissileState.IDLE;
missileTrail.GetComponent <TrailRenderer>().enabled = false;
transform.parent = homeTube.transform;
this.transform.localPosition = Vector3.zero;
this.transform.localRotation = Quaternion.Euler(-90, 0, 0);
}
public Projectile(Point location, int direction, int range) : base(location, new Size(1, 1))
{
ZIndex = 2; // draw projectiles on top of invaders
State = MissileState.Lauched;
Direction = direction;
Range = range;
UpdateTimer.Reset(50);
SetBrick(Point.Empty, Brick.From('^', ConsoleColor.Red));
}
void StageOneLogic()
{
Vector3 newDirection = Vector3.RotateTowards(transform.forward, _targetPos.position, Mathf.Deg2Rad * 30.0f * Time.deltaTime, 0.0f);
transform.rotation = Quaternion.LookRotation(newDirection);
transform.position += transform.forward * (_speed * 0.5f) * Time.deltaTime;
_timer += Time.deltaTime;
if (_timer >= _stageOneTimer)
{
state = MissileState.StageTwo;
}
}
/// <summary>
/// Publiczny konstruktor bezargumentowy. Tworzy obiekt amunicji
/// o podanych parametrach.
/// </summary>
/// <param name="planeSpeed">Wektor ruchu.</param>
/// <param name="level">Referencja do obiektu level.</param>
/// <param name="angle">Kat nachylenia.</param>
/// <param name="owner">Wlasciciel broni.</param>
/// <author>Michal Ziober</author>
public Ammunition(Level level, float angle, IObject2D owner)
{
//referencja na obiekt Level
refToLevel = level;
//kat pod jakim spada pocisk
relativeAngle = angle;
//ustawiam pocisk jako niezniszczony.
state = MissileState.Intact;
//wlasciciel broni.
ammunitionOwner = owner;
}
public override void Launch(Gun gun, string parentTag, Vector2 movingDirection, float rotation)
{
rotationSpeed = startRotationSpeed;
state = MissileState.Launching;
Vector2 velocity = gun.Parent.GetComponent <Rigidbody2D>().velocity + MathHelpers.DegreeToVector2(gun.transform.rotation.eulerAngles.z) * speed;
speed = velocity.magnitude;
velocity /= speed;
launchingDeceleration = speed / launchingAnimationTime;
base.Launch(gun, parentTag, velocity, rotation);
}
private new void Update()
{
switch (state)
{
case MissileState.Seeking:
if (target)
{
Move(target);
}
else
{
state = MissileState.StandBy;
}
break;
case MissileState.Launching:
float newSpeed = speed - Time.deltaTime * launchingDeceleration;
if (newSpeed <= 0f)
{
speed = 0.01f;
state = MissileState.StandBy;
rigidbody.velocity = MathHelpers.DegreeToVector2(transform.rotation.eulerAngles.z) * speed;
}
else
{
rigidbody.velocity = rigidbody.velocity / (speed / newSpeed);
speed = newSpeed;
}
break;
case MissileState.StandBy:
newSpeed = speed + acceleration * Time.deltaTime;
if (newSpeed >= maxSpeed)
{
newSpeed = maxSpeed;
}
rigidbody.velocity = rigidbody.velocity / (speed / newSpeed);
speed = newSpeed;
FindTarget();
if (target)
{
state = MissileState.Seeking;
}
break;
}
base.Update();
}
internal override void Update(BehaviorUpdateContext context)
{
switch (_state)
{
case MissileState.Inactive:
_nextStateChangeTime = context.Time.TotalTime + _moduleData.IgnitionDelay;
_state = MissileState.WaitingForIgnition;
goto case MissileState.WaitingForIgnition;
case MissileState.WaitingForIgnition:
if (context.Time.TotalTime > _nextStateChangeTime)
{
_moduleData.IgnitionFX?.Value?.Execute(
new FXListExecutionContext(
GameObject.Rotation,
GameObject.Translation,
context.GameContext));
if (_moduleData.DistanceToTravelBeforeTurning > 0)
{
var pointToReachBeforeTurning = context.GameObject.Translation
+ Vector3.TransformNormal(Vector3.UnitX, context.GameObject.TransformMatrix) * _moduleData.DistanceToTravelBeforeTurning;
AddTargetPoint(pointToReachBeforeTurning);
}
// TODO: What to do if target doesn't exist anymore?
if (context.GameObject.CurrentWeapon.CurrentTarget != null)
{
AddTargetPoint(context.GameObject.CurrentWeapon.CurrentTarget.TargetPosition);
}
context.GameObject.Speed = _moduleData.InitialVelocity;
_state = MissileState.Moving;
}
break;
case MissileState.Moving:
// TODO: TryToFollowTarget
BezierProjectileBehavior.CheckForHit(context, _moduleData.DetonateCallsKill, DetonationFX);
break;
default:
throw new InvalidOperationException();
}
base.Update(context);
}
// Update is called once per frame
void Update()
{
spawnWait = Random.Range(spawnShortWait, spawnLongWait);
//So I just made a timer for once the countDownTimer reaches 0, these objects will dissappear.
if (state == MissileState.Spawning)
{
StartCoroutine("MissileSpawnPointLifeSpam");
state = MissileState.Wait;
}
if (countDownTime == 0)
{
StopCoroutine("MissileSpawnPointLifeSpam");
Destroy(gameObject);
}
}
public virtual void Destroy()
{
/* if (this is GunBullet)
* {
* if (!GunBulletView.table.ContainsKey(GetHashCode().ToString()))
* {
* GunBulletView.table[GetHashCode().ToString()] = 1;
* }
* else
* {
* GunBulletView.table[GetHashCode().ToString()]++;
* }
* }*/
refToLevel.Controller.OnUnregisterAmmunition(this);
state = MissileState.Destroyed;
}
void StageTwoLogic()
{
Vector3 targetDirection = _targetPos.position - transform.position;
Vector3 newDirection = Vector3.RotateTowards(transform.forward, targetDirection, rotationSpeed * Time.deltaTime, 0.0F);
transform.Translate(Vector3.forward * Time.deltaTime * _speed, Space.Self);
if (Vector3.Distance(transform.position, _targetPos.position) < stageTwoDistance)
{
state = MissileState.StageThree;
}
transform.rotation = Quaternion.LookRotation(newDirection);
Debug.DrawRay(transform.position, targetDirection * 5, Color.black);
Debug.DrawRay(transform.position, newDirection * 5, Color.cyan);
}
void Roam()
{
missile.radar.GetNearestTarget();
if (missile.radar.target != "" && missile.radar.target != null)
{
targetObject = GameObject.Find(missile.radar.target);
if (targetObject.GetComponent <ShipController>())
{
if (targetObject.GetComponent <ShipController>().IFF != missile.IFF)
{
missileState = MissileState.locked;
CancelInvoke("Roam");
invokeSet = false;
}
}
}
}
// Use this for initialization
void Start()
{
armed = false;
desiredHeading = parentShip.transform.eulerAngles.z;
mass = gameObject.GetComponent <Rigidbody2D>().mass;
gameObject.GetComponent <BoxCollider2D>().enabled = false;
missile = GetComponent <ShipController>();
missile.fuel = initialFuel;
if (missile.radar.target == "")
{
missileState = MissileState.roaming;
}
else if (missile.radar.target != "")
{
targetObject = GameObject.Find(missile.radar.target);
}
// Debug.Log("Parent: " + parentShip.name);
// Debug.Log("targeT: " + targetObject.name);
}
// Use this for initialization
void Start()
{
debug = SettingsManager.GetDebug() == 1;
if (!debug)
{
statusText.text = "";
}
stateChanging = false;
missileState = MissileState.disarmed;
damageRadius = Mathf.Sqrt(armingSQRDistance);
mass = gameObject.GetComponent <Rigidbody2D>().mass;
gameObject.GetComponent <BoxCollider2D>().enabled = false;
missile = GetComponent <ShipController>();
missile.fuel = initialFuel;
InvokeRepeating("TargetCheck", 1f, 1f);
}
void Pursue()
{
// check for radar lock
if (targetObject)
{
sqrToTarget = (gameObject.GetComponent <Rigidbody2D>().position - targetObject.GetComponent <Rigidbody2D>().position).sqrMagnitude;
if (sqrToTarget < armingSQRDistance * armingSQRDistance)
{
if (sqrToTarget > minSqrToTarget)
{
Detonate();
}
}
if (debug)
{
statusText.text = statusText.text + " " + targetObject.name;
}
Vector2 killBurn = RAMP.GetHitBurn(targetObject.transform, gameObject.transform, missile.fuel, mass);
desiredHeading = killBurn.x;
LateralCorrection();
missile.Rotate(desiredHeading, Time.deltaTime);
if (Mathf.Abs(desiredHeading - missile.transform.eulerAngles.z) < 0.5f)
{
ExecuteThrust(killBurn.y);
}
}
else
{
stateChanging = true;
missileState = MissileState.mine;
}
minSqrToTarget = sqrToTarget;
}
void Pursue()
{
if (targetObject)
{
float distanceToTarget = Vector2.Distance(new Vector2(gameObject.transform.position.x, gameObject.transform.position.y), new Vector2(targetObject.transform.position.x, targetObject.transform.position.y));
// Switch to Roaming mode if target is out of radar range
if (distanceToTarget > missile.radar.pingReach)
{
missileState = MissileState.roaming;
CancelInvoke("Pursue");
invokeSet = false;
return;
}
Vector2 killBurn = RouteAndManeuverPlanner.GetHitBurn(targetObject.transform, gameObject.transform, missile.fuel, mass);
desiredHeading = killBurn.x;
if (Mathf.Abs(desiredHeading - missile.transform.eulerAngles.z) < 0.5f)
{
// ExecuteThrust(killBurn.y);
}
}
}
// Update is called once per frame
void Update()
{
//can i do this with functions? yes.
//will I? f**k no.
//why not? because f**k formatting (also it helps me keep track of whats happening)
//I am chaos
switch (state)
{
case MissileState.IDLE: //do nothing
break;
case MissileState.LAUNCHED: //fly up
transform.position += Vector3.up * Time.deltaTime * MissileLauncher.missileSpeed * (0.1f + 0.9f * (seconds / launchLength));
transform.position += Quaternion.Euler(0f, from.GetComponent <ClientMaster>().GetShipCore().GetRotation(), 0f) * Vector3.forward * Time.deltaTime * from.GetComponent <ClientMaster>().GetShipCore().GetSpeed() * (1f - (seconds / launchLength));
this.transform.localRotation = Quaternion.Euler(-90, 0, 0);
break;
case MissileState.HOMING: //track laser point and turn towards it
direction = trackPoint - this.transform.position;
heading = direction.normalized; // / direction.magnitude;//normalize
look = Quaternion.LookRotation(heading);
body.rotation = Quaternion.RotateTowards(body.rotation, look, MissileLauncher.missileTrackStrength * Time.deltaTime);
body.position += transform.forward * Time.deltaTime * MissileLauncher.missileSpeed;
break;
}
if (state != MissileState.IDLE && state != MissileState.WAITING)//flight time
{
seconds += Time.deltaTime;
if (seconds >= 6)//repool after 6 seconds
{
Explode();
}
else if (state != MissileState.HOMING && seconds >= launchLength)//start homing after half a second
{
body.isKinematic = false;
state = MissileState.HOMING;
}
if (transform.position.y < -5f)
{
Explode();
}
}
if (state == MissileState.IDLE)
{
if (transform.localPosition != Vector3.zero)
{
transform.localPosition = Vector3.zero;
}
if (transform.parent == null)
{
transform.parent = homeTube.transform;
}
}
// Missile Wing Animation
if (seconds <= 0.25f && (state == MissileState.LAUNCHED || state == MissileState.HOMING) && missileWings.transform.localRotation.eulerAngles.y != 90f)
{
missileWings.transform.localRotation = Quaternion.Euler(0f, 90f, 0f);
}
else if (seconds > 0.25f && seconds <= 0.55f && (state == MissileState.LAUNCHED || state == MissileState.HOMING))
{
missileWings.transform.localRotation = Quaternion.Euler(0f, 90f * (1f - ((seconds - 0.25f) / 0.3f)), 0f);
}
else if (seconds > 0.55f && (state == MissileState.LAUNCHED || state == MissileState.HOMING) && missileWings.transform.localRotation.eulerAngles.y != 0f)
{
missileWings.transform.localRotation = Quaternion.Euler(0f, 0f, 0f);
}
}
// Start is called before the first frame update
void Start()
{
state = MissileState.StageOne;
Destroy(gameObject, 15);
}
public virtual void fire(PhysicsGameObject target)
{
this.m_AngularHomingModule = new AngularHomingModule(this, target, ANGULAR_HOMING_COEFFICIENT);
this.m_DirectionalHomingModule = new DirectionalHomingModule(this, target, DIRECTIONAL_HOMING_CONVERSION);
this.pm.Add(this);
this.state = MissileState.FIRED;
}
// Update is called once per frame
void Update()
{
switch (missileState)
{
case MissileState.Launching:
if (LaunchBase.transform.InverseTransformPoint(transform.position).z < LauchingDistance)
{
transform.Translate(transform.forward.normalized * LauchingForce * Time.deltaTime, Space.World);
}
else
{
this.gameObject.GetComponent <Rigidbody>().velocity = Vector3.zero;
this.gameObject.GetComponent <SphereCollider>().enabled = true;
timeStick = 0;
missileState = MissileState.Targeting;
this.transform.parent = null;
GetComponent <Light>().enabled = true;
}
break;
case MissileState.Targeting:
timeStick += Time.deltaTime;
if (timeStick < TargetingTime)
{
// y = (s2-s1)/t * x + s1
transform.Translate(transform.forward.normalized * Time.deltaTime *
((FiringForce - LauchingForce) / TargetingTime * timeStick + LauchingForce)
, Space.World);
if (Target != null)
{
Vector3 dir = Target.transform.position - transform.position;
Quaternion rot = Quaternion.LookRotation(dir);
transform.rotation = Quaternion.Slerp(transform.rotation, rot, SteerFactor * timeStick / TargetingTime);
}
}
else
{
missileState = MissileState.Following;
timeStick = 0;
}
break;
case MissileState.Following:
timeStick += Time.deltaTime;
if (timeStick < Lifetime)
{
// move in the current forward direction at specified speed:
transform.Translate(transform.forward.normalized * FiringForce * Time.deltaTime, Space.World);
if (Target != null)
{
Vector3 dir = Target.transform.position - transform.position;
Quaternion rot = Quaternion.LookRotation(dir);
transform.rotation = Quaternion.Slerp(transform.rotation, rot, 1);
}
}
else
{
Instantiate(ExplosionMissile).transform.position = transform.position;
Destroy(this.gameObject);
}
break;
default:
break;
}
}
// Update is called once per frame
void Update()
{
// Missile state flow:
switch (missileState)
{
case MissileState.disarmed:
missile.radar.SetRadarOn();
if (debug)
{
statusText.text = "DA";
}
missile.ThrustForward(1f); // to clear the player
SQRdistanceToOwner = Vector2.SqrMagnitude(gameObject.transform.position - parentShip.position);
if (SQRdistanceToOwner > armingSQRDistance)
{
stateChanging = true;
if (!targetObject)
{
if (intendedState == MissileState.locked)
{
missileState = MissileState.scouting;
}
else
{
missileState = intendedState;
}
gameObject.GetComponent <BoxCollider2D>().enabled = true;
}
else
{
// InitialLockedManeuver();
missileState = MissileState.locked;
gameObject.GetComponent <BoxCollider2D>().enabled = true;
}
}
break;
case MissileState.locked:
if (debug)
{
statusText.text = "LCK";
}
if (stateChanging)
{
AudioSource.PlayClipAtPoint(missileArmed, gameObject.transform.position, 0.8f);
stateChanging = false;
}
Pursue();
break;
case MissileState.scouting:
if (debug)
{
statusText.text = "SCT";
}
if (stateChanging)
{
AudioSource.PlayClipAtPoint(missileArmed, gameObject.transform.position, 0.8f);
gameObject.GetComponent <BoxCollider2D>().enabled = true;
stateChanging = false;
}
Scout();
break;
case MissileState.mine:
if (debug)
{
statusText.text = "MN";
}
Loiter();
break;
}
if (missile.fuel < 0 && targetObject == null)
{
missile.SelfDestruct();
}
if (debug)
{
statusText.text = statusText.text + " R: " + missile.radar.radarState + " F: " + missile.fuel;
}
}
// Update is called once per frame
void Update()
{
// -------------------------- DISARMED ------------------------- //
if (!armed)
{
if (parentShip)
{
distanceToOwner = Vector2.Distance(gameObject.transform.position, parentShip.position);
if (distanceToOwner > armingDistance)
{
armed = true;
// Debug.Log("Missile Armed.");
AudioSource.PlayClipAtPoint(missileArmed, gameObject.transform.position, 0.8f);
gameObject.GetComponent <BoxCollider2D>().enabled = true;
if (!targetObject)
{
ExecuteThrust(initialSpeed);
missileState = MissileState.roaming;
}
else
{
// InitialLockedManeuver();
missileState = MissileState.locked;
}
}
}
else
{
armed = true;
}
// -------------------------- ARMED ------------------------- //
}
else if (armed)
{
missile.Rotate(desiredHeading, Time.deltaTime);
LateralCorrection();
// Debug.Log(" Desired heading: " + desiredHeading);
if (!invokeSet)
{
switch (missileState)
{
case MissileState.locked:
InvokeRepeating("Pursue", 0.0000f, 0.2f);
invokeSet = true;
break;
case MissileState.roaming:
InvokeRepeating("Roam", 0.0000f, 1f);
missile.radar.SetRadarWide();
invokeSet = true;
break;
}
}
}
// Debug.Log("Missile fuel: " + missile.fuel);
if (missile.fuel < 0)
{
Invoke("missile.SelfDestruct", 1f);
}
missile.ThrustForward(constantAcceleration);
}
