Merge pull request #29 from lr8soft/dev-y

lr8soft · web-flow · commit 6d6ce3d87a58 · 2019-10-29T11:18:44.000+08:00
v0.32_update1
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
diff --git a/PythonSTG/XCCore/Attack/NormalStrike.cpp b/PythonSTG/XCCore/Attack/NormalStrike.cpp
@@ -95,7 +95,7 @@ void NormalStrike::checkCollisionWithBoss(BossObject * pBoss)
 		float cornerDistance_sq = pow((distX - width / 2), 2) + pow(distY - height / 2, 2);
 		if (distX <= (width / 2) || distY <= (height / 2) || cornerDistance_sq <= pow(collisionRadius, 2)) {
 			ParticleHelper* particleGroup = new ParticleHelper;
-			particleGroup->addNewParticle(6, 15.0f, 0.6f, 0.4f, glm::vec4(1.0f), glm::vec3(NowPosition[0], NowPosition[1],0.0f));
+			particleGroup->addNewParticle(6, 12.0f, 0.6f, 0.4f, glm::vec4(1.0f), glm::vec3(NowPosition[0], NowPosition[1],0.0f));
 			RenderManager::getInstance()->AddRenderObject(ParticleGroupUuid, particleGroup);
 
 			pBoss->hurtBossObject(0.2f);
@@ -116,7 +116,7 @@ void NormalStrike::checkCollisionWithEnemy(EnemyObject * pEnemy)
 		if (enemyPosition[0] <= NowPosition[0] + halfWidth && enemyPosition[0] >= NowPosition[0] - halfWidth){
 			if (enemyPosition[1] <= NowPosition[1] + halfHeight && enemyPosition[1] >= lastY - halfHeight) {
 				ParticleHelper* particleGroup = new ParticleHelper;
-				particleGroup->addNewParticle(6, 15.0f, 0.6f, 0.4f, glm::vec4(1.0f), enemyPosition);
+				particleGroup->addNewParticle(6, 12.0f, 0.6f, 0.4f, glm::vec4(1.0f), enemyPosition);
 				RenderManager::getInstance()->AddRenderObject(ParticleGroupUuid, particleGroup);
 
 				pEnemy->hurtEnemy(0.2f);
diff --git a/PythonSTG/XCCore/Bullet/BulletHelper.cpp b/PythonSTG/XCCore/Bullet/BulletHelper.cpp
@@ -17,8 +17,8 @@ Bullet * BulletHelper::getNewBulletObject(std::string bulletImage,std::string bu
 			particleDensity, particleFinishTime, particleVelocity, particleSize, particleColor);
 	}
 	else if (bulletType == "rectangleTypeBullet") {
-		/*bullet = new RectangleTypeBullet(bulletImage, divideInfo, scaleInfo, collideSize, initCoord, velocity, acceleration, angle, increateAngle, reboundTime, aimPlayer,
-			particleDensity, particleFinishTime, particleVelocity, particleSize, particleColor);*/
+		bullet = new RectangleTypeBullet(bulletImage, divideInfo, scaleInfo, collideSize, initCoord, velocity, acceleration, angle, increateAngle, reboundTime, aimPlayer,
+			particleDensity, particleFinishTime, particleVelocity, particleSize, particleColor);
 	}
 	return bullet;
 }
diff --git a/PythonSTG/XCCore/Bullet/CircleTypeBullet.cpp b/PythonSTG/XCCore/Bullet/CircleTypeBullet.cpp
@@ -89,7 +89,7 @@ void CircleTypeBullet::Release()
 bool CircleTypeBullet::BulletCollideWithPoint(float x, float y,bool &haveGraze)
 {
 	bool value = false;
-	if (isInit && timer.getAccumlateTime() >=0.1f) {
+	if (isInit && timer.getAccumlateTime() >=0.2f) {
 		float distance = (x - NowPosition[0])*(x - NowPosition[0]) + (y - NowPosition[1])*(y - NowPosition[1]);
 		float parameter = collideSize[0] * collideSize[0];
 
diff --git a/PythonSTG/XCCore/Bullet/OvalTypeBullet.cpp b/PythonSTG/XCCore/Bullet/OvalTypeBullet.cpp
@@ -92,12 +92,13 @@ void OvalTypeBullet::Release()
 bool OvalTypeBullet::BulletCollideWithPoint(float x, float y, bool &haveGraze)
 {
 	bool value = false;
-	if (isInit && timer.getAccumlateTime() >= 0.1f) {
+	if (isInit && timer.getAccumlateTime() >= 0.2f) {
 		x -= NowPosition[0];
 		y -= NowPosition[1];
 
-		float NewX = x * cos(angle) + y * sin(angle);
-		float NewY = -x * sin(angle) + y * cos(angle);
+		float theta = glm::radians(angle);
+		float NewX = x * cos(theta) + y * sin(theta);
+		float NewY = -x * sin(theta) + y * cos(theta);
 
 		float distance = pow(NewX, 2) + pow(NewY, 2);
 		float ovalParameter = pow(NewX, 2) / pow(collideSize.x, 2) + pow(NewY, 2) / pow(collideSize.y, 2);
diff --git a/PythonSTG/XCCore/Bullet/RectangleTypeBullet.cpp b/PythonSTG/XCCore/Bullet/RectangleTypeBullet.cpp
@@ -1,8 +1,13 @@
 #include "RectangleTypeBullet.h"
 #include "../../XCFrameInfo.h"
+#include "../XCCollide/CollideInfo.h"
+#include "../XCRender/ParticleHelper.h"
+#include "../XCRender/RenderManager.h"
 #include <GL3/gl3w.h>
 #include <iostream>
-RectangleTypeBullet::RectangleTypeBullet(std::string bulletImagePath, glm::vec4 dInfo, glm::vec3 sInfo,glm::vec3 cSize ,glm::vec3 initCoord, float v, float a, float agl, float incA, int rbTime, bool ap)
+RectangleTypeBullet::RectangleTypeBullet(std::string bulletImagePath, glm::vec4 dInfo, glm::vec3 sInfo,glm::vec3 cSize ,glm::vec3 initCoord,
+	float v, float a, float agl, float incA, int rbTime, bool ap,
+	int pDensity, float pFinishTime, float pVelocity, float pSize, glm::vec4 pColor)
 {
 	imagePath = bulletImagePath;
 
@@ -19,6 +24,12 @@ RectangleTypeBullet::RectangleTypeBullet(std::string bulletImagePath, glm::vec4
 	increaseAngle = incA;
 	reBoundTime = rbTime;
 	aimToPlayer = ap;
+	//release part
+	particleDensity = pDensity;
+	particleFinishTime = pFinishTime;
+	particleVelocity = pVelocity;
+	particleSize = pSize;
+	particleColor = pColor;
 
 	//define current type
 	setCurrentType(BulletType);
@@ -36,10 +47,9 @@ void RectangleTypeBullet::Render()
 {
 	if (isInit) {
 		timer.Tick();
-		NowPosition[0] += velocity * cos(angle / 180.0f * 3.1415926f) * timer.getDeltaFrame();
-		NowPosition[1] += velocity * sin(angle / 180.0f * 3.1415926f) * timer.getDeltaFrame();
-		angle += increaseAngle * timer.getDeltaFrame();
-		velocity += acceleration * timer.getDeltaFrame();
+		auto pPlayerHelper1 = CollideInfo::getCollideHelper();
+		float* playerPos = (pPlayerHelper1 == nullptr ? nullptr : pPlayerHelper1->getPlayerPosition());
+		Bullet::solveBulletMovement(aimToPlayer, playerPos, velocity, angle, acceleration, increaseAngle, timer.getDeltaFrame());
 
 		glEnable(GL_BLEND);
 		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
@@ -63,11 +73,41 @@ void RectangleTypeBullet::Release()
 	}
 }
 
-bool RectangleTypeBullet::BulletCollideWithPoint(float x, float y, bool& haveGraze)
+bool RectangleTypeBullet::BulletCollideWithPoint(float x, float y, bool &haveGraze)
 {
-	return false;
+	bool value = false;
+	if (isInit && timer.getAccumlateTime() >= 0.2f) {
+		x -= NowPosition[0];
+		y -= NowPosition[1];
+
+		float theta = glm::radians(angle);
+		float NewX = x * cos(theta) + y * sin(theta);
+		float NewY = -x * sin(theta) + y * cos(theta);
+
+		float distance = pow(NewX, 2) + pow(NewY, 2);
+
+		if (!haveCheckGraze && distance <= CollideInfo::getGrazeDistance()) {
+			haveGraze = true;
+			haveCheckGraze = true;
+		}
+		float parameterX = collideSize.x;
+		float parameterY =  collideSize.y;
+		if (NewX >=  -parameterX && NewX <=  parameterX) {
+			if (NewY >= -parameterY && NewY <= parameterY) {
+				value = true;
+			}
+		}
+	
+	}
+
+	return value;
 }
 
 void RectangleTypeBullet::setBulletTerminate()
 {
+	ParticleHelper* particleGroup = new ParticleHelper;
+	particleGroup->addNewParticle(particleDensity, particleSize, particleVelocity, particleFinishTime, particleColor,
+		glm::vec3(NowPosition[0], NowPosition[1], NowPosition[2]));
+	RenderManager::getInstance()->AddRenderObject(ParticleGroupUuid, particleGroup);
+	isWorkFinish = true;
 }
diff --git a/PythonSTG/XCCore/Bullet/RectangleTypeBullet.h b/PythonSTG/XCCore/Bullet/RectangleTypeBullet.h
@@ -20,14 +20,19 @@ class RectangleTypeBullet :public Bullet {
 	int  reBoundTime = 0;
 	float velocity = 0.0f, acceleration = 0.0f, angle = 0.0f, increaseAngle = 0.0f, angleRadius = 0.0f;
 
+	int particleDensity = 3;
+	float particleFinishTime = 0.0f, particleVelocity = 0.6f, particleSize = 15.0f;
+	glm::vec4 particleColor;
+
 	XCGameTimer timer;
 	XCImageHelper* image;
-	bool aimToPlayer = false;
+	bool aimToPlayer = false, haveCheckGraze = false;
 public:
 	/*#! Attention scaleInfo will work both collide and render.
 #! renderSize: scaleX * widthRate : scaleY * heightRate  ,collideSize : scaleX : scaleY*/
 	RectangleTypeBullet(std::string bulletImagePath, glm::vec4 divideInfo, glm::vec3 scaleInfo, glm::vec3 collideSize, glm::vec3 initCoord,
-		 float velocity, float acceleration, float angle, float increateAngle, int reboundTime, bool aimPlayer);
+		 float velocity, float acceleration, float angle, float increateAngle, int reboundTime, bool aimPlayer,
+		int particleDensity, float particleFinishTime, float particleVelocity, float particleSize, glm::vec4 particleColor);
 	virtual void Init()  override;
 	virtual void Render() override;
 	virtual void Release() override;
diff --git a/PythonSTG/XCCore/Enemy/EnemyObject.cpp b/PythonSTG/XCCore/Enemy/EnemyObject.cpp
@@ -119,7 +119,7 @@ void EnemyObject::hurtEnemy(float damage)
 	else {
 		AudioHelper::playFromBuffer(deadEffect.wavBuffer);
 		ParticleHelper* particleGroup = new ParticleHelper;
-		particleGroup->addNewParticle(20, 15.0f, 1.0f, 0.6f, glm::vec4(1.0f), NowPosition);
+		particleGroup->addNewParticle(20, 12.0f, 1.0f, 0.6f, glm::vec4(1.0f), NowPosition);
 		RenderManager::getInstance()->AddRenderObject(ParticleGroupUuid, particleGroup);
 		
 		currentHealth = 0;
diff --git a/PythonSTG/XCCore/XCRender/RenderManager.cpp b/PythonSTG/XCCore/XCRender/RenderManager.cpp
@@ -72,8 +72,8 @@ void RenderManager::RenderWork()
 		}
 
 	}
-	std::unordered_multimap<std::string, RenderObject*>::iterator renderBegin = renderObjectList.begin();
-	std::unordered_multimap<std::string, RenderObject*>::iterator renderEnd = renderObjectList.end();
+	std::multimap<std::string, RenderObject*>::iterator renderBegin = renderObjectList.begin();
+	std::multimap<std::string, RenderObject*>::iterator renderEnd = renderObjectList.end();
 	for (auto object = renderBegin; object != renderEnd; object++) {
 		RenderObject *renderObject = object->second;
 		if (!renderObject->getIsTerminate()) {
@@ -170,8 +170,8 @@ void RenderManager::solveAsyncCommand()
 		{
 		case RenderManager::cRenderObject:
 			{
-				std::unordered_multimap<std::string, RenderObject*>::iterator targetBegin = renderObjectList.find(uuid);
-				std::unordered_multimap<std::string, RenderObject*>::iterator targetEnd = renderObjectList.end();
+				std::map<std::string, RenderObject*>::iterator targetBegin = renderObjectList.find(uuid);
+				std::map<std::string, RenderObject*>::iterator targetEnd = renderObjectList.end();
 				for (auto object = targetBegin; object != targetEnd; object = renderObjectList.find(uuid)) {
 					RenderObject *renderObject = object->second;
 					renderObject->Release();
@@ -190,8 +190,8 @@ void RenderManager::solveAsyncCommand()
 			break;
 		case RenderManager::cAllRenderObject:
 			{
-				std::unordered_multimap<std::string, RenderObject*>::iterator renderBegin = renderObjectList.begin();
-				std::unordered_multimap<std::string, RenderObject*>::iterator renderEnd = renderObjectList.end();
+				std::map<std::string, RenderObject*>::iterator renderBegin = renderObjectList.begin();
+				std::map<std::string, RenderObject*>::iterator renderEnd = renderObjectList.end();
 				for (auto object = renderBegin; object != renderEnd; object++) {
 					RenderObject *renderObject = object->second;
 					renderObject->Release();
@@ -203,8 +203,8 @@ void RenderManager::solveAsyncCommand()
 			break;
 		case RenderManager::tBullet:
 			{
-				std::unordered_multimap<std::string, RenderObject*>::iterator bulletBegin = renderObjectList.begin();
-				std::unordered_multimap<std::string, RenderObject*>::iterator bulletEnd = renderObjectList.end();
+				std::map<std::string, RenderObject*>::iterator bulletBegin = renderObjectList.begin();
+				std::map<std::string, RenderObject*>::iterator bulletEnd = renderObjectList.end();
 				for (auto object = bulletBegin; object != bulletEnd; object++) {
 					if (object->first == uuid) {
 						RenderObject *renderObject = object->second;
@@ -218,8 +218,8 @@ void RenderManager::solveAsyncCommand()
 			break;
 		case RenderManager::tAllBullet:
 			{
-				std::unordered_multimap<std::string, RenderObject*>::iterator bulletBegin = renderObjectList.begin();
-				std::unordered_multimap<std::string, RenderObject*>::iterator bulletEnd = renderObjectList.end();
+				std::map<std::string, RenderObject*>::iterator bulletBegin = renderObjectList.begin();
+				std::map<std::string, RenderObject*>::iterator bulletEnd = renderObjectList.end();
 				for (auto object = bulletBegin; object != bulletEnd; object++) {
 					RenderObject *renderObject = object->second;
 					if (renderObject->getCurrentType() == RenderObject::BulletType) {
diff --git a/PythonSTG/XCCore/XCRender/RenderManager.h b/PythonSTG/XCCore/XCRender/RenderManager.h
@@ -16,7 +16,7 @@ class RenderManager {
 	enum insideCommand {
 		cRenderObject = 0, cAllRenderObject, tBullet, cUserInterface, tAllBullet
 	};
-	std::unordered_multimap<std::string, RenderObject*> renderObjectList;
+	std::multimap<std::string, RenderObject*> renderObjectList;
 	std::unordered_multimap<insideCommand, std::string> externCommandList;
 	std::unordered_multimap<std::string, RenderObject*> asyncRenderObjectList;
 
diff --git a/PythonSTG/XCFrame.h b/PythonSTG/XCFrame.h
@@ -7,7 +7,7 @@
 #include "util/GameTimer.h"
 class XCFrame {
 private:
-	const char* PythonSTGVersion = "v0.31x_update2";
+	const char* PythonSTGVersion = "v0.32_release_update1";
 	std::atomic_bool isFrameTerminate = false;
 	GLFWwindow* pscreen = nullptr, *tscreen = nullptr;
 	static XCFrame* pInstance;
diff --git a/PythonSTG/assets/Bullet/cardBullet.png b/PythonSTG/assets/Bullet/cardBullet.png
diff --git a/PythonSTG/script/Bullet/Bullet.py b/PythonSTG/script/Bullet/Bullet.py
@@ -78,7 +78,6 @@ def _setReleaseParticleSize(self, size=15):
 
     def _setRenderSize(self, size=[0.1, 0.1, 0.1]):
         self.scaleSize = size
-        self.collideSize = size
 
     def _setCollideSize(self, size):
         self.collideSize = size
diff --git a/PythonSTG/script/Bullet/CardBullet.py b/PythonSTG/script/Bullet/CardBullet.py
@@ -0,0 +1,30 @@
+from .RectangleTypeBullet import RectangleTypeBullet, BulletColor
+
+class CardBullet(RectangleTypeBullet):
+    def __init__(self):
+        super().__init__()
+        self.divideInfo = [1, 16, 1, 6]
+        self.isLight = False
+        super()._setCollideSize([0.0352, 0.02, 0.055])
+        super()._setRenderSize([0.0352, 0.044, 0.055])
+        super().setBulletImage("assets/Bullet/cardBullet.png")
+
+        super()._setReleaseParticleDensity(10)
+        super()._setReleaseParticleLifeTime(0.5)
+        super()._setReleaseParticleSize(15)
+        super()._setReleaseParticleVelocity(0.6)
+
+    def setBulletColor(self, color=BulletColor.BLUE):
+        if self.isLight:
+            self.divideInfo[3] = 16 - color.value * 2
+        else:
+            self.divideInfo[3] = 16 - color.value * 2 + 1
+        self._ovalBullet_setReleaseColor(color)
+
+    def setBulletColorLight(self, isLight):
+        lastValue = self.isLight
+        self.isLight = isLight
+        if (not lastValue) and self.isLight:
+            self.divideInfo[3] += 1
+        elif lastValue and (not self.isLight):
+            self.divideInfo[3] -= 1
diff --git a/PythonSTG/script/Bullet/CircleBullet.py b/PythonSTG/script/Bullet/CircleBullet.py
@@ -6,7 +6,7 @@ def __init__(self):
         super().__init__()
         self.divideInfo = [8, 1, 6, 1]
         super()._setRenderSize([0.055, 0.055, 0.055])
-        super()._setCollideSize([0.055, 0.055, 0.055])
+        super()._setCollideSize([0.05, 0.05, 0.05])
         super().setBulletImage("assets/Bullet/bullet0.png")
 
         super()._setReleaseParticleDensity(6)
diff --git a/PythonSTG/script/Bullet/RectangleTypeBullet.py b/PythonSTG/script/Bullet/RectangleTypeBullet.py
@@ -0,0 +1,41 @@
+from .Bullet import Bullet, BulletColor, abstractmethod
+
+
+class RectangleTypeBullet(Bullet):
+    def __init__(self):
+        super().__init__()
+        self.divideInfo = [1, 1, 1, 1]
+        super()._setCollideSize([0.055, 0.0275, 0.055])
+        super()._setRenderSize([0.055, 0.055, 0.055])
+        self.bulletType = "rectangleTypeBullet"
+        self.bulletImage = ""
+
+    @abstractmethod
+    def setBulletColor(self, color=BulletColor.BLUE):
+        pass
+
+    def setBulletImage(self, bulletImagePath):
+        self.bulletImage = bulletImagePath
+
+    def _cpp_getInitRenderInfo(self):
+        return self.bulletImage, self.bulletType, tuple(self.divideInfo), tuple(self.scaleSize), tuple(self.collideSize)
+
+    def _ovalBullet_setReleaseColor(self, color=BulletColor.BLUE):
+        if color == BulletColor.LIGHTGREEN:
+            super()._setReleaseParticleColor([0.58, 0.72, 0.15, 1.0])
+        elif color == BulletColor.RED:
+            super()._setReleaseParticleColor([1.0, 0.0, 0.0, 1.0])
+        elif color == BulletColor.BLUE:
+            super()._setReleaseParticleColor([0.0, 0.0, 1.0, 1.0])
+        elif color == BulletColor.YELLOW:
+            super()._setReleaseParticleColor([1.0, 0.85, 0.15, 1.0])
+        elif color == BulletColor.LIGHTBLUE:
+            super()._setReleaseParticleColor([0.0, 1.0, 1.0, 1.0])
+        elif color == BulletColor.ORANGE:
+            super()._setReleaseParticleColor([1.0, 0.55, 0.27, 1.0])
+        elif color == BulletColor.PURPLE:
+            super()._setReleaseParticleColor([1.0, 0.35, 1.0, 1.0])
+        elif color == BulletColor.WHITE:
+            super()._setReleaseParticleColor([0.76, 0.76, 0.76, 1.0])
+        else:
+            super()._setReleaseParticleColor([0.8, 0.8, 0.8, 1.0])
diff --git a/PythonSTG/script/TestStage.py b/PythonSTG/script/TestStage.py
@@ -5,6 +5,7 @@
 from .Bullet.HugeBullet import HugeBullet
 from .Bullet.RiceBullet import RiceBullet
 from .Bullet.OvalBullet import OvalBullet
+from .Bullet.CardBullet import CardBullet
 from .Stage.Task import Task, TaskUnit
 from .Stage.TaskEnemy import TaskEnemy, EnemyColor
 from .Stage.XCStage import XCStage, StageRank
@@ -118,10 +119,12 @@ def setupMyStage():
     #spellcard test
     unit_spellcard = TaskUnit(repeatTime=60,waitFrame=20)
     for j in range(0, 36):
-        bullet = CircleBullet()
-        bullet.setVelocity(0.6)
+        bullet = CardBullet()
+        bullet.setVelocity(0.6*(1+random.random()))
         bullet.setAngle(j * 10)
-        bullet.setBulletColor(BulletColor.BLUE)
+        bullet.setBulletColor(BulletColor.RED)
+        if j %2 == 0:
+            bullet.setBulletColorLight(True)
         unit_spellcard.addBullet(bullet)
 
     task_spellcard = Task(durationFrame=-1)
@@ -133,10 +136,12 @@ def setupMyStage():
 
     unit_spellcard2 =TaskUnit(repeatTime=60,waitFrame=20)
     for j in range(0, 36):
-        bullet = CircleBullet()
+        bullet = CardBullet()
         bullet.setVelocity(0.6)
-        bullet.setAngle(j * 10 * random.random())
+        bullet.setAngle(j * 10)
         bullet.setBulletColor(BulletColor.RED)
+        if j % 2 == 0:
+            bullet.setBulletColorLight(True)
         unit_spellcard2.addBullet(bullet)
 
     task_spellcard2 = Task(durationFrame=-1)
diff --git a/PythonSTG/script/XCCore.py b/PythonSTG/script/XCCore.py
@@ -4,7 +4,7 @@
 # demo stage 演示关卡
 import script.TestStage as TestStage
 
-winTitle = "PythonSTG v0.32-Release"
+winTitle = "PythonSTG v0.32-update1"
 
 # PySTG default function
 def coreInitializer():

Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,8 @@ Bullet * BulletHelper::getNewBulletObject(std::string bulletImage,std::string bu`
`17`	`17`	`particleDensity, particleFinishTime, particleVelocity, particleSize, particleColor);`
`18`	`18`	`}`
`19`	`19`	`else if (bulletType == "rectangleTypeBullet") {`
`20`		`- /*bullet = new RectangleTypeBullet(bulletImage, divideInfo, scaleInfo, collideSize, initCoord, velocity, acceleration, angle, increateAngle, reboundTime, aimPlayer,`
`21`		`- particleDensity, particleFinishTime, particleVelocity, particleSize, particleColor);*/`
	`20`	`+ bullet = new RectangleTypeBullet(bulletImage, divideInfo, scaleInfo, collideSize, initCoord, velocity, acceleration, angle, increateAngle, reboundTime, aimPlayer,`
	`21`	`+ particleDensity, particleFinishTime, particleVelocity, particleSize, particleColor);`
`22`	`22`	`}`
`23`	`23`	`return bullet;`
`24`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ void CircleTypeBullet::Release()`
`89`	`89`	`bool CircleTypeBullet::BulletCollideWithPoint(float x, float y,bool &haveGraze)`
`90`	`90`	`{`
`91`	`91`	`bool value = false;`
`92`		`- if (isInit && timer.getAccumlateTime() >=0.1f) {`
	`92`	`+ if (isInit && timer.getAccumlateTime() >=0.2f) {`
`93`	`93`	`float distance = (x - NowPosition[0])(x - NowPosition[0]) + (y - NowPosition[1])(y - NowPosition[1]);`
`94`	`94`	`float parameter = collideSize[0] * collideSize[0];`
`95`	`95`