Beispiel #1
0
    public FriendlySpaceship getNearbyFriendly(MissleBehaviour attacker)
    {
        FriendlySpaceship ret = null;

        d = -1;
        v1.Set(attacker.gameObject.transform.position.x, attacker.gameObject.transform.position.z);
        foreach (FriendlySpaceship target in friendlySpaceships)
        {
            v2.Set(target.gameObject.transform.position.x, target.gameObject.transform.position.z);
            if (d < 0)
            {
                ret = target;
                v2.Set(v1.x - v2.x, v1.y - v2.y);
                d = v2.sqrMagnitude;
            }
            else
            {
                v2.Set(v1.x - v2.x, v1.y - v2.y);
                if (d > v2.sqrMagnitude)
                {
                    ret = target;
                    d   = v2.sqrMagnitude;
                }
            }
        }
        return(ret);
    }
    public void LaunchThorpede(MissleSide side, Object beh)
    {
        if (side == MissleSide.FRIENDLY)
        {
            friendlyInstance = (FriendlySpaceship)beh;
            misTmp           = getFreeThorpede(side);

            misTmp.gameObject.transform.position    = friendlyInstance.MisslesLaunchPoint.transform.position;
            misTmp.gameObject.transform.eulerAngles = new Vector3(270, friendlyInstance.transform.eulerAngles.y, 0);
            misTmp.Activate();
            misTmp.hideIcon();
            misTmp.gameObject.SetActive(true);
            activeFriendlyThorpedes.Add(misTmp);
        }
        if (side == MissleSide.ENEMY)
        {
            enemyInstance = (EnemySpaceship)beh;
            misTmp        = getFreeThorpede(side);
            misTmp.gameObject.transform.position    = enemyInstance.MissleLaunchPos.transform.position;
            misTmp.gameObject.transform.eulerAngles = new Vector3(270, enemyInstance.transform.eulerAngles.y, 0);
            misTmp.Activate();
            misTmp.gameObject.SetActive(true);
            activeEnemyThorpeds.Add(misTmp);
        }
    }
    private void CalculatePath()
    {
        target = GameStorage.getInstance().getNearbyFriendly(this);
        if (target != null)
        {
            v2tmp1 = new Vector2(target.transform.position.x - transform.position.x, target.transform.position.z - transform.position.z);
            v2tmp2 = oneVec;
            f1tmp  = (v2tmp2.x * v2tmp1.y - v2tmp2.y * v2tmp1.x); // sinphi
            f2tmp  = Vector2.Angle(v2tmp1, v2tmp2);               // mangle
            if (f1tmp >= 0)
            {
                f2tmp = (180 - f2tmp) + 180;
            }

            between = GameStorage.getInstance().getAngleDst(transform.eulerAngles.y, f2tmp);


            if (Mathf.Abs(between) > maxAngle)
            {
                if (preferencedDirection == -1)
                {
                    newAngle = Mathf.Repeat(transform.eulerAngles.y - maxAngle, 360);
                }
                else if (preferencedDirection == 1)
                {
                    newAngle = Mathf.Repeat(transform.eulerAngles.y + maxAngle, 360);
                }
                else
                {
                    if (between > 0)
                    {
                        newAngle = Mathf.Repeat(transform.eulerAngles.y - maxAngle, 360);
                    }
                    else
                    {
                        newAngle = Mathf.Repeat(transform.eulerAngles.y + maxAngle, 360);
                    }
                }
            }
            else
            {
                newAngle = Mathf.Repeat(transform.eulerAngles.y - between, 360);
            }

            targetPosition = Quaternion.Euler(0, 0, -newAngle) * new Vector2(0, Random.Range(minLen, maxLen));
            attackIcon.transform.position = new Vector3(targetPosition.x + transform.position.x, 5, targetPosition.y + transform.position.z);
        }


        point1  = new Vector2(transform.position.x, transform.position.z);
        point2  = Quaternion.Euler(0, 0, -transform.eulerAngles.y) * new Vector2(0, minLen * Mathf.Abs(getAngleDst(transform.eulerAngles.y, getAttackIconAngle()) / maxAngle) * Vector2.Distance(point1, point4) / maxLen) * planeTemplate.lowerSmooth;
        point2 += point1;
        point4  = new Vector2(attackIcon.transform.position.x, attackIcon.transform.position.z);
        pointz  = new Vector2(point4.x - point2.x, point4.y - point2.y) / 2;
        point3  = new Vector2(pointz.y, -pointz.x) * getAngleDst(transform.eulerAngles.y, getAttackIconAngle()) / maxAngle * Vector2.Distance(point1, point4) / maxLen * planeTemplate.upperSmooth;
        point3  = point3 + point2 + pointz;
    }
    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;
        }
    }
