using Assets.src.player;

public class BM
{
	private const int bombangle = 0;

	private const sbyte bombForce = 5;

	public const int rangeActive = 165;

	public const int airPlaneStartX = 400;

	public const int airPlaneStartY = 320;

	public static Image airFighter;

	public MyVector bullets = new MyVector();

	public sbyte numShoot;

	private int x;

	private int y;

	public static int angle;

	public static sbyte force;

	private sbyte type;

	private sbyte whoShot;

	private sbyte delayBullCound = -1;

	private sbyte delayBullType = -1;

	private int nDelayBull = 1;

	private int nLazerDelay;

	private int nMeteorDelay;

	private int timedelay;

	private bool isEndDelayBull = true;

	public static bool active = false;

	private static bool isActiveAirFly;

	private static bool isActiveBomBay;

	private static bool isActiveLazer;

	public static bool isActiveTornado;

	private static bool isAciveExplore;

	private static bool isActiveEgg;

	private static bool isActiveMeteor;

	private static bool isActive4Missile;

	private static bool isActiveMissileRain;

	public int nBull;

	private static int nArray = 20;

	public static int nBum = 0;

	public static int[] bumX = new int[nArray];

	public static int[] bumY = new int[nArray];

	public static int[] bumX_Last = new int[nArray];

	public static int[] bumY_Last = new int[nArray];

	public static int airPlaneStartVx = 20;

	public static int airPlaneX;

	public static int airPlaneY;

	private int airPlaneVx;

	private static int lazerX;

	private static int lazerY;

	private static int tonardoX;

	private static int tonardoY;

	public static MyVector vTornado = new MyVector();

	private static int exploreX;

	private static int exploreY;

	private static sbyte exploreForce;

	private static int exploreAngel;

	private static int exploreVx;

	private static int exploreVy;

	public static bool allSendENDSHOOT = false;

	public static bool shootNextStep = true;

	private static int eggX;

	private static int eggY;

	private static int meteorX;

	private static int meteorY;

	private static int meteorDesX;

	private static int meteorDesY;

	private static int missileXS;

	private static int missileYS;

	private static int missileXD;

	private static int missileYD;

	private static int missileP;

	private static int missleAngle;

	private static int mRainX;

	private static int mRainY;

	private int nWasShoot;

	private static int xChicken;

	private static int yChicken;

	public static int nOrbit;

	public static bool activeUFOLazer;

	public static MyVector lazerPosition = new MyVector();

	private short[][] xPaint;

	private short[][] yPaint;

	private short[][] xHit;

	private short[][] yHit;

	private int bIndex;

	public static sbyte force2;

	public static bool isBombBalloon;

	public sbyte critical;

	public int idBullet;

	private bool isDouble;

	public static bool isPrepareShooting;

	private int tPrepareShoot;

	private bool endShoot;

	public BM()
	{
		active = false;
		nBull = 0;
		numShoot = 0;
	}

	public static void loadImage()
	{
		airFighter = CCanvas.loadImage("/gui/fighter.png");
	}

	public void setBullType(sbyte critical, sbyte whoShot, sbyte type, short[][] xPaint, short[][] yPaint, sbyte nShoot, sbyte force2, short[][] xHit, short[][] yHit, int idBullet)
	{
		this.type = type;
		this.xPaint = xPaint;
		this.yPaint = yPaint;
		this.xHit = xHit;
		this.yHit = yHit;
		this.critical = critical;
		this.idBullet = idBullet;
		xChicken = x;
		yChicken = y;
		this.whoShot = whoShot;
		BM.force2 = force2;
		active = true;
		numShoot = nShoot;
		if (numShoot == 2)
		{
			isDouble = true;
		}
		nWasShoot = 1;
		bIndex = 0;
		allSendENDSHOOT = false;
		shootNextStep = true;
		endShoot = false;
		isBombBalloon = false;
		if (type == 43)
		{
			isBombBalloon = true;
		}
	}

