Example #1
0
    public void STEP()
    {
        if (!exploded)
        {
            foreach (Templates.GunOnShuttle gun in planeTemplate.guns)
            {
                gunTemp = Templates.getInstance().getGunTemplate(gun.gunId);
                if (!gun.ready)
                {
                    if (gun.shotTime + gunTemp.reuse < Time.time)
                    {
                        gun.ready = true;
                    }
                }

                enemy = GameStorage.getInstance().getFriendlyInFireZone(this, gun);
                if (gun.ready && enemy != null)
                {
                    f = Quaternion.Euler(0, 0, -gameObject.transform.eulerAngles.y) * gun.pos;
                    BulletPoolManager.getInstance().shotBullet(BulletSide.ENEMY, new Vector3(transform.position.x + f.x, 5, transform.position.z + f.y), enemy.transform.position, gunTemp.damage, gunTemp.bulletSpeed, gunTemp.gunType, gunTemp.attackRange, gunTemp.bulletDispersion);
                    gun.ready    = false;
                    gun.shotTime = Time.time;
                }
            }

            if (underGas)
            {
                if (Time.time >= lastGasBurned + Abilities.GasParameters.gasReuse)
                {
                    Attacked(Abilities.GasParameters.gasDamage);
                    lastGasBurned = Time.time;
                }
            }

            t       += 1f / 151f;
            x        = (1 - t) * (1 - t) * (1 - t) * point1.x + 3 * (1 - t) * (1 - t) * t * point2.x + 3 * (1 - t) * t * t * point3.x + t * t * t * point4.x;
            y        = (1 - t) * (1 - t) * (1 - t) * point1.y + 3 * (1 - t) * (1 - t) * t * point2.y + 3 * (1 - t) * t * t * point3.y + t * t * t * point4.y;
            tmpVec.x = x;
            tmpVec.y = 5;
            tmpVec.z = y;

            v2tmp1.x = x - transform.position.x;
            v2tmp1.y = y - transform.position.z;
            v2tmp2   = new Vector2(0, 5);
            f1tmp    = (v2tmp2.x * v2tmp1.y - v2tmp2.y * v2tmp1.x);
            f2tmp    = Vector2.Angle(v2tmp2, v2tmp1);
            if (f1tmp > 0)
            {
                f2tmp = (180 - f2tmp) + 180;
            }
            transform.eulerAngles = new Vector3(270, f2tmp, 0);
            fortestAngle          = f2tmp;

            transform.position = tmpVec;
        }
    }
    private void createArcs()
    {
        arcObjs = new ArrayList();
        foreach (Templates.GunOnShuttle goss in planeTemplate.guns)
        {
            //go
            gunTmp = (GameObject)Instantiate(Resources.Load("prefab/gunArcPrefab"), transform.position, Quaternion.Euler(0, goss.turnAngle, 0));
            gt     = Templates.getInstance().getGunTemplate(goss.gunId);
            m      = gunTmp.GetComponent <MeshFilter>().mesh;
            m.Clear();
            vertices[0] = new Vector3(0, 1, 0);
            d           = gt.attackRange;

            Vector2 va;
            i = 1;
            for (float ang = -gt.attackAngle; ang <= gt.attackAngle; ang += (2 * gt.attackAngle) / 100.0f)
            {
                va          = Quaternion.Euler(0, 0, ang) * new Vector2(0, d);
                vertices[i] = new Vector3(va.x, 0, va.y);
                i++;
                if (i == 101)
                {
                    break;
                }
            }

            int[] triangles = new int[vertices.Length * 3];
            int   bb        = 0;
            for (i = 0; i < 99; i++)
            {
                triangles[bb * 3]     = 0;
                triangles[bb * 3 + 1] = i + 1;
                triangles[bb * 3 + 2] = i + 2;
                bb++;
            }

            Vector2[] uvs = new Vector2[vertices.Length];
            for (i = 0; i < uvs.Length; i++)
            {
                uvs[i] = new Vector2(vertices[i].x, vertices[i].z);
            }

            m.vertices  = vertices;
            m.triangles = triangles;
            m.uv        = uvs;
            m.RecalculateBounds();
            m.RecalculateNormals();
            arcObjs.Add(gunTmp);
            gunTmp.transform.SetParent(transform);
            gunTmp.transform.eulerAngles    = new Vector3(0, transform.eulerAngles.y + goss.turnAngle, 0);
            gunTmp.transform.localPosition -= new Vector3(goss.pos.x, goss.pos.y, 0);
            gunTmp.SetActive(false);
        }
    }