Beispiel #5
0
 public void toggleShowAllAttackIcons(FriendlySpaceship exclude)
 {
     foreach (FriendlySpaceship obj in friendlySpaceships)
     {
         if (obj != exclude)
         {
             obj.showAttackIcon();
         }
     }
     MisslePoolManager.getInstance().ToggleShowAllAttackIcons(null);
 }
 public void LaunchGas(MissleSide side, Object beh)
 {
     if (side == MissleSide.FRIENDLY)
     {
         friendlyInstance = (FriendlySpaceship)beh;
         misTmp           = getFreeGas(side);
         misTmp.gameObject.transform.position    = friendlyInstance.transform.position;
         misTmp.gameObject.transform.eulerAngles = new Vector3(270, friendlyInstance.transform.eulerAngles.y, 0);
         misTmp.Activate();
         misTmp.gameObject.SetActive(true);
         activeFriendlyGasList.Add(misTmp);
     }
     if (side == MissleSide.ENEMY)
     {
         enemyInstance = (EnemySpaceship)beh;
         misTmp        = getFreeGas(side);
         misTmp.gameObject.transform.position    = enemyInstance.transform.position;
         misTmp.gameObject.transform.eulerAngles = new Vector3(270, enemyInstance.transform.eulerAngles.y, 0);
         misTmp.Activate();
         misTmp.gameObject.SetActive(true);
         activeEnemyGasList.Add(misTmp);
     }
 }
