新增同时动作；

新增EFileUtils和ERandom

Easy2D/Action/ActionCallback.cpp

@@ -1,31 +0,0 @@
-#include "..\eactions.h"
-
-e2d::ActionCallback::ActionCallback(const std::function<void()>& callback) :
-	m_Callback(callback)
-{
-}
-
-e2d::ActionCallback::~ActionCallback()
-{
-}
-
-e2d::ActionCallback * e2d::ActionCallback::copy() const
-{
-	return new ActionCallback(m_Callback);
-}
-
-void e2d::ActionCallback::_init()
-{
-	EAction::_init();
-}
-
-void e2d::ActionCallback::_exec()
-{
-	m_Callback();
-	this->stop();
-}
-
-void e2d::ActionCallback::_reset()
-{
-	EAction::_reset();
-}

Easy2D/Action/ActionMoveBy.cpp

@@ -1,53 +0,0 @@
-#include "..\eactions.h"
-
-
-e2d::ActionMoveBy::ActionMoveBy(float duration, EVec vector) :
-	Animation(duration)
-{
-	m_MoveVector = vector;
-}
-
-e2d::ActionMoveBy::~ActionMoveBy()
-{
-}
-
-void e2d::ActionMoveBy::_init()
-{
-	Animation::_init();
-	m_BeginPos = m_pTarget->getPos();
-}
-
-void e2d::ActionMoveBy::_exec()
-{
-	while (Animation::_isDelayEnough())
-	{
-		// 计算移动位置
-		float scale = static_cast<float>(m_nDuration) / m_nTotalDuration;
-		// 移动 Sprite
-		m_pTarget->setPos(
-			m_BeginPos.x + m_MoveVector.x * scale, 
-			m_BeginPos.y + m_MoveVector.y * scale
-		);
-		// 判断动作是否结束
-		if (_isEnd())
-		{
-			this->stop();
-			break;
-		}
-	}
-}
-
-void e2d::ActionMoveBy::_reset()
-{
-	Animation::_reset();
-}
-
-e2d::ActionMoveBy * e2d::ActionMoveBy::copy() const
-{
-	return new ActionMoveBy(m_nAnimationInterval / 1000.0f, m_MoveVector);
-}
-
-e2d::ActionMoveBy * e2d::ActionMoveBy::reverse() const
-{
-	return new ActionMoveBy(m_nTotalDuration / 1000.0f, EVec(-m_MoveVector.x, -m_MoveVector.y));
-}

Easy2D/Action/ActionMoveTo.cpp

@@ -1,27 +0,0 @@
-#include "..\eactions.h"
-
-e2d::ActionMoveTo::ActionMoveTo(float duration, EPoint pos) :
-	ActionMoveBy(duration, EVec())
-{
-	m_EndPos = pos;
-}
-
-e2d::ActionMoveTo::~ActionMoveTo()
-{
-}
-
-e2d::ActionMoveTo * e2d::ActionMoveTo::copy() const
-{
-	return new ActionMoveTo(m_nAnimationInterval / 1000.0f, m_EndPos);
-}
-
-void e2d::ActionMoveTo::_init()
-{
-	ActionMoveBy::_init();
-	m_MoveVector = m_EndPos - m_BeginPos;
-}
-
-void e2d::ActionMoveTo::_reset()
-{
-	ActionMoveBy::_reset();
-}

Easy2D/Action/ActionNeverStop.cpp

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

Easy2D/Action/ActionOpacityBy.cpp

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

Easy2D/Action/ActionOpacityTo.cpp

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

Easy2D/Action/ActionScaleBy.cpp

@@ -1,52 +0,0 @@
-#include "..\eactions.h"
-
-
-e2d::ActionScaleBy::ActionScaleBy(float duration, float scaleX, float scaleY) :
-	Animation(duration)
-{
-	m_nVariationX = scaleX;
-	m_nVariationY = scaleY;
-}
-
-e2d::ActionScaleBy::~ActionScaleBy()
-{
-}
-
-void e2d::ActionScaleBy::_init()
-{
-	Animation::_init();
-	m_nBeginScaleX = m_pTarget->getScaleX();
-	m_nBeginScaleY = m_pTarget->getScaleY();
-}
-
-void e2d::ActionScaleBy::_exec()
-{
-	while (Animation::_isDelayEnough())
-	{
-		// 计算移动位置
-		float scale = static_cast<float>(m_nDuration) / m_nTotalDuration;
-		// 移动 Sprite
-		m_pTarget->setScale(m_nBeginScaleX + m_nVariationX * scale, m_nBeginScaleX + m_nVariationX * scale);
-		// 判断动作是否结束
-		if (_isEnd())
-		{
-			this->stop();
-			break;
-		}
-	}
-}
-
-void e2d::ActionScaleBy::_reset()
-{
-	Animation::_reset();
-}
-
-e2d::ActionScaleBy * e2d::ActionScaleBy::copy() const
-{
-	return new ActionScaleBy(m_nAnimationInterval / 1000.0f, m_nVariationX, m_nVariationY);
-}
-
-e2d::ActionScaleBy * e2d::ActionScaleBy::reverse() const
-{
-	return new ActionScaleBy(m_nTotalDuration / 1000.0f, -m_nVariationX, -m_nVariationY);
-}