	private void createShootInfo()
	{
		CRes.outz("CReateBullet nShoot: " + numShoot);
		isEndDelayBull = true;
		nBum = 0;
		for (int i = 0; i < nArray; i++)
		{
			bumX[i] = -1;
			bumY[i] = -1;
			bumX_Last[i] = -1;
			bumY_Last[i] = -1;
		}
		CRes.outz("CReateBullet after nShoot: " + numShoot);
		createBullet(type);
		CRes.outz("CReateBullet xong");
		bool flag = true;
		int index = 0;
		switch (type)
		{
		case 0:
		case 32:
		case 40:
		case 41:
		case 48:
		case 49:
			nBull = 1;
			break;
		case 1:
			delayBullType = 10;
			isEndDelayBull = false;
			nBull = ((critical != 0) ? 6 : 2);
			break;
		case 2:
			index = 1;
			if (critical == 0)
			{
				nBull = 3;
			}
			if (critical == 1)
			{
				nBull = 7;
			}
			break;
		case 4:
			isActiveAirFly = false;
			isActiveBomBay = false;
			airPlaneX = 400;
			airPlaneY = airPlaneStartVx;
			nBull = 2;
			break;
		case 5:
		case 36:
			nBull = 1;
			break;
		case 6:
			index = 1;
			nBull = 3;
			break;
		case 7:
		case 31:
			nBull = 1;
			break;
		case 8:
			nBull = 1;
			break;
		case 9:
			nBull = 4;
			break;
		case 10:
			if (critical == 0 || critical == 1)
			{
				delayBullType = 10;
				isEndDelayBull = false;
				nBull = 3;
			}
			break;
		case 11:
			delayBullType = 10;
			isEndDelayBull = false;
			nBull = ((critical != 0) ? 10 : 5);
			break;
		case 16:
			nBull = 7;
			break;
		case 14:
			nBull = 2;
			break;
		case 13:
			nBull = 1;
			break;
		case 19:
			nBull = 1;
			break;
		case 23:
			nBull = 8;
			break;
		case 26:
			nBull = 5;
			break;
		case 17:
			nBull = 1;
			break;
		case 28:
			nBull = 14;
			break;
		case 30:
			nBull = 1;
			break;
		case 21:
			nBull = 1;
			break;
		case 25:
			nBull = 1;
			break;
		case 22:
			nBull = 1;
			break;
		case 33:
			delayBullType = 5;
			isEndDelayBull = false;
			nBull = 5;
			break;
		case 34:
			nBull = 1;
			break;
		case 35:
			nBull = 1;
			break;
		case 37:
			delayBullType = 5;
			isEndDelayBull = false;
			nBull = 4;
			break;
		case 42:
			nBull = 1;
			break;
		case 43:
			delayBullType = 11;
			isEndDelayBull = false;
			nBull = 10;
			break;
		case 44:
			delayBullType = 3;
			isEndDelayBull = false;
			nBull = 15;
			break;
		case 45:
			nBull = 1;
			break;
		case 47:
			delayBullType = 2;
			isEndDelayBull = false;
			nBull = 5;
			break;
		case 51:
			nBull = 1;
			break;
		case 50:
			nBull = 1;
			break;
		case 52:
			nBull = 1;
			break;
		case 58:
			nBull = 1;
			break;
		case 54:
			nBull = 1;
			break;
		case 55:
			nBull = 1;
			break;
		case 56:
			nBull = 3;
			break;
		case 57:
			nBull = 1;
			break;
		case 59:
			nBull = 2;
			break;
		}
		if (flag && type != 43)
		{
			GameScr.cam.setBulletMode((Bullet)bullets.elementAt(index));
		}
		nDelayBull = nBull;
		delayBullCound = delayBullType;
	}

