v0.28x

Python2D/Python2D.vcxproj

@@ -141,9 +141,11 @@
     <ClCompile Include="XCCore\Bullet\BulletHelper.cpp" />
     <ClCompile Include="XCCore\Bullet\CircleTypeBullet.cpp" />
     <ClCompile Include="XCCore\Bullet\RectangleTypeBullet.cpp" />
+    <ClCompile Include="XCCore\Enemy\EnemyObject.cpp" />
     <ClCompile Include="XCCore\Task\Task.cpp" />
     <ClCompile Include="XCCore\Task\TaskDispatcher.cpp" />
     <ClCompile Include="XCCore\Task\TaskHelper.cpp" />
+    <ClCompile Include="XCCore\Task\TaskEnemy.cpp" />
     <ClCompile Include="XCCore\Task\TaskInsideUnit.cpp" />
     <ClCompile Include="XCCore\UserInterface\CoverInterface.cpp" />
     <ClCompile Include="XCCore\UserInterface\GameInfoInterface.cpp" />
@@ -185,9 +187,11 @@
     <ClInclude Include="XCCore\Bullet\BulletHelper.h" />
     <ClInclude Include="XCCore\Bullet\CircleTypeBullet.h" />
     <ClInclude Include="XCCore\Bullet\RectangleTypeBullet.h" />
+    <ClInclude Include="XCCore\Enemy\EnemyObject.h" />
     <ClInclude Include="XCCore\Task\Task.h" />
     <ClInclude Include="XCCore\Task\TaskDispatcher.h" />
     <ClInclude Include="XCCore\Task\TaskHelper.h" />
+    <ClInclude Include="XCCore\Task\TaskEnemy.h" />
     <ClInclude Include="XCCore\Task\TaskInsideUnit.h" />
     <ClInclude Include="XCCore\UserInterface\CoverInterface.h" />
     <ClInclude Include="XCCore\UserInterface\GameInfoInterface.h" />

Python2D/Python2D.vcxproj.filters

@@ -40,6 +40,9 @@
     <Filter Include="XCCore\XCAudio">
       <UniqueIdentifier>{d0df81fa-abea-42c1-a3d3-a689a213969e}</UniqueIdentifier>
     </Filter>
+    <Filter Include="XCCore\Enemy">
+      <UniqueIdentifier>{2e419218-6347-4310-bc9f-14bf80549af2}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="util\ConfigManager.cpp">
@@ -156,6 +159,12 @@
     <ClCompile Include="XCCore\XCRender\RenderManager.cpp">
       <Filter>XCCore\XCRender</Filter>
     </ClCompile>
+    <ClCompile Include="XCCore\Enemy\EnemyObject.cpp">
+      <Filter>XCCore\Enemy</Filter>
+    </ClCompile>
+    <ClCompile Include="XCCore\Task\TaskEnemy.cpp">
+      <Filter>XCCore\Task</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="util\ConfigManager.h">
@@ -289,5 +298,11 @@
     <ClInclude Include="XCCore\XCRender\RenderObject.h">
       <Filter>XCCore\XCRender</Filter>
     </ClInclude>
+    <ClInclude Include="XCCore\Enemy\EnemyObject.h">
+      <Filter>XCCore\Enemy</Filter>
+    </ClInclude>
+    <ClInclude Include="XCCore\Task\TaskEnemy.h">
+      <Filter>XCCore\Task</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

Python2D/XCCore/Bullet/Bullet.h

