private IEnumerator GrabProjectiles(PlayerController owner)
{
Collider[] enemyProjectiles = Physics.OverlapSphere(owner.transform.position, m_radius, m_grabMask, QueryTriggerInteraction.Collide);
//Do some sort of visual here
if (enemyProjectiles.Length == 0)
{
//If anyprojectiles are near but not caught, minus the grab skill
enemyProjectiles = Physics.OverlapSphere(owner.transform.position, m_missRadius, m_grabMask, QueryTriggerInteraction.Collide);
if (enemyProjectiles.Length != 0)
{
CurveFlowManager.AppendValue("GrabSkill", 0.0f);
}
//Spell has not gotten a projectile, don't lock casting and just let the whiff animation play
yield return(null);
}
else
{
//Spell has gotten at least one projectile, grab them and enter into the special mode for it
owner.m_abilityManager.m_isCasting = true;
float DRAWTIME = 0.6f;
//Disable their projectileMovement scripts and then pull all them in all fancy like
for (int j = 0; j < enemyProjectiles.Length; j++)
{
ProjectileMovement proj = enemyProjectiles[j].GetComponent <ProjectileMovement>();
owner.StartCoroutine(DrawInProjectile(owner, proj, DRAWTIME));
CurveFlowManager.AppendValue("GrabSkill", 1.0f);
}
yield return(new WaitForSeconds(DRAWTIME));
owner.m_abilityManager.SetGrab(enemyProjectiles.Length);
owner.m_abilityManager.m_isCasting = false;
}
}
public void SetProjectile(SpellCreationSegment seg, ProjectileSpellBook sp)
{
spellSeg = seg;
if (pm == null)
{
pm = gameObject.GetComponent <ProjectileMovement>();
}
pm.speed = seg.GetSpeed();
pm.turnSpeed = seg.GetTurnSpeed();
spell = sp;
string[] layers = sp.layerMaskNames;
foreach (Transform child in transform)
{
if (sp.source == ProjectileSpellBookBuilder.spellSource.enemy)
{
child.gameObject.layer = LayerMask.NameToLayer("ProjectileEnemy");
}
else if (sp.source == ProjectileSpellBookBuilder.spellSource.player)
{
child.gameObject.layer = LayerMask.NameToLayer("ProjectilePlayer");
}
else
{
child.gameObject.layer = LayerMask.NameToLayer("ProjectileNeutral");
}
child.gameObject.GetComponent <MovementCheck>().layerMask = LayerMask.GetMask(layers);
}
}
void shoot()
{
if (reloadTimer > timeToReload)
{
// check if there are any targets within range
if (playerList.Count > 0)
{
anim.SetTrigger("attack");
reloadTimer = 0;
//shoot at each player in range
GameObject obj = playerList[0];
// Create the projectile and Access its Rigidbody to add force
Vector3 startPosition = gameObject.transform.position;
Vector3 targetPosition = obj.transform.position;
GameObject newProjectile = (GameObject)Instantiate(projectile, gameObject.transform.position, gameObject.transform.rotation);
newProjectile.transform.position = startPosition;
ProjectileMovement bulletComp = newProjectile.GetComponent <ProjectileMovement>();
bulletComp.target = obj.gameObject;
bulletComp.startPosition = startPosition;
bulletComp.targetPosition = targetPosition;
}
}
else
{
reloadTimer += Time.deltaTime;
}
}
private void ShootProjectile()
{
GameObject projectileGameObject = _objectPooler.SpawnFromPool(currentWeapon.Projectile.ToString(), _weaponTransform.position, Quaternion.identity);
ProjectileMovement projectileInstance = projectileGameObject?.GetComponent <ProjectileMovement>();
projectileInstance?.SetRotation(_weaponTransform.rotation);
}
protected void ShootProjectile()
{
Vector3 vectorToEnemy = troopObjective.transform.position - this.transform.position;
ProjectileMovement projectileSpawned = Instantiate(projectile, new Vector3(this.transform.position.x, this.transform.position.y, -0.5f), Quaternion.LookRotation(vectorToEnemy)) as ProjectileMovement;
projectileSpawned.target = troopObjective;
}
// Update is called once per frame
void Update()
{
#region User movement input
//translate/rotate
float xAxis = Input.GetAxis("Horizontal");
float yAxis = Input.GetAxis("Vertical");
transform.Translate(xAxis * Time.deltaTime * speed, yAxis * Time.deltaTime * speed, 0.0f);
//transform.Translate(0.0f, yAxis * Time.deltaTime * speed, 0.0f);
//transform.Rotate(transform.forward, - xAxis * Time.deltaTime * turnSpeed);
//clamp to world
levelBehavior.ClampToWorld(transform, 5.0f);
#endregion
#region Fire projectile
if (Input.GetAxis("Fire1") > 0f) //Left-Control
{
if (delayCount-- <= 0 && Projectile != null)
{
GameObject e = Instantiate(Projectile) as GameObject;
ProjectileMovement proj = e.GetComponent <ProjectileMovement>();
if (null != proj)
{
e.transform.position = transform.position;
//change projectile direction
switch (currentFacing)
{
case Facing.East:
proj.SetForwardDirection(transform.right);
break;
case Facing.West:
proj.SetForwardDirection(-transform.right);
break;
case Facing.South:
proj.SetForwardDirection(-transform.up);
break;
default:
proj.SetForwardDirection(transform.up);
break;
}
}
delayCount = recastDelay;
}
}
#endregion
//Toggle movement
if (Input.GetButtonUp("Jump"))
{
levelBehavior.Movement = !levelBehavior.Movement;
}
//Update facing
updateFacing(xAxis, yAxis);
}
// Update is called once per frame
void Update()
{
if (AmmoText != null)
{
AmmoText.text = CurrentLoad.ToString() + "/" + Magazine.ToString();
}
if (Input.GetMouseButtonDown(0) && !OnCooldown && !OnReload && CurrentLoad > 0)
{
GameObject tmp_cb = Instantiate(Projectile, transform.position, transform.rotation);
ProjectileMovement tmp_cb_c = tmp_cb.GetComponent <ProjectileMovement> ();
tmp_cb_c.InitialVelocity = parentRB.velocity;
//tmp_cb_c.Damage += AddDamage;
CurrentLoad--;
OnCooldown = true;
if (CurrentLoad == 0)
{
OnReload = true;
StartCoroutine(Reload());
}
else
{
StartCoroutine(Cooldown());
}
}
}
private void OnTriggerEnter(Collider other)
{
if (m_isDead)
{
return;
}
//enemy projectile
if (other.gameObject.layer == 12)
{
if (!m_invincible)
{
ProjectileMovement proj = other.gameObject.GetComponent <ProjectileMovement>();
if (proj != null && proj.gameObject.layer == 12)
{
TakeDamage(proj.m_damage);
proj.gameObject.SetActive(false);
//If they got hit by a projectile and could have grabbed it
if (m_abilityManager.IsGrabAvalible())
{
CurveFlowManager.AppendValue("GrabSkill", 0.0f);
}
}
else
{
Debug.Log("Hit by unkown object: " + other.gameObject.name);
}
}
}
//room trigger
else if (other.gameObject.layer == 16)
{
other.gameObject.SetActive(false);
WorldController.i.StartCombat(other.transform.parent);
}
}
public override void Cast(PlayerController owner)
{
ProjectileMovement proj = Instantiate(m_projectilePrefab, owner.transform.position +
(owner.transform.rotation * owner.m_projectileSpawnOffset), owner.transform.rotation).GetComponent <ProjectileMovement>();
proj.m_speed = m_projectileSpeed;
proj.m_damage = m_damage;
}
void Start()
{
hpController = GameObject.FindGameObjectWithTag("HpController").transform.GetComponent <HpController>();
physicsObject = GetComponent <PhysicsObject>();
spriteRenderer = GetComponent <SpriteRenderer>();
projectileMovement = ProjectilePrefab.GetComponent <ProjectileMovement>();
projectileRadius = projectileMovement.transform.localScale.x * projectileMovement.transform.GetComponent <CircleCollider2D>().radius;
playerRadius = transform.localScale.x * transform.GetComponent <CircleCollider2D>().radius;
}
private void Fire()
{
m_anim.SetTrigger("Attack");
ProjectileMovement bullet = Instantiate(m_projectilePrefab, transform.TransformPoint(m_projectileSpawnPosition), transform.rotation).GetComponent <ProjectileMovement>();
bullet.m_speed = m_projectileSpeed;
bullet.m_damage = m_attackDamage;
bullet.transform.Rotate(0, Random.Range(-m_attackSpread, m_attackSpread), 0);
}
public virtual void Attack(Vector3 attackDirection)
{
GameObject projectile = Instantiate(ProjectilePrefab, transform.position - attackDirection, Quaternion.identity) as GameObject;
ProjectileMovement mov = projectile.GetComponent <ProjectileMovement>();
mov.Rotate(attackDirection);
ProjectileDamage damage = projectile.GetComponent <ProjectileDamage>();
damage.Creator = transform;
}
protected override void ComputeVelocity()
{
Vector2 move = Vector2.zero;
move.x = Input.GetAxis("Horizontal");
if (Input.GetButtonDown("Jump") && grounded)
{
velocity.y = jumpTakeOffSpeed;
}
else if (Input.GetButtonUp("Jump"))
{
if (velocity.y > 0)
{
velocity.y = velocity.y * .5f;
}
}
if (move.x > 0)
{
spriteRenderer.flipX = false;
}
else if (move.x < 0)
{
spriteRenderer.flipX = true;
}
flipOld = spriteRenderer.flipX;
if (move.x == 0)
{
spriteRenderer.flipX = flipOld;
}
if (Input.GetButtonDown("Fire1") && defaultProjectile)
{
GameObject instProj;
if (spriteRenderer.flipX == false && canShot)
{
instProj = Instantiate(defaultProjectile, projSpawn.position, new Quaternion());
ProjectileMovement projMov = instProj.GetComponent <ProjectileMovement>();
projMov.flipProj = spriteRenderer.flipX;
}
else if (spriteRenderer.flipX == true && canShot)
{
instProj = Instantiate(defaultProjectile, projSpawnBis.position, new Quaternion());
ProjectileMovement projMov = instProj.GetComponent <ProjectileMovement>();
projMov.flipProj = spriteRenderer.flipX;
}
}
targetVelocity = move * maxSpeed;
Debug.Log("hp =" + hp);
}
public override void Cast(PlayerController owner)
{
GameObject bullet = Instantiate(m_projectilePrefab, owner.transform.position + (owner.transform.rotation * owner.m_projectileSpawnOffset), owner.transform.rotation);
bullet.transform.Rotate(0, Random.Range(-m_bulletSpread, m_bulletSpread), 0);
bullet.transform.GetChild(0).rotation = Random.rotation;
ProjectileMovement proj = bullet.GetComponent <ProjectileMovement>();
proj.m_damage = m_damage;
proj.m_speed = m_bulletSpeed;
}
void Update()
{
firingTimePassed += Time.deltaTime;
if (firingTimePassed >= firingDelay)
{
firingTimePassed = 0;
GameObject projectile = projectileSpawner.SpawnObject();
ProjectileMovement projectileMovement = projectile.GetComponent <ProjectileMovement> ();
projectileMovement.speed = projectileSpeed;
projectileMovement.horizontalDirection = spawnDirection;
messenger.Invoke(Message.PROJECTILE_FIRED, null);
}
}
private void SpawnPerFrame()
{
if (spawnCounter >= spawnFrame)
{
ProjectileMovement spawned = Instantiate <ProjectileMovement>(spawnPrefab);
spawned.Setup(transform.position, target.transform.position, 0.1f);
spawnCounter = 0;
}
else
{
spawnCounter++;
}
}
// Update is called once per frame
void FixedUpdate()
{
var x = Input.GetAxisRaw("Fire1");
var y = Input.GetAxis("Fire2");
if ((x != 0 || y != 0) && !GameObject.Find(ball.name + "(Clone)"))
{
instantBall = Instantiate(ball, new Vector3(transform.position.x + x, transform.position.y + y, transform.position.z), Quaternion.identity);
instantBall.AddComponent(typeof(ProjectileMovement));
projScript = instantBall.GetComponent <ProjectileMovement>();
projScript.SetDir(new Vector2(x, y));
}
}
protected override IEnumerator InnerDoAttack(int id, CombatSystem ownerCombatSystem, Transform target)
{
if (target == null)
{
yield break;
}
while (!AnimationStates[id])
{
yield return(null);
}
GameObject projectile = PoolersManager.Instance.TryGetPooler(data.ProjectilePrefab).GetPooledObject(data.DestroyTime);
projectile.transform.position = ownerCombatSystem.ProjectileAnchor.position;
projectile.transform.rotation = ownerCombatSystem.ProjectileAnchor.rotation;
AttackCollider projectileAttackCollider = projectile.GetComponentInChildren <AttackCollider>();
projectileAttackCollider.Initialize(id, data.ColliderRadius, this, ownerCombatSystem.transform.root, ownerCombatSystem);
projectileAttackCollider.SetRadius(data.ColliderRadius);
ProjectileMovement projectileMovement = projectile.GetComponent <ProjectileMovement>();
projectileMovement.Launch(target, ownerCombatSystem.ProjectileAnchor, data.MinDistance, data.MaxDistance, data.ProjectileSpeed);
float timer = 0.0f;
while (timer <= data.DestroyTime)
{
if (HasHit[id])
{
projectileMovement.Stop();
if (!data.SplashDamage)
{
yield break;
}
projectileAttackCollider.SetRadius(data.SplashDamageRadius);
yield return(new WaitForSeconds(data.SplashDamageTime));
yield break;
}
timer += Time.deltaTime;
yield return(null);
}
}
private void OnTriggerEnter(Collider other)
{
ProjectileMovement proj = other.gameObject.GetComponent <ProjectileMovement>();
if (proj != null && proj.gameObject.layer == 11)
{
TakeDamage(proj.m_damage);
proj.CollideWithObject();
}
else
{
Debug.Log("Hit by unkown object: " + other.gameObject.name);
}
}
private void OnCollisionEnter2D(Collision2D collision)
{
if (collision.collider.tag == "ProjectilePlayer")
{
Physics2D.IgnoreCollision(collision.collider.GetComponent <Collider2D>(), GetComponent <Collider2D>());
}
if (collision.collider.tag == "Projectile")
{
Physics2D.IgnoreCollision(collision.collider.GetComponent <Collider2D>(), GetComponent <Collider2D>());
ProjectileMovement proj = collision.collider.GetComponent <ProjectileMovement>();
hp = hp - proj.damage;
isTakingDamage = true;
Destroy(collision.collider.gameObject);
}
}
void Awake()
{
Damage = ScriptableObject.Instantiate(Damage);
Direction = ScriptableObject.Instantiate(Direction);
Velocity = ScriptableObject.Instantiate(Velocity);
ProjectileMovement movement = GetComponent <ProjectileMovement>();
movement.Direction.InstanceVariable = Direction;
movement.Velocity.InstanceVariable = Velocity;
ProjectileDamage damage = GetComponent <ProjectileDamage>();
damage.Damage.InstanceVariable = Damage;
}
void spawnVFX()
{
GameObject vfx; // i guess the way instantite() works this doesnt go out of scope
//if(firePoint != null) {
vfx = Instantiate(effectToSpawn, gameObject.transform.position, Quaternion.identity); //firePoint.transform.position, Quaternion.identity);
//}
vfx.transform.right = rotateToMouse.getRotation();
ProjectileMovement projectile = vfx.GetComponent <ProjectileMovement>();
projectile.timeCreated = Time.timeSinceLevelLoad;
// Destroy(vfx, 2.0f);
}
void Fire(Vector2 direction)
{
ProjectileMovement b = (ProjectileMovement)Instantiate(bullet, spawn.position, gun.rotation);
if (transform.localScale.x > 0f)
{
b.transform.localEulerAngles = new Vector3(0f, 0f, rotation);
}
else
{
b.transform.localEulerAngles = new Vector3(0f, 0f, -rotation);
}
b.direction = direction;
lastFire = Time.time;
}
private IEnumerator DrawInProjectile(PlayerController owner, ProjectileMovement proj, float time)
{
proj.enabled = false;
proj.GetComponent <Collider>().enabled = false;
float timer = 0f;
Vector3 startPos = proj.transform.position;
while (timer < time)
{
float percent = timer / time;
proj.transform.localScale = Vector3.one * (1f - percent);
proj.transform.position = Vector3.Slerp(startPos, owner.transform.TransformPoint(owner.m_projectileSpawnOffset), percent);
timer += Time.deltaTime;
yield return(null);
}
Destroy(proj.gameObject);
}
void FireProjectile()
{
Vector3 ProjectileDirection = Vector3.zero;
if (playerMovementComponent)
{
// Debug.Log("Im shooting in the direction " + playerMovementComponent.PlayerDirection);
switch (playerMovementComponent.PlayerDirection)
{
case PlayerMovementScript.EnumPlayerDirection.Up:
ProjectileDirection.y = 1;
break;
case PlayerMovementScript.EnumPlayerDirection.Left:
ProjectileDirection.x = -1;
break;
case PlayerMovementScript.EnumPlayerDirection.Right:
ProjectileDirection.x = 1;
break;
case PlayerMovementScript.EnumPlayerDirection.Down:
ProjectileDirection.y = -1;
break;
}
}
SkeletonAnimation skeletonAnimation = playerMovementComponent.GetSkeleton();
Spine.Bone bone = skeletonAnimation.skeleton.FindBone("Prcs_arm_back_empty5");
Vector3 weaponSlotPosition = skeletonAnimation.transform.TransformPoint(new Vector3(bone.WorldX, bone.WorldY, 0f));
Vector2 ProjectileSpawnLocation = weaponSlotPosition;
GameObject CreatedProjectile = Instantiate(ProjectilePrefab, ProjectileSpawnLocation, Quaternion.identity, null);
ProjectileMovement projectileMovement = CreatedProjectile.GetComponent <ProjectileMovement>();
if (projectileMovement)
{
// Debug.Log(ProjectileDirection);
projectileMovement.SetLaunchDirection(ProjectileDirection);
}
SpawnedProjectile = CreatedProjectile;
}
float CalculateDps()
{
float rate = (rate1 * (weaponModuleBase.data.rafaleCount - 1.0f) + rate2) / weaponModuleBase.data.rafaleCount;
ProjectileMovement pm = weaponModuleMagazine.projectilsPool.pooledObject.GetComponent <ProjectileMovement>();
float dmg;
if (pm)
{
dmg = pm.data.damages;
}
else
{
Debug.Log("prout");
dmg = 0.0f;
}
return((weaponModuleCannon.cannons.Length * dmg) / rate);
}
private void Awake()
{
_ProjectileMovement = GetComponent <ProjectileMovement>();
waitMissileDisable = new WaitUntil(() => (Vector3.Distance(_InitialPosition, transform.position) > 30.0f));
_ProjectileMovement.detectableLayer = 1 << LayerMask.NameToLayer("PlayerableCharacter");
_ProjectileMovement.onProjectileOverlapped += (collider, projectilePosition) =>
{
var sceneInstance = SceneManager.Instance.sceneInstance as GameSceneInstance;
// 플레이어블 캐릭터에게 피해를 가합니다.
sceneInstance.allocatedCharacters[collider].ApplyDamage(
_EnemyCharacter, this, 20.0f);
// 미사일 비활성화
DisableMissile();
};
}
private void Awake()
{
if (movement == null)
{
movement = GetComponent <ProjectileMovement>();
}
if (detect == null)
{
detect = GetComponent <ProjectileDetect>();
}
if (impact == null)
{
impact = GetComponents <ProjectileImpact>();
}
trans = transform;
rd = model.GetComponent <SpriteRenderer>();
}
private void OnCollisionEnter(Collision collision)
{
// Debug.Log("Collision!");
ProjectileMovement pm = collision.collider.GetComponentInParent <ProjectileMovement>();
if (pm)
{
//this.enabled = false;
//if (!explosion.isPlaying)
//{
// explosion.Play();
//}
Destroy(pm.gameObject);
Explode();
Debug.Log("Destoryed!" + count);
}
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
testBulletObj = pooler.SpawnFromPool("Bullet01", muzzle.position, muzzle.rotation);
if (testBulletObj.TryGetComponent(out ProjectileMovement projectile))
{
testProjectile = projectile;
testProjectile.SetVelocity(bulletSpeed, muzzle.forward);
testProjectile = null;
testBulletObj = null;
}
}
}
// Use this for initialization
void Start()
{
projectileMovement = new Orbital(shooter, this);
}
