public ProjectilePool(ProjectileConfig config, IPlayer player, float size)
{
_size = size;
_projectilePosition = player.View.transform;
_poolSize = config.PoolSize;
_projectileFactory = new ProjectileFactory(config);
}
// Use this for initialization
public void Start()
{
if (!testModeanualHealth)
{
maxHealth = GameManager.getMaxHealth();
}
health = maxHealth;
moveSpeed = defaultMoveSpeed;
_animator = gameObject.GetComponent <Animator>();
_rigidbody = gameObject.GetComponent <Rigidbody2D>();
_trailRenderer = gameObject.GetComponent <TrailRenderer>();
_trailRenderer.material = trailMaterial;
mouseDownLocation = transform.position;
moveTarget = transform.position;
elementType = ElementType.Default;
projectileFactory = GameManager.gm.GetComponent <ProjectileFactory>();
guiManager = GameManager.gm.GetComponent <GUIManager>();
//GetComponent<NetworkAnimator>().SetParameterAutoSend(0, true);
//Custom spawn, not very good..? A lot more work than it should be I think...
//NetworkManager_Custom nw = GameObject.FindGameObjectWithTag("NetworkManager").GetComponent<NetworkManager_Custom>();
//if (transform.position.Equals(new Vector3()))
//{
// Debug.Log("Player at 0");
// transform.position = nw.GetStartPosition().position;
//}
if (isLocalPlayer)
{
guiManager.register(gameObject);
gameObject.layer = 9;
// Cameras are disabled by default, this enables only one camera for each client.
transform.Find("Main Camera").gameObject.SetActive(true);
}
}
void OnEnable()
{
if (!m_Inst)
m_Inst = this;
else if (m_Inst != this)
Destroy(gameObject);
}
private void OnDestroy()
{
if (theProjectileFactory == this)
{
theProjectileFactory = null;
}
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
NativeQueue <ProjectileQueueData> queueData = new NativeQueue <ProjectileQueueData>(Allocator.TempJob);
// set weapon states
JobHandle processWeaponJob = new ProcessWeaponState()
{
inputs = InputQuery.ToComponentDataArray <InputState>(Allocator.TempJob),
inputsOwner = InputQuery.ToComponentDataArray <OwnerID>(Allocator.TempJob)
}.Schedule(this, inputDeps);
// create projectile data for weapons
JobHandle shootJob = new ShootWeaponJob()
{
queueData = queueData.AsParallelWriter()
}.Schedule(this, processWeaponJob);
shootJob.Complete();
// Spawn all of projectiles from the weapons
for (int i = 0; i < queueData.Count; i++)
{
ProjectileQueueData data = queueData.Dequeue();
ProjectileFactory.CreateProjectiles(WeaponParameters.Instance.GetWeaponDataByID(data.WeaponID).projectileId, data.SpawnPos, data.SpawnRot, data.Owner);
}
queueData.Dispose();
return(shootJob);
}
public void StartShootingAtMonster(MonsterView[] monsters)
{
List <MonsterController> controllers = new List <MonsterController>();
foreach (MonsterView view in monsters)
{
if (!(view.Controller.Model).WillDie)
{
controllers.Add(view.Controller);
}
}
if (controllers.Count == 0)
{
return;
}
int randomIndex = random.Next(controllers.Count);
MonsterController monsterController = controllers[randomIndex];
Projectile projectileModel = Model.Shoot(monsterController.Model);
fireCooldownCounter = new Cooldown(Model.AttackSpeed);
if (projectileModel != null)
{
ProjectileController projectileController = ProjectileFactory.CreateProjectile(this, projectileModel, projectileModel.Type);
View.Shoot(monsterController.View, projectileController);
fireCooldownCounter.Reset();
}
}
public static Projectile Postfix(Projectile __result, ProjectileFactory __instance, SpellObject spellObj)
{
var proj = __result;
var being = spellObj.being;
if (!spellObj.tags.Contains(Tag.Weapon) && !spellObj.tags.Contains(Tag.Drone))
{
if (proj.damage > 0)
{
var totalSpellpower = being.GetAmount(Status.SpellPower);
if ((bool)being.player)
{
totalSpellpower += being.player.spellPower;
}
// unadjust the damage
proj.damage -= totalSpellpower;
proj.damage += (int)CalcDamage(proj.damage, totalSpellpower);
if (proj.damage < 1)
{
proj.damage = 1;
}
}
}
return(proj);
}
private ShipModel LoadPlayerShipModel(ProjectileFactory projectileFactory)
{
var sprite = new Sprite(Image.FromFile("Assets/player/ship2.png"));
var model = new ShipModel(sprite, 1.0f, 100, projectileFactory, TimeSpan.FromSeconds(2), StandardShipDamage);
return(model);
}
protected override void Shoot()
{
PlayerProjectile projectile = ProjectileFactory.CreateProjectile(ProjectileType.PLAYER) as PlayerProjectile;
projectile.transform.position = shootPosition.position;
projectile.Launch(shootPosition.forward, ShoudProjectileRecochet(), GameField);
}
public IEnumerator TestAoeOnMovingEnemy()
{
GameObject maincanvas = Instantiate(Resources.Load("Tests/maincanvas")) as GameObject;
GameObject maincamera = Instantiate(Resources.Load("Tests/maincamera")) as GameObject;
GameObject gm = Instantiate(Resources.Load("Tests/GameManager")) as GameObject;
var enemy = Resources.Load("Tests/Enemy_Bat 1");
Vector2 startposition = new Vector2(0.0f, 0.0f);
Vector2 endposition = new Vector2(0.0f, 10.0f);
GameObject enemy1 = Instantiate(enemy, endposition, new Quaternion()) as GameObject;
//GameObject enemy2 = Instantiate (enemy, new Vector2 (0.0f, 20.0f), new Quaternion()) as GameObject;
int startHealth = enemy1.GetComponentInChildren <Enemy>().hp;
NetworkServer.Listen(7777);
yield return(new WaitForSeconds(1));
ProjectileFactory projectileFactory = gm.GetComponent <ProjectileFactory> ();
PlayerController.ElementType element = PlayerController.ElementType.Water;
int level = 2;
GameObject projectileClone = Instantiate(Resources.Load("Tests/WaterProjectile2"), startposition, new Quaternion()) as GameObject;
projectileClone.GetComponent <ProjectileController>().belongsToPlayer();
Vector2 shootDirection = new Vector2(0.0f, 1.0f);
Vector2 velocity = shootDirection.normalized * projectileClone.GetComponent <ProjectileController> ().projectileSpeed;
float rotation = Mathf.Atan2(shootDirection.y, shootDirection.x) * Mathf.Rad2Deg;
int projectiledamage = projectileClone.GetComponent <ProjectileController> ().projectileDamage;
int aoedamage = projectileClone.GetComponent <ProjectileController> ().AOEExplosionPrefab.GetComponent <AOEExplosion> ().AOEDamage;
float endTime = Time.time + 5.0f;
bool once = true;
bool once2 = true;
enemy1.GetComponentInChildren <Enemy> ().moveSpeed = 0.1f;
while (Time.time < endTime)
{
//if (enemy1.GetComponentInChildren<Enemy>().hp<startHealth && once){
if (once)
{
GameObject waypoint = GameObject.FindGameObjectWithTag("WayPoint");
waypoint.transform.position = new Vector2(0.0f, 20.0f);
once = false;
}
if (endTime - Time.time < 4.0f && once2)
{
projectileClone.GetComponent <ProjectileController> ().setVelocityAndRotation(velocity, rotation);
once2 = false;
}
yield return(new WaitForEndOfFrame());
}
int totaldamage = projectiledamage + aoedamage;
int expectedhealth = startHealth - totaldamage;
GameObject newenemy = GameObject.FindGameObjectWithTag("Enemy");
int actualhealth = newenemy.GetComponent <Enemy> ().hp;
Assert.AreEqual(expectedhealth, actualhealth);
}
protected IEnumerator CreateProjectileBurst()
{
WaitForSeconds delay = new WaitForSeconds(projectileInfo.burstDelay);
int count = projectileInfo.projectileCount;
for (int i = 0; i < count; i++)
{
Projectile shot = ProjectileFactory.CreateProjectile(projectileInfo, effectOrigin, ParentAbility.Source, i);
shot.Initialize(this);
if (projectileInfo.addInitialForce == true)
{
Vector2 force = projectileInfo.initialForce.CalcDirectionAndForce(shot.gameObject, Source);
shot.GetComponent <Rigidbody2D>().AddForce(force);
}
if (projectileInfo.burstDelay > 0)
{
yield return(delay);
}
else
{
yield return(null);
}
}
}
private ProjectileFactory LoadProjectileFactory()
{
var image = Image.FromFile("Assets/projectiles/shotoval.png");
var sprite = new Sprite(image);
var factory = new ProjectileFactory(sprite, 10);
return(factory);
}
protected override void OverrideProperties()
{
Projectile = ProjectileFactory.CreateHomingProjectile();
ProjectilesPerShot = 2;
MaxOffsetAngle = 10;
SecondsBetweenShots = 0.7f;
ProjectileShooterName = "Alien Gun";
}
public GameObject Spawn(ProjectileInfo info, float angle)
{
Quaternion projectileRotation = MathfExt.QuaternionFromAngle2D(angle);
GameObject projectile = ProjectileFactory.Create(info.ProjectileType, transform.position, projectileRotation, info.CollisionLayer);
projectile.GetComponent <IProjectileLogic>().OnInitialize(info, projectileRotation * Vector2.up);
return(projectile);
}
// Use this for initialization
void Start()
{
projectilePool.Initialize();
GenerateTypeMap();
theProjectileFactory = this;
}
public override void DoInitialProjectileSubAbility(ProjectileAbility pa)
{
GameObject tempProjectile;
tempProjectile = ProjectileFactory.ProduceProjectile(projectilePrefab, pa.ability, pa.sources[0].position, pa.quatProjectileFireAngle);
pa.projectilesFired++;
EndProjectileSubAbility();
}
public ShipModel(Sprite sprite, float velocity, int health, ProjectileFactory projectileFactory, TimeSpan coolDown, int damage) : base(sprite)
{
Health = health;
Velocity = velocity;
ProjectileFactory = projectileFactory;
CoolDown = coolDown;
Damage = damage;
}
public void ShootAt(Vector3 targetPosition)
{
transform.LookAt(targetPosition);
if (Time.time > lastAttackTime + coolDown)
{
ProjectileFactory.Create(opposantLayerMask, transform.position, transform.rotation);
lastAttackTime = Time.time;
}
}
public override void DoProjectileSubAbility(ProjectileAbility pa)
{
//Fireable and my projectile factory gauruntees that projectile will have a rigidbody. ProjectileFactory is hooked up to my pooler which duplicates the functionality of instantiate,
//but insures that we wont be endlessly instantiating objects that already exist in deactivated states.
projectileInstance = ProjectileFactory.ProduceProjectile(projectilePrefab.gameObject, pa.ability, pa.sources[0].position, pa.quatProjectileFireAngle);
projectileInstance.GetComponent <Rigidbody2D>().AddForce(projectileInstance.transform.right * pa.power, ForceMode2D.Impulse);
pa.projectilesFired++;
EndProjectileSubAbility();
}
protected override void Shoot()
{
EnemyProjectile projectile = ProjectileFactory.CreateProjectile(ProjectileType.ENEMY) as EnemyProjectile;
projectile.transform.position = shootPosition.position;
Transform playerTransform = FindObjectOfType <PlayerView>().transform;
projectile.Launch(playerTransform, this);
}
private List <ShipModel> LoadShipModels(ProjectileFactory factory)
{
var list = new List <ShipModel>();
var image = Image.FromFile("Assets/enemies/kamikaze.png");
var sprite = new Sprite(image);
var model = new ShipModel(sprite, 0.25f, 10, factory, TimeSpan.FromSeconds(2), StandardShipDamage);
list.Add(model);
return(list);
}
private void _fireProjectile()
{
if ((DateTime.Now.Ticks - _fireInterval) > _lastFired)
{
var projectileFactory = ProjectileFactory.GetInstance();
projectileFactory.AddStandardProjectile(_location, _direction, Color.Red);
SoundEffectEngine.GetInstance().PlayLaserShot();
_lastFired = DateTime.Now.Ticks;
}
}
protected override void OverrideProperties()
{
ProjectilesPerShot = 1;
SecondsBetweenShots = 0.3f;
MaxOffsetAngle = 2;
Ammo = 100;
MagSize = 100;
ProjectileShooterName = "Rocket Launcher";
Projectile = ProjectileFactory.CreateRocket();
}
// Update is called once per frame
void Update()
{
timeTillNextSpawn -= Time.deltaTime;
if (timeTillNextSpawn < 0)
{
timeTillNextSpawn = timeBetweenSpawns;
ProjectileFactory.CreateProjectiles(ProjectileID, transform.position, transform.rotation, 0);
}
}
public AbstractProjectile Get()
{
if (_queue.Count > 0)
{
return(_queue.Dequeue());
}
var projectileScene = ProjectileFactory.CreateBullet();
return(projectileScene.Instance() as AbstractProjectile);
}
public override void DoInitialProjectileSubAbility(ProjectileAbility pa)
{
if (curProjectile == null)
{
curProjectile = ProjectileFactory.ProduceProjectile(projectilePrefab, pa.ability);
}
curProjectile.transform.position = pa.sources[0].position;
curProjectile.transform.rotation = pa.quatProjectileFireAngle;
curProjectile.SetActive(true);
pa.projectilesFired++;
}
public void Attack(Rigidbody2D body, int damage, Vector2 direction)
{
ProjectileFactory fac = new ProjectileFactory();
GameObject proj = Object.Instantiate(fac.GetProjectile(EnemyType.Demon).GetProjectilePrefab(), body.position, new Quaternion());
proj.GetComponent <Rigidbody2D>().velocity = direction * proj.GetComponent <Projectile>().speed;
proj.GetComponent <Rigidbody2D>().rotation = 0;
body.velocity = Vector2.zero;
//proj.GetComponent<Projectile>().damage = damage;
//yield return new WaitForSeconds(1f);
}
public void SetDependencies(GameState gameState, ProjectileFactory projectileFactory,
IInputSystem inputSystem, ProjectileDataContainer projectileDataContainer, QTEController qteController, AudioManager audioManager)
{
_spriteRenderer = GetComponent <SpriteRenderer>();
_gameState = gameState;
_qteController = qteController;
_rigidBody2d = GetComponent <Rigidbody2D>();
_animationController = new AnimationController(_animator);
_movementController = new MovementController(_rigidBody2d, _data, gameState, transform, _animationController);
_shootingController = new ShootingController(projectileFactory, _shootingPivot, gameState, inputSystem,
projectileDataContainer, _data, transform, _arm, audioManager);
}
protected void DeliverProjectiles()
{
if (projectileInfo.projectileCount == 1)
{
Projectile shot = ProjectileFactory.CreateProjectile(projectileInfo, effectOrigin, ParentAbility.Source);
shot.Initialize(this);
}
else
{
ParentAbility.Source.GetMonoBehaviour().StartCoroutine(CreateProjectileBurst());
}
}
public void GetAndRelease(AbstractGameObject player)
{
if (availableFireballs > 0)
{
availableFireballs--;
FireBall newFireball = (FireBall)ProjectileFactory.Create(ProjectileType.FireBall, player, GetPosition(player));
FireBalls.Add(newFireball);
newFireball.CoolDown = 0;
GameGrid.Instance.Add(newFireball);
EventManager.Instance.TriggerFireballFire(newFireball);
}
}
public void Update()
{
if (deathTime <= Time.time)
{
Debug.Log(fireable);
Debug.Log(fireable.sourceAbility);
ProjectileFactory.ProduceProjectile(objectToTurnOn, fireable.sourceAbility, transform.position);
if (turnOffSelfOnTime)
{
gameObject.SetActive(false);
}
}
}
public override void Initialize(GameObject parent)
{
rifleSprite = Resources.Load<Sprite>(@"temp_rifle");
projectileFactory = Resolver.Instance.GetController<ProjectileFactory>();
}
