新增同时动作，新增EFileUtils和ERandom

Demo/main.cpp

@@ -24,6 +24,8 @@ int WINAPI WinMain(
 		text->setColor(EColor::WHITE);
 		scene->add(text);
 
+		text->runAction(new EActionLoop(new EActionTwo(new EActionFadeOut(1), new EActionFadeIn(1))));
+
 		app.enterScene(scene);
 		app.run();
 	}

Easy2D/Action/EAction.cpp

@@ -1,7 +1,7 @@
 #include "..\eactions.h"
 
 e2d::EAction::EAction() :
-	m_bRunning(true),
+	m_bRunning(false),
 	m_bWaiting(false),
 	m_bEnding(false),
 	m_bInit(false),
@@ -21,7 +21,7 @@ bool e2d::EAction::isRunning()
 	return m_bRunning && !m_bWaiting;
 }
 
-bool e2d::EAction::isEnding()
+bool e2d::EAction::_isEnding()
 {
 	return m_bEnding;
 }
@@ -45,12 +45,12 @@ void e2d::EAction::stop()
 {
 	m_bEnding = true;
 }
-void e2d::EAction::wait()
+void e2d::EAction::_wait()
 {
 	m_bWaiting = true;
 }
 
-void e2d::EAction::notify()
+void e2d::EAction::_notify()
 {
 	m_bWaiting = false;
 }

Easy2D/Action/EActionCallback.cpp

@@ -5,11 +5,7 @@ e2d::EActionCallback::EActionCallback(const std::function<void()>& callback) :
 {
 }
 
-e2d::EActionCallback::~EActionCallback()
+e2d::EActionCallback * e2d::EActionCallback::clone() const
-{
-}
-
-e2d::EActionCallback * e2d::EActionCallback::copy() const
 {
 	return new EActionCallback(m_Callback);
 }
@@ -19,7 +15,7 @@ void e2d::EActionCallback::_init()
 	EAction::_init();
 }
 
-void e2d::EActionCallback::_exec()
+void e2d::EActionCallback::_callOn()
 {
 	m_Callback();
 	this->stop();

Easy2D/Action/EActionDelay.cpp

@@ -6,11 +6,7 @@ e2d::EActionDelay::EActionDelay(float duration)
 	setInterval(LONGLONG(duration * 1000));
 }
 
-e2d::EActionDelay::~EActionDelay()
+e2d::EActionDelay * e2d::EActionDelay::clone() const
-{
-}
-
-e2d::EActionDelay * e2d::EActionDelay::copy() const
 {
 	return new EActionDelay(m_nAnimationInterval / 1000.0f);
 }
@@ -22,7 +18,7 @@ void e2d::EActionDelay::_init()
 	m_nLast = GetNow();
 }
 
-void e2d::EActionDelay::_exec()
+void e2d::EActionDelay::_callOn()
 {
 	// 判断时间间隔是否足够
 	if (GetInterval(m_nLast) > m_nAnimationInterval)

Easy2D/Action/EActionFrames.cpp

@@ -30,7 +30,7 @@ void e2d::EActionFrames::_init()
 	m_nLast = GetNow();
 }
 
-void e2d::EActionFrames::_exec()
+void e2d::EActionFrames::_callOn()
 {
 	// 判断时间间隔是否足够
 	while (GetInterval(m_nLast) > m_nAnimationInterval)
@@ -65,7 +65,7 @@ void e2d::EActionFrames::addFrame(ESpriteFrame * frame)
 	}
 }
 
-e2d::EActionFrames * e2d::EActionFrames::copy() const
+e2d::EActionFrames * e2d::EActionFrames::clone() const
 {
 	auto a = new EActionFrames(this->m_nAnimationInterval);
 	for (auto f : m_vFrames)
@@ -77,7 +77,7 @@ e2d::EActionFrames * e2d::EActionFrames::copy() const
 
 e2d::EActionFrames * e2d::EActionFrames::reverse() const
 {
-	auto a = this->copy();
+	auto a = this->clone();
 	a->m_vFrames.reserve(m_vFrames.size());
 	return a;
 }

Easy2D/Action/EActionMoveBy.cpp

@@ -7,17 +7,13 @@ e2d::EActionMoveBy::EActionMoveBy(float duration, EVec vector) :
 	m_MoveVector = vector;
 }
 
-e2d::EActionMoveBy::~EActionMoveBy()
-{
-}
-
 void e2d::EActionMoveBy::_init()
 {
 	EAnimation::_init();
 	m_BeginPos = m_pTarget->getPos();
 }
 
-void e2d::EActionMoveBy::_exec()
+void e2d::EActionMoveBy::_callOn()
 {
 	while (EAnimation::_isDelayEnough())
 	{
@@ -42,7 +38,7 @@ void e2d::EActionMoveBy::_reset()
 	EAnimation::_reset();
 }
 
-e2d::EActionMoveBy * e2d::EActionMoveBy::copy() const
+e2d::EActionMoveBy * e2d::EActionMoveBy::clone() const
 {
 	return new EActionMoveBy(m_nAnimationInterval / 1000.0f, m_MoveVector);
 }

Easy2D/Action/EActionMoveTo.cpp

@@ -6,11 +6,7 @@ e2d::EActionMoveTo::EActionMoveTo(float duration, EPoint pos) :
 	m_EndPos = pos;
 }
 
-e2d::EActionMoveTo::~EActionMoveTo()
+e2d::EActionMoveTo * e2d::EActionMoveTo::clone() const
-{
-}
-
-e2d::EActionMoveTo * e2d::EActionMoveTo::copy() const
 {
 	return new EActionMoveTo(m_nAnimationInterval / 1000.0f, m_EndPos);
 }

Easy2D/Action/EActionNeverStop.cpp

@@ -1,39 +1,39 @@
 #include "..\eactions.h"
 
-e2d::EActionNeverStop::EActionNeverStop(EAction * action) :
+e2d::EActionLoop::EActionLoop(EAction * action) :
 	m_Action(action)
 {
 	m_Action->retain();
 }
 
-e2d::EActionNeverStop::~EActionNeverStop()
+e2d::EActionLoop::~EActionLoop()
 {
 	SafeRelease(&m_Action);
 }
 
-e2d::EActionNeverStop * e2d::EActionNeverStop::copy() const
+e2d::EActionLoop * e2d::EActionLoop::clone() const
 {
-	return new EActionNeverStop(m_Action->copy());
+	return new EActionLoop(m_Action->clone());
 }
 
-void e2d::EActionNeverStop::_init()
+void e2d::EActionLoop::_init()
 {
 	EAction::_init();
 	m_Action->m_pTarget = m_pTarget;
 	m_Action->_init();
 }
 
-void e2d::EActionNeverStop::_exec()
+void e2d::EActionLoop::_callOn()
 {
-	m_Action->_exec();
+	m_Action->_callOn();
 
-	if (m_Action->isEnding())
+	if (m_Action->_isEnding())
 	{
 		m_Action->_reset();
 	}
 }
 
-void e2d::EActionNeverStop::_reset()
+void e2d::EActionLoop::_reset()
 {
 	EAction::_reset();
 }

Easy2D/Action/EActionOpacityBy.cpp