Example #3
0
    public void Launch(Vector2 targetPos, Vector2 startPos, Templates.GunOnShuttle gun)
    {
        gos=Templates.getInstance().getGunTemplate(gun.gunId);
        startPoint=startPos;
        targetPoint=new Vector2(targetPos.x+UnityEngine.Random.Range(-gos.bulletDispersion,gos.bulletDispersion),targetPos.y+UnityEngine.Random.Range(-gos.bulletDispersion,gos.bulletDispersion));
        targetPoint=new Vector2(targetPoint.x-startPoint.x,targetPoint.y-startPoint.y);
        targetPoint/=targetPoint.magnitude;
        targetPoint*=gos.attackRange;
        targetPoint=new Vector2(targetPoint.x+startPoint.x,targetPoint.y+startPoint.y);
        transform.eulerAngles=new Vector3(0,GameStorage.getInstance().getAngleRelative(startPoint,targetPoint),0);

        setuped=true;
    }
Example #4
0
	public void STEP()
	{
		if(!exploded)
		{
			foreach(Templates.GunOnShuttle gun in planeTemplate.guns)
			{
				gunTemp=Templates.getInstance().getGunTemplate(gun.gunId);
				if(!gun.ready)
					if(gun.shotTime+gunTemp.reuse<Time.time)
						gun.ready=true;
				
				enemy=GameStorage.getInstance().getFriendlyInFireZone(this,gun);
				if(gun.ready && enemy!=null)
				{
					f = Quaternion.Euler(0,0,-gameObject.transform.eulerAngles.y)*gun.pos;
					BulletPoolManager.getInstance().shotBullet(BulletSide.ENEMY,new Vector3(transform.position.x+f.x,5,transform.position.z+f.y),enemy.transform.position,gunTemp.damage,gunTemp.bulletSpeed,gunTemp.gunType,gunTemp.attackRange,gunTemp.bulletDispersion);
					gun.ready=false;
					gun.shotTime=Time.time;
				}
			}
			
			if(underGas)
			{
				if(Time.time >= lastGasBurned+Abilities.GasParameters.gasReuse)
				{
					Attacked(Abilities.GasParameters.gasDamage);
					lastGasBurned=Time.time;
				}
			}
			
			t+=1f/151f;
			x=(1-t)*(1-t)*(1-t)*point1.x+3*(1-t)*(1-t)*t*point2.x+3*(1-t)*t*t*point3.x+t*t*t*point4.x;
			y=(1-t)*(1-t)*(1-t)*point1.y+3*(1-t)*(1-t)*t*point2.y+3*(1-t)*t*t*point3.y+t*t*t*point4.y;
			tmpVec.x=x;
			tmpVec.y=5;
			tmpVec.z=y;
			
			v2tmp1.x=x-transform.position.x;
			v2tmp1.y=y-transform.position.z;
			v2tmp2 = new Vector2(0,5);
			f1tmp = (v2tmp2.x*v2tmp1.y - v2tmp2.y*v2tmp1.x);
			f2tmp = Vector2.Angle(v2tmp2,v2tmp1);
			if(f1tmp>0)
				f2tmp=(180-f2tmp)+180;
			transform.eulerAngles=new Vector3(270,f2tmp,0);
			fortestAngle=f2tmp;
			
			transform.position=tmpVec;
		}
	}
Example #5
0
 void initBullets()
 {
     foreach (Templates.GunOnShuttle gun in planeTemplate.guns)
     {
         gunTemp = Templates.getInstance().getGunTemplate(gun.gunId);
         if (gunTemp.gunType == BulletType.GUN_SMALL_BULLET)
         {
             BulletPoolManager.getInstance().createPoolObjs(BulletType.GUN_SMALL_BULLET, 15);
         }
         else if (gunTemp.gunType == BulletType.GUN_MID_BULLET)
         {
             BulletPoolManager.getInstance().createPoolObjs(BulletType.GUN_MID_BULLET, 10);
         }
         else if (gunTemp.gunType == BulletType.GUN_LARGE_BULLET)
         {
             BulletPoolManager.getInstance().createPoolObjs(BulletType.GUN_LARGE_BULLET, 10);
         }
     }
 }