	private void createBullet(sbyte Type)
	{
		CRes.outz(nBull + " ************** " + bIndex);
		if (bIndex == xPaint.Length)
		{
			endShootz();
			return;
		}
		int num = nBull * (nWasShoot - 1);
		if (PM.p[whoShot] != null && PM.p[whoShot].GetType() == typeof(BigBoss))
		{
			if (PM.p[whoShot].type == 2)
			{
				bullets.addElement(new Bullet(59, xPaint[bIndex], yPaint[bIndex], whoShot, idBullet));
				bIndex++;
				return;
			}
			if (PM.p[whoShot].type == 1)
			{
				bullets.addElement(new Bullet(60, xPaint[bIndex], yPaint[bIndex], whoShot, idBullet));
				bIndex++;
				return;
			}
		}
		switch (Type)
		{
		case 0:
		case 49:
		{
			Bullet o = new Bullet(Type, xPaint[bIndex], yPaint[bIndex], whoShot, idBullet);
			bullets.addElement(o);
			bIndex++;
			break;
		}
		case 32:
		case 34:
		case 35:
		case 37:
		case 41:
		case 42:
		case 45:
		case 50:
		case 51:
		case 52:
		case 54:
		case 55:
		case 57:
		case 58:
			bullets.addElement(new Bullet(Type, xPaint[bIndex], yPaint[bIndex], whoShot));
			bIndex++;
			break;
		case 48:
			bullets.addElement(new Bullet(Type, xPaint[bIndex], yPaint[bIndex], whoShot, xHit[bIndex], yHit[bIndex]));
			bIndex++;
			break;
		case 43:
			bullets.addElement(new Bullet(Type, xPaint[bIndex], yPaint[bIndex], whoShot));
			bIndex++;
			break;
		case 10:
			bullets.addElement(new Bullet(Type, xPaint[bIndex], yPaint[bIndex], whoShot, idBullet));
			bIndex++;
			break;
		case 1:
			bullets.addElement(new Bullet(Type, xPaint[bIndex], yPaint[bIndex], whoShot, idBullet));
			bIndex++;
			break;
		case 33:
		case 44:
		case 47:
			bullets.addElement(new Bullet(Type, xPaint[bIndex], yPaint[bIndex], whoShot));
			bIndex++;
			break;
		case 11:
			CRes.outz("ID BULLET= " + idBullet + " @@@@@ bIndex=" + bIndex + " //// xP len=" + xPaint.Length + " , " + yPaint.Length);
			bullets.addElement(new Bullet(Type, xPaint[bIndex], yPaint[bIndex], whoShot, idBullet));
			bIndex++;
			break;
		case 2:
		{
			int num2 = ((critical != 0) ? 7 : 3);
			for (int l = 0; l < num2; l++)
			{
				bullets.addElement(new Bullet(Type, xPaint[l + bIndex], yPaint[l + bIndex], whoShot, idBullet));
			}
			bIndex += num2;
			break;
		}
		case 56:
		{
			for (int num5 = 0; num5 < 3; num5++)
			{
				bullets.addElement(new Bullet(Type, xPaint[num5 + bIndex], yPaint[num5 + bIndex], whoShot));
			}
			bIndex += 3;
			break;
		}
		case 3:
			bullets.addElement(new Bullet(Type, xPaint[1], yPaint[1], whoShot));
			GameScr.isDarkEffect = false;
			break;
		case 4:
			bullets.addElement(new Bullet(Type, xPaint[0], yPaint[0], whoShot));
			break;
		case 5:
		case 36:
			bullets.addElement(new Bullet(Type, xPaint[0], yPaint[0], whoShot));
			break;
		case 6:
		{
			for (int num4 = 0; num4 < 3; num4++)
			{
				bullets.addElement(new Bullet(Type, xPaint[num4], yPaint[num4], whoShot, idBullet));
			}
			break;
		}
		case 7:
		case 31:
			bullets.addElement(new Bullet(Type, xPaint[0], yPaint[0], whoShot));
			break;
		case 8:
			bullets.addElement(new Bullet(Type, xPaint[0], yPaint[0], whoShot));
			break;
		case 9:
		{
			for (int num3 = 0; num3 < 4; num3++)
			{
				bullets.addElement(new Bullet(Type, xPaint[num3 + bIndex], yPaint[num3 + bIndex], whoShot, idBullet));
			}
			bIndex += 4;
			break;
		}
		case 16:
			bullets.addElement(new Bullet(16, xPaint[0], yPaint[0], whoShot));
			break;
		case 12:
		{
			for (int n = 1; n <= 6; n++)
			{
				bullets.addElement(new Bullet(Type, xPaint[n], yPaint[n], whoShot));
			}
			break;
		}
		case 14:
		case 40:
			bullets.addElement(new Bullet(Type, xPaint[0], yPaint[0], whoShot));
			break;
		case 15:
			bullets.addElement(new Bullet(Type, xPaint[1], yPaint[1], whoShot));
			break;
		case 19:
			bullets.addElement(new Bullet(Type, xPaint[bIndex], yPaint[bIndex], whoShot, idBullet));
			bIndex++;
			break;
		case 13:
		case 17:
			bullets.addElement(new Bullet(Type, xPaint[bIndex], yPaint[bIndex], whoShot, idBullet));
			bIndex++;
			break;
		case 20:
			bullets.addElement(new Bullet(Type, xPaint[bIndex], yPaint[bIndex], whoShot));
			nBull++;
			bIndex++;
			break;
		case 18:
			if (!endShoot)
			{
				for (int m = 0; m < 3; m++)
				{
					bullets.addElement(new Bullet(Type, xPaint[bIndex], yPaint[bIndex], whoShot, idBullet));
					bIndex++;
				}
			}
			break;
		case 21:
			bullets.addElement(new Bullet(Type, xPaint[bIndex], yPaint[bIndex], whoShot, idBullet));
			bIndex++;
			break;
		case 22:
			bullets.addElement(new Bullet(Type, xPaint[bIndex], yPaint[bIndex], whoShot));
			break;
		case 23:
			bullets.addElement(new Bullet(Type, xPaint[0], yPaint[0], whoShot));
			break;
		case 24:
		{
			for (int k = 1; k <= 7; k++)
			{
				bullets.addElement(new Bullet(Type, xPaint[k], yPaint[k], whoShot));
			}
			break;
		}
		case 25:
			bullets.addElement(new Bullet(Type, xPaint[0], yPaint[0], whoShot));
			break;
		case 26:
			bullets.addElement(new Bullet(Type, xPaint[0], yPaint[0], whoShot));
			break;
		case 27:
		{
			for (int j = 1; j <= 4; j++)
			{
				bullets.addElement(new Bullet(Type, xPaint[j], yPaint[j], whoShot));
			}
			break;
		}
		case 28:
			bullets.addElement(new Bullet(Type, xPaint[0], yPaint[0], whoShot));
			break;
		case 29:
		{
			for (int i = 1; i <= 13; i++)
			{
				bullets.addElement(new Bullet(Type, xPaint[i], yPaint[i], whoShot));
			}
			break;
		}
		case 30:
			bullets.addElement(new Bullet(Type, xPaint[0], yPaint[0], whoShot));
			break;
		case 38:
		case 39:
		case 46:
		case 53:
			break;
		}
	}

