Lenheart
/
Magic_Game
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

新增同时动作； 

新增EFileUtils和ERandom
This commit is contained in:
Nomango 2017-10-19 12:47:36 +08:00
parent b87998b6a8
commit 9a67931163
27 changed files with 538 additions and 490 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
Easy2D/Action/ActionCallback.cpp
View File

@ -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();
}

53
Easy2D/Action/ActionMoveBy.cpp
View File

@ -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));
}

27
Easy2D/Action/ActionMoveTo.cpp
View File

@ -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();
}

39
Easy2D/Action/ActionNeverStop.cpp
View File

@ -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();
}

50
Easy2D/Action/ActionOpacityBy.cpp
View File

@ -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);
}

28
Easy2D/Action/ActionOpacityTo.cpp
View File

@ -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();
}

52
Easy2D/Action/ActionScaleBy.cpp
View File

@ -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);
}

29
Easy2D/Action/ActionScaleTo.cpp
View File

@ -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();
}

0
Easy2D/Action/Action.cpp → Easy2D/Action/EAction.cpp
View File

31
Easy2D/Action/EActionCallback.cpp Normal file
View File

@ -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();
}

14
Easy2D/Action/ActionDelay.cpp → Easy2D/Action/EActionDelay.cpp
View File

@ -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();
// 记录当前时间

22
Easy2D/Action/ActionFrames.cpp → Easy2D/Action/EActionFrames.cpp
View File

@ -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());

53
Easy2D/Action/EActionMoveBy.cpp Normal file
View File

@ -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));
}

27
Easy2D/Action/EActionMoveTo.cpp Normal file
View File

@ -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();
}

39
Easy2D/Action/EActionNeverStop.cpp Normal file
View File

@ -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();
}

50
Easy2D/Action/EActionOpacityBy.cpp Normal file
View File

@ -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);
}

28
Easy2D/Action/EActionOpacityTo.cpp Normal file
View File

@ -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();
}

52
Easy2D/Action/EActionScaleBy.cpp Normal file
View File

@ -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);
}

29
Easy2D/Action/EActionScaleTo.cpp Normal file
View File

@ -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();
}

22
Easy2D/Action/ActionSequence.cpp → Easy2D/Action/EActionSequence.cpp
View File

@ -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)

20
Easy2D/Action/ActionTwo.cpp → Easy2D/Action/EActionTwo.cpp
View File

@ -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();

12
Easy2D/Action/Animation.cpp → Easy2D/Action/EAnimation.cpp
View File

@ -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;

28
Easy2D/Easy2D.vcxproj
View File

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

84
Easy2D/Easy2D.vcxproj.filters
View File

@ -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">

20
Easy2D/Node/ENode.cpp
View File

@ -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)

170
Easy2D/eactions.h
View File