@@ -7,17 +7,13 @@ e2d::EActionOpacityBy::EActionOpacityBy(float duration, float opacity) :
 	m_nVariation = opacity;
 }
 
-e2d::EActionOpacityBy::~EActionOpacityBy()
-{
-}
-
 void e2d::EActionOpacityBy::_init()
 {
 	EAnimation::_init();
 	m_nBeginVal = m_pTarget->getOpacity();
 }
 
-void e2d::EActionOpacityBy::_exec()
+void e2d::EActionOpacityBy::_callOn()
 {
 	while (EAnimation::_isDelayEnough())
 	{
@@ -39,7 +35,7 @@ void e2d::EActionOpacityBy::_reset()
 	EAnimation::_reset();
 }
 
-e2d::EActionOpacityBy * e2d::EActionOpacityBy::copy() const
+e2d::EActionOpacityBy * e2d::EActionOpacityBy::clone() const
 {
 	return new EActionOpacityBy(m_nAnimationInterval / 1000.0f, m_nVariation);
 }

Easy2D/Action/EActionOpacityTo.cpp

@@ -7,11 +7,7 @@ e2d::EActionOpacityTo::EActionOpacityTo(float duration, float opacity) :
 	m_nEndVal = opacity;
 }
 
-e2d::EActionOpacityTo::~EActionOpacityTo()
+e2d::EActionOpacityTo * e2d::EActionOpacityTo::clone() const
-{
-}
-
-e2d::EActionOpacityTo * e2d::EActionOpacityTo::copy() const
 {
 	return new EActionOpacityTo(m_nAnimationInterval / 1000.0f, m_nEndVal);
 }

Easy2D/Action/EActionRotateBy.cpp

@@ -0,0 +1,46 @@
+#include "..\eactions.h"
+
+
+e2d::EActionRotateBy::EActionRotateBy(float duration, float rotation) :
+	EAnimation(duration)
+{
+	m_nVariation = rotation;
+}
+
+void e2d::EActionRotateBy::_init()
+{
+	EAnimation::_init();
+	m_nBeginVal = m_pTarget->getOpacity();
+}
+
+void e2d::EActionRotateBy::_callOn()
+{
+	while (EAnimation::_isDelayEnough())
+	{
+		// 计算移动位置
+		float scale = static_cast<float>(m_nDuration) / m_nTotalDuration;
+		// 移动 Sprite
+		m_pTarget->setRotation(m_nBeginVal + m_nVariation * scale);
+		// 判断动作是否结束
+		if (_isEnd())
+		{
+			this->stop();
+			break;
+		}
+	}
+}
+
+void e2d::EActionRotateBy::_reset()
+{
+	EAnimation::_reset();
+}
+
+e2d::EActionRotateBy * e2d::EActionRotateBy::clone() const
+{
+	return new EActionRotateBy(m_nAnimationInterval / 1000.0f, m_nVariation);
+}
+
+e2d::EActionRotateBy * e2d::EActionRotateBy::reverse() const
+{
+	return new EActionRotateBy(m_nTotalDuration / 1000.0f, -m_nVariation);
+}

Easy2D/Action/EActionRotateTo.cpp

@@ -0,0 +1,24 @@
+#include "..\eactions.h"
+
+
+e2d::EActionRotateTo::EActionRotateTo(float duration, float opacity) :
+	EActionRotateBy(duration, 0)
+{
+	m_nEndVal = opacity;
+}
+
+e2d::EActionRotateTo * e2d::EActionRotateTo::clone() const
+{
+	return new EActionRotateTo(m_nAnimationInterval / 1000.0f, m_nEndVal);
+}
+
+void e2d::EActionRotateTo::_init()
+{
+	EActionRotateBy::_init();
+	m_nVariation = m_nEndVal - m_nBeginVal;
+}
+
+void e2d::EActionRotateTo::_reset()
+{
+	EActionRotateBy::_reset();
+}

Easy2D/Action/EActionScaleBy.cpp

@@ -8,10 +8,6 @@ e2d::EActionScaleBy::EActionScaleBy(float duration, float scaleX, float scaleY)
 	m_nVariationY = scaleY;
 }
 
-e2d::EActionScaleBy::~EActionScaleBy()
-{
-}
-
 void e2d::EActionScaleBy::_init()
 {
 	EAnimation::_init();
@@ -19,7 +15,7 @@ void e2d::EActionScaleBy::_init()
 	m_nBeginScaleY = m_pTarget->getScaleY();
 }
 
-void e2d::EActionScaleBy::_exec()
+void e2d::EActionScaleBy::_callOn()
 {
 	while (EAnimation::_isDelayEnough())
 	{
@@ -41,7 +37,7 @@ void e2d::EActionScaleBy::_reset()
 	EAnimation::_reset();
 }
 
-e2d::EActionScaleBy * e2d::EActionScaleBy::copy() const
+e2d::EActionScaleBy * e2d::EActionScaleBy::clone() const
 {
 	return new EActionScaleBy(m_nAnimationInterval / 1000.0f, m_nVariationX, m_nVariationY);
 }

Easy2D/Action/EActionScaleTo.cpp

@@ -7,11 +7,7 @@ e2d::EActionScaleTo::EActionScaleTo(float duration, float scaleX, float scaleY)
 	m_nEndScaleY = scaleY;
 }
 
-e2d::EActionScaleTo::~EActionScaleTo()
+e2d::EActionScaleTo * e2d::EActionScaleTo::clone() const
-{
-}
-
-e2d::EActionScaleTo * e2d::EActionScaleTo::copy() const
 {
 	return new EActionScaleTo(m_nAnimationInterval / 1000.0f, m_nEndScaleX, m_nEndScaleY);
 }

Easy2D/Action/EActionSequence.cpp

@@ -41,11 +41,11 @@ void e2d::EActionSequence::_init()
 	m_vActions[0]->_init();
 }
 
-void e2d::EActionSequence::_exec()
+void e2d::EActionSequence::_callOn()
 {
-	m_vActions[m_nActionIndex]->_exec();
+	m_vActions[m_nActionIndex]->_callOn();
 
-	if (m_vActions[m_nActionIndex]->isEnding())
+	if (m_vActions[m_nActionIndex]->_isEnding())
 	{
 		m_nActionIndex++;
 		if (m_nActionIndex == m_vActions.size())
@@ -75,12 +75,12 @@ void e2d::EActionSequence::addAction(EAction * action)
 	action->retain();
 }
 
-e2d::EActionSequence * e2d::EActionSequence::copy() const
+e2d::EActionSequence * e2d::EActionSequence::clone() const
 {
 	auto a = new EActionSequence();
 	for (auto action : m_vActions)
 	{
-		a->addAction(action->copy());
+		a->addAction(action->clone());
 	}
 	return a;
 }
@@ -96,7 +96,7 @@ e2d::EActionSequence * e2d::EActionSequence::reverse(bool actionReverse) const
 		}
 		else
 		{
-			a->addAction(action->copy());
+			a->addAction(action->clone());
 		}
 	}
 	// 将动作顺序逆序排列

Easy2D/Action/EActionTwo.cpp

@@ -1,59 +1,59 @@
 #include "..\eactions.h"
 
 e2d::EActionTwo::EActionTwo(EAction * actionFirst, EAction * actionSecond) :
