bool MoveMissile(MissileData args, Vec3U16 pos, Vec3U16 target)
{
BlockID block = p.level.GetBlock(pos.X, pos.Y, pos.Z);
if (block != Block.Air && !args.all.Contains(pos) && OnHitBlock(args, pos, block))
{
return(false);
}
p.level.Blockchange(pos.X, pos.Y, pos.Z, args.block);
args.visible.Add(pos);
args.all.Add(pos);
if (HitsPlayer(args, pos))
{
return(false);
}
if (pos == target && p.level.physics >= 3 && args.type >= WeaponType.Explode)
{
p.level.MakeExplosion(target.X, target.Y, target.Z, 2);
return(false);
}
if (args.visible.Count > 12)
{
pos = args.visible[0];
p.level.Blockchange(pos.X, pos.Y, pos.Z, Block.Air, true);
args.visible.RemoveAt(0);
}
return(true);
}
Vec3U16 MissileTarget(MissileData args)
{
args.start = (Vec3U16)p.Pos.BlockCoords;
args.dir = DirUtils.GetDirVector(p.Rot.RotY, p.Rot.HeadX);
int i;
for (i = 1; ; i++)
{
Vec3U16 target = args.PosAt(i);
BlockID block = p.level.GetBlock(target.X, target.Y, target.Z);
if (block == Block.Invalid)
{
break;
}
if (block != Block.Air && !args.all.Contains(target))
{
break;
}
Player hit = PlayerAt(p, target, true);
if (hit != null)
{
return((Vec3U16)hit.Pos.BlockCoords);
}
}
return(args.PosAt(i - 1));
}
public override void OnMissileHit(BaseEntity2D sender, MissileData missile, Vector2 point)
{
if (machine.currentState.GetName() != StateTypes.Dead.ToString())
{
machine.ChangeState(StateTypes.Dead.ToString());
}
}
/// <summary>
/// Crée les données du sort avec comme effet l'invocation du missile depuis son possesseur et vers sa cible.
/// Certaines données sont écrites par défaut :
/// L'animation du posesseur lors de l'incantation du sort est de type Cast, le pourcentage du déclenchement de
/// l'effet est de 1 (ce qui signifie que le sort est lancé à la fin de son incantation) et la portée du sort
/// équivaut à la portée du missile invoqué.
/// Ces données prennent en compte les statistiques de son possesseur.
/// </summary>
/// <param name="missile"> Le projectile invoqué </param>
/// <param name="cooldown"> Le temps de rechargemetn du sort </param>
/// <param name="castTimeMs"> Le temps de lancement du sort </param>
/// <param name="canMove"> Indique si le lanceur peut bouger pendant le lancement du sort </param>
/// <param name="nbCharges"> Le nombre de charges du sort (minimum 1) </param>
/// <param name="icon"> L'icône du sort, qui est affichée des les slots de sorts des joueurs </param>
public MissileSpellData(MissileData missile, double cooldown, int castTimeMs, bool canMove,
int nbCharges = 1, Bitmap icon = null) : base((owner, target) =>
{
new Missile(owner, target, missile);
}, AnimationType.Cast, cooldown, castTimeMs, 1, canMove, nbCharges, missile.Range, icon)
{
}
public static MissileData GetData(string data)
{
MissileData missileData = new MissileData();
StringReader reader = new StringReader(data);
string line = "";
int lineNumber = 0;
while ((line = reader.ReadLine()) != null)
{
lineNumber++;
if (line == "[/MISSILES]")
{
break;
}
else if (line == "[MISSILE]")
{
missileData.Missiles.Add(ReadMissile(ref reader, ref lineNumber));
}
}
reader.Close();
reader.Dispose();
return(missileData);
}
private void Awake()
{
data = Resources.Load <MissileData>("ScriptableObjects/MissileData");
rb = GetComponent <Rigidbody2D>();
Assert.IsNotNull(data, "Could not find MissileData");
Assert.IsNotNull(rb, "Could not find Rigidbody2D component");
}
void Start()
{
SoundManager.GetInstance().PlayOneShot(AudioRepository.LoadExplosionAudio(missile.audioID));
animator.AnimationCompleted = delegate(tk2dSpriteAnimator sprite, tk2dSpriteAnimationClip clip)
{
animator.AnimationCompleted = null;
missile = null;
Destroy(gameObject);
};
if (missile.WOE != 0)
{
Collider2D[] hits = Physics2D.OverlapCircleAll(this.transform.position, this.missile.WOE);
IList <GameObject> hitedCache = new List <GameObject>();
foreach (Collider2D hit in hits)
{
MonsterEntity2D entity = hit.gameObject.GetComponent <MonsterEntity2D>();
if (entity != null && !hitedCache.Contains(entity.gameObject))
{
entity.OnMissileHit(sender, missile, this.transform.position);
hitedCache.Add(hit.gameObject);
}
}
hitedCache.Clear();
}
}
protected override bool OnHitBlock(MissileData args, Vec3U16 pos, BlockID block)
{
if (p.level.physics >= 3)
{
p.level.MakeExplosion(pos.X, pos.Y, pos.Z, 1);
}
return(true);
}
private void WriteMissileDataFile(MissileData missileData)
{
_writer.Write((short)missileData.Missiles.Count);
foreach (var missile in missileData.Missiles)
{
WriteMissile(missile);
}
}
private void ExtractConstantsFromMissileData(MissileData missileData)
{
MAXACCEL = missileData.MaximumAcceleration;
MAXWGT = MASS = missileData.WeightAtLaunch;
MINWGT = missileData.WeightAtBurnout;
MOTORBURNTIME = missileData.TimeOfMotorBurn;
MAXTRT = missileData.Thrust;
DETRNG = missileData.Range;
}
public void Init(MissileData data, Vector3 target)
{
_rigidbody = GetComponent <Rigidbody>();
transform.LookAt(target);
var direction = target - transform.position;
_rigidbody.velocity = direction.normalized * data.FlightSpeed;
_data = data;
}
public override void OnMissileHit(BaseEntity2D sender, MissileData missile, Vector2 point)
{
if (sender != null && machine.currentState.GetName() != StateTypes.Dead.ToString())
{
PetData pet = sender.data as PetData;
data.attributeBox.Validate(ValidateType.Injured, pet.attributeBox, missile, point);
}
}
protected override void OnHitPlayer(MissileData args, Player pl)
{
if (pl.level.physics >= 3)
{
pl.HandleDeath(Block.Cobblestone, "@p %Swas blown up by " + p.ColoredName, true);
}
else
{
base.OnHitPlayer(args, pl);
}
}
bool HitsPlayer(MissileData args, Vec3U16 pos)
{
Player pl = PlayerAt(p, pos, true);
if (pl == null)
{
return(false);
}
OnHitPlayer(args, pl);
return(true);
}
private MissileData ReadMissileDataFile()
{
MissileData rawFile = new MissileData();
int missileCount = _reader.ReadInt16();
for (int i = 0; i < missileCount; i++)
{
rawFile.Missiles.Add(ReadMissile());
}
return(rawFile);
}
private void Awake()
{
enemyLayer = LayerMask.NameToLayer("Enemy");
trackableLayer = LayerMask.NameToLayer("Trackable");
if (gameObject.layer != trackableLayer && gameObject.layer != enemyLayer)
{
throw new System.Exception("LayerMask Busy");
}
data = Resources.Load <MissileData>("ScriptableObjects/MissileData");
Assert.IsNotNull(data, "Could not find the MissileData ScriptableObject, has it been removed from the Resources/ScriptableObjects folder?");
data.trackableObjects.Add(gameObject);
}
protected override void OnActivated(Vec3F32 dir, BlockID block)
{
MissileData args = new MissileData();
args.block = block;
args.type = type;
args.pos = (Vec3U16)p.Pos.BlockCoords;
SchedulerTask task = new SchedulerTask(MissileCallback, args,
TimeSpan.FromMilliseconds(100), true);
p.CriticalTasks.Add(task);
Disable();
}
public static MissileData CultistFireball()
{
if (_cultistFireball == null)
{
_cultistFireball = new MissileData
{
Range = 550,
Speed = 350,
Animations = Sprites.Fireball,
Size = 25,
Damage = 30
};
}
return(_cultistFireball);
}
public static MissileData CthulhuVoidball()
{
if (_cthulhuVoidball == null)
{
_cthulhuVoidball = new MissileData
{
Range = 150,
Speed = 100,
Animations = Sprites.CthulhuVoidball,
Size = 25,
Damage = 30
};
}
return(_cthulhuVoidball);
}
public static MissileData Holyball()
{
if (_holyball == null)
{
_holyball = new MissileData
{
Damage = 70,
Range = 700,
Speed = 400,
Size = 20,
Animations = Sprites.Holyball
};
}
return(_holyball);
}
public static MissileData Arrow()
{
if (_arrow == null)
{
_arrow = new MissileData
{
Damage = 40,
Range = 600,
Speed = 600,
Size = 15,
Animations = Sprites.Arrow
};
}
return(_arrow);
}
protected override bool OnHitBlock(MissileData args, Vec3U16 pos, BlockID block)
{
if (p.level.physics < 2)
{
return(true);
}
if (!p.level.Props[block].LavaKills)
{
return(true);
}
// Penetrative missile goes through blocks lava can go through
p.level.Blockchange(pos.X, pos.Y, pos.Z, Block.Air);
return(false);
}
void PerformMove(MissileData args)
{
while (true)
{
args.iterations++;
Vec3U16 target = MissileTarget(args);
FindNext(target, ref args.pos, args.buffer);
if (args.iterations <= 3)
{
continue;
}
args.moving = MoveMissile(args, args.pos, target);
return;
}
}
private IEnumerable <TrajectoryStep> GetTrajectoryPoints(MissileData data, float time)
{
var hits = _emptyPlanetData;
while (hits.Length == 0)
{
var backUpTime = time;
var positions = _planetsData.Select(x => GetPositionAtTime(x, backUpTime));
var missilePosition = GetPosition(data);
time += Time.fixedDeltaTime;
hits = GetPlanetHits(data, time);
yield return(new TrajectoryStep()
{
Point = missilePosition, Planets = hits
});
}
}
void MissileCallback(SchedulerTask task)
{
MissileData args = (MissileData)task.State;
if (args.moving)
{
PerformMove(args); return;
}
if (args.visible.Count > 0)
{
Vec3U16 pos = args.visible[0];
args.visible.RemoveAt(0);
p.level.Blockchange(pos.X, pos.Y, pos.Z, Block.Air, true);
}
task.Repeating = args.visible.Count > 0;
}
private void ExtractMissileData()
{
string fileData = System.IO.File.ReadAllText(_path);
string[] lines = fileData.Split("\n"[0]);
for (int i = 0; i < lines.Length; i++)
{
//Skip first line as we already know what to expect
if (i == 0)
{
continue;
}
string[] lineData = (lines[i].Trim()).Split(',');
AircraftMisileData aircraftMissileData = new AircraftMisileData();
string aircraftType = lineData[0];
int noOfMissiles = int.Parse(lineData[1]);
aircraftMissileData.totalMissiles = noOfMissiles;
MissileData missileData = new MissileData();
missileData.WeightAtLaunch = double.Parse(lineData[2]);
missileData.WeightAtBurnout = double.Parse(lineData[3]);
missileData.Thrust = double.Parse(lineData[4]);
missileData.TimeOfMotorBurn = double.Parse(lineData[5]);
missileData.MaximumAcceleration = double.Parse(lineData[6]);
missileData.Range = double.Parse(lineData[7]);
//Save this missile data in aircraft missile data struct
aircraftMissileData.installedMissile = missileData;
//map aircraft type to aircraft missile data (avoid duplication)
if (!aircraftMissileMap.ContainsKey(aircraftType))
{
aircraftMissileMap.Add(aircraftType, aircraftMissileData);
}
else
{
Debug.LogError("Error in missile data ! Duplication of aircraft type found");
}
Debug.Log(missileData.ToString());
}
}
private void LaunchMissile(MissileData missileData, GameObject sourceAircraft, GameObject destinationAircraft)
{
Transform parent = sourceAircraft.transform.GetChild(0);
GameObject missile = Instantiate(missilePrefab, parent);
missile.transform.SetParent(_missileParent);
MissileMovement missieMovementScript = missile.GetComponent <MissileMovement>();
if (destinationAircraft != null)
{
missieMovementScript.SetTarget(destinationAircraft.transform.GetChild(0).gameObject);
}
missieMovementScript.SetVelocityPerSecond(7500f);
missieMovementScript.SetBurnTime((float)missileData.TimeOfMotorBurn);
missieMovementScript.SetMinimumFocus(70f);
missieMovementScript.SetLaunchingAircraft(sourceAircraft);
}
public static string GetString(MissileData missileData)
{
StringBuilder builder = new StringBuilder();
builder.AppendLine("[MISSILES]");
if (missileData.Missiles.Count > 0)
{
foreach (var missile in missileData.Missiles)
{
builder.AppendMissile(missile);
}
}
builder.Append("[/MISSILES]");
return(builder.ToString());
}
/// <summary>
/// Logic for the player performing their action
/// </summary>
public void PerformAction()
{
Direction = (new Vector3(transform.position.x, transform.position.y, 0) - Vector3.zero).normalized;
switch (Action)
{
case "Shoot":
if (Target == null) //target shouldn't be null if shooting
{
break;
}
//GameObject newMissile = Instantiate(missile, transform);
MissileData newMissileData = new MissileData(this, Target);
GameManager.Instance.missiles.Add(newMissileData);
GameManager.Instance.numMissiles++;
AudioManager.Instance.PlayOneShot("missile_Launch", 1);
//newMissile.GetComponent<Missile>().Launch(this, Target);
//newMissile.GetComponent<Missile>().origin = this;
//newMissile.GetComponent<Missile>().destination = Target;
Resources -= 1;
break;
case "Reflect":
Resources -= 1;
TurnOnDish();
break;
case "Shield":
ShieldOn = true;
AudioManager.Instance.FadeInLayer("forcefield_Idle", 0.7f, shieldTime);
break;
case "Load":
Resources++;
DrillOn = true;
debris.Play();
AudioManager.Instance.FadeInLayer("drill", 0.7f, 1f);
break;
}
}
void Start()
{
missilePools = new List <MissileData> [missileTypes.Count];
for (int i = 0; i < missilePools.Length; i++)
{
missilePools[i] = new List <MissileData>();
for (int j = 0; j < poolSize; j++)
{
MissileData missileData = Instantiate(missileTypes[i]);
missileData.gameObject.SetActive(false);
missileData.transform.position = transform.position;
missileData.transform.localScale = Vector2.one * missileData.GetInitialColliderSize();
missileData.SetIsPlayerOwned(IsPlayerOwned());
missilePools[i].Add(missileData);
}
}
Initialise();
}
private List<MissileData> SerializeMissiles()
{
var list = new List<MissileData>();
foreach (var missile in _inGame._game.Components.OfType<MissileSpell>())
{
var missileData = new MissileData
{
Position = missile.Position,
Direction = missile.Direction,
};
list.Add(missileData);
}
return list;
}
