void spawnProjectileDualBullets(BulletTypes type, float facingFloat, float verticalOffset)
{
bulletCost++;
if (bulletCost >= 2)
{
bulletCost = 0;
LoseKinergy(1);
}
BoxCollider box = this.GetComponent <BoxCollider> ();
Vector3 spawnPosition;
if (facingFloat == 1f)
{
spawnPosition = new Vector3(box.bounds.max.x + 0.35f, box.bounds.center.y + verticalOffset, box.bounds.max.z + 0.01f);
}
else
{
spawnPosition = new Vector3(box.bounds.min.x - 0.35f, box.bounds.center.y + verticalOffset, box.bounds.max.z + 0.01f);
}
var bullet = (GameObject)Instantiate(projectileDualBullets, spawnPosition, Quaternion.identity, this.transform);
SpriteRenderer sr = bullet.GetComponent <SpriteRenderer> ();
ProjectileProperties projProp = bullet.GetComponent <ProjectileProperties> ();
if (facingFloat != 1f)
{
sr.flipX = true;
}
projProp.Fire(facingFloat, 3, 1f, type);
}
public void SetBulletType(BulletTypes type)
{
// set sprite image & collider radius
sprite.sprite = bulletData[(int)type].sprite;
cc2d.radius = bulletData[(int)type].radius;
transform.localScale = bulletData[(int)type].scale;
}
public Bullet CreateBullet(BulletTypes type, Vector2 pos)
{
Vector2 randV2 = UnityEngine.Random.insideUnitCircle.normalized * 5;
GameObject toRetObj = null;
IPoolable poolable = ObjectPool.Instance.RetrieveFromPool(type);
if (poolable != null)
{
toRetObj = poolable.GetGameObject;
}
else
{
toRetObj = _CreateBullet(type).gameObject;
}
Bullet toRet = toRetObj.GetComponent <Bullet>();
if (!toRet)
{
Debug.LogError("Something went wrong in bullet factory, object: " + toRetObj.name + " did not contain a bullet script. Returning Null");
}
else
{
toRet.transform.position = pos;
BulletManager.Instance.Addbullet(toRet);
}
return(toRet);
}
public void spawnProjectile(BulletTypes type)
{
BoxCollider box = this.GetComponent <BoxCollider> ();
float facingFloat = (facing == FacingDirection.East) ? 1f : -1f;
if (type == BulletTypes.KinergyBulletFront)
{
verticalOffset = 0.008f;
spawnProjectileKinergyBullets(type, verticalOffset, facingFloat);
}
else if (type == BulletTypes.KinergyBulletBack)
{
verticalOffset = 0.008f;
spawnProjectileKinergyBullets(type, verticalOffset, facingFloat);
}
else if (type == BulletTypes.KinergyBulletUp)
{
verticalOffset = 0.02f;
spawnProjectileKinergyBullets(type, verticalOffset, facingFloat);
}
else if (type == BulletTypes.DualBullets1 || type == BulletTypes.DualBullets2 || type == BulletTypes.DualBullets3 ||
type == BulletTypes.DualBullets4 || type == BulletTypes.DualBullets5 || type == BulletTypes.DualBullets6)
{
spawnProjectileDualBullets(type, facingFloat, verticalOffset);
}
else if (type == BulletTypes.Nuke)
{
spawnProjectileNuke(type, facingFloat, verticalOffset);
}
}
public GameObject createBullet(BulletTypes type = BulletTypes.RANDOM)
{
if (type == BulletTypes.RANDOM)
{
var randombullet = Random.Range(0, 3);
type = (BulletTypes)randombullet;
}
GameObject tempBullet = null;
switch (type)
{
case BulletTypes.REGULAR:
tempBullet = Instantiate(regularBullet);
tempBullet.GetComponent <BulletController>().damage = 10;
break;
case BulletTypes.FAT:
tempBullet = Instantiate(fatBullet);
tempBullet.GetComponent <BulletController>().damage = 20;
break;
case BulletTypes.PULSING:
tempBullet = Instantiate(pulsinBullet);
tempBullet.GetComponent <BulletController>().damage = 30;
break;
}
tempBullet.transform.parent = transform;
tempBullet.SetActive(false);
return(tempBullet);
}
public Bullet(Vector2 Position, Color[] Mask, int AnimationIndex, AnimatedSprite Clone, BulletTypes BulletType = BulletTypes.Normal)
: base(Clone.ActiveSprite, Mask, Clone.AnimationFrameCount, Clone.Origin, Clone.AnimationSpeed)
{
this.Position = Position;
SpriteSource.X = AnimationIndex * SpriteWidth;
Speed = new Vector2();
this.BulletType = BulletType;
}
private HashSet <BaseBulletController> GetBulletHashSet(BulletTypes type)
{
if (!_bulletPool.ContainsKey(type))
{
_bulletPool[type] = new HashSet <BaseBulletController>();
}
return(_bulletPool[type]);
}
public BulletConfig(BulletTypes bulletType, float maxVelocity, Texture2D texture, Rectangle drawRectangle, float initialDamage, float bounce, TimeSpan fireDelay)
{
BulletType = bulletType;
MaxVelocity = maxVelocity;
Texture = texture;
DrawRectangle = drawRectangle;
InitialDamage = initialDamage;
Bounce = bounce;
FireDelay = fireDelay;
}
public void Construct(float speed, float lifeTime, BulletTypes type)
{
_type = type;
_speed = speed;
_lifeTime = lifeTime;
_renderer.material = type == BulletTypes.FromEnemy ? _enemyMaterial : _playerMaterial;
_startTime = Time.realtimeSinceStartup;
}
public void SpawnBullet(BulletTypes bulletType, Vector3 start, Vector3 targetPos, float shooterSpeed = 0)
{
GameObject tempMyBullet = Instantiate(Bullet, start, Quaternion.identity) as GameObject;
if (bulletType == BulletTypes.Medium || bulletType == BulletTypes.FastMedium)
{
tempMyBullet.transform.localScale *= 5;
}
if (bulletType == BulletTypes.Big || bulletType == BulletTypes.FastBig)
{
tempMyBullet.transform.localScale *= 20;
}
targetPos = targetPos - start;
tempMyBullet.transform.rotation = Quaternion.Euler(0, 0, Mathf.Atan2(targetPos.y, targetPos.x) * Mathf.Rad2Deg);
Vector3 velocity = tempMyBullet.transform.rotation * Vector3.right;
if (bulletType == BulletTypes.Small)
{
velocity *= SmallBulletSpeed + shooterSpeed;
}
if (bulletType == BulletTypes.FastSmall)
{
velocity *= FastSmallBulletSpeed + shooterSpeed;
}
if (bulletType == BulletTypes.Medium)
{
velocity *= MediumBulletSpeed + shooterSpeed;
}
if (bulletType == BulletTypes.FastMedium)
{
velocity *= FastMediumBulletSpeed + shooterSpeed;
}
if (bulletType == BulletTypes.Big)
{
velocity *= BigBulletSpeed + shooterSpeed;
}
if (bulletType == BulletTypes.FastBig)
{
velocity *= FastBigBulletSpeed + shooterSpeed;
}
tempMyBullet.GetComponent <Rigidbody2D>().AddRelativeForce(velocity);
}
public GameObject GetBullet(BulletTypes type)
{
IPoolable entity = AllocateEntity(bulletPools[(int)type]);
if (entity == null)
{
return(null);
}
return(entity.GetGameObject());
}
public void AddToPool(BulletTypes bulletTypes, IPoolable iPoolableBulletStack)
{
if (!pulledBullet.ContainsKey(bulletTypes))
{
pulledBullet.Add(bulletTypes, new Stack <IPoolable>());
}
pulledBullet[bulletTypes].Push(iPoolableBulletStack);
iPoolableBulletStack.GetGameObject.transform.SetParent(objectPoolParent);
iPoolableBulletStack.GetGameObject.SetActive(false);
iPoolableBulletStack.Pooled(); //Just in case the object wants to be alerted
}
public IPoolable RetrieveFromPool(BulletTypes bulletTypes)
{
if (pulledBullet.ContainsKey(bulletTypes) && pulledBullet[bulletTypes].Count > 0)
{
IPoolable toRet = pulledBullet[bulletTypes].Pop();
toRet.GetGameObject.transform.SetParent(null);
toRet.GetGameObject.SetActive(true);
toRet.DePooled(); //Just in case the object wants to be alerted
return(toRet);
}
return(null);
}
public Bullet(BulletDatas bulletData)
{
switch (bulletType = bulletData.Type) {
case BulletTypes.Common:
this.Source = GlobalMethod.GetImage(string.Format("Bullet/{0}.png", bulletData.Code), UriType.Project);
Offset = new Point(Source.PixelWidth, Source.PixelHeight / 2);
break;
case BulletTypes.Animation:
AnimationBase animation = new AnimationBase() { Code = bulletData.Code, Loop = bulletData.Loop };
animation.HeartStart();
this.Children.Add(animation);
Offset = new Point(animation.Center.X * 2, animation.Center.Y);
break;
}
}
public void RestoreData()
{
_bulletType = _originalData._bulletType;
_delayBeforeShoot = _originalData._delayBeforeShoot;
_delayAfterShoot = _originalData._delayAfterShoot;
_timeScale = _originalData._timeScale;
_position = _originalData._position;
_direction = _originalData._direction;
_bulletAmount = _originalData._bulletAmount;
_spreadAngleDegrees = _originalData._spreadAngleDegrees;
_bulletSpeed = _originalData._bulletSpeed;
_bulletDamage = _originalData._bulletDamage;
_bulletSize = _originalData._bulletSize;
_workOnce = _originalData._workOnce;
}
private Bullet _CreateBullet(BulletTypes bulletTypes)
{
if (!bulletPrefabDict.ContainsKey(bulletTypes))
{
Debug.LogError("Bullet of name: " + bulletTypes + " not found in bulletDict");
return(null);
}
GameObject newBulletObj = GameObject.Instantiate(bulletPrefabDict[bulletTypes]);
Bullet newBullet = newBulletObj.GetComponent <Bullet>();
return(newBullet);
}
public void UpdateBulletManager()
{
while (BulletsToRemoveStack.Count > 0)
{
Bullet toRemove = BulletsToRemoveStack.Pop();
BulletTypes mBulletTypes = toRemove.types;
if (!bulletDict.ContainsKey(mBulletTypes) || !bulletDict[mBulletTypes].Contains(toRemove))
{
Debug.LogError("Stack tried to remove element of type: " + mBulletTypes.ToString() + " but was not found in dictionary ? ");
}
else
{
bulletDict[mBulletTypes].Remove(toRemove);
ObjectPool.Instance.AddToPool(toRemove.types, toRemove);//----------------------------------------
if (bulletDict[mBulletTypes].Count == 0)
{
bulletDict.Remove(mBulletTypes);
}
}
}
while (BulletsToAddStack.Count > 0)
{
Bullet toAdd = BulletsToAddStack.Pop();
BulletTypes aBulletTypes = toAdd.types;
if (!bulletDict.ContainsKey(aBulletTypes))
{
bulletDict.Add(aBulletTypes, new List <Bullet>()
{
toAdd
});
}
else if (!bulletDict[aBulletTypes].Contains(toAdd))
{
bulletDict[aBulletTypes].Add(toAdd);
}
else
{
Debug.LogError("The bullet you are trying to add is already in the bullet dict");
}
}
}
public BaseBulletController GetBullet(BulletTypes type)
{
BaseBulletController result;
switch (type)
{
case BulletTypes.Laser:
result = GetBullet(GetBulletHashSet(type));
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, "Не предусмотрен в программе");
}
return(result);
}
public void ShootBullet(BulletTypes bulletType, Transform firePos, bool p1, bool p2)
{
if (bulletType.isHoming)
{
}
else if (bulletType.isCharger)
{
}
else
{
if (p1)
{
player1.InstantiateBullet();
bullet.RegShoot(p1, p2, player1.facingRight);
}
}
}
public void AddBullet(BulletTypes bulletTypes, List <BulletTypes> types)
{
var col = stdBullet;
if (bulletTypes == BulletTypes.Silver)
{
col = silverBullet;
}
else if (bulletTypes == BulletTypes.Blood)
{
col = bloodBullet;
}
else if (bulletTypes == BulletTypes.Hellfire)
{
col = hellBullet;
}
StartCoroutine(RotateRevolverRoll());
bulletsPlaces[types.Count - 1].color = Color.white;
bulletsPlaces[types.Count - 1].sprite = col;
}
public ControllerBullet MakeBullet(BulletTypes bulletType)
{
ControllerBullet temp = null;
switch (bulletType)
{
case BulletTypes.defaultBullet: temp = new ControllerDefaultBullet();
bulletList.Add(temp);
break;
case BulletTypes.fastBullet: temp = new ControllerFastBullet();
bulletList.Add(temp);
break;
case BulletTypes.explossiveBullet: temp = new ControllerExplossiveBullet();
bulletList.Add(temp);
break;
}
temp.OnBulletDestroy += RemoveBullet;
// Debug.Log(bulletList.Count);
return(temp);
}
protected static void Shoot(int bulletAmount = 1, float spreadAngle = 10f, float bulletSpeed = 7f,
BulletTypes bulletType = BulletTypes.BossSpikeBullet,
Vector3?position = null, float bulletSize = 1f,
Vector2?direction = null)
{
if (position.HasValue == false)
{
position = Boss.Instance.transform.position;
}
if (direction.HasValue == false)
{
direction = Vector2.down;
}
float _halfBulletAmount = 0f;
float _angleStep = 0f;
if (bulletAmount > 1)
{
_halfBulletAmount = (bulletAmount - 1) / 2f;
_angleStep = spreadAngle / _halfBulletAmount / 2f;
}
else
{
_halfBulletAmount = 0f;
_angleStep = 0f;
}
for (int i = 0; i < bulletAmount; ++i)
{
GameObject bullet = BulletPoolsContainer.Instance.GetObjectFromPool(bulletType);
(bullet.GetComponent(typeof(IBulletMovement)) as IBulletMovement).SpeedMultiplier = bulletSpeed;
bullet.transform.position = position.Value;
bullet.transform.localScale = bulletSize * Vector3.one;
bullet.transform.localEulerAngles = new Vector3(0f, 0f, Vector2.SignedAngle(Vector2.up, direction.Value) + (_angleStep * (i - _halfBulletAmount)));
}
}
public GameObject GetObjectFromPool(BulletTypes type)
{
return(_pools[(int)type].GetObjectFromPool());
}
void Update()
{
// Show what bullet type it is currently
switch (bulletType)
{
case BulletTypes.Frozen:
bulletFaceUI.GetComponent <Renderer>().material.color = Color.blue;
break;
case BulletTypes.Fire:
bulletFaceUI.GetComponent <Renderer>().material.color = Color.red;
break;
case BulletTypes.Shock:
bulletFaceUI.GetComponent <Renderer>().material.color = Color.yellow;
break;
case BulletTypes.Normal:
bulletFaceUI.GetComponent <Renderer>().material.color = Color.black;
break;
default:
bulletFaceUI.GetComponent <Renderer>().material.color = Color.black;
break;
}
if (Input.GetKeyDown("q"))
{
if (weaponIndex < 3)
{
weaponIndex++;
}
ammoCount = 0;
reloadTimer = Time.time;
bulletType = (BulletTypes)weaponIndex;
}
if (Input.GetKeyDown("e"))
{
if (weaponIndex > 0)
{
weaponIndex--;
}
ammoCount = 0;
reloadTimer = Time.time;
bulletType = (BulletTypes)weaponIndex;
}
if (Input.GetKeyDown("r"))
{
switch (bulletType)
{
case BulletTypes.Frozen:
case BulletTypes.Fire:
case BulletTypes.Shock:
if (ammoCount != 5)
{
ammoCount = 0;
}
break;
case BulletTypes.Normal:
if (ammoCount != 20)
{
ammoCount = 0;
}
break;
}
}
if (ammoCount > 0)
{
if (Input.GetKey(KeyCode.X))
{
if (shootCooldown <= Time.time)
{
shootCooldown = Time.time + shootInterval;
storage = WeaponSpray(sprayValue);
gunRay.SetPosition(0, gunpoint.position);
gunRay.SetPosition(1, gunpoint.transform.TransformDirection(0, 0, range) + storage);
if (Physics.Raycast(transform.position + new Vector3(0, transform.localScale.y / 4, 0), transform.TransformDirection(0, 0, range) + storage, out hit))
{
ammoCount--;
if (currentTarget != null)
{
if (!currentTarget.GetComponent <BaseClass>())
{
currentTarget = null;
}
}
if (currentTarget != hit.transform.gameObject)
{
if (hit.transform.root.gameObject.GetComponent <BaseClass>())
{
currentTarget = hit.transform.gameObject;
target = hit.transform.root.gameObject.GetComponent <BaseClass>();
}
else
{
currentTarget = null;
}
}
if (currentTarget != null)
{
target.DamageRecieved(weaponDamage, hit.transform.gameObject);
switch (bulletType)
{
case BulletTypes.Frozen:
target.speed = 0.5f;
target.enemyUI.UpdateState("Frozen");
StartCoroutine(target.Restoration(3));
break;
case BulletTypes.Fire:
StartCoroutine(target.Persistent(1, 20));
target.enemyUI.UpdateState("Fire");
break;
case BulletTypes.Shock:
target.speed = 0;
target.enemyUI.UpdateState("Shock");
StartCoroutine(target.Restoration(2));
break;
}
}
GameObject explosion = (GameObject)Instantiate(explosionEffect, hit.point, Quaternion.identity);
explosion.GetComponent <ExplosionEffectScript>().bulletState = bulletType.ToString();
}
}
}
}
else
{
if (reloadTimer < Time.time)
{
if (!reloadedYet)
{
reloadTimer = Time.time + 2;
reloadedYet = true;
}
else
{
reloadedYet = false;
switch (bulletType)
{
case BulletTypes.Frozen:
case BulletTypes.Fire:
case BulletTypes.Shock:
ammoCount = 5;
break;
case BulletTypes.Normal:
ammoCount = 20;
break;
}
}
}
}
}
public void ReturnBullet(BulletTypes type, GameObject bullet)
{
IPoolable entity = bullet.GetComponent <IPoolable>();
DeallocateEntity(bulletPools[(int)type], entity);
}
public void ReturnObjectToPool(BulletTypes type, GameObject go)
{
_pools[(int)type].ReturnObjectToPool(go);
}