	public void update()
	{
		if (isPrepareShooting)
		{
			tPrepareShoot++;
			if (tPrepareShoot > 35)
			{
				isPrepareShooting = false;
				tPrepareShoot = 0;
				if (!BackgroundNew.lowGraphic)
				{
					PM.getCurPlayer().isLuaDauNong = true;
				}
			}
			return;
		}
		for (int i = 0; i < bullets.size(); i++)
		{
			((Bullet)bullets.elementAt(i)).update();
		}
		if (!isEndDelayBull)
		{
			if (!isBombBalloon)
			{
				delayBullCound--;
				if (delayBullCound == 0 && nDelayBull > 0)
				{
					createBullet(type);
					delayBullCound = delayBullType;
					nDelayBull--;
					if (nDelayBull <= 1)
					{
						isEndDelayBull = true;
						nDelayBull = 1;
					}
				}
			}
			else
			{
				CPlayer cPlayer = PM.p[whoShot];
				if (xPaint[bIndex][0] <= cPlayer.x + 50 && xPaint[bIndex][0] >= cPlayer.x - 50)
				{
					createBullet(type);
					nDelayBull--;
					if (nDelayBull <= 1)
					{
						isEndDelayBull = true;
						nDelayBull = 1;
					}
				}
			}
		}
		else if (bullets.size() == 0 && nBull <= 0 && numShoot > 0 && !allSendENDSHOOT)
		{
			createShootInfo();
			numShoot--;
			nWasShoot++;
			if (nWasShoot == numShoot)
			{
				nWasShoot = 0;
			}
		}
		if (isActiveAirFly)
		{
			airPlaneX += ((!CScreen.isUseHighFrameRate()) ? airPlaneStartVx : (airPlaneStartVx / 2));
			if (!isActiveBomBay && airPlaneX >= x - 165)
			{
				createBullet(3);
				GameScr.cam.setBulletMode((Bullet)bullets.elementAt(0));
				isActiveBomBay = true;
			}
			if (airPlaneX >= MM.mapWidth)
			{
				isActiveAirFly = false;
			}
		}
		if (isActiveLazer && !CScreen.highFrameRate())
		{
			nLazerDelay++;
			if (nLazerDelay == 10)
			{
				GameScr.cam.setTargetPointMode(lazerX, 100);
			}
			if (nLazerDelay == 20)
			{
				nLazerDelay = 0;
				isActiveLazer = false;
				createBullet(15);
				GameScr.cam.setLazerMode((Bullet)bullets.elementAt(0));
			}
		}
		if (vTornado.size() != 0)
		{
			isActiveTornado = true;
			for (int j = 0; j < vTornado.size(); j++)
			{
				((Tornado)vTornado.elementAt(j)).update();
			}
		}
		else
		{
			isActiveTornado = false;
		}
		if (isAciveExplore)
		{
			isAciveExplore = false;
			createBullet(18);
			GameScr.cam.setBulletMode((Bullet)bullets.elementAt(0));
		}
		if (isActiveEgg)
		{
			isActiveEgg = false;
			createBullet(20);
			if (eggX > -500 && eggY > -500)
			{
				GameScr.cam.setBulletMode((Bullet)bullets.elementAt(bullets.size() - 1));
			}
		}
		if (isActiveMeteor)
		{
			nMeteorDelay++;
			if (nMeteorDelay == 20)
			{
				nMeteorDelay = 0;
				isActiveMeteor = false;
				createBullet(24);
				GameScr.cam.setMeteorMode((Bullet)bullets.elementAt(0));
			}
		}
		if (isActive4Missile)
		{
			isActive4Missile = false;
			createBullet(27);
			GameScr.cam.setBulletMode((Bullet)bullets.elementAt(0));
		}
		if (isActiveMissileRain)
		{
			isActiveMissileRain = false;
			createBullet(29);
			GameScr.cam.setMRainMode((Bullet)bullets.elementAt(0));
		}
		if (activeUFOLazer && CCanvas.gameTick % 3 == 0)
		{
			if (lazerPosition.size() != 0)
			{
				Position position = (Position)lazerPosition.elementAt(0);
				GameScr.sm.addLazer(position.xF, position.yF, position.xT, position.yT, 1);
				int num = position.xT + CRes.random(-35, 35);
				int num2 = position.yT + CRes.random(-10, 10);
				new Explosion(position.xT, position.yT, 9);
				new Explosion(num, num2, 9);
				new Explosion(num + CRes.random(-30, 30), num2 + CRes.random(-10, 10), 9);
				lazerPosition.removeElement(position);
			}
			else
			{
				activeUFOLazer = false;
			}
		}
	}