Beispiel #7
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);
    }
	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 CalculatePath()
	{
		target=GameStorage.getInstance().getNearbyFriendly(this);
		if(target!=null)
		{
			v2tmp1 = new Vector2(target.transform.position.x-transform.position.x,target.transform.position.z-transform.position.z);
			v2tmp2 = oneVec;
			f1tmp = (v2tmp2.x*v2tmp1.y - v2tmp2.y*v2tmp1.x); // sinphi
			f2tmp = Vector2.Angle(v2tmp1,v2tmp2); // mangle
			if(f1tmp>=0)
				f2tmp=(180-f2tmp)+180;
			
			between = GameStorage.getInstance().getAngleDst(transform.eulerAngles.y,f2tmp);
			
			
			if(Mathf.Abs(between)>maxAngle)
			{
				if(preferencedDirection==-1)
					newAngle=Mathf.Repeat(transform.eulerAngles.y-maxAngle,360);
				else if(preferencedDirection==1)
					newAngle=Mathf.Repeat(transform.eulerAngles.y+maxAngle,360);
				else
				{
					if(between>0)
						newAngle=Mathf.Repeat(transform.eulerAngles.y-maxAngle,360);
					else
						newAngle=Mathf.Repeat(transform.eulerAngles.y+maxAngle,360);
				}
			}
			else
				newAngle=Mathf.Repeat(transform.eulerAngles.y-between,360);
			
			targetPosition=Quaternion.Euler(0,0,-newAngle)*new Vector2(0,Random.Range(minLen,maxLen));
			attackIcon.transform.position=new Vector3(targetPosition.x+transform.position.x,5,targetPosition.y+transform.position.z);
		}
	
		
		point1=new Vector2(transform.position.x,transform.position.z);
		point2=Quaternion.Euler(0,0,-transform.eulerAngles.y)*new Vector2(0,minLen*Mathf.Abs(getAngleDst(transform.eulerAngles.y,getAttackIconAngle())/maxAngle)*Vector2.Distance(point1,point4)/maxLen)*planeTemplate.lowerSmooth;
		point2+=point1;
		point4=new Vector2(attackIcon.transform.position.x,attackIcon.transform.position.z);
		pointz = new Vector2(point4.x-point2.x,point4.y-point2.y)/2;
		point3 = new Vector2(pointz.y,-pointz.x)*getAngleDst(transform.eulerAngles.y,getAttackIconAngle())/maxAngle*Vector2.Distance(point1,point4)/maxLen*planeTemplate.upperSmooth;
		point3 = point3+point2+pointz;	
	}
	public void LaunchMine(MissleSide side, Object beh)
	{
		if(side==MissleSide.FRIENDLY)
		{
			friendlyInstance=(FriendlySpaceship) beh;
			misTmp=getFreeMine(side);
			misTmp.gameObject.transform.position=friendlyInstance.transform.position;
			misTmp.gameObject.transform.eulerAngles=new Vector3(270,friendlyInstance.transform.eulerAngles.y,0);
			misTmp.Activate();
			misTmp.gameObject.SetActive(true);
			activeFriendlyMinesList.Add(misTmp);
		}
		if(side==MissleSide.ENEMY)
		{
			enemyInstance=(EnemySpaceship) beh;
			misTmp=getFreeMine(side);
			misTmp.gameObject.transform.position=enemyInstance.transform.position;
			misTmp.gameObject.transform.eulerAngles=new Vector3(270,enemyInstance.transform.eulerAngles.y,0);
			misTmp.Activate();
			misTmp.gameObject.SetActive(true);
			activeEnemyMinesList.Add(misTmp);
		}
	}
	private void CalculatePath()
	{
		if(side==MissleSide.ENEMY)
		{
			target=GameStorage.getInstance().getNearbyFriendly(this);
			if(target!=null)
			{
				v2tmp1 = new Vector2(target.transform.position.x-transform.position.x,target.transform.position.z-transform.position.z);
				v2tmp2 = TagsStorage.oneVec;
				f1tmp = (v2tmp2.x*v2tmp1.y - v2tmp2.y*v2tmp1.x); // sinphi
				f2tmp = Vector2.Angle(v2tmp1,v2tmp2); // mangle
				if(f1tmp>=0)
					f2tmp=(180-f2tmp)+180;
				
				between = GameStorage.getInstance().getAngleDst(transform.eulerAngles.y,f2tmp);
				
				
				if(Mathf.Abs(between)>maxAngle)
				{
					if(between>0)
						newAngle=Mathf.Repeat(transform.eulerAngles.y-maxAngle,360);
					else
						newAngle=Mathf.Repeat(transform.eulerAngles.y+maxAngle,360);
				}
				else
					newAngle=Mathf.Repeat(transform.eulerAngles.y-between,360);
				
				targetPosition=Quaternion.Euler(0,0,-newAngle)*new Vector2(0,Random.Range(minLen,maxLen));
				attackIcon.transform.position=new Vector3(targetPosition.x+transform.position.x,5,targetPosition.y+transform.position.z);
			}
		}
		
		point1=new Vector2(transform.position.x,transform.position.z);
		point2=Quaternion.Euler(0,0,-transform.eulerAngles.y)*new Vector2(0,minLen*Mathf.Abs(getAngleDst(transform.eulerAngles.y,getAttackIconAngle())/maxAngle)*Vector2.Distance(point1,point4)/maxLen)*lowerSmooth;
		point2+=point1;
		point4=new Vector2(attackIcon.transform.position.x,attackIcon.transform.position.z);
		pointz = new Vector2(point4.x-point2.x,point4.y-point2.y)/2;
		point3 = new Vector2(pointz.y,-pointz.x)*getAngleDst(transform.eulerAngles.y,getAttackIconAngle())/maxAngle*Vector2.Distance(point1,point4)/maxLen*upperSmooth;
		point3 = point3+point2+pointz;
		
		if(side==MissleSide.FRIENDLY)
		{
			i=0;
			for(tt=0f;tt<=1;tt+=step)
			{
				x = Mathf.Pow((1-tt),3)*point1.x+3*(1-tt)*(1-tt)*tt*point2.x+3*(1-tt)*tt*tt*point3.x+tt*tt*tt*point4.x;
				y = Mathf.Pow((1-tt),3)*point1.y+3*(1-tt)*(1-tt)*tt*point2.y+3*(1-tt)*tt*tt*point3.y+tt*tt*tt*point4.y;
				lineRenderer.SetPosition(i,new Vector3(x,0,y));
				if(i==49)
				{
					v2tmp2.x=x;
					v2tmp2.y=y;
				}
				else if(i==50)
				{
					
					v2tmp2.x=x-v2tmp2.x;
					v2tmp2.y=y-v2tmp2.y;
					v2tmp1 = TagsStorage.oneVec;
					f1tmp = (v2tmp1.x*v2tmp2.y - v2tmp1.y*v2tmp2.x);
					f2tmp = Vector2.Angle(v2tmp1,v2tmp2);
					if(f1tmp<=0)
						attackAngleMov= f2tmp;
					else
						attackAngleMov = (180-f2tmp)+180;
					attackIcon.transform.localEulerAngles=new Vector3(0,180,-attackAngleMov+270+transform.eulerAngles.y);
					attackIcon.transform.GetChild(0).transform.eulerAngles=new Vector3(90,attackAngleMov+270,0);
				}
				
				i++;
			}	
		}	
	}
    private void CalculatePath()
    {
        if (side == MissleSide.ENEMY)
        {
            target = GameStorage.getInstance().getNearbyFriendly(this);
            if (target != null)
            {
                v2tmp1 = new Vector2(target.transform.position.x - transform.position.x, target.transform.position.z - transform.position.z);
                v2tmp2 = TagsStorage.oneVec;
                f1tmp  = (v2tmp2.x * v2tmp1.y - v2tmp2.y * v2tmp1.x); // sinphi
                f2tmp  = Vector2.Angle(v2tmp1, v2tmp2);               // mangle
                if (f1tmp >= 0)
                {
                    f2tmp = (180 - f2tmp) + 180;
                }

                between = GameStorage.getInstance().getAngleDst(transform.eulerAngles.y, f2tmp);


                if (Mathf.Abs(between) > maxAngle)
                {
                    if (between > 0)
                    {
                        newAngle = Mathf.Repeat(transform.eulerAngles.y - maxAngle, 360);
                    }
                    else
                    {
                        newAngle = Mathf.Repeat(transform.eulerAngles.y + maxAngle, 360);
                    }
                }
                else
                {
                    newAngle = Mathf.Repeat(transform.eulerAngles.y - between, 360);
                }

                targetPosition = Quaternion.Euler(0, 0, -newAngle) * new Vector2(0, Random.Range(minLen, maxLen));
                attackIcon.transform.position = new Vector3(targetPosition.x + transform.position.x, 5, targetPosition.y + transform.position.z);
            }
        }

        point1  = new Vector2(transform.position.x, transform.position.z);
        point2  = Quaternion.Euler(0, 0, -transform.eulerAngles.y) * new Vector2(0, minLen * Mathf.Abs(getAngleDst(transform.eulerAngles.y, getAttackIconAngle()) / maxAngle) * Vector2.Distance(point1, point4) / maxLen) * lowerSmooth;
        point2 += point1;
        point4  = new Vector2(attackIcon.transform.position.x, attackIcon.transform.position.z);
        pointz  = new Vector2(point4.x - point2.x, point4.y - point2.y) / 2;
        point3  = new Vector2(pointz.y, -pointz.x) * getAngleDst(transform.eulerAngles.y, getAttackIconAngle()) / maxAngle * Vector2.Distance(point1, point4) / maxLen * upperSmooth;
        point3  = point3 + point2 + pointz;

        if (side == MissleSide.FRIENDLY)
        {
            i = 0;
            for (tt = 0f; tt <= 1; tt += step)
            {
                x = Mathf.Pow((1 - tt), 3) * point1.x + 3 * (1 - tt) * (1 - tt) * tt * point2.x + 3 * (1 - tt) * tt * tt * point3.x + tt * tt * tt * point4.x;
                y = Mathf.Pow((1 - tt), 3) * point1.y + 3 * (1 - tt) * (1 - tt) * tt * point2.y + 3 * (1 - tt) * tt * tt * point3.y + tt * tt * tt * point4.y;
                lineRenderer.SetPosition(i, new Vector3(x, 0, y));
                if (i == 49)
                {
                    v2tmp2.x = x;
                    v2tmp2.y = y;
                }
                else if (i == 50)
                {
                    v2tmp2.x = x - v2tmp2.x;
                    v2tmp2.y = y - v2tmp2.y;
                    v2tmp1   = TagsStorage.oneVec;
                    f1tmp    = (v2tmp1.x * v2tmp2.y - v2tmp1.y * v2tmp2.x);
                    f2tmp    = Vector2.Angle(v2tmp1, v2tmp2);
                    if (f1tmp <= 0)
                    {
                        attackAngleMov = f2tmp;
                    }
                    else
                    {
                        attackAngleMov = (180 - f2tmp) + 180;
                    }
                    attackIcon.transform.localEulerAngles = new Vector3(0, 180, -attackAngleMov + 270 + transform.eulerAngles.y);
                    attackIcon.transform.GetChild(0).transform.eulerAngles = new Vector3(90, attackAngleMov + 270, 0);
                }

                i++;
            }
        }
    }
Beispiel #13
0
	public void toggleShowAllAttackIcons(FriendlySpaceship exclude)
	{
		foreach(FriendlySpaceship obj in friendlySpaceships)
			if(obj!=exclude)
				obj.showAttackIcon();
		MisslePoolManager.getInstance().ToggleShowAllAttackIcons(null);
	}
Beispiel #14
0
	public EnemySpaceship getEnemyInFireZone(FriendlySpaceship friendlyShuttle, Templates.GunOnShuttle gun)
	{
		EnemySpaceship 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(EnemySpaceship enemy in enemySpaceships)
		{
			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;
	}