-	m_FirstAction(actionFirst),
+	m_pFirstAction(actionFirst),
-	m_SecondAction(actionSecond)
+	m_pSecondAction(actionSecond)
 {
-	m_FirstAction->retain();
+	m_pFirstAction->retain();
-	m_SecondAction->retain();
+	m_pSecondAction->retain();
 }
 
 e2d::EActionTwo::~EActionTwo()
 {
-	SafeRelease(&m_FirstAction);
+	SafeRelease(&m_pFirstAction);
-	SafeRelease(&m_SecondAction);
+	SafeRelease(&m_pSecondAction);
 }
 
-e2d::EActionTwo * e2d::EActionTwo::copy() const
+e2d::EActionTwo * e2d::EActionTwo::clone() const
 {
-	return new EActionTwo(m_FirstAction->copy(), m_SecondAction->copy());
+	return new EActionTwo(m_pFirstAction->clone(), m_pSecondAction->clone());
 }
 
 e2d::EActionTwo * e2d::EActionTwo::reverse(bool actionReverse) const
 {
 	if (actionReverse)
 	{
-		return new EActionTwo(m_SecondAction->reverse(), m_FirstAction->reverse());
+		return new EActionTwo(m_pSecondAction->reverse(), m_pFirstAction->reverse());
 	}
 	else
 	{
-		return new EActionTwo(m_SecondAction->copy(), m_FirstAction->copy());
+		return new EActionTwo(m_pSecondAction->clone(), m_pFirstAction->clone());
 	}
 }
 
 void e2d::EActionTwo::_init()
 {
 	EAction::_init();
-	m_FirstAction->m_pTarget = m_pTarget;
+	m_pFirstAction->m_pTarget = m_pTarget;
-	m_SecondAction->m_pTarget = m_pTarget;
+	m_pSecondAction->m_pTarget = m_pTarget;
 
-	m_FirstAction->_init();
+	m_pFirstAction->_init();
 }
 