@ -5,18 +5,18 @@
namespace e2d
{
class ActionTwo;
class ActionNeverStop;
class ActionSequence;
class EActionTwo;
class EActionNeverStop;
class EActionSequence;
class EAction :
public EObject
{
friend ENode;
friend EActionManager;
friend ActionTwo;
friend ActionNeverStop;
friend ActionSequence;
friend EActionTwo;
friend EActionNeverStop;
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);
virtual ~Animation();
EAnimation(float duration);
virtual ~EAnimation();
protected:
LONGLONG m_nDuration;
@ -91,15 +101,15 @@ protected:
};
class ActionMoveBy :
public Animation
class EActionMoveBy :
public EAnimation
{
public:
ActionMoveBy(float duration, EVec vector);
virtual ~ActionMoveBy();
EActionMoveBy(float duration, EVec vector);
virtual ~EActionMoveBy();
virtual ActionMoveBy * copy() const override;
virtual ActionMoveBy * reverse() const override;
virtual EActionMoveBy * copy() const override;
virtual EActionMoveBy * reverse() const override;
protected:
EPoint m_BeginPos;
@ -112,14 +122,14 @@ protected:
};
class ActionMoveTo :
public ActionMoveBy
class EActionMoveTo :
public EActionMoveBy
{
public:
ActionMoveTo(float duration, EPoint pos);
virtual ~ActionMoveTo();
EActionMoveTo(float duration, EPoint pos);
virtual ~EActionMoveTo();
virtual ActionMoveTo * copy() const override;
virtual EActionMoveTo * copy() const override;
protected:
EPoint m_EndPos;
@ -130,15 +140,15 @@ protected:
};
class ActionScaleBy :
public Animation
class EActionScaleBy :
public EAnimation
{
public:
ActionScaleBy(float duration, float scaleX, float scaleY);
virtual ~ActionScaleBy();
EActionScaleBy(float duration, float scaleX, float scaleY);
virtual ~EActionScaleBy();
virtual ActionScaleBy * copy() const override;
virtual ActionScaleBy * reverse() const override;
virtual EActionScaleBy * copy() const override;
virtual EActionScaleBy * reverse() const override;
protected:
float m_nBeginScaleX;
@ -153,14 +163,14 @@ protected:
};
class ActionScaleTo :
public ActionScaleBy
class EActionScaleTo :
public EActionScaleBy
{
public:
ActionScaleTo(float duration, float scaleX, float scaleY);
virtual ~ActionScaleTo();
EActionScaleTo(float duration, float scaleX, float scaleY);
virtual ~EActionScaleTo();
virtual ActionScaleTo * copy() const override;
virtual EActionScaleTo * copy() const override;
protected:
float m_nEndScaleX;
@ -172,15 +182,15 @@ protected:
};
class ActionOpacityBy :
public Animation
class EActionOpacityBy :
public EAnimation
{
public:
ActionOpacityBy(float duration, float opacity);
virtual ~ActionOpacityBy();
EActionOpacityBy(float duration, float opacity);
virtual ~EActionOpacityBy();
virtual ActionOpacityBy * copy() const override;
virtual ActionOpacityBy * reverse() const override;
virtual EActionOpacityBy * copy() const override;
virtual EActionOpacityBy * reverse() const override;
protected:
float m_nBeginVal;
@ -193,14 +203,14 @@ protected:
};
class ActionOpacityTo :
public ActionOpacityBy
class EActionOpacityTo :
public EActionOpacityBy
{
public:
ActionOpacityTo(float duration, float opacity);
virtual ~ActionOpacityTo();
EActionOpacityTo(float duration, float opacity);
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);
virtual ~ActionTwo();
EActionTwo(EAction * actionFirst, EAction * actionSecond);
virtual ~EActionTwo();
virtual ActionTwo * copy() const override;
virtual ActionTwo * reverse(bool actionReverse = true) const;
virtual EActionTwo * copy() const override;
virtual EActionTwo * reverse(bool actionReverse = true) const;
protected:
EAction * m_FirstAction;
@ -248,17 +258,17 @@ protected:
};
class ActionSequence :
class EActionSequence :
public EAction
{
public:
ActionSequence();
ActionSequence(int number, EAction * action1, ...);
virtual ~ActionSequence();
EActionSequence();
EActionSequence(int number, EAction * action1, ...);
virtual ~EActionSequence();
void addAction(EAction * action);
virtual ActionSequence * copy() const override;
virtual ActionSequence * reverse(bool actionReverse = true) const;
virtual EActionSequence * copy() const override;
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);
virtual ~ActionDelay();
EActionDelay(float duration);
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);
virtual ~ActionNeverStop();
EActionNeverStop(EAction * action);
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();
ActionFrames(LONGLONG frameDelay);
~ActionFrames();
EActionFrames();
EActionFrames(LONGLONG frameDelay);
~EActionFrames();
void addFrame(Image * frame);
virtual ActionFrames * copy() const override;
virtual ActionFrames * reverse() const override;
void addFrame(ESpriteFrame * frame);
virtual EActionFrames * copy() const override;
virtual EActionFrames * reverse() const override;
protected:
UINT m_nFrameIndex;
EVector<Image*> m_vFrames;
UINT m_nFrameIndex;
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);
~ActionCallback();
EActionCallback(const std::function<void()>& callback);
~EActionCallback();
virtual ActionCallback * copy() const override;
virtual EActionCallback * copy() const override;
protected:
std::function<void()> m_Callback;

18
Easy2D/enodes.h
View File

@ -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
{