Easy2D/Action/ActionScaleTo.cpp

@@ -1,29 +0,0 @@
-#include "..\eactions.h"
-
-e2d::ActionScaleTo::ActionScaleTo(float duration, float scaleX, float scaleY) :
-	ActionScaleBy(duration, 0, 0)
-{
-	m_nEndScaleX = scaleX;
-	m_nEndScaleY = scaleY;
-}
-
-e2d::ActionScaleTo::~ActionScaleTo()
-{
-}
-
-e2d::ActionScaleTo * e2d::ActionScaleTo::copy() const
-{
-	return new ActionScaleTo(m_nAnimationInterval / 1000.0f, m_nEndScaleX, m_nEndScaleY);
-}
-
-void e2d::ActionScaleTo::_init()
-{
-	ActionScaleBy::_init();
-	m_nVariationX = m_nEndScaleX - m_nBeginScaleX;
-	m_nVariationY = m_nEndScaleY - m_nBeginScaleY;
-}
-
-void e2d::ActionScaleTo::_reset()
-{
-	ActionScaleBy::_reset();
-}

Easy2D/Action/EActionCallback.cpp

@@ -0,0 +1,31 @@
+#include "..\eactions.h"
+
+e2d::EActionCallback::EActionCallback(const std::function<void()>& callback) :
+	m_Callback(callback)
+{
+}
+
+e2d::EActionCallback::~EActionCallback()
+{
+}
+
+e2d::EActionCallback * e2d::EActionCallback::copy() const
+{
+	return new EActionCallback(m_Callback);
+}
+
+void e2d::EActionCallback::_init()
+{
+	EAction::_init();
+}
+
+void e2d::EActionCallback::_exec()
+{
+	m_Callback();
+	this->stop();
+}
+
+void e2d::EActionCallback::_reset()
+{
+	EAction::_reset();
+}

Easy2D/Action/EActionDelay.cpp

@@ -1,28 +1,28 @@
 #include "..\eactions.h"
 #include "..\Win\winbase.h"
 
-e2d::ActionDelay::ActionDelay(float duration)
+e2d::EActionDelay::EActionDelay(float duration)
 {
 	setInterval(LONGLONG(duration * 1000));
 }
 
-e2d::ActionDelay::~ActionDelay()
+e2d::EActionDelay::~EActionDelay()
 {
 }
 
-e2d::ActionDelay * e2d::ActionDelay::copy() const
+e2d::EActionDelay * e2d::EActionDelay::copy() const
 {
-	return new ActionDelay(m_nAnimationInterval / 1000.0f);
+	return new EActionDelay(m_nAnimationInterval / 1000.0f);
 }
 
-void e2d::ActionDelay::_init()
+void e2d::EActionDelay::_init()
 {
 	EAction::_init();
 	// 记录当前时间
 	m_nLast = GetNow();
 }
 
-void e2d::ActionDelay::_exec()
+void e2d::EActionDelay::_exec()
 {
 	// 判断时间间隔是否足够
 	if (GetInterval(m_nLast) > m_nAnimationInterval)
@@ -31,7 +31,7 @@ void e2d::ActionDelay::_exec()
 	}
 }
 