	public void removeAll(int x, int y, int x_Last, int y_Last, sbyte whoShot)
	{
		for (int i = 0; i < bullets.size(); i++)
		{
			Bullet b = (Bullet)bullets.elementAt(i);
			removeBullet(b, true, x, y, x_Last, y_Last, whoShot);
		}
	}

	public void paint(mGraphics g)
	{
		for (int i = 0; i < bullets.size(); i++)
		{
			((Bullet)bullets.elementAt(i)).paint(g);
		}
		if (isActiveAirFly)
		{
			g.drawImage(airFighter, airPlaneX, airPlaneY + CCanvas.gameTick % 3, mGraphics.VCENTER | mGraphics.HCENTER, false);
		}
		if (isActiveLazer && nLazerDelay > 5 && nLazerDelay < 20)
		{
			g.setColor(16771821);
			g.fillRect(lazerX - 2, -100, 4, lazerY + 100, false);
		}
		if (isActiveTornado)
		{
			for (int j = 0; j < vTornado.size(); j++)
			{
				((Tornado)vTornado.elementAt(j)).paint(g);
			}
		}
	}

	public bool isHaveEgg()
	{
		for (int i = 0; i < bullets.size(); i++)
		{
			if (((Bullet)bullets.elementAt(i)).type == 20)
			{
				return true;
			}
		}
		return false;
	}