-void e2d::EActionTwo::_exec()
+void e2d::EActionTwo::_callOn()
 {
-	if (!m_FirstAction->isEnding())
+	if (!m_pFirstAction->_isEnding())
 	{
-		m_FirstAction->_exec();
+		m_pFirstAction->_callOn();
-		if (m_FirstAction->isEnding())
+		if (m_pFirstAction->_isEnding())
 		{
 			// 返回 true 表示第一个动作已经结束
-			m_SecondAction->_init();
+			m_pSecondAction->_init();
 		}
 	}
-	else if (!m_SecondAction->isEnding())
+	else if (!m_pSecondAction->_isEnding())
 	{
-		m_SecondAction->_exec();
+		m_pSecondAction->_callOn();
 	}
 	else
 	{
@@ -65,6 +65,6 @@ void e2d::EActionTwo::_reset()
 {
 	EAction::_reset();
 
-	m_FirstAction->_reset();
+	m_pFirstAction->_reset();
-	m_SecondAction->_reset();
+	m_pSecondAction->_reset();
 }

Easy2D/Action/EActionTwoAtSameTime.cpp

@@ -0,0 +1,69 @@
+#include "..\eactions.h"
+
+e2d::EActionTwoAtSameTime::EActionTwoAtSameTime(EAction * actionFirst, EAction * actionSecond) :
+	m_pFirstAction(actionFirst),
+	m_pSecondAction(actionSecond)
+{
+	m_pFirstAction->retain();
+	m_pSecondAction->retain();
+}
+
+e2d::EActionTwoAtSameTime::~EActionTwoAtSameTime()
+{
+	SafeRelease(&m_pFirstAction);
+	SafeRelease(&m_pSecondAction);
+}
+
+e2d::EActionTwoAtSameTime * e2d::EActionTwoAtSameTime::clone() const
+{
+	return new EActionTwoAtSameTime(m_pFirstAction->clone(), m_pSecondAction->clone());
+}
+
+e2d::EActionTwoAtSameTime * e2d::EActionTwoAtSameTime::reverse(bool actionReverse) const
+{
+	if (actionReverse)
+	{
+		return new EActionTwoAtSameTime(m_pSecondAction->reverse(), m_pFirstAction->reverse());
+	}
+	else
+	{
+		return new EActionTwoAtSameTime(m_pSecondAction->clone(), m_pFirstAction->clone());
+	}
+}
+
+void e2d::EActionTwoAtSameTime::_init()
+{
+	EAction::_init();
+	m_pFirstAction->m_pTarget = m_pTarget;
+	m_pSecondAction->m_pTarget = m_pTarget;
+
+	m_pFirstAction->_init();
+	m_pSecondAction->_init();
+}
+
+void e2d::EActionTwoAtSameTime::_callOn()
+{
+	if (!m_pFirstAction->_isEnding())
+	{
+		m_pFirstAction->_callOn();
+	}
+	if (!m_pSecondAction->_isEnding())
+	{
+		m_pSecondAction->_callOn();
+	}
+
+	// 两个动作都结束时，动作结束
+	if (m_pFirstAction->_isEnding() &&
+		m_pSecondAction->_isEnding())
+	{
+		this->stop();
+	}
+}
+
+void e2d::EActionTwoAtSameTime::_reset()
+{
+	EAction::_reset();
+
+	m_pFirstAction->_reset();
+	m_pSecondAction->_reset();
+}

Easy2D/Action/EAnimation.cpp

@@ -7,10 +7,6 @@ e2d::EAnimation::EAnimation(float duration)
 	m_nTotalDuration = UINT(duration * 1000);
 }
 
-e2d::EAnimation::~EAnimation()
-{
-}
-
 bool e2d::EAnimation::_isEnd() const
 {
 	return m_nDuration >= m_nTotalDuration;

Easy2D/Easy2D.vcxproj

@@ -201,10 +201,13 @@
     <ClCompile Include="Action\EActionNeverStop.cpp" />
     <ClCompile Include="Action\EActionOpacityBy.cpp" />
     <ClCompile Include="Action\EActionOpacityTo.cpp" />
+    <ClCompile Include="Action\EActionRotateBy.cpp" />
+    <ClCompile Include="Action\EActionRotateTo.cpp" />
     <ClCompile Include="Action\EActionScaleBy.cpp" />
     <ClCompile Include="Action\EActionScaleTo.cpp" />
     <ClCompile Include="Action\EActionSequence.cpp" />
     <ClCompile Include="Action\EActionTwo.cpp" />
+    <ClCompile Include="Action\EActionTwoAtSameTime.cpp" />
     <ClCompile Include="Action\EAnimation.cpp" />
     <ClCompile Include="Base\EApp.cpp" />
     <ClCompile Include="Base\EObject.cpp" />
@@ -225,7 +228,9 @@
     <ClCompile Include="Node\EFont.cpp" />
     <ClCompile Include="Node\ETexture.cpp" />
     <ClCompile Include="Tool\EActionManager.cpp" />
+    <ClCompile Include="Tool\EFileUtils.cpp" />
     <ClCompile Include="Tool\EObjectManager.cpp" />
+    <ClCompile Include="Tool\ERandom.cpp" />
     <ClCompile Include="Tool\ETimerManager.cpp" />
     <ClCompile Include="Win\winbase.cpp" />
   </ItemGroup>

Easy2D/Easy2D.vcxproj.filters

@@ -132,6 +132,21 @@
     <ClCompile Include="Action\EAnimation.cpp">
       <Filter>Action</Filter>
     </ClCompile>
+    <ClCompile Include="Action\EActionRotateBy.cpp">
+      <Filter>Action</Filter>
+    </ClCompile>
+    <ClCompile Include="Action\EActionRotateTo.cpp">
+      <Filter>Action</Filter>
+    </ClCompile>
+    <ClCompile Include="Tool\EFileUtils.cpp">
+      <Filter>Tool</Filter>
+    </ClCompile>
+    <ClCompile Include="Tool\ERandom.cpp">
+      <Filter>Tool</Filter>
+    </ClCompile>
+    <ClCompile Include="Action\EActionTwoAtSameTime.cpp">
+      <Filter>Action</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Win\winbase.h">

Easy2D/Tool/EActionManager.cpp

@@ -1,62 +1,224 @@
 #include "..\etools.h"
+#include "..\eactions.h"
+
+static e2d::EVector<e2d::EAction*> s_vActions;
 
 
-void e2d::EActionManager::bindAction(EAction * action, ENode * pParentNode)
+void e2d::EActionManager::bindAction(EAction * action, ENode * pTargetNode)
 {
+	ASSERT(
+		(!action->m_pTarget),
+		"The action is already running, it cannot running again!"
+	);
+	WARN_IF(action == nullptr, "EAction NULL pointer exception!");
+	WARN_IF(pTargetNode == nullptr, "EAction's target is NULL!");
+
+	if (action && pTargetNode)
+	{
+		action->start();
+		action->retain();
+		action->m_pTarget = pTargetNode;
+		s_vActions.push_back(action);
+	}
 }
 
 void e2d::EActionManager::startAllActionsBindedWith(EScene * pParentScene)
 {
+	if (pParentScene)
+	{
+		for (const auto &child : pParentScene->getChildren())
+		{
+			EActionManager::startAllActionsBindedWith(child);
+		}
+	}
 }
 
 void e2d::EActionManager::stopAllActionsBindedWith(EScene * pParentScene)
 {
+	if (pParentScene)
+	{
+		for (const auto &child : pParentScene->getChildren())
+		{
+			EActionManager::stopAllActionsBindedWith(child);
+		}
+	}
 }
 
 void e2d::EActionManager::clearAllActionsBindedWith(EScene * pParentScene)
 {
+	if (pParentScene)
+	{
+		for (const auto & child : pParentScene->getChildren())
+		{
+			ETimerManager::clearAllTimersBindedWith(child);
+		}
+	}
 }
 
-void e2d::EActionManager::startAllActionsBindedWith(ENode * pParentNode)
+void e2d::EActionManager::startAllActionsBindedWith(ENode * pTargetNode)
 {
+	if (pTargetNode)
+	{
+		for (const auto &action : s_vActions)
+		{
+			if (action->getTarget() == pTargetNode)
+			{
+				action->start();
+			}
+		}
+		for (const auto &child : pTargetNode->getChildren())
+		{
+			EActionManager::startAllActionsBindedWith(child);
+		}
+	}
 }
 
-void e2d::EActionManager::stopAllActionsBindedWith(ENode * pParentNode)
+void e2d::EActionManager::stopAllActionsBindedWith(ENode * pTargetNode)
 {
+	if (pTargetNode)
+	{
+		for (const auto &action : s_vActions)
+		{
+			if (action->getTarget() == pTargetNode)
+			{
+				action->stop();
+			}
+		}
+		for (const auto &child : pTargetNode->getChildren())
+		{
+			EActionManager::stopAllActionsBindedWith(child);
+		}
+	}
 }
 
-void e2d::EActionManager::clearAllActionsBindedWith(ENode * pParentNode)
+void e2d::EActionManager::clearAllActionsBindedWith(ENode * pTargetNode)
 {
+	if (pTargetNode)
+	{
+		for (size_t i = 0; i < s_vActions.size();)
+		{
+			auto a = s_vActions[i];
+			if (a->getTarget() == pTargetNode)
+			{
+				a->autoRelease();
+				a->release();
+				s_vActions.erase(s_vActions.begin() + i);
+			}
+			else
+			{
+				i++;
+			}
+		}
+		for (auto child : pTargetNode->getChildren())
+		{
+			ETimerManager::clearAllTimersBindedWith(child);
+		}
+	}
 }
 
 void e2d::EActionManager::startAllActions()
 {
+	EActionManager::startAllActionsBindedWith(EApp::getCurrentScene());
 }
 
 void e2d::EActionManager::stopAllActions()
 {
+	EActionManager::stopAllActionsBindedWith(EApp::getCurrentScene());
 }
 
 void e2d::EActionManager::clearAllActions()
 {
+	EActionManager::clearAllActionsBindedWith(EApp::getCurrentScene());
 }
 
 void e2d::EActionManager::_waitAllActionsBindedWith(EScene * pParentScene)
 {
+	if (pParentScene)
+	{
+		for (const auto &child : pParentScene->getChildren())
+		{
+			EActionManager::_waitAllActionsBindedWith(child);
+		}
+	}
 }
 
 void e2d::EActionManager::_notifyAllActionsBindedWith(EScene * pParentScene)
 {
+	if (pParentScene)
+	{
+		for (const auto &child : pParentScene->getChildren())
+		{
+			EActionManager::_notifyAllActionsBindedWith(child);
+		}
+	}
 }
 
-void e2d::EActionManager::_waitAllActionsBindedWith(ENode * pParentNode)
+void e2d::EActionManager::_waitAllActionsBindedWith(ENode * pTargetNode)
 {
+	if (pTargetNode)
+	{
+		for (const auto &action : s_vActions)
+		{
+			if (action->getTarget() == pTargetNode)
+			{
+				action->_wait();
+			}
+		}
+		for (const auto &child : pTargetNode->getChildren())
+		{
+			EActionManager::_waitAllActionsBindedWith(child);
+		}
+	}
 }
 
-void e2d::EActionManager::_notifyAllActionsBindedWith(ENode * pParentNode)
+void e2d::EActionManager::_notifyAllActionsBindedWith(ENode * pTargetNode)
 {
+	if (pTargetNode)
+	{
+		for (const auto &action : s_vActions)
+		{
+			if (action->getTarget() == pTargetNode)
+			{
+				action->_notify();
+			}
+		}
+		for (const auto &child : pTargetNode->getChildren())
+		{
+			EActionManager::_notifyAllActionsBindedWith(child);
+		}
+	}
 }
 
 void e2d::EActionManager::ActionProc()
 {
+	if (s_vActions.empty())
+		return;
+	
+	EAction * action;
+	// 循环遍历所有正在运行的动作
+	for (size_t i = 0; i < s_vActions.size(); i++)
+	{
+		action = s_vActions[i];
+		// 获取动作运行状态
+		if (action->isRunning())
+		{
+			if (action->_isEnding())
+			{
+				// 动作已经结束
+				action->autoRelease();
+				action->release();
+				s_vActions.erase(s_vActions.begin() + i);
+			}
+			else
+			{
+				// 初始化动作
+				if (!action->m_bInit)
+				{
+					action->_init();
+				}
+				// 执行动作
+				action->_callOn();
+			}
+		}
+	}
 }

Easy2D/Tool/EFileUtils.cpp

@@ -0,0 +1,138 @@
+#include "..\etools.h"
+#include "..\Win\winbase.h"
+#include <sstream>
+#include <algorithm>
+#include <commdlg.h>
+
+#define DEFINE_KNOWN_FOLDER(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+	EXTERN_C const GUID DECLSPEC_SELECTANY name \
+	= { l, w1, w2,{ b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } }
+
+DEFINE_KNOWN_FOLDER(FOLDERID_LocalAppData, 0xF1B32785, 0x6FBA, 0x4FCF, 0x9D, 0x55, 0x7B, 0x8E, 0x7F, 0x15, 0x70, 0x91);
+
+typedef HRESULT(WINAPI* pFunSHGetKnownFolderPath)(
+	const GUID& rfid,
+	DWORD dwFlags,
+	HANDLE hToken,
+	PWSTR *ppszPath);
+
+e2d::EString e2d::EFileUtils::getLocalAppDataPath()
+{
+	// 获取 AppData\Local 文件夹的路径
+	PWSTR pszPath = NULL;
+	HMODULE hModule = LoadLibrary(L"shell32.dll");
+	pFunSHGetKnownFolderPath SHGetKnownFolderPath = (pFunSHGetKnownFolderPath)GetProcAddress(hModule, "SHGetKnownFolderPath");
+	HRESULT hr = SHGetKnownFolderPath(FOLDERID_LocalAppData, 0, NULL, &pszPath);
+
+	if (SUCCEEDED(hr))
+	{
+		EString path = pszPath;
+		CoTaskMemFree(pszPath);
+		return path;
+	}
+	return L"";
+}
+
+e2d::EString e2d::EFileUtils::getDefaultSavePath()
+{
+	EString path = EFileUtils::getLocalAppDataPath();
+	WARN_IF(path.empty(), "Cannot get local AppData path!");
+
+	path.append(L"\\");
+	path.append(EApp::getAppName());
+
+	if (_waccess(path.c_str(), 0) == -1)
+	{
+		_wmkdir(path.c_str());
+	}
+
+	path.append(L"\\DefaultData.ini");
+
+	return path;
+}
+
+void e2d::EFileUtils::saveInt(LPCTSTR key, int value)
+{
+	std::wstringstream ss;
+	ss << value;
+	::WritePrivateProfileString(L"Default", key, ss.str().c_str(), getDefaultSavePath().c_str());
+}
+
+void e2d::EFileUtils::saveDouble(LPCTSTR key, double value)
+{
+	std::wstringstream ss;
+	ss << value;
+	::WritePrivateProfileString(L"Default", key, ss.str().c_str(), getDefaultSavePath().c_str());
+}
+
+void e2d::EFileUtils::saveString(LPCTSTR key, EString value)
+{
+	::WritePrivateProfileString(L"Default", key, value.c_str(), getDefaultSavePath().c_str());
+}
+
+int e2d::EFileUtils::getInt(LPCTSTR key, int default)
+{
+	return ::GetPrivateProfileInt(L"Default", key, default, getDefaultSavePath().c_str());
+}
+
+double e2d::EFileUtils::getDouble(LPCTSTR key, double default)
+{
+	// 将 default 参数转化为字符串
+	std::wstringstream ss;
+	ss << default;
+	// 读取数据
+	TCHAR temp[128] = { 0 };
+	::GetPrivateProfileString(L"Default", key, ss.str().c_str(), temp, 128, getDefaultSavePath().c_str());
+	// 转换为字符串流
+	ss.str(L"");
+	ss << temp;
+	// 将字符串转化为 double
+	return _wtof(ss.str().c_str());
+}
+
+e2d::EString e2d::EFileUtils::geTString(LPCTSTR key, EString default)
+{
+	TCHAR temp[128] = { 0 };
+	::GetPrivateProfileString(L"Default", key, default.c_str(), temp, 128, getDefaultSavePath().c_str());
+	return EString(temp);
+}
+
+e2d::EString e2d::EFileUtils::getFileExtension(const EString & filePath)
+{
+	EString fileExtension;
+	// 找到文件名中的最后一个 '.' 的位置
+	size_t pos = filePath.find_last_of('.');
+	// 判断 pos 是否是个有效位置
+	if (pos != EString::npos)
+	{
+		// 截取扩展名
+		fileExtension = filePath.substr(pos, filePath.length());
+		// 转换为小写字母
+		std::transform(fileExtension.begin(), fileExtension.end(), fileExtension.begin(), ::tolower);
+	}
+
+	return fileExtension;
+}
+
+e2d::EString e2d::EFileUtils::getSaveFilePath(LPCTSTR title, LPCTSTR defExt)
+{
+	// 弹出保存对话框
+	OPENFILENAME ofn = { 0 };
+	TCHAR strFilename[MAX_PATH] = { 0 };				// 用于接收文件名
+	ofn.lStructSize = sizeof(OPENFILENAME);				// 结构体大小
+	ofn.hwndOwner = GetHWnd();							// 拥有着窗口句柄，NULL 表示对话框是非模态的
+	ofn.lpstrFilter = L"所有文件\0*.*\0\0";			// 设置过滤
+	ofn.nFilterIndex = 1;								// 过滤器索引
+	ofn.lpstrFile = strFilename;						// 接收返回的文件路径和文件名
+	ofn.nMaxFile = sizeof(strFilename);					// 缓冲区长度
+	ofn.lpstrInitialDir = NULL;							// 初始目录为默认
+	ofn.Flags = OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;// 目录必须存在，覆盖文件前发出警告
+	ofn.lpstrTitle = title;								// 使用系统默认标题留空即可
+	ofn.lpstrDefExt = defExt;							// 默认追加的扩展名
+
+	if (GetSaveFileName(&ofn))
+	{
+		return strFilename;
+	}
+	return L"";
+}

Easy2D/Tool/ERandom.cpp

@@ -0,0 +1,8 @@
+#include "..\etools.h"
+
+std::default_random_engine &e2d::ERandom::getEngine()
+{
+	static std::random_device device;
+	static std::default_random_engine engine(device());
+	return engine;
+}

Easy2D/Tool/ETimerManager.cpp

@@ -254,6 +254,8 @@ void e2d::ETimerManager::clearAllTimers()
 void e2d::ETimerManager::TimerProc()
 {
 	for (auto t : s_vTimers)
+	{
+		if (t->isRunning())
 		{
 			if (GetInterval(t->m_tLast) >= t->m_nInterval)
 			{
@@ -262,3 +264,4 @@ void e2d::ETimerManager::TimerProc()
 			}
 		}
 	}
+}

Easy2D/eactions.h

@@ -6,17 +6,18 @@ namespace e2d
 {
 
 class EActionTwo;
-class EActionNeverStop;
+class EActionLoop;
 class EActionSequence;
+class EActionTwoAtSameTime;
 
 class EAction :
 	public EObject
 {
-	friend ENode;
 	friend EActionManager;
 	friend EActionTwo;
-	friend EActionNeverStop;
+	friend EActionLoop;
 	friend EActionSequence;
+	friend EActionTwoAtSameTime;
 
 public:
 	EAction();
@@ -26,9 +27,6 @@ public:
 	// 获取动作运行状态
 	virtual bool isRunning();
 
-	// 获取动作结束状态
-	virtual bool isEnding();
-
 	// 继续动作
 	virtual void start();
 
@@ -41,16 +39,17 @@ public:
 	// 停止动作
 	virtual void stop();
 
+	// 获取一个新的拷贝动作
+	virtual EAction * clone() const = 0;
+
+	// 获取一个新的逆向动作
+	virtual EAction * reverse() const;
+
 	// 设置动作每一帧的时间间隔
 	virtual void setInterval(
 		LONGLONG milliSeconds
 	);
 
-	// 获取一个新的拷贝动作
-	virtual EAction * copy() const = 0;
-
-	// 获取一个新的逆向动作
-	virtual EAction * reverse() const;
 	// 获取执行该动作的目标
 	virtual ENode * getTarget();
 
@@ -59,16 +58,19 @@ protected:
 	virtual void _init();
 
 	// 执行动作
-	virtual void _exec() = 0;
+	virtual void _callOn() = 0;
+
+	// 获取动作结束状态
+	virtual bool _isEnding();
 
 	// 重置动作
 	virtual void _reset();
 
 	// 进入等待状态
-	virtual void wait();
+	virtual void _wait();
 
 	// 唤醒
-	virtual void notify();
+	virtual void _notify();
 
 protected:
 	bool		m_bRunning;
@@ -86,18 +88,27 @@ class EAnimation :
 	public EAction
 {
 public:
-	EAnimation(float duration);
+	// 创建时长动画
-	virtual ~EAnimation();
+	EAnimation(
+		float duration
+	);
+
+protected:
+	// 判断动作是否结束
+	bool _isEnd() const;
+
+	// 判断延时是否足够
+	bool _isDelayEnough();
+
+	// 初始化动画
+	virtual void _init() override;
+
+	// 重置动画
+	virtual void _reset() override;
 
 protected:
 	LONGLONG m_nDuration;
 	LONGLONG m_nTotalDuration;
-
-protected:
-	bool _isEnd() const;
-	bool _isDelayEnough();
-	virtual void _init() override;
-	virtual void _reset() override;
 };
 
 
@@ -105,20 +116,31 @@ class EActionMoveBy :
 	public EAnimation
 {
 public:
-	EActionMoveBy(float duration, EVec vector);
+	// 创建相对位移动画
-	virtual ~EActionMoveBy();
+	EActionMoveBy(
+		float duration, /* 动画持续时长 */
+		EVec vector		/* 位移向量 */
+	);
 
-	virtual EActionMoveBy * copy() const override;
+	// 获取该动画的拷贝对象
+	virtual EActionMoveBy * clone() const override;
+
+	// 获取该动画的逆动画
 	virtual EActionMoveBy * reverse() const override;
 
+protected:
+	// 初始化动画
+	virtual void _init() override;
+
+	// 执行动画
+	virtual void _callOn() override;
+
+	// 重置动画
+	virtual void _reset() override;
+
 protected:
 	EPoint	m_BeginPos;
 	EVec	m_MoveVector;
-
-protected:
-	virtual void _init() override;
-	virtual void _exec() override;
-	virtual void _reset() override;
 };
 
 
@@ -126,17 +148,24 @@ class EActionMoveTo :
 	public EActionMoveBy
 {
 public:
-	EActionMoveTo(float duration, EPoint pos);
+	// 创建位移动画
-	virtual ~EActionMoveTo();
+	EActionMoveTo(
+		float duration, /* 动画持续时长 */
+		EPoint pos		/* 位移至目标点的坐标 */
+	);
 
-	virtual EActionMoveTo * copy() const override;
+	// 获取该动画的拷贝对象
+	virtual EActionMoveTo * clone() const override;
+
+protected:
+	// 初始化动画
+	virtual void _init() override;
+
+	// 重置动画
+	virtual void _reset() override;
 
 protected:
 	EPoint m_EndPos;
-
-protected:
-	virtual void _init() override;
-	virtual void _reset() override;
 };
 
 
@@ -144,22 +173,34 @@ class EActionScaleBy :
 	public EAnimation
 {
 public:
-	EActionScaleBy(float duration, float scaleX, float scaleY);
+	// 创建相对缩放动画
-	virtual ~EActionScaleBy();
+	EActionScaleBy(
+		float duration, /* 动画持续时长 */
+		float scaleX,	/* 横向缩放比例变化 */
+		float scaleY	/* 纵向缩放比例变化 */
+	);
 
-	virtual EActionScaleBy * copy() const override;
+	// 获取该动画的拷贝对象
+	virtual EActionScaleBy * clone() const override;
+
+	// 获取该动画的逆动画
 	virtual EActionScaleBy * reverse() const override;
 
+protected:
+	// 初始化动画
+	virtual void _init() override;
+
+	// 执行动画
+	virtual void _callOn() override;
+
+	// 重置动画
+	virtual void _reset() override;
+
 protected:
 	float	m_nBeginScaleX;
 	float	m_nBeginScaleY;
 	float	m_nVariationX;
 	float	m_nVariationY;
-
-protected:
-	virtual void _init() override;
-	virtual void _exec() override;
-	virtual void _reset() override;
 };
 
 
@@ -167,18 +208,26 @@ class EActionScaleTo :
 	public EActionScaleBy
 {
 public:
-	EActionScaleTo(float duration, float scaleX, float scaleY);
+	// 创建缩放动画
-	virtual ~EActionScaleTo();
+	EActionScaleTo(
+		float duration, /* 动画持续时长 */
+		float scaleX,	/* 横向缩放至目标比例 */
+		float scaleY	/* 纵向缩放至目标比例 */
+	);
 
-	virtual EActionScaleTo * copy() const override;
+	// 获取该动画的拷贝对象
+	virtual EActionScaleTo * clone() const override;
+
+protected:
+	// 初始化动画
+	virtual void _init() override;
+
+	// 重置动画
+	virtual void _reset() override;
 
 protected:
 	float	m_nEndScaleX;
 	float	m_nEndScaleY;
-
-protected:
-	virtual void _init() override;
-	virtual void _reset() override;
 };
 
 
@@ -186,20 +235,31 @@ class EActionOpacityBy :
 	public EAnimation
 {
 public:
-	EActionOpacityBy(float duration, float opacity);
+	// 创建透明度相对渐变动画
-	virtual ~EActionOpacityBy();
+	EActionOpacityBy(
+		float duration, /* 动画持续时长 */
+		float opacity	/* 透明度相对变化值 */
+	);
 
-	virtual EActionOpacityBy * copy() const override;
+	// 获取该动画的拷贝对象
+	virtual EActionOpacityBy * clone() const override;
+
+	// 获取该动画的逆动画
 	virtual EActionOpacityBy * reverse() const override;
 
+protected:
+	// 初始化动画
+	virtual void _init() override;
+
+	// 执行动画
+	virtual void _callOn() override;
+
+	// 重置动画
+	virtual void _reset() override;
+
 protected:
 	float m_nBeginVal;
 	float m_nVariation;
-
-protected:
-	virtual void _init() override;
-	virtual void _exec() override;
-	virtual void _reset() override;
 };
 
 
@@ -207,33 +267,103 @@ class EActionOpacityTo :
 	public EActionOpacityBy
 {
 public:
-	EActionOpacityTo(float duration, float opacity);
+	// 创建透明度渐变动画
-	virtual ~EActionOpacityTo();
+	EActionOpacityTo(
+		float duration,	/* 动画持续时长 */
+		float opacity	/* 透明度渐变至目标值 */
+	);
 
-	virtual EActionOpacityTo * copy() const override;
+	// 获取该动画的拷贝对象
+	virtual EActionOpacityTo * clone() const override;
+
+protected:
+	// 初始化动画
+	virtual void _init() override;
+
+	// 重置动画
+	virtual void _reset() override;
 
 protected:
 	float m_nEndVal;
+};
+
+
+class EActionFadeIn :
+	public EActionOpacityTo
+{
+public:
+	// 创建淡入动画
+	EActionFadeIn(
+		float duration	/* 动画持续时长 */
+	) : EActionOpacityTo(duration, 1) {}
+};
+
+
+class EActionFadeOut :
+	public EActionOpacityTo
+{
+public:
+	// 创建淡出动画
+	EActionFadeOut(
+		float duration	/* 动画持续时长 */
+	) : EActionOpacityTo(duration, 0) {}
+};
+
+
+class EActionRotateBy :
+	public EAnimation
+{
+public:
+	// 创建相对旋转动画
+	EActionRotateBy(
+		float duration,	/* 动画持续时长 */
+		float rotation	/* 旋转角度变化值 */
+	);
+
+	// 获取该动画的拷贝对象
+	virtual EActionRotateBy * clone() const override;
+
+	// 获取该动画的逆动画
+	virtual EActionRotateBy * reverse() const override;
 
 protected:
+	// 初始化动画
 	virtual void _init() override;
+
+	// 执行动画
+	virtual void _callOn() override;
+
+	// 重置动画
 	virtual void _reset() override;
+
+protected:
+	float m_nBeginVal;
+	float m_nVariation;
 };
 
 
-class ActionFadeIn :
+class EActionRotateTo :
-	public EActionOpacityTo
+	public EActionRotateBy
 {
 public:
-	ActionFadeIn(float duration) : EActionOpacityTo(duration, 1) {}
+	// 创建旋转动画
-};
+	EActionRotateTo(
+		float duration,	/* 动画持续时长 */
+		float rotation	/* 旋转角度至目标值 */
+	);
 
+	// 获取该动画的拷贝对象
+	virtual EActionRotateTo * clone() const override;
 
-class ActionFadeOut :
+protected:
-	public EActionOpacityTo
+	// 初始化动画
-{
+	virtual void _init() override;
-public:
+
-	ActionFadeOut(float duration) : EActionOpacityTo(duration, 0) {}
+	// 重置动画
+	virtual void _reset() override;
+
+protected:
+	float m_nEndVal;
 };
 
 
@@ -241,20 +371,35 @@ class EActionTwo :
 	public EAction
 {
 public:
-	EActionTwo(EAction * actionFirst, EAction * actionSecond);
+	// 创建两个动作的连续动作
+	EActionTwo(
+		EAction * actionFirst,	/* 第一个动作 */
+		EAction * actionSecond	/* 第二个动作 */
+	);
+
 	virtual ~EActionTwo();
 
-	virtual EActionTwo * copy() const override;
+	// 获取该动作的拷贝对象
-	virtual EActionTwo * reverse(bool actionReverse = true) const;
+	virtual EActionTwo * clone() const override;
-
+
-protected:
+	// 获取该动作的逆动作
-	EAction *	m_FirstAction;
+	virtual EActionTwo * reverse(
-	EAction *	m_SecondAction;
+		bool actionReverse = true	/* 子动作是否执行逆动作 */
+	) const;
 
 protected:
+	// 初始化动作
 	virtual void _init() override;
-	virtual void _exec() override;
+
+	// 执行动作
+	virtual void _callOn() override;
+
+	// 重置动作
 	virtual void _reset() override;
+
+protected:
+	EAction *	m_pFirstAction;
+	EAction *	m_pSecondAction;
 };
 
 
@@ -262,22 +407,44 @@ class EActionSequence :
 	public EAction
 {
 public:
+	// 创建顺序动作
 	EActionSequence();
-	EActionSequence(int number, EAction * action1, ...);
+
+	// 创建顺序动作
+	EActionSequence(
+		int number,			/* 顺序动作数量 */
+		EAction * action1,	/* 第一个动作 */
+		...
+	);
+
 	virtual ~EActionSequence();
 
-	void addAction(EAction * action);
+	// 向顺序动作中添加动作
-	virtual EActionSequence * copy() const override;
+	void addAction(
-	virtual EActionSequence * reverse(bool actionReverse = true) const;
+		EAction * action	/* 将动作添加至顺序动作尾部 */
+	);
+
+	// 获取该动作的拷贝对象
+	virtual EActionSequence * clone() const override;
+
+	// 获取该动作的逆动作
+	virtual EActionSequence * reverse(
+		bool actionReverse = true	/* 子动作是否执行逆动作 */
+	) const;
+
+protected:
+	// 初始化动作
+	virtual void _init() override;
+
+	// 执行动作
+	virtual void _callOn() override;
+
+	// 重置动作
+	virtual void _reset() override;
 
 protected:
 	UINT					m_nActionIndex;
 	std::vector<EAction*>	m_vActions;
-
-protected:
-	virtual void _init() override;
-	virtual void _exec() override;
-	virtual void _reset() override;
 };
 
 
@@ -285,34 +452,88 @@ class EActionDelay :
 	public EAction
 {
 public:
-	EActionDelay(float duration);
+	// 创建延时动作
-	virtual ~EActionDelay();
+	EActionDelay(
+		float duration	/* 延迟时长（秒） */
+	);
 
-	virtual EActionDelay * copy() const override;
+	// 获取该动作的拷贝对象
+	virtual EActionDelay * clone() const override;
 
 protected:
+	// 初始化动作
 	virtual void _init() override;
-	virtual void _exec() override;
+
+	// 执行动作
+	virtual void _callOn() override;
+
+	// 重置动作
 	virtual void _reset() override;
 };
 
 
-class EActionNeverStop :
+class EActionTwoAtSameTime :
 	public EAction
 {
 public:
-	EActionNeverStop(EAction * action);
+	// 创建两个动作同时执行的动作
-	virtual ~EActionNeverStop();
+	EActionTwoAtSameTime(
+		EAction * actionFirst,	/* 第一个动作 */
+		EAction * actionSecond	/* 第二个动作 */
+	);
 
-	virtual EActionNeverStop * copy() const override;
+	virtual ~EActionTwoAtSameTime();
+
+	// 获取该动作的拷贝对象
+	virtual EActionTwoAtSameTime * clone() const override;
+
+	// 获取该动作的逆动作
+	virtual EActionTwoAtSameTime * reverse(
+		bool actionReverse = true	/* 子动作是否执行逆动作 */
+	) const;
+
+protected:
+	// 初始化动作
+	virtual void _init() override;
+
+	// 执行动作
+	virtual void _callOn() override;
+
+	// 重置动作
+	virtual void _reset() override;
+
+protected:
+	EAction *	m_pFirstAction;
+	EAction *	m_pSecondAction;
+};
+
+
+class EActionLoop :
+	public EAction
+{
+public:
+	// 创建循环动作
+	EActionLoop(
+		EAction * action	/* 执行循环的动作 */
+	);
+
+	virtual ~EActionLoop();
+
+	// 获取该动作的拷贝对象
+	virtual EActionLoop * clone() const override;
+
+protected:
+	// 初始化动作
+	virtual void _init() override;
+
+	// 执行动作
+	virtual void _callOn() override;
+
+	// 重置动作
+	virtual void _reset() override;
 
 protected:
 	EAction * m_Action;
-
-protected:
-	virtual void _init() override;
-	virtual void _exec() override;
-	virtual void _reset() override;
 };
 
 
@@ -320,22 +541,40 @@ class EActionFrames :
 	public EAction
 {
 public:
+	// 创建帧动画
 	EActionFrames();
-	EActionFrames(LONGLONG frameDelay);
-	~EActionFrames();
 
-	void addFrame(ESpriteFrame * frame);
+	// 创建特定帧间隔的帧动画
-	virtual EActionFrames * copy() const override;
+	EActionFrames(
+		LONGLONG frameDelay	/* 帧间隔（毫秒） */
+	);
+
+	virtual ~EActionFrames();
+
+	// 添加帧
+	void addFrame(
+		ESpriteFrame * frame /* 添加帧 */
+	);
+
+	// 获取该动画的拷贝对象
+	virtual EActionFrames * clone() const override;
+
+	// 获取该动画的逆动画
 	virtual EActionFrames * reverse() const override;
 
+protected:
+	// 初始化动作
+	virtual void _init() override;
+
+	// 执行动作
+	virtual void _callOn() override;
+
+	// 重置动作
+	virtual void _reset() override;
+
 protected:
 	UINT m_nFrameIndex;
 	EVector<ESpriteFrame*> m_vFrames;
-
-protected:
-	virtual void _init() override;
-	virtual void _exec() override;
-	virtual void _reset() override;
 };
 
 
@@ -343,18 +582,26 @@ class EActionCallback :
 	public EAction
 {
 public:
-	EActionCallback(const std::function<void()>& callback);
+	// 创建执行回调函数的动作
-	~EActionCallback();
+	EActionCallback(
+		const std::function<void()> & callback /* 回调函数 */
+	);
 
-	virtual EActionCallback * copy() const override;
+	// 获取该动作的拷贝对象
+	virtual EActionCallback * clone() const override;
+
+protected:
+	// 初始化动作
+	virtual void _init() override;
+
+	// 执行动作
+	virtual void _callOn() override;
+
+	// 重置动作
+	virtual void _reset() override;
 
 protected:
 	std::function<void()> m_Callback;
-
-protected:
-	virtual void _init() override;
-	virtual void _exec() override;
-	virtual void _reset() override;
 };
 
 }

Easy2D/emacros.h

@@ -11,12 +11,18 @@
 #define _WIN32_WINNT 0x0700 // Change this to the appropriate value to target other versions of Windows.
 #endif
 
+#ifndef NTDDI_VERSION
+#define NTDDI_VERSION NTDDI_WIN7
+#endif
+
 #ifndef UNICODE
 #define UNICODE
 #endif
 
 // Exclude rarely-used items from Windows headers.
+#ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
+#endif
 
 // Windows Header Files:
 #include <windows.h>

Easy2D/etools.h

@@ -1,6 +1,7 @@
 #pragma once
 #include "ebase.h"
 #include <chrono>
+#include <random>
 
 namespace e2d
 {
@@ -230,7 +231,7 @@ public:
 	// 绑定动作到节点
 	static void bindAction(
 		EAction * action,
-		ENode * pParentNode
+		ENode * pTargetNode
 	);
 
 	// 启动绑定在场景子节点上的所有动作
@@ -250,17 +251,17 @@ public:
 
 	// 启动绑定在节点上的所有动作
 	static void startAllActionsBindedWith(
-		ENode * pParentNode
+		ENode * pTargetNode
 	);
 
 	// 停止绑定在节点上的所有动作
 	static void stopAllActionsBindedWith(
-		ENode * pParentNode
+		ENode * pTargetNode
 	);
 
 	// 清空绑定在节点上的所有动作
 	static void clearAllActionsBindedWith(
-		ENode * pParentNode
+		ENode * pTargetNode
 	);
 
 	// 启动所有动作
@@ -285,16 +286,84 @@ private:
 
 	// 挂起绑定在节点上的所有动作
 	static void _waitAllActionsBindedWith(
-		ENode * pParentNode
+		ENode * pTargetNode
 	);
 
 	// 重启绑定在节点上的所有动作
 	static void _notifyAllActionsBindedWith(
-		ENode * pParentNode
+		ENode * pTargetNode
 	);
 
 	// 动作执行程序
 	static void ActionProc();
 };
 
+
+class EFileUtils
+{
+public:
+	// 获取系统的 AppData\Local 路径
+	static EString getLocalAppDataPath();
+
+	// 获取默认的保存路径
+	static EString getDefaultSavePath();
+
+	// 保存 int 型的值
+	static void saveInt(LPCTSTR key, int value);
+
+	// 保存 double 型的值
+	static void saveDouble(LPCTSTR key, double value);
+
+	// 保存 字符串 型的值（不要在 Unicode 字符集下保存中文字符）
+	static void saveString(LPCTSTR key, EString value);
+
+	// 获取 int 型的值（若不存在则返回 default 参数的值）
+	static int getInt(LPCTSTR key, int default);
+
+	// 获取 double 型的值（若不存在则返回 default 参数的值）
+	static double getDouble(LPCTSTR key, double default);
+
+	// 获取 字符串 型的值（若不存在则返回 default 参数的值）
+	static EString geTString(LPCTSTR key, EString default);
+
+	// 得到文件扩展名（小写）
+	static EString getFileExtension(const EString & filePath);
+
+	/**
+	*  打开保存文件对话框，得到有效保存路径返回 true
+	*  参数：返回文件路径的字符串，窗口标题，设置扩展名过滤，设置默认扩展名
+	*/
+	static EString getSaveFilePath(LPCTSTR title = L"保存到", LPCTSTR defExt = NULL);
+};
+
+
+class ERandom
+{
+public:
+	// 取得整型范围内的一个随机数
+	template<typename T>
+	static T randomInt(T min, T max)
+	{
+		std::uniform_int_distribution<T> dist(min, max);
+		return dist(getEngine());
+	}
+
+	// 取得浮点数类型范围内的一个随机数
+	template<typename T>
+	static T randomReal(T min, T max)
+	{
+		std::uniform_real_distribution<T> dist(min, max);
+		return dist(getEngine());
+	}
+
+	// 获取随机数产生器
+	static std::default_random_engine &getEngine();
+};
+
+template<typename T>
+inline T random(T min, T max) { return e2d::ERandom::randomInt(min, max); }
+inline float random(float min, float max) { return e2d::ERandom::randomReal(min, max); }
+inline double random(double min, double max) { return e2d::ERandom::randomReal(min, max); }
+inline long double random(long double min, long double max) { return e2d::ERandom::randomReal(min, max); }
+
 }