Example #6
0
    public FriendlySpaceship getFriendlyInFireZone(EnemySpaceship friendlyShuttle, Templates.GunOnShuttle gun)
    {
        FriendlySpaceship ret     = null;
        float             dist    = 0;
        float             mindist = -1;

        Templates.GunTemplate gunTemp = Templates.getInstance().getGunTemplate(gun.gunId);
        Vector2 gunPos   = new Vector2(friendlyShuttle.gameObject.transform.position.x + gun.pos.x, friendlyShuttle.gameObject.transform.position.z + gun.pos.y);
        float   gunAngle = Mathf.Repeat(friendlyShuttle.transform.eulerAngles.y + gun.turnAngle, 360);
        Vector2 pos2;

        foreach (FriendlySpaceship enemy in friendlySpaceships)
        {
            if (enemy.isAlive())
            {
                pos2 = new Vector2(enemy.gameObject.transform.position.x, enemy.gameObject.transform.position.z);
                if ((dist = Vector2.Distance(gunPos, pos2)) <= gunTemp.attackRange && Mathf.Abs(getAngleDst(gunAngle, getAngleRelative(friendlyShuttle.gameObject, enemy.gameObject))) <= gunTemp.attackAngle)
                {
                    if (mindist < 0)
                    {
                        ret     = enemy;
                        mindist = dist;
                    }
                    else
                    {
                        if (dist < mindist)
                        {
                            ret     = enemy;
                            mindist = dist;
                        }
                    }
                }
            }
        }
        return(ret);
    }
	void initBullets()
	{
		foreach(Templates.GunOnShuttle gun in planeTemplate.guns)
		{
			gunTemp=Templates.getInstance().getGunTemplate(gun.gunId);
			if(gunTemp.gunType==BulletType.GUN_SMALL_BULLET)
				BulletPoolManager.getInstance().createPoolObjs(BulletType.GUN_SMALL_BULLET,15);
			else if(gunTemp.gunType==BulletType.GUN_MID_BULLET)
				BulletPoolManager.getInstance().createPoolObjs(BulletType.GUN_MID_BULLET,10);
			else if(gunTemp.gunType==BulletType.GUN_LARGE_BULLET)
				BulletPoolManager.getInstance().createPoolObjs(BulletType.GUN_LARGE_BULLET,10);
		}
	}
	private void createArcs()
	{
		arcObjs=new ArrayList();
		foreach(Templates.GunOnShuttle goss in planeTemplate.guns)
		{
			//go
			gunTmp = (GameObject) Instantiate(Resources.Load("prefab/gunArcPrefab"),transform.position,Quaternion.Euler(0,goss.turnAngle,0));
			gt = Templates.getInstance().getGunTemplate(goss.gunId);
			m = gunTmp.GetComponent<MeshFilter>().mesh;
	      	m.Clear();
	        vertices[0]=new Vector3(0,1,0);
	        d=gt.attackRange;
	        
	        Vector2 va;
	        i=1;
	        for(float ang = -gt.attackAngle; ang<=gt.attackAngle; ang+=(2*gt.attackAngle)/100.0f)
	        {
	        	va=Quaternion.Euler(0,0,ang)*new Vector2(0,d);
	        	vertices[i]=new Vector3(va.x,0,va.y);
	        	i++;
	        	if(i==101) break;
	        }
	        
	        int[] triangles = new int[vertices.Length*3];
	        int bb=0;
	        for(i=0;i<99;i++)
	        {
	        	triangles[bb*3]=0;
	        	triangles[bb*3+1]=i+1;
	        	triangles[bb*3+2]=i+2;
	        	bb++;
	        }
	   
	        Vector2[] uvs = new Vector2[vertices.Length];
			for (i = 0; i < uvs.Length; i++) {
				uvs[i] = new Vector2(vertices[i].x, vertices[i].z);
			}
       
	        m.vertices=vertices;
	        m.triangles=triangles;
	        m.uv=uvs;
	       	m.RecalculateBounds();
	        m.RecalculateNormals();
	        arcObjs.Add(gunTmp);
	        gunTmp.transform.SetParent(transform);
	        gunTmp.transform.eulerAngles=new Vector3(0,transform.eulerAngles.y+goss.turnAngle,0);
	        gunTmp.transform.localPosition-=new Vector3(goss.pos.x,goss.pos.y,0);
	        gunTmp.SetActive(false);
		}
	}
	public void STEP()
	{
		if(!exploded)
		{
			if(!Abilities.getLockGun(activeAbil))
			{
				foreach(Templates.GunOnShuttle gun in planeTemplate.guns)
				{
					gunTemp=Templates.getInstance().getGunTemplate(gun.gunId);
					if(!gun.ready)
						if(gun.shotTime+gunTemp.reuse<Time.time)
							gun.ready=true;
					
					enemy=GameStorage.getInstance().getEnemyInFireZone(this,gun);
					if(gun.ready && enemy!=null)
					{
						//SHOT PROCEDURE WITH POOLING
						f = Quaternion.Euler(0,0,-gameObject.transform.eulerAngles.y)*gun.pos;
						BulletPoolManager.getInstance().shotBullet(BulletSide.FRIENDLY,new Vector3(transform.position.x+f.x,5,transform.position.z+f.y),enemy.transform.position,gunTemp.damage,gunTemp.bulletSpeed,gunTemp.gunType,gunTemp.attackRange,gunTemp.bulletDispersion);
						gun.ready=false;
						gun.shotTime=Time.time;
					}
				}
			}
			
			if(underGas)
			{
				if(Time.time >= lastGasBurned+Abilities.GasParameters.gasReuse)
				{
					Attacked(Abilities.GasParameters.gasDamage);
					lastGasBurned=Time.time;
				}
			}
			
			t+=1f/151f;
			x=(1-t)*(1-t)*(1-t)*point1.x+3*(1-t)*(1-t)*t*point2.x+3*(1-t)*t*t*point3.x+t*t*t*point4.x;
			y=(1-t)*(1-t)*(1-t)*point1.y+3*(1-t)*(1-t)*t*point2.y+3*(1-t)*t*t*point3.y+t*t*t*point4.y;
			tmpVec.x=x;
			tmpVec.y=5;
			tmpVec.z=y;
			curDistance+=Vector3.Distance(forDist,tmpVec);
			if(activeAbil==Abilities.AbilityType.halfRoundTurn)
				f2tmp=transform.eulerAngles.y+abilRandonRotateDirection*180*Time.fixedDeltaTime/3;
			else if(activeAbil==Abilities.AbilityType.turnAround)
				f2tmp=transform.eulerAngles.y+abilRandonRotateDirection*360*Time.fixedDeltaTime/3;
			else
			{
				v2tmp1.x=x-transform.position.x;
				v2tmp1.y=y-transform.position.z;
				v2tmp2 = new Vector2(0,5);
				f1tmp = (v2tmp2.x*v2tmp1.y - v2tmp2.y*v2tmp1.x);
				f2tmp = Vector2.Angle(v2tmp2,v2tmp1);
				if(f1tmp>0)
					f2tmp=(180-f2tmp)+180;
			}
			
			if(activeAbil==Abilities.AbilityType.homingMissle && t>=0.5f && !rocketLaunched)
			{
				MisslePoolManager.getInstance().LaunchRocket(MissleSide.FRIENDLY,this);
				rocketLaunched=true;
			}
			else if(activeAbil==Abilities.AbilityType.homingThorpede && t>=0.5f && !rocketLaunched)
			{
				MisslePoolManager.getInstance().LaunchThorpede(MissleSide.FRIENDLY,this);
				rocketLaunched=true;
			}
			else if(activeAbil==Abilities.AbilityType.gas)
			{
				if(curDistance>=gasLastSpawnDist)
				{
					MisslePoolManager.getInstance().LaunchGas(MissleSide.FRIENDLY,this);
					gasLastSpawnDist=curDistance+Abilities.GasParameters.betweenDist;
				}
			}
			else if(activeAbil==Abilities.AbilityType.mines)
			{
				if(curDistance>=gasLastSpawnDist)
				{
					MisslePoolManager.getInstance().LaunchMine(MissleSide.FRIENDLY,this);
					gasLastSpawnDist=curDistance+Abilities.MinesParameters.betweenDist;
				}
			}
			
			transform.eulerAngles=new Vector3(270,f2tmp,0);
			//Debug.Log("ALLY: "+f2tmp);
			fortestAngle=f2tmp;
			
			transform.position=tmpVec;
			forDist=transform.position;
		}
	}
    public void STEP()
    {
        if (!exploded)
        {
            if (!Abilities.getLockGun(activeAbil))
            {
                foreach (Templates.GunOnShuttle gun in planeTemplate.guns)
                {
                    gunTemp = Templates.getInstance().getGunTemplate(gun.gunId);
                    if (!gun.ready)
                    {
                        if (gun.shotTime + gunTemp.reuse < Time.time)
                        {
                            gun.ready = true;
                        }
                    }

                    enemy = GameStorage.getInstance().getEnemyInFireZone(this, gun);
                    if (gun.ready && enemy != null)
                    {
                        //SHOT PROCEDURE WITH POOLING
                        f = Quaternion.Euler(0, 0, -gameObject.transform.eulerAngles.y) * gun.pos;
                        BulletPoolManager.getInstance().shotBullet(BulletSide.FRIENDLY, new Vector3(transform.position.x + f.x, 5, transform.position.z + f.y), enemy.transform.position, gunTemp.damage, gunTemp.bulletSpeed, gunTemp.gunType, gunTemp.attackRange, gunTemp.bulletDispersion);
                        gun.ready    = false;
                        gun.shotTime = Time.time;
                    }
                }
            }

            if (underGas)
            {
                if (Time.time >= lastGasBurned + Abilities.GasParameters.gasReuse)
                {
                    Attacked(Abilities.GasParameters.gasDamage);
                    lastGasBurned = Time.time;
                }
            }

            t           += 1f / 151f;
            x            = (1 - t) * (1 - t) * (1 - t) * point1.x + 3 * (1 - t) * (1 - t) * t * point2.x + 3 * (1 - t) * t * t * point3.x + t * t * t * point4.x;
            y            = (1 - t) * (1 - t) * (1 - t) * point1.y + 3 * (1 - t) * (1 - t) * t * point2.y + 3 * (1 - t) * t * t * point3.y + t * t * t * point4.y;
            tmpVec.x     = x;
            tmpVec.y     = 5;
            tmpVec.z     = y;
            curDistance += Vector3.Distance(forDist, tmpVec);
            if (activeAbil == Abilities.AbilityType.halfRoundTurn)
            {
                f2tmp = transform.eulerAngles.y + abilRandonRotateDirection * 180 * Time.fixedDeltaTime / 3;
            }
            else if (activeAbil == Abilities.AbilityType.turnAround)
            {
                f2tmp = transform.eulerAngles.y + abilRandonRotateDirection * 360 * Time.fixedDeltaTime / 3;
            }
            else
            {
                v2tmp1.x = x - transform.position.x;
                v2tmp1.y = y - transform.position.z;
                v2tmp2   = new Vector2(0, 5);
                f1tmp    = (v2tmp2.x * v2tmp1.y - v2tmp2.y * v2tmp1.x);
                f2tmp    = Vector2.Angle(v2tmp2, v2tmp1);
                if (f1tmp > 0)
                {
                    f2tmp = (180 - f2tmp) + 180;
                }
            }

            if (activeAbil == Abilities.AbilityType.homingMissle && t >= 0.5f && !rocketLaunched)
            {
                MisslePoolManager.getInstance().LaunchRocket(MissleSide.FRIENDLY, this);
                rocketLaunched = true;
            }
            else if (activeAbil == Abilities.AbilityType.homingThorpede && t >= 0.5f && !rocketLaunched)
            {
                MisslePoolManager.getInstance().LaunchThorpede(MissleSide.FRIENDLY, this);
                rocketLaunched = true;
            }
            else if (activeAbil == Abilities.AbilityType.gas)
            {
                if (curDistance >= gasLastSpawnDist)
                {
                    MisslePoolManager.getInstance().LaunchGas(MissleSide.FRIENDLY, this);
                    gasLastSpawnDist = curDistance + Abilities.GasParameters.betweenDist;
                }
            }
            else if (activeAbil == Abilities.AbilityType.mines)
            {
                if (curDistance >= gasLastSpawnDist)
                {
                    MisslePoolManager.getInstance().LaunchMine(MissleSide.FRIENDLY, this);
                    gasLastSpawnDist = curDistance + Abilities.MinesParameters.betweenDist;
                }
            }

            transform.eulerAngles = new Vector3(270, f2tmp, 0);
            //Debug.Log("ALLY: "+f2tmp);
            fortestAngle = f2tmp;

            transform.position = tmpVec;
            forDist            = transform.position;
        }
    }