	public void removeBullet(Bullet b, bool isExplode, int x, int y, int x_Last, int y_Last, sbyte whoShot)
	{
		bullets.removeElement(b);
		if (bullets.size() > 0)
		{
			Bullet bullet = (Bullet)bullets.elementAt(0);
			if (bullet.type != 19 && bullet.type != 43)
			{
				if (bullet.type == 29)
				{
					GameScr.cam.setMRainMode(bullet);
				}
				else
				{
					GameScr.cam.setBulletMode(bullet);
				}
			}
		}
		if (!Bullet.isFlagBull(b.type) || type == 14)
		{
			nBum++;
			int num = nBum - 1;
			if (isExplode)
			{
				bumX[num] = x;
				bumY[num] = y;
				bumX_Last[num] = x_Last;
				bumY_Last[num] = y_Last;
			}
			else
			{
				bumX[num] = -1;
				bumY[num] = -1;
				bumX_Last[num] = -1;
				bumY_Last[num] = -1;
			}
		}
		if (Bullet.isFlagBull(b.type))
		{
			if (isExplode)
			{
				this.x = x;
				this.y = y;
			}
			else
			{
				nBull = 1;
			}
		}
		if (type == 19)
		{
			this.x = xChicken;
			this.y = yChicken;
		}
		nBull--;
		if (nBull <= 0 && numShoot <= 0)
		{
			nBull = 0;
			numShoot = 0;
			if (whoShot == GameScr.myIndex)
			{
				allSendENDSHOOT = true;
				shootNextStep = true;
			}
			if (numShoot == 0)
			{
				endShootz();
				if (PM.p[whoShot] != null && PM.p[whoShot].GetType() == typeof(BigBoss))
				{
					PM.p[whoShot].state = 0;
				}
			}
			mSystem.mNotify();
			GameService.gI().check_cross((sbyte)nBum, bumX_Last, bumY_Last);
		}
		CRes.outz("REMOVE " + bullets.size() + " nBull= " + nBull + " nBoom= " + nBum);
	}

	public static void removeTornado()
	{
		vTornado.removeAllElements();
	}

	public void tornadoTurnUpd()
	{
		if (isActiveTornado)
		{
			for (int i = 0; i < vTornado.size(); i++)
			{
				Tornado tornado = (Tornado)vTornado.elementAt(i);
				tornado.nturn--;
			}
		}
	}

	public void endShootz()
	{
		active = false;
		nBull = 0;
		numShoot = 0;
		endShoot = true;
		CPlayer.isStopFire = false;
		tornadoTurnUpd();
		CRes.outz("END SHOOT");
		CCanvas.lockNotify = true;
		CCanvas.tNotify = 0;
		CPlayer.closeMirror = true;
	}

	public void activeAirplane(int X, int Y)
	{
		isActiveAirFly = true;
		airPlaneX = X - 400;
		airPlaneY = Y - 320;
		GameScr.cam.setTargetPointMode(X - 180, Y - 320);
		GameScr.isDarkEffect = false;
	}

	public void activeLazer(int X, int Y)
	{
		isActiveLazer = true;
		lazerX = X;
		lazerY = Y;
		GameScr.cam.setTargetPointMode(X, Y);
	}

	public void activeTornado(int X, int Y)
	{
		vTornado.addElement(new Tornado(X, Y, 3));
		tonardoX = X;
		tonardoY = Y;
	}

	public void activeExplore(int XD, int YD, int X, int Y, int VX, int VY, int force, int angle)
	{
		isAciveExplore = true;
		exploreX = X;
		exploreY = Y;
		exploreVx = 0;
		exploreVy = 0;
		exploreForce = (sbyte)force;
		int dx = x - X;
		int dy = y - Y;
		int num = CRes.angle(dx, dy);
		exploreForce = (sbyte)(force / 2);
		exploreAngel = 180 - (angle + num);
	}

	public void activeEgg(int X, int Y)
	{
		isActiveEgg = true;
		eggX = X;
		eggY = Y;
	}

	public void activeMortarBum(int x, int y)
	{
		this.x = x;
		this.y = y - 500;
		createBullet(12);
	}

	public void active4Missle(int XSource, int YSource, int XDes, int YDes)
	{
		isActive4Missile = true;
		missileXS = XSource;
		missileYS = YSource;
		missileXD = XDes;
		missileYD = YDes;
		missileP = ((angle < 90 && angle > -90) ? 1 : (-1));
		missleAngle = ((missileP <= 0) ? (180 - angle) : angle);
	}

	public void activeMeteor(int X, int Y, int angle)
	{
		isActiveMeteor = true;
		meteorX = X;
		meteorY = -30;
		meteorDesX = X;
		meteorDesY = Y;
	}

	public void activeMissleRain(int X, int Y)
	{
		isActiveMissileRain = true;
		mRainX = X;
		mRainY = Y;
	}
}