@@ -67,8 +67,8 @@ class Bullet:public RenderObject {
 			else {
 				float renderWidth = scaleX * XCFrameInfo::FrameRight;
 				float renderHeight = scaleY * XCFrameInfo::FrameTop;
-				if (renderY + renderHeight   > frameHeight || renderY + renderHeight< -frameHeight
-					|| renderX + renderWidth  > frameWidth || renderX + renderWidth  < -frameWidth) {
+				if (renderY - renderHeight   > frameHeight || renderY + renderHeight< -frameHeight
+					|| renderX - renderWidth  > frameWidth || renderX + renderWidth  < -frameWidth) {
 					return true;
 				}
 			}

Python2D/XCCore/Enemy/EnemyObject.cpp

@@ -0,0 +1,91 @@
+#include "EnemyObject.h"
+#include <GL3/gl3w.h>
+#include "../../XCFrameInfo.h"
+
+EnemyObject::EnemyObject(IRenderHelper *ptr, glm::vec2 dInfo, glm::vec3 sInfo, glm::vec2 sbInfo, glm::vec2 wInfo,
+	glm::vec3 iCoord, float v, float a, float agle, float agleA, int type)
+{
+	imageHelper = ptr;
+	divideInfo = dInfo;
+	scaleInfo = sInfo;
+	standbyInfo = sbInfo;
+	walkInfo = wInfo;
+	NowPosition = iCoord;
+
+	velocity = v;
+	acceleration = a;
+	angle = agle;
+	angleAcceleration = agleA;
+
+	colorType = type;
+
+
+	//set as enemytype
+	setCurrentType(EnemyType);
+}
+
+void EnemyObject::Init()
+{
+	if ((angle == 0 && velocity == 0) || angle == 270.0f || angle == 90.0f) {
+		nowTexIndex = standbyInfo[0];
+	}
+	else {
+		nowTexIndex = walkInfo[0];
+	}
+}
+
+void EnemyObject::Render()
+{
+	timer.Tick();
+	float deltaTime = timer.getDeltaFrame();
+	float pi = 3.1415926535f;
+	NowPosition[0] += velocity * cos(angle / 180.0f * pi) * deltaTime;
+	NowPosition[1] += velocity * sin(angle / 180.0f * pi) * deltaTime;
+	angle += angleAcceleration * deltaTime;
+	velocity += acceleration * deltaTime;
+
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	bool isAnti = false;
+	if ((angle == 0 && velocity == 0) || angle == 270.0f || angle == 90.0f) {
+		if (nowTexIndex < standbyInfo[1])
+			nowTexIndex += 8.0f * deltaTime;
+		else
+			nowTexIndex = standbyInfo[0];
+	}
+	else {
+		if (nowTexIndex < walkInfo[1])
+			nowTexIndex += 8.0f * deltaTime;
+		else
+			nowTexIndex = walkInfo[0];
+
+		if (angle >= 90.0f && angle <= 270.0f) {
+			isAnti = true;
+		}
+	}
+
+	imageHelper->Render(NowPosition, glm::vec4(1.0f), glm::radians(isAnti ? 180.0f : 0.0f), glm::vec3(0, 1, 0), scaleInfo,
+		IRenderHelper::GetSpecificTexWithRate(XCFrameInfo::FrameRight, XCFrameInfo::FrameTop, divideInfo[0], divideInfo[1], (int)nowTexIndex, colorType));
+
+	glDisable(GL_BLEND);
+
+	float frameWidth = XCFrameInfo::FrameRight, frameHeight = XCFrameInfo::FrameTop;
+	float renderWidth = scaleInfo[0] * XCFrameInfo::FrameRight;
+	float renderHeight = scaleInfo[1] * XCFrameInfo::FrameTop;
+	float renderX = NowPosition[0] * frameWidth, renderY = NowPosition[1] * frameHeight;
+	if (renderY - renderHeight > frameHeight || renderY + renderHeight< -frameHeight
+		|| renderX - renderWidth  > frameWidth || renderX + renderWidth < -frameWidth) {
+		isWorkFinish = true;
+	}
+}
+
+void EnemyObject::Release()
+{
+	imageHelper->Release();
+	delete imageHelper;
+}
+
+glm::vec3 EnemyObject::getNowPosition()
+{
+	return NowPosition;
+}

Python2D/XCCore/Enemy/EnemyObject.h

@@ -0,0 +1,28 @@
+#pragma once
+#ifndef _ENEMY_OBJECT_H_
+#define _ENEMY_OBJECT_H_
+#include "../XCRender/RenderObject.h"
+#include "../XCRender/IRenderHelper.h"
+#include "../../util/GameTimer.h"
+#include <glm/glm.hpp>
+class EnemyObject :public RenderObject {
+private:
+	XCGameTimer timer;
+	IRenderHelper* imageHelper = nullptr;
+	glm::vec2 divideInfo;
+	glm::vec3 scaleInfo;
+	glm::vec2 standbyInfo;
+	glm::vec2 walkInfo;
+	glm::vec3 NowPosition;
+	int colorType; float nowTexIndex = 0;
+	float velocity = 0.0f, acceleration = 0.0f, angle = 0.0f, angleAcceleration = 0.0f;
+public:
+	EnemyObject(IRenderHelper*, glm::vec2 divideInfo, glm::vec3 scaleInfo, glm::vec2 standbyInfo, glm::vec2 walkInfo,
+		glm::vec3 initCoord, float velocity, float acceleration, float angle, float angleAcceleration, int type);
+	virtual void Init() override;
+	virtual void Render() override;
+	virtual void Release() override;
+
+	glm::vec3 getNowPosition();
+};
+#endif

Python2D/XCCore/Task/Task.cpp

@@ -20,6 +20,11 @@ void Task::TaskInit()
 {
 	if (!taskIsInit) {
 		TaskDispatcher::addTask(targetUUID);
+		auto iterBegin = subUnitGroup.begin();
+		auto iterEnd = subUnitGroup.end();
+		for (auto unit = iterBegin; unit != iterEnd; unit++) {
+			(*unit)->UnitInit();
+		}
 		taskIsInit = true;
 	}
 }

Python2D/XCCore/Task/Task.h

@@ -17,12 +17,12 @@ class Task {
 public:
 	/*while taskType==TaskWait, the task will wait for target task to end and start.
 	repeatTime == -1 means task will work repeatedly.*/
-	Task(std::string taskUuid, std::string targetTaskUuid, int repeatTime = -1, int intervalFrame = 0);
+	Task(std::string taskUuid, std::string targetTaskUuid, int repeatTime, int intervalFrame);
 	void addSubUnit(TaskInsideUnit* unit);
 
-	void TaskInit();
-	void TaskWork();
-	void TaskRelease();	
+	virtual void TaskInit();
+	virtual void TaskWork();
+	virtual void TaskRelease();
 
 	bool getTaskFinish();
 	bool getTaskInit();

Python2D/XCCore/Task/TaskEnemy.cpp

@@ -0,0 +1,109 @@
+#include "TaskEnemy.h"
+#include "../XCRender/XCImageHelper.h"
+#include "../XCRender/RenderManager.h"
+#include "TaskDispatcher.h"
+TaskEnemy::TaskEnemy(std::string taskUuid, std::string targetTaskUuid, int repeatTime, int intervalFrame,
+	std::string enemyImage, glm::vec2 dInfo, glm::vec3 sInfo, glm::vec2 sbInfo, glm::vec2 wInfo,
+	glm::vec3 iCoord, float v, float a, float agle, float agleA, int type, float hp):Task(taskUuid, targetTaskUuid, repeatTime, intervalFrame)
+{
+	imagePath = enemyImage;
+	divideInfo = dInfo;
+	scaleInfo = sInfo;
+	standbyInfo = sbInfo;
+	walkInfo = wInfo;
+	NowPosition = iCoord;
+
+	velocity = v;
+	acceleration = a;
+	angle = agle;
+	angleAcceleration = agleA;
+
+	colorType = type;
+	nowLife = hp;
+}
+
+void TaskEnemy::TaskInit()
+{
+	if (!taskIsInit) {
+		TaskDispatcher::addTask(targetUUID);
+		auto iterBegin = subUnitGroup.begin();
+		auto iterEnd = subUnitGroup.end();
+		for (auto unit = iterBegin; unit != iterEnd; unit++) {
+			(*unit)->UnitInit();
+		}
+
+		XCImageHelper *image = new XCImageHelper(imagePath, true);
+		enemyImage = new EnemyObject(image, divideInfo, scaleInfo, standbyInfo, walkInfo,
+			NowPosition, velocity, acceleration, angle, angleAcceleration, colorType);
+		enemyImage->Init();
+		taskIsInit = true;
+	}
+
+
+}
+
+void TaskEnemy::TaskWork()
+{
+	if (taskNowDurationFrame < taskDurationFrame || taskDurationFrame < 0) {
+		if (taskAccumlateTime >= taskIntervalFrame) {
+			if (!haveImageAddInQueue) {
+				RenderManager::getInstance()->AddRenderObject(taskUUID, enemyImage);
+				haveImageAddInQueue = true;
+			}
+			else {
+				NowPosition = enemyImage->getNowPosition();
+			}
+			auto iterBegin = subUnitGroup.begin();
+			auto iterEnd = subUnitGroup.end();
+			for (auto unit = iterBegin; unit != iterEnd; unit++) {
+				if (!(*unit)->IsAddToQueue()) {
+					(*unit)->setBulletInitCoord(NowPosition[0], NowPosition[1], NowPosition[2]);
+					(*unit)->UnitWork();
+				}
+				if ((*unit)->IsAddToQueue()) {//release here
+					(*unit)->UnitRelease();
+					delete (*unit);
+					if (std::next(unit) == subUnitGroup.end()) {
+						subUnitGroup.erase(unit);
+						break;
+					}
+					else {
+						unit = subUnitGroup.erase(unit);
+						iterEnd = subUnitGroup.end();
+					}
+				}
+			}
+			if ( (subUnitGroup.empty() && RenderManager::getInstance()->CheckRenderComplete(taskUUID)) || enemyImage->getIsTerminate())
+				taskFinish = true;
+			taskNowDurationFrame++;
+		}
+		taskAccumlateTime++;
+	}
+	else {
+		taskFinish = true;
+	}
+}
+
+void TaskEnemy::TaskRelease()
+{
+	TaskDispatcher::updateTask(taskUUID, true);
+	auto iterBegin = subUnitGroup.begin();
+	auto iterEnd = subUnitGroup.end();
+	for (auto unit = iterBegin; unit != iterEnd; unit++) {
+		(*unit)->UnitRelease();
+		delete (*unit);
+	}
+	RenderManager::getInstance()->CleanRenderObject(taskUUID);
+	subUnitGroup.clear();
+
+	if (!haveImageAddInQueue) {
+		enemyImage->Release();
+		delete enemyImage;
+	}
+	taskIsInit = false;
+}
+
+
+
+
+