-void e2d::ActionDelay::_reset()
+void e2d::EActionDelay::_reset()
 {
 	EAction::_reset();
 	// 记录当前时间

Easy2D/Action/EActionFrames.cpp

@@ -1,20 +1,20 @@
 #include "..\eactions.h"
 #include "..\Win\winbase.h"
 
-e2d::ActionFrames::ActionFrames() :
+e2d::EActionFrames::EActionFrames() :
 	m_nFrameIndex(0)
 {
 	// 帧动画默认 .5s 刷新一次
 	setInterval(500);
 }
 
-e2d::ActionFrames::ActionFrames(LONGLONG frameDelay) :
+e2d::EActionFrames::EActionFrames(LONGLONG frameDelay) :
 	m_nFrameIndex(0)
 {
 	setInterval(frameDelay);
 }
 
-e2d::ActionFrames::~ActionFrames()
+e2d::EActionFrames::~EActionFrames()
 {
 	for (auto frame : m_vFrames)
 	{
@@ -23,21 +23,21 @@ e2d::ActionFrames::~ActionFrames()
 	}
 }
 
-void e2d::ActionFrames::_init()
+void e2d::EActionFrames::_init()
 {
 	EAction::_init();
 	// 记录当前时间
 	m_nLast = GetNow();
 }
 
-void e2d::ActionFrames::_exec()
+void e2d::EActionFrames::_exec()
 {
 	// 判断时间间隔是否足够
 	while (GetInterval(m_nLast) > m_nAnimationInterval)
 	{
 		// 重新记录时间
 		m_nLast += milliseconds(m_nAnimationInterval);
-		m_pTarget->setImage(m_vFrames[m_nFrameIndex]);
+		//m_pTarget->setImage(m_vFrames[m_nFrameIndex]);
 		m_nFrameIndex++;
 		// 判断动作是否结束
 		if (m_nFrameIndex == m_vFrames.size())
@@ -48,7 +48,7 @@ void e2d::ActionFrames::_exec()
 	}
 }
 
-void e2d::ActionFrames::_reset()
+void e2d::EActionFrames::_reset()
 {
 	EAction::_reset();
 	m_nFrameIndex = 0;
@@ -56,7 +56,7 @@ void e2d::ActionFrames::_reset()
 	m_nLast = steady_clock::now();
 }
 
-void e2d::ActionFrames::addFrame(Image * frame)
+void e2d::EActionFrames::addFrame(ESpriteFrame * frame)
 {
 	if (frame)
 	{
@@ -65,9 +65,9 @@ void e2d::ActionFrames::addFrame(Image * frame)
 	}
 }
 
-e2d::ActionFrames * e2d::ActionFrames::copy() const
+e2d::EActionFrames * e2d::EActionFrames::copy() const
 {
-	auto a = new ActionFrames(this->m_nAnimationInterval);
+	auto a = new EActionFrames(this->m_nAnimationInterval);
 	for (auto f : m_vFrames)
 	{
 		a->addFrame(f);
@@ -75,7 +75,7 @@ e2d::ActionFrames * e2d::ActionFrames::copy() const
 	return a;
 }
 
-e2d::ActionFrames * e2d::ActionFrames::reverse() const
+e2d::EActionFrames * e2d::EActionFrames::reverse() const
 {
 	auto a = this->copy();
 	a->m_vFrames.reserve(m_vFrames.size());

Easy2D/Action/EActionMoveBy.cpp

@@ -0,0 +1,53 @@
+#include "..\eactions.h"
+
+
+e2d::EActionMoveBy::EActionMoveBy(float duration, EVec vector) :
+	EAnimation(duration)
+{
+	m_MoveVector = vector;
+}
+
+e2d::EActionMoveBy::~EActionMoveBy()
+{
+}
+
+void e2d::EActionMoveBy::_init()
+{
+	EAnimation::_init();
+	m_BeginPos = m_pTarget->getPos();
+}
+
+void e2d::EActionMoveBy::_exec()
+{
+	while (EAnimation::_isDelayEnough())
+	{
+		// 计算移动位置
+		float scale = static_cast<float>(m_nDuration) / m_nTotalDuration;
+		// 移动 Sprite
+		m_pTarget->setPos(
+			m_BeginPos.x + m_MoveVector.x * scale, 
+			m_BeginPos.y + m_MoveVector.y * scale
+		);
+		// 判断动作是否结束
+		if (_isEnd())
+		{
+			this->stop();
+			break;
+		}
+	}
+}
+
+void e2d::EActionMoveBy::_reset()
+{
+	EAnimation::_reset();
+}
+
+e2d::EActionMoveBy * e2d::EActionMoveBy::copy() const
+{
+	return new EActionMoveBy(m_nAnimationInterval / 1000.0f, m_MoveVector);
+}
+
+e2d::EActionMoveBy * e2d::EActionMoveBy::reverse() const
+{
+	return new EActionMoveBy(m_nTotalDuration / 1000.0f, EVec(-m_MoveVector.x, -m_MoveVector.y));
+}

Easy2D/Action/EActionMoveTo.cpp

@@ -0,0 +1,27 @@
+#include "..\eactions.h"
+
+e2d::EActionMoveTo::EActionMoveTo(float duration, EPoint pos) :
+	EActionMoveBy(duration, EVec())
+{
+	m_EndPos = pos;
+}
+
+e2d::EActionMoveTo::~EActionMoveTo()
+{
+}
+
+e2d::EActionMoveTo * e2d::EActionMoveTo::copy() const
+{
+	return new EActionMoveTo(m_nAnimationInterval / 1000.0f, m_EndPos);
+}
+
+void e2d::EActionMoveTo::_init()
+{
+	EActionMoveBy::_init();
+	m_MoveVector = m_EndPos - m_BeginPos;
+}
+
+void e2d::EActionMoveTo::_reset()
+{
+	EActionMoveBy::_reset();
+}

Easy2D/Action/EActionNeverStop.cpp

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

Easy2D/Action/EActionOpacityBy.cpp

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

Easy2D/Action/EActionOpacityTo.cpp

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

Easy2D/Action/EActionScaleBy.cpp

@@ -0,0 +1,52 @@
+#include "..\eactions.h"
+
+
+e2d::EActionScaleBy::EActionScaleBy(float duration, float scaleX, float scaleY) :
+	EAnimation(duration)
+{
+	m_nVariationX = scaleX;
+	m_nVariationY = scaleY;
+}
+
+e2d::EActionScaleBy::~EActionScaleBy()
+{
+}
+
+void e2d::EActionScaleBy::_init()
+{
+	EAnimation::_init();
+	m_nBeginScaleX = m_pTarget->getScaleX();
+	m_nBeginScaleY = m_pTarget->getScaleY();
+}
+
+void e2d::EActionScaleBy::_exec()
+{
+	while (EAnimation::_isDelayEnough())
+	{
+		// 计算移动位置
+		float scale = static_cast<float>(m_nDuration) / m_nTotalDuration;
+		// 移动 Sprite
+		m_pTarget->setScale(m_nBeginScaleX + m_nVariationX * scale, m_nBeginScaleX + m_nVariationX * scale);
+		// 判断动作是否结束
+		if (_isEnd())
+		{
+			this->stop();
+			break;
+		}
+	}
+}
+
+void e2d::EActionScaleBy::_reset()
+{
+	EAnimation::_reset();
+}
+
+e2d::EActionScaleBy * e2d::EActionScaleBy::copy() const
+{
+	return new EActionScaleBy(m_nAnimationInterval / 1000.0f, m_nVariationX, m_nVariationY);
+}
+
+e2d::EActionScaleBy * e2d::EActionScaleBy::reverse() const
+{
+	return new EActionScaleBy(m_nTotalDuration / 1000.0f, -m_nVariationX, -m_nVariationY);
+}

Easy2D/Action/EActionScaleTo.cpp

@@ -0,0 +1,29 @@
+#include "..\eactions.h"
+
+e2d::EActionScaleTo::EActionScaleTo(float duration, float scaleX, float scaleY) :
+	EActionScaleBy(duration, 0, 0)
+{
+	m_nEndScaleX = scaleX;
+	m_nEndScaleY = scaleY;
+}
+
+e2d::EActionScaleTo::~EActionScaleTo()
+{
+}
+
+e2d::EActionScaleTo * e2d::EActionScaleTo::copy() const
+{
+	return new EActionScaleTo(m_nAnimationInterval / 1000.0f, m_nEndScaleX, m_nEndScaleY);
+}
+
+void e2d::EActionScaleTo::_init()
+{
+	EActionScaleBy::_init();
+	m_nVariationX = m_nEndScaleX - m_nBeginScaleX;
+	m_nVariationY = m_nEndScaleY - m_nBeginScaleY;
+}
+
+void e2d::EActionScaleTo::_reset()
+{
+	EActionScaleBy::_reset();
+}

Easy2D/Action/EActionSequence.cpp

@@ -1,12 +1,12 @@
 #include "..\eactions.h"
 #include <stdarg.h>
 
-e2d::ActionSequence::ActionSequence() :
+e2d::EActionSequence::EActionSequence() :
 	m_nActionIndex(0)
 {
 }
 
-e2d::ActionSequence::ActionSequence(int number, EAction * action1, ...) :
+e2d::EActionSequence::EActionSequence(int number, EAction * action1, ...) :
 	m_nActionIndex(0)
 {
 	va_list params;
@@ -21,7 +21,7 @@ e2d::ActionSequence::ActionSequence(int number, EAction * action1, ...) :
 	va_end(params);
 }
 
-e2d::ActionSequence::~ActionSequence()
+e2d::EActionSequence::~EActionSequence()
 {
 	for (auto action : m_vActions)
 	{
@@ -29,7 +29,7 @@ e2d::ActionSequence::~ActionSequence()
 	}
 }
 
-void e2d::ActionSequence::_init()
+void e2d::EActionSequence::_init()
 {
 	EAction::_init();
 	// ½«ËùÓж¯×÷ÓëÄ¿±ê°ó¶¨
@@ -41,7 +41,7 @@ void e2d::ActionSequence::_init()
 	m_vActions[0]->_init();
 }
 
-void e2d::ActionSequence::_exec()
+void e2d::EActionSequence::_exec()
 {
 	m_vActions[m_nActionIndex]->_exec();
 
@@ -59,7 +59,7 @@ void e2d::ActionSequence::_exec()
 	}
 }
 
-void e2d::ActionSequence::_reset()
+void e2d::EActionSequence::_reset()
 {
 	EAction::_reset();
 	for (auto action : m_vActions)
@@ -69,15 +69,15 @@ void e2d::ActionSequence::_reset()
 	m_nActionIndex = 0;
 }
 
-void e2d::ActionSequence::addAction(EAction * action)
+void e2d::EActionSequence::addAction(EAction * action)
 {
 	m_vActions.push_back(action);
 	action->retain();
 }
 
-e2d::ActionSequence * e2d::ActionSequence::copy() const
+e2d::EActionSequence * e2d::EActionSequence::copy() const
 {
-	auto a = new ActionSequence();
+	auto a = new EActionSequence();
 	for (auto action : m_vActions)
 	{
 		a->addAction(action->copy());
@@ -85,9 +85,9 @@ e2d::ActionSequence * e2d::ActionSequence::copy() const
 	return a;
 }
 
-e2d::ActionSequence * e2d::ActionSequence::reverse(bool actionReverse) const
+e2d::EActionSequence * e2d::EActionSequence::reverse(bool actionReverse) const
 {
-	auto a = new ActionSequence();
+	auto a = new EActionSequence();
 	for (auto action : a->m_vActions)
 	{
 		if (actionReverse)

Easy2D/Action/EActionTwo.cpp

@@ -1,6 +1,6 @@
 #include "..\eactions.h"
 
-e2d::ActionTwo::ActionTwo(EAction * actionFirst, EAction * actionSecond) :
+e2d::EActionTwo::EActionTwo(EAction * actionFirst, EAction * actionSecond) :
 	m_FirstAction(actionFirst),
 	m_SecondAction(actionSecond)
 {
@@ -8,30 +8,30 @@ e2d::ActionTwo::ActionTwo(EAction * actionFirst, EAction * actionSecond) :
 	m_SecondAction->retain();
 }
 
-e2d::ActionTwo::~ActionTwo()
+e2d::EActionTwo::~EActionTwo()
 {
 	SafeRelease(&m_FirstAction);
 	SafeRelease(&m_SecondAction);
 }
 
-e2d::ActionTwo * e2d::ActionTwo::copy() const
+e2d::EActionTwo * e2d::EActionTwo::copy() const
 {
-	return new ActionTwo(m_FirstAction->copy(), m_SecondAction->copy());
+	return new EActionTwo(m_FirstAction->copy(), m_SecondAction->copy());
 }
 
-e2d::ActionTwo * e2d::ActionTwo::reverse(bool actionReverse) const
+e2d::EActionTwo * e2d::EActionTwo::reverse(bool actionReverse) const
 {
 	if (actionReverse)
 	{
-		return new ActionTwo(m_SecondAction->reverse(), m_FirstAction->reverse());
+		return new EActionTwo(m_SecondAction->reverse(), m_FirstAction->reverse());
 	}
 	else
 	{
-		return new ActionTwo(m_SecondAction->copy(), m_FirstAction->copy());
+		return new EActionTwo(m_SecondAction->copy(), m_FirstAction->copy());
 	}
 }
 
-void e2d::ActionTwo::_init()
+void e2d::EActionTwo::_init()
 {
 	EAction::_init();
 	m_FirstAction->m_pTarget = m_pTarget;
@@ -40,7 +40,7 @@ void e2d::ActionTwo::_init()
 	m_FirstAction->_init();
 }
 
-void e2d::ActionTwo::_exec()
+void e2d::EActionTwo::_exec()
 {
 	if (!m_FirstAction->isEnding())
 	{
@@ -61,7 +61,7 @@ void e2d::ActionTwo::_exec()
 	}
 }
 
-void e2d::ActionTwo::_reset()
+void e2d::EActionTwo::_reset()
 {
 	EAction::_reset();
 

Easy2D/Action/EAnimation.cpp

@@ -1,29 +1,29 @@
 #include "..\eactions.h"
 #include "..\Win\winbase.h"
 
-e2d::Animation::Animation(float duration)
+e2d::EAnimation::EAnimation(float duration)
 {
 	m_nDuration = 0;
 	m_nTotalDuration = UINT(duration * 1000);
 }
 
-e2d::Animation::~Animation()
+e2d::EAnimation::~EAnimation()
 {
 }
 
-bool e2d::Animation::_isEnd() const
+bool e2d::EAnimation::_isEnd() const
 {
 	return m_nDuration >= m_nTotalDuration;
 }
 
-void e2d::Animation::_init()
+void e2d::EAnimation::_init()
 {
 	EAction::_init();
 	// 记录当前时间
 	m_nLast = GetNow();
 }
 
-bool e2d::Animation::_isDelayEnough()
+bool e2d::EAnimation::_isDelayEnough()
 {
 	// 判断时间间隔是否足够
 	if (GetInterval(m_nLast) > m_nAnimationInterval)
@@ -36,7 +36,7 @@ bool e2d::Animation::_isDelayEnough()
 	return false;
 }
 
-void e2d::Animation::_reset()
+void e2d::EAnimation::_reset()
 {
 	EAction::_reset();
 	m_nDuration = 0;

Easy2D/Easy2D.vcxproj

@@ -192,20 +192,20 @@
     </Lib>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClCompile Include="Action\Action.cpp" />
+    <ClCompile Include="Action\EAction.cpp" />
-    <ClCompile Include="Action\ActionCallback.cpp" />
+    <ClCompile Include="Action\EActionCallback.cpp" />
-    <ClCompile Include="Action\ActionDelay.cpp" />
+    <ClCompile Include="Action\EActionDelay.cpp" />
-    <ClCompile Include="Action\ActionFrames.cpp" />
+    <ClCompile Include="Action\EActionFrames.cpp" />
-    <ClCompile Include="Action\ActionMoveBy.cpp" />
+    <ClCompile Include="Action\EActionMoveBy.cpp" />
-    <ClCompile Include="Action\ActionMoveTo.cpp" />
+    <ClCompile Include="Action\EActionMoveTo.cpp" />
-    <ClCompile Include="Action\ActionNeverStop.cpp" />
+    <ClCompile Include="Action\EActionNeverStop.cpp" />
-    <ClCompile Include="Action\ActionOpacityBy.cpp" />
+    <ClCompile Include="Action\EActionOpacityBy.cpp" />
-    <ClCompile Include="Action\ActionOpacityTo.cpp" />
+    <ClCompile Include="Action\EActionOpacityTo.cpp" />
-    <ClCompile Include="Action\ActionScaleBy.cpp" />
+    <ClCompile Include="Action\EActionScaleBy.cpp" />
-    <ClCompile Include="Action\ActionScaleTo.cpp" />
+    <ClCompile Include="Action\EActionScaleTo.cpp" />
-    <ClCompile Include="Action\ActionSequence.cpp" />
+    <ClCompile Include="Action\EActionSequence.cpp" />
-    <ClCompile Include="Action\ActionTwo.cpp" />
+    <ClCompile Include="Action\EActionTwo.cpp" />
-    <ClCompile Include="Action\Animation.cpp" />
+    <ClCompile Include="Action\EAnimation.cpp" />
     <ClCompile Include="Base\EApp.cpp" />
     <ClCompile Include="Base\EObject.cpp" />
     <ClCompile Include="Base\EScene.cpp" />

Easy2D/Easy2D.vcxproj.filters

@@ -87,51 +87,51 @@
     <ClCompile Include="Node\ETexture.cpp">
       <Filter>Node</Filter>
     </ClCompile>
-    <ClCompile Include="Action\Action.cpp">
-      <Filter>Action</Filter>
-    </ClCompile>
-    <ClCompile Include="Action\ActionCallback.cpp">
-      <Filter>Action</Filter>
-    </ClCompile>
-    <ClCompile Include="Action\ActionDelay.cpp">
-      <Filter>Action</Filter>
-    </ClCompile>
-    <ClCompile Include="Action\ActionFrames.cpp">
-      <Filter>Action</Filter>
-    </ClCompile>
-    <ClCompile Include="Action\ActionMoveBy.cpp">
-      <Filter>Action</Filter>
-    </ClCompile>
-    <ClCompile Include="Action\ActionMoveTo.cpp">
-      <Filter>Action</Filter>
-    </ClCompile>
-    <ClCompile Include="Action\ActionNeverStop.cpp">
-      <Filter>Action</Filter>
-    </ClCompile>
-    <ClCompile Include="Action\ActionOpacityBy.cpp">
-      <Filter>Action</Filter>
-    </ClCompile>
-    <ClCompile Include="Action\ActionOpacityTo.cpp">
-      <Filter>Action</Filter>
-    </ClCompile>
-    <ClCompile Include="Action\ActionScaleBy.cpp">
-      <Filter>Action</Filter>
-    </ClCompile>
-    <ClCompile Include="Action\ActionScaleTo.cpp">
-      <Filter>Action</Filter>
-    </ClCompile>
-    <ClCompile Include="Action\ActionSequence.cpp">
-      <Filter>Action</Filter>
-    </ClCompile>
-    <ClCompile Include="Action\ActionTwo.cpp">
-      <Filter>Action</Filter>
-    </ClCompile>
-    <ClCompile Include="Action\Animation.cpp">
-      <Filter>Action</Filter>
-    </ClCompile>
     <ClCompile Include="Tool\EActionManager.cpp">
       <Filter>Tool</Filter>
     </ClCompile>
+    <ClCompile Include="Action\EAction.cpp">
+      <Filter>Action</Filter>
+    </ClCompile>
+    <ClCompile Include="Action\EActionCallback.cpp">
+      <Filter>Action</Filter>
+    </ClCompile>
+    <ClCompile Include="Action\EActionDelay.cpp">
+      <Filter>Action</Filter>
+    </ClCompile>
+    <ClCompile Include="Action\EActionFrames.cpp">
+      <Filter>Action</Filter>
+    </ClCompile>
+    <ClCompile Include="Action\EActionMoveBy.cpp">
+      <Filter>Action</Filter>
+    </ClCompile>
+    <ClCompile Include="Action\EActionMoveTo.cpp">
+      <Filter>Action</Filter>
+    </ClCompile>
+    <ClCompile Include="Action\EActionNeverStop.cpp">
+      <Filter>Action</Filter>
+    </ClCompile>
+    <ClCompile Include="Action\EActionOpacityBy.cpp">
+      <Filter>Action</Filter>
+    </ClCompile>
+    <ClCompile Include="Action\EActionOpacityTo.cpp">
+      <Filter>Action</Filter>
+    </ClCompile>
+    <ClCompile Include="Action\EActionScaleBy.cpp">
+      <Filter>Action</Filter>
+    </ClCompile>
+    <ClCompile Include="Action\EActionScaleTo.cpp">
+      <Filter>Action</Filter>
+    </ClCompile>
+    <ClCompile Include="Action\EActionSequence.cpp">
+      <Filter>Action</Filter>
+    </ClCompile>
+    <ClCompile Include="Action\EActionTwo.cpp">
+      <Filter>Action</Filter>
+    </ClCompile>
+    <ClCompile Include="Action\EAnimation.cpp">
+      <Filter>Action</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Win\winbase.h">

Easy2D/Node/ENode.cpp

@@ -642,8 +642,28 @@ void e2d::ENode::runAction(EAction * action)
 	EActionManager::bindAction(action, this);
 }
 
+void e2d::ENode::resumeAction(EAction * action)
+{
+	if (action->getTarget() == this)
+	{
+		action->resume();
+	}
+}
+
+void e2d::ENode::pauseAction(EAction * action)
+{
+	if (action->getTarget() == this)
+	{
+		action->pause();
+	}
+}
+
 void e2d::ENode::stopAction(EAction * action)
 {
+	if (action->getTarget() == this)
+	{
+		action->stop();
+	}
 }
 
 void e2d::ENode::setVisiable(bool value)

Easy2D/eactions.h

@@ -5,18 +5,18 @@
 namespace e2d
 {
 
-class ActionTwo;
+class EActionTwo;
-class ActionNeverStop;
+class EActionNeverStop;
-class ActionSequence;
+class EActionSequence;
 
 class EAction :
 	public EObject
 {
 	friend ENode;
 	friend EActionManager;
-	friend ActionTwo;
+	friend EActionTwo;
-	friend ActionNeverStop;
+	friend EActionNeverStop;
-	friend ActionSequence;
+	friend EActionSequence;
 
 public:
 	EAction();
@@ -25,20 +25,30 @@ public:
 
 	// 获取动作运行状态
 	virtual bool isRunning();
+
 	// 获取动作结束状态
 	virtual bool isEnding();
+
 	// 继续动作
 	virtual void start();
+
 	// 继续动作
 	virtual void resume();
+
 	// 暂停动作
 	virtual void pause();
+
 	// 停止动作
 	virtual void stop();
-	// 设置动作每一帧时间间隔
+
-	virtual void setInterval(LONGLONG milliSeconds);
+	// 设置动作每一帧的时间间隔
+	virtual void setInterval(
+		LONGLONG milliSeconds
+	);
+
 	// 获取一个新的拷贝动作
 	virtual EAction * copy() const = 0;
+
 	// 获取一个新的逆向动作
 	virtual EAction * reverse() const;
 	// 获取执行该动作的目标
@@ -72,12 +82,12 @@ protected:
 };
 
 
-class Animation :
+class EAnimation :
 	public EAction
 {
 public:
-	Animation(float duration);
+	EAnimation(float duration);
-	virtual ~Animation();
+	virtual ~EAnimation();
 
 protected:
 	LONGLONG m_nDuration;
@@ -91,15 +101,15 @@ protected:
 };
 
 
-class ActionMoveBy :
+class EActionMoveBy :
-	public Animation
+	public EAnimation
 {
 public:
-	ActionMoveBy(float duration, EVec vector);
+	EActionMoveBy(float duration, EVec vector);
-	virtual ~ActionMoveBy();
+	virtual ~EActionMoveBy();
 
-	virtual ActionMoveBy * copy() const override;
+	virtual EActionMoveBy * copy() const override;
-	virtual ActionMoveBy * reverse() const override;
+	virtual EActionMoveBy * reverse() const override;
 
 protected:
 	EPoint	m_BeginPos;
@@ -112,14 +122,14 @@ protected:
 };
 
 
-class ActionMoveTo :
+class EActionMoveTo :
-	public ActionMoveBy
+	public EActionMoveBy
 {
 public:
-	ActionMoveTo(float duration, EPoint pos);
+	EActionMoveTo(float duration, EPoint pos);
-	virtual ~ActionMoveTo();
+	virtual ~EActionMoveTo();
 
-	virtual ActionMoveTo * copy() const override;
+	virtual EActionMoveTo * copy() const override;
 
 protected:
 	EPoint m_EndPos;
@@ -130,15 +140,15 @@ protected:
 };
 
 
-class ActionScaleBy :
+class EActionScaleBy :
-	public Animation
+	public EAnimation
 {
 public:
-	ActionScaleBy(float duration, float scaleX, float scaleY);
+	EActionScaleBy(float duration, float scaleX, float scaleY);
-	virtual ~ActionScaleBy();
+	virtual ~EActionScaleBy();
 
-	virtual ActionScaleBy * copy() const override;
+	virtual EActionScaleBy * copy() const override;
-	virtual ActionScaleBy * reverse() const override;
+	virtual EActionScaleBy * reverse() const override;
 
 protected:
 	float	m_nBeginScaleX;
@@ -153,14 +163,14 @@ protected:
 };
 
 
-class ActionScaleTo :
+class EActionScaleTo :
-	public ActionScaleBy
+	public EActionScaleBy
 {
 public:
-	ActionScaleTo(float duration, float scaleX, float scaleY);
+	EActionScaleTo(float duration, float scaleX, float scaleY);
-	virtual ~ActionScaleTo();
+	virtual ~EActionScaleTo();
 
-	virtual ActionScaleTo * copy() const override;
+	virtual EActionScaleTo * copy() const override;
 
 protected:
 	float	m_nEndScaleX;
@@ -172,15 +182,15 @@ protected:
 };
 
 
-class ActionOpacityBy :
+class EActionOpacityBy :
-	public Animation
+	public EAnimation
 {
 public:
-	ActionOpacityBy(float duration, float opacity);
+	EActionOpacityBy(float duration, float opacity);
-	virtual ~ActionOpacityBy();
+	virtual ~EActionOpacityBy();
 
-	virtual ActionOpacityBy * copy() const override;
+	virtual EActionOpacityBy * copy() const override;
-	virtual ActionOpacityBy * reverse() const override;
+	virtual EActionOpacityBy * reverse() const override;
 
 protected:
 	float m_nBeginVal;
@@ -193,14 +203,14 @@ protected:
 };
 
 
-class ActionOpacityTo :
+class EActionOpacityTo :
-	public ActionOpacityBy
+	public EActionOpacityBy
 {
 public:
-	ActionOpacityTo(float duration, float opacity);
+	EActionOpacityTo(float duration, float opacity);
-	virtual ~ActionOpacityTo();
+	virtual ~EActionOpacityTo();
 
-	virtual ActionOpacityTo * copy() const override;
+	virtual EActionOpacityTo * copy() const override;
 
 protected:
 	float m_nEndVal;
@@ -212,30 +222,30 @@ protected:
 
 
 class ActionFadeIn :
-	public ActionOpacityTo
+	public EActionOpacityTo
 {
 public:
-	ActionFadeIn(float duration) : ActionOpacityTo(duration, 1) {}
+	ActionFadeIn(float duration) : EActionOpacityTo(duration, 1) {}
 };
 
 
 class ActionFadeOut :
-	public ActionOpacityTo
+	public EActionOpacityTo
 {
 public:
-	ActionFadeOut(float duration) : ActionOpacityTo(duration, 0) {}
+	ActionFadeOut(float duration) : EActionOpacityTo(duration, 0) {}
 };
 
 
-class ActionTwo :
+class EActionTwo :
 	public EAction
 {
 public:
-	ActionTwo(EAction * actionFirst, EAction * actionSecond);
+	EActionTwo(EAction * actionFirst, EAction * actionSecond);
-	virtual ~ActionTwo();
+	virtual ~EActionTwo();
 
-	virtual ActionTwo * copy() const override;
+	virtual EActionTwo * copy() const override;
-	virtual ActionTwo * reverse(bool actionReverse = true) const;
+	virtual EActionTwo * reverse(bool actionReverse = true) const;
 
 protected:
 	EAction *	m_FirstAction;
@@ -248,17 +258,17 @@ protected:
 };
 
 
-class ActionSequence :
+class EActionSequence :
 	public EAction
 {
 public:
-	ActionSequence();
+	EActionSequence();
-	ActionSequence(int number, EAction * action1, ...);
+	EActionSequence(int number, EAction * action1, ...);
-	virtual ~ActionSequence();
+	virtual ~EActionSequence();
 
 	void addAction(EAction * action);
-	virtual ActionSequence * copy() const override;
+	virtual EActionSequence * copy() const override;
-	virtual ActionSequence * reverse(bool actionReverse = true) const;
+	virtual EActionSequence * reverse(bool actionReverse = true) const;
 
 protected:
 	UINT					m_nActionIndex;
@@ -271,14 +281,14 @@ protected:
 };
 
 
-class ActionDelay :
+class EActionDelay :
 	public EAction
 {
 public:
-	ActionDelay(float duration);
+	EActionDelay(float duration);
-	virtual ~ActionDelay();
+	virtual ~EActionDelay();
 
-	virtual ActionDelay * copy() const override;
+	virtual EActionDelay * copy() const override;
 
 protected:
 	virtual void _init() override;
@@ -287,14 +297,14 @@ protected:
 };
 
 
-class ActionNeverStop :
+class EActionNeverStop :
 	public EAction
 {
 public:
-	ActionNeverStop(EAction * action);
+	EActionNeverStop(EAction * action);
-	virtual ~ActionNeverStop();
+	virtual ~EActionNeverStop();
 
-	virtual ActionNeverStop * copy() const override;
+	virtual EActionNeverStop * copy() const override;
 
 protected:
 	EAction * m_Action;
@@ -306,21 +316,21 @@ protected:
 };
 
 
-class ActionFrames :
+class EActionFrames :
 	public EAction
 {
 public:
-	ActionFrames();
+	EActionFrames();
-	ActionFrames(LONGLONG frameDelay);
+	EActionFrames(LONGLONG frameDelay);
-	~ActionFrames();
+	~EActionFrames();
 
-	void addFrame(Image * frame);
+	void addFrame(ESpriteFrame * frame);
-	virtual ActionFrames * copy() const override;
+	virtual EActionFrames * copy() const override;
-	virtual ActionFrames * reverse() const override;
+	virtual EActionFrames * reverse() const override;
 
 protected:
-	UINT			m_nFrameIndex;
+	UINT m_nFrameIndex;
-	EVector<Image*> m_vFrames;
+	EVector<ESpriteFrame*> m_vFrames;
 
 protected:
 	virtual void _init() override;
@@ -329,14 +339,14 @@ protected:
 };
 
 
-class ActionCallback :
+class EActionCallback :
 	public EAction
 {
 public:
-	ActionCallback(const std::function<void()>& callback);
+	EActionCallback(const std::function<void()>& callback);
-	~ActionCallback();
+	~EActionCallback();
 
-	virtual ActionCallback * copy() const override;
+	virtual EActionCallback * copy() const override;
 
 protected:
 	std::function<void()> m_Callback;

Easy2D/enodes.h

@@ -260,6 +260,16 @@ public:
 		EAction * action
 	);
 
+	// 继续动画
+	virtual void resumeAction(
+		EAction * action
+	);
+
+	// 暂停动画
+	virtual void pauseAction(
+		EAction * action
+	);
+
 	// 停止动画
 	virtual void stopAction(
 		EAction * action
@@ -484,6 +494,14 @@ protected:
 };
 
 
+class ESpriteFrame :
+	public EObject
+{
+protected:
+	ETexture * texture;
+};
+
+
 class EFont :
 	public EObject
 {