public void Update(StartUserProjectileServerMessage m)
{
var newEntity = new ProjectileEntity(m.Id, m.OwnerId, GetOrPlaceholder(m.OwnerId), m.Start,
m.Start.GetHeading(m.Finish), m.Finish, (int)m.Speed, m.Time.Ticks);
Register(newEntity);
}
public override void HandleOnTargetHit(ProjectileEntity source, EntityComponent target)
{
base.HandleOnTargetHit(source, target);
target.Damage(Magnitude, MyEntityComponent);
target.BroadcastMessage("BeingAttacked", this.MyEntityComponent);
}
protected override void OnTick(float interval)
{
if (ShootingEnemy.GetComponent <ShootingEnemyComponent>().AmmoLeft <= 0)
{
EventManager.Instance.QueueEvent(new OutOfAmmoEvent(ShootingEnemy));
return;
}
if (!Engine.GetEntities().Contains(ShootingEnemy))
{
Kill();
return;
}
TransformComponent transformComp = ShootingEnemy.GetComponent <TransformComponent>();
Vector2 shootingEnemyDirection = new Vector2((float)Math.Cos(ShootingEnemy.GetComponent <TransformComponent>().Rotation), (float)Math.Sin(ShootingEnemy.GetComponent <TransformComponent>().Rotation));
Entity projectile = ProjectileEntity.Create(Engine, Vector2.Zero, shootingEnemyDirection);
TransformComponent projectileTransformComp = projectile.GetComponent <TransformComponent>();
Vector2 projectilePosition = shootingEnemyDirection * (_shootingEnemyTip * transformComp.Scale + _projectileLength * projectileTransformComp.Scale + _errorBuffer) + transformComp.Position;
projectileTransformComp.SetPosition(projectilePosition, true);
projectileTransformComp.SetRotation(transformComp.Rotation, true);
EventManager.Instance.QueueEvent(new ProjectileFiredEvent());
ShootingEnemy.GetComponent <ShootingEnemyComponent>().AmmoLeft -= 1;
}
private ProjectileEntity CreateProjectile()
{
ProjectileEntity entity = new ProjectileEntity(this, direction);
AddChild(entity);
entity.GlobalPosition = caster.Entity.GlobalPosition;
return(entity);
}
public Projectile(GameInstance parent, float initX, float initY, FieldObjectEntity objectField, ProjectileEntity objectProjectile)
: base(parent.Rect.point.layer, initX, objectField, parent.ToLeft)
{
Move(new Vector2(0, initY));
this.objectProjectile = objectProjectile;
this.parent = parent;
}
public Projectile(Character target, Character owner, ProjectileEntity prefab, int damage, float speed)
{
m_target = target;
m_owner = owner;
m_prefab = prefab;
m_projectileDamage = damage;
m_projectileSpeed = speed;
m_projectileFinished = false;
}
public void CreateEntity()
{
if (m_entity != null)
{
GameObject.Destroy(m_entity.gameObject);
}
m_entity = GameObject.Instantiate <ProjectileEntity>(m_prefab);
m_entity.transform.SetParent(m_owner.Entity.transform, false);
m_direction = Mathf.Abs(m_target.Entity.transform.position.x - m_owner.Entity.transform.position.x) / (m_target.Entity.transform.position.x - m_owner.Entity.transform.position.x);
m_entity.transform.position = m_owner.Entity.transform.position;
}
void DangerousTilesSetDanger(bool dangerous, ProjectileEntity proj)
{
foreach (Animator anim in proj.dangerousSprites)
{
if (dangerous)
{
anim.gameObject.tag = dangerousTag;
}
else
{
anim.gameObject.tag = untaggedTag;
}
}
}
public virtual void HandleOnTargetHit(ProjectileEntity source, EntityComponent target)
{
//Apply our attack effects.
if (target != null && target.Alive)
{
foreach (EntityModifier modifier in actionModifiers.Values)
{
modifier.DeepClone().Attach(target);
}
}
//Let any listeners know
if (OnTargetHitEvent != null)
OnTargetHitEvent(MyEntityComponent, MyActionManager.myBehaviorManager.CurrentTarget);
}
public void DestroyProjectile(ProjectileEntity projectile)
{
for (int i = projectile.dangerousSprites.Count - 1; i >= 0; i--)
{
projectile.dangerousSprites[i].SetTrigger("Stop");
Destroy(projectile.dangerousSprites[i].gameObject, 1f);
}
projectiles.Remove(projectile);
gm.entityList.RemoveEntity(projectile.health);
var particles = Instantiate(projectile.deathParticles, projectile.deathPosition, Quaternion.identity);
Destroy(particles, 2);
Destroy(projectile.gameObject);
}
public void Fire()
{
if (coolDownTime == 0f)
{
projectile = Instantiate(projectilePrefab,
transform.position + positionOffset,
Quaternion.AngleAxis(aimController.aimDegrees, Vector3.forward),
transform).GetComponent <ProjectileEntity>();
//projectile.transform.position = aimController.transform.position;
//projectile.transform.rotation = Quaternion.AngleAxis(aimController.aimDegrees, Vector3.forward);
projectile.Fly(aimController.aimVector, range);
coolDownTime = rateOfFire;
}
}
protected override void OnTick(float interval)
{
if (shootingEnemy.GetComponent <ShootingEnemyComponent>().ammoLeft <= 0)
{
EventManager.Instance.QueueEvent(new OutOfAmmoEvent(shootingEnemy));
return;
}
if (!engine.GetEntities().Contains(shootingEnemy))
{
Kill();
return;
}
ProjectileEntity.Create(engine, Content.Load <Texture2D>(Constants.Resources.TEXTURE_ENEMY_BULLET), shootingEnemy.GetComponent <TransformComponent>().Position, shootingEnemy.GetComponent <MovementComponent>().direction);
EventManager.Instance.QueueEvent(new ProjectileFiredEvent());
shootingEnemy.GetComponent <ShootingEnemyComponent>().ammoLeft -= 1;
Console.WriteLine(shootingEnemy.GetComponent <ShootingEnemyComponent>().ammoLeft);
}
IEnumerator CalculateDangerousTiles(ProjectileEntity proj)
{
if (proj.telegraphTurn)
{
}
int wallOnWay = 10000000;
for (int i = 0; i < proj.dangerousSprites.Count; i++)
{
if (wallOnWay > i)
{
Animator anim = proj.dangerousSprites[i];
anim.gameObject.SetActive(false);
anim.transform.position = proj.newPos + proj.direction * i;
anim.transform.LookAt(anim.transform.position + proj.direction);
RaycastHit hit;
if (Physics.Raycast(proj.dangerousSprites[i].transform.position + Vector3.up * 5, Vector3.down, out hit, 10, gm.movementSystem.movementMask))
{
if (hit.collider.tag == "Wall")
{
proj.wallOnWay = true;
proj.deathPosition = proj.dangerousSprites[i].transform.position;
wallOnWay = i;
//proj.stepsLast = 0;
proj.dangerousSprites[i].gameObject.SetActive(false);
}
else if (hit.collider.tag == "Unit" && hit.collider.gameObject != proj.master.gameObject)
{
}
}
}
}
for (int i = 0; i < proj.dangerousSprites.Count; i++)
{
if (wallOnWay > i)
{
proj.dangerousSprites[i].gameObject.SetActive(true);
proj.dangerousSprites[i].SetTrigger("Reset");
yield return(new WaitForSeconds(0.1f));
}
}
}
public void MoveProjectile(ProjectileEntity proj)
{
if (!proj.telegraphTurn)
{
proj.master.npc.projectileToFire = null;
Vector3 newPos = proj.transform.position + proj.direction * proj.movementSpeed;
proj.newPos = newPos;
proj.stepsLast--;
StartCoroutine(MoveProjectileOverTime(proj));
}
else
{
proj.master.anim.SetTrigger("Attack");
proj.telegraphTurn = false;
}
}
public override void HandleOnTargetHit(ProjectileEntity source, EntityComponent target)
{
base.HandleOnTargetHit(source, target);
Collider[] colliders = Physics.OverlapSphere(target.transform.position, Radius, layerMask);
//Loop through all resulting colliders, seeing if we can snatch an EntityComponent from them that is of our target type
//Then damage it if that is the case!
foreach (Collider collider in colliders)
{
EntityComponent entity = collider.gameObject.GetComponent<EntityComponent>();
if (entity != null && entity.GetType() == myTargetType)
{
entity.Damage(Magnitude, MyEntityComponent);
entity.BroadcastMessage("BeingAttacked", this.MyEntityComponent);
}
}
}
IEnumerator MoveProjectileOverTime(ProjectileEntity proj)
{
Vector3 newPos = proj.newPos;
if (proj.damagedObject)
{
newPos = proj.damagedObject.transform.position;
}
else if (proj.wallOnWay)
{
newPos = proj.deathPosition;
}
for (int t = 0; t < 8; t++)
{
if (proj != null)
{
proj.transform.position = Vector3.Lerp(proj.transform.position, newPos, 0.2f);
yield return(new WaitForSeconds(0.01f));
}
else
{
break;
}
}
if (proj != null)
{
proj.transform.position = proj.newPos;
if (!proj.wallOnWay)
{
proj.deathPosition = proj.newPos;
}
if (proj.stepsLast > 0 && !proj.damagedObject)
{
StartCoroutine(CalculateDangerousTiles(proj));
}
}
}
private void SpreadProjectile()
{
// TODO make better Spread projectile physics using better formula.
float radSpace = 0.04f * Mathf.Sqrt(physicist.ProjectileCount);
float rad = radSpace;
float count = physicist.ProjectileCount;
if (physicist.ProjectileCount % 2 != 0)
{
CreateProjectile();
count--;
}
for (int i = 0; i < count; i++)
{
ProjectileEntity projectile = CreateProjectile();
projectile.Rotate(rad);
projectile.Direction = projectile.Direction.Rotated(rad);
rad += rad > 0 ? radSpace : -radSpace;
rad *= -1;
}
}
public Entity createProjectile(string name, ProjectileController controller, Vector2 pos, ref Sprite sprite)
{
// Entity entity = createEntity("Entity");
ProjectileEntity waveProjectile = new ProjectileEntity(name, controller, ProjectileType.WAVE);
//Hardcoding position adjustments
//pos.X += 16;
waveProjectile.position = pos;
//Attach Sprite
sprite.setRenderLayer(1);
waveProjectile.addComponent <Sprite>(sprite);
//Attack physics
PhysicsHandler physicsHandler = new PhysicsHandler(controller.collisionResult);
physicsHandler.isProjectile = true;
physicsHandler.applyGravity = false;
waveProjectile.addComponent <PhysicsHandler>(physicsHandler);
//Attach hit detection
CircleCollider circleCollider = new CircleCollider(sprite.width);
waveProjectile.addComponent <CircleCollider>(circleCollider);
Flags.setFlagExclusive(ref circleCollider.collidesWithLayers, 0); //Prevent collisions on layer 0
Flags.setFlagExclusive(ref circleCollider.physicsLayer, 2); //
//Attack mover
Mover mover = new Mover();
waveProjectile.addComponent <Mover>(mover);
entity.scene.addEntity <ProjectileEntity>(waveProjectile);
return(waveProjectile);
}
public ProjectileCustom(GameInstance parent, float initX, float initY, FieldObjectEntity objectField, ProjectileEntity objectProjectile, Action2 action)
: base(parent, initX, initY, objectField, objectProjectile)
{
List<VectorEntity> pattern = VectorGenerator.Custom(objectProjectile.speed, objectProjectile.speedY, objectProjectile.gravity, parent.ToLeft);
//pattern.Add(new LinearVelocity(parent.Velocity));
SetMove(pattern);
InitAction(action);
}
public bool Equals(ProjectileEntity other)
{
return(Id.Equals(other?.Id));
}
void HandleBounceCollision(Entity reflector, Entity bouncer)
{
if (reflector.HasComponent <EdgeComponent>())
{
if (bouncer.HasComponent <ProjectileComponent>() && bouncer.HasComponent <MovementComponent>())
{
EventManager.Instance.QueueEvent(new ProjectileBouncedEvent(bouncer, bouncer.GetComponent <TransformComponent>().Position, reflector));
bouncer.GetComponent <ProjectileComponent>().BouncesLeft -= 1;
if (bouncer.GetComponent <ProjectileComponent>().BouncesLeft <= 0)
{
Color color = Color.White;
if (bouncer.HasComponent <ColoredExplosionComponent>())
{
color = bouncer.GetComponent <ColoredExplosionComponent>().Color;
}
EventManager.Instance.QueueEvent(new CreateExplosionEvent(bouncer.GetComponent <TransformComponent>().Position, color, false));
Engine.DestroyEntity(bouncer);
}
}
if (bouncer != null && bouncer.HasComponent <MovementComponent>())
{
Vector2 bounceDirection = bouncer.GetComponent <MovementComponent>().MovementVector;
if (bounceDirection.Length() == 0)
{
// Length is zero
bounceDirection = new Vector2(0, 0);
}
else
{
bounceDirection.Normalize();
}
bouncer.GetComponent <MovementComponent>().MovementVector = getReflectionVector(
bounceDirection, reflector.GetComponent <EdgeComponent>().Normal)
* bouncer.GetComponent <MovementComponent>().MovementVector.Length();
}
}
if (reflector.HasComponent <PlayerShieldComponent>())
{
EventManager.Instance.QueueEvent(new ProjectileBouncedEvent(bouncer, bouncer.GetComponent <TransformComponent>().Position, reflector));
Entity playerShip = reflector.GetComponent <PlayerShieldComponent>().ShipEntity;
TransformComponent shipTransformComp = playerShip.GetComponent <TransformComponent>();
TransformComponent shieldTransformComp = reflector.GetComponent <TransformComponent>();
Vector2 shieldNormal = shieldTransformComp.Position - shipTransformComp.Position;
shieldNormal.Normalize();
Vector2 bouncerDirection = bouncer.GetComponent <MovementComponent>().MovementVector;
if (bouncerDirection.Length() == 0)
{
// Length is zero
bouncerDirection = new Vector2(0, 0);
}
else
{
bouncerDirection.Normalize();
}
if (Vector2.Dot(shieldNormal, bouncerDirection) < 0)
{
bouncerDirection = getReflectionVector(bouncerDirection, shieldNormal);
}
bouncer.GetComponent <MovementComponent>().MovementVector = bouncerDirection * (bouncer.GetComponent <MovementComponent>().MovementVector.Length() + playerShip.GetComponent <MovementComponent>().MovementVector.Length());
if (bouncer.HasComponent <ProjectileComponent>() &&
reflector.HasComponent <PlayerShieldComponent>())
{
ProjectileEntity.ConvertToFriendlyProjectile(bouncer);
bouncer.GetComponent <ProjectileComponent>().LastBouncedBy
= reflector.GetComponent <PlayerShieldComponent>().ShipEntity.GetComponent <PlayerComponent>().Player;
}
}
if (reflector.HasComponent <PlayerShipComponent>() && bouncer.HasComponent <PlayerShipComponent>())
{
Vector2 ref2bounce = bouncer.GetComponent <TransformComponent>().Position - reflector.GetComponent <TransformComponent>().Position;
Vector2 bounce2ref = reflector.GetComponent <TransformComponent>().Position - bouncer.GetComponent <TransformComponent>().Position;
ref2bounce.Normalize();
bounce2ref.Normalize();
if (Vector2.Dot(ref2bounce, bounce2ref) < 0)
{
ref2bounce = getReflectionVector(ref2bounce, bounce2ref);
reflector.GetComponent <MovementComponent>().MovementVector = ref2bounce *
(bouncer.GetComponent <MovementComponent>().MovementVector.Length() + reflector.GetComponent <MovementComponent>().MovementVector.Length()) / 2;
bounce2ref = getReflectionVector(bounce2ref, ref2bounce);
bouncer.GetComponent <MovementComponent>().MovementVector = bounce2ref *
(bouncer.GetComponent <MovementComponent>().MovementVector.Length() + reflector.GetComponent <MovementComponent>().MovementVector.Length()) / 2;
}
}
}
protected static void SetProjectileSettings(ProjectileEntity projectile, XmlNode node)
{
float speed = 10f, minDistanceToTarget = 10f;
Vector2 projectileOffset = Vector2.zero;
if (node.SelectSingleNode("./speed") != null)
{
float.TryParse(node.SelectSingleNode("./speed").InnerText, NumberStyles.Float, CultureInfo.InvariantCulture, out speed);
}
if (node.SelectSingleNode("./minDistanceToTarget") != null)
{
float.TryParse(node.SelectSingleNode("./minDistanceToTarget").InnerText, NumberStyles.Float, CultureInfo.InvariantCulture, out minDistanceToTarget);
}
if (node.SelectSingleNode("./offset") != null)
{
float x = 0, y = 0;
float.TryParse(node.SelectSingleNode("./offset").Attributes["x"].Value, NumberStyles.Float, CultureInfo.InvariantCulture, out x);
float.TryParse(node.SelectSingleNode("./offset").Attributes["y"].Value, NumberStyles.Float, CultureInfo.InvariantCulture, out y);
projectileOffset = new Vector2(x, y);
}
projectile.speed = speed;
projectile.minDistanceToTarget = minDistanceToTarget;
projectile.FiringOffset = projectileOffset;
}
void HandleOnTargetHit(ProjectileEntity source, EntityComponent target)
{
//If it was hit by a projectile then unsubscribe from its event.
if (source != null)
{
source.OnProjectileHitTargetEvent -= HandleOnTargetHit;
}
if (audioInfo.audioClipNames.ContainsKey("attackHit"))
SoundEffectManager.PlayClipAtLocation(audioInfo.audioClipNames["attackHit"], target.transform.position);
if (target != null && target.Alive)
target.Damage(attackDamage, myEntityComponent);
//Apply our attack effects.
if (target != null && target.Alive)
{
foreach (EntityModifier modifier in attackModifiers.Values)
{
modifier.DeepClone().Attach(target);
}
}
if (OnTargetHitEvent != null)
OnTargetHitEvent(myEntityComponent, target);
}
public void NpcAttack(NpcEntity npc) // NPC
{
if (npc.health.health <= 0)
{
// do nothing
}
else // NPC ACT
{
gm.movementSystem.SavePosition(npc);
var he = npc.health;
// enemies attack
if (he.npc && he.npc.weaponEntity)
{
he.npc.attackTarget = gm.player;
if (he.npc.weaponEntity.aimType == WeaponEntity.AimType.Cross)
{
if (Mathf.Round(he.transform.position.x) == Mathf.Round(gm.player.transform.position.x) || Mathf.Round(he.transform.position.z) == Mathf.Round(gm.player.transform.position.z))
{
ProjectileEntity projectile = Instantiate(he.npc.weaponEntity.projectile, he.transform.position, Quaternion.identity);
projectile.master = he;
HealthEntity projectileHealth = projectile.GetComponent <HealthEntity>();
projectile.health = projectileHealth;
projectileHealth.proj = projectile;
gm.entityList.AddObject(projectileHealth);
if (gm.player.transform.position.x > projectile.transform.position.x)
{
projectile.direction = new Vector3(1, 0, 0);
}
else if (gm.player.transform.position.x < projectile.transform.position.x)
{
projectile.direction = new Vector3(-1, 0, 0);
}
else if (gm.player.transform.position.z < projectile.transform.position.z)
{
projectile.direction = new Vector3(0, 0, -1);
}
else if (gm.player.transform.position.z > projectile.transform.position.z)
{
projectile.direction = new Vector3(0, 0, 1);
}
projectile.newPos = projectile.transform.position;
he.npc.shotCooldownCurrent = he.npc.shotCooldownMax;
projectiles.Add(projectile);
projectile.telegraphTurn = true;
npc.projectileToFire = projectile;
for (int i = 0; i <= projectile.movementSpeed; i++)
{
Animator newDangerousSprite = Instantiate(projectile.dangerousSprite, projectile.transform.position, Quaternion.identity);
projectile.dangerousSprites.Add(newDangerousSprite);
}
npc.moveCooldown = 1;
StartCoroutine(CalculateDangerousTiles(projectile));
}
}
}
}
}
