DirectionalLight::DirectionalLight()
{
this->m_direction = FLOAT3(0.0f, 0.0f, 0.0f);
this->m_la = FLOAT3(0.0f, 0.0f, 0.0f);
this->m_ld = FLOAT3(0.0f, 0.0f, 0.0f);
this->m_ls = FLOAT3(0.0f, 0.0f, 0.0f);
}
void ChainStrikeClientSkillEffect::update(float _dt)
{
m_lifetime += _dt;
m_eTarget = ClientEntityHandler::getEntity(m_target);
FLOAT3 myVec = FLOAT3(0, 0, 0);
if(m_eTarget)
myVec = m_eTarget->m_model->getPosition() - FLOAT3(m_orig.x, m_orig.y, m_orig.z);
D3DXVECTOR3 distanceToTarget(myVec.x, myVec.y, myVec.z);
float onePercent = 1.0f/(ChainStrikeEffect::TIME_BETWEEN_JUMPS);
m_percentToTarget += onePercent * _dt;
D3DXVECTOR3 incY(0, 0.5f, 0);
if(m_eOrig)
//m_chainEffect->setOrig(D3DXVECTOR3(m_eOrig->m_model->getPosition().x, m_eOrig->m_model->getPosition().y, m_eOrig->m_model->getPosition().z));
//m_chainEffect->setOrig(D3DXVECTOR3(m_superPos.x, m_superPos.y + 0.2f,m_superPos.z));
pe[0]->setPosition(m_orig + (distanceToTarget*m_percentToTarget) + incY);
pe[1]->setPosition(m_orig + (distanceToTarget*m_percentToTarget) + incY);
pe[2]->setPosition(m_orig + (distanceToTarget*m_percentToTarget) + incY);
//else
//m_lifetime = ChainStrikeEffect::TIME_BETWEEN_JUMPS;
//if(m_eTarget)
//m_chainEffect->setTarget(D3DXVECTOR3(m_eTarget->m_model->getPosition().x, m_eTarget->m_model->getPosition().y + 0.2f, m_eTarget->m_model->getPosition().z));
//m_chainEffect->setTarget(D3DXVECTOR3(m_superPos.x, m_superPos.y, m_superPos.z));
//pe[1]->setPosition(D3DXVECTOR3(m_superPos.x, m_superPos.y, m_superPos.z));
//m_chainEffect->setCamPos(g_graphicsEngine->getCamera()->getPos());
//m_chainEffect->setViewProj(g_graphicsEngine->getCamera()->getViewProjectionMatrix());
}
//----------------------------------------------------------------------------------------------------
void EERotateByProcess(EEObject* _object, float _time, float _radians, const FLOAT2& _center, float _delay, bool _isInfinite, float _startTime)
{
try
{
float remainTime = _delay + _time;
float progress = _startTime;
float speed = _radians / _time;
while (1)
{
EEThreadSleep(20);
std::lock_guard<std::mutex> mutex(_object->GetThreadMutex());
float currTime = (float)EECore::s_EECore->GetTotalTime();
float deltaTime = currTime - progress;
progress = currTime;
if (remainTime <= deltaTime + _time)
{
remainTime = _time;
break;
}
else
{
remainTime -= deltaTime;
}
}
while (1)
{
EEThreadSleep(20);
std::lock_guard<std::mutex> mutex(_object->GetThreadMutex());
float currTime = (float)EECore::s_EECore->GetTotalTime();
float deltaTime = currTime - progress;
progress = currTime;
if (remainTime <= deltaTime && !_isInfinite)
{
MATRIX rotation = MatrixRotationAxisN(FLOAT3(0.0f, 0.0f, 1.0f), speed * remainTime);
FLOAT3 position = _object->GetPosition() - _center;
position *= rotation;
_object->SetPosition(position + _center);
remainTime = 0.f;
return;
}
else
{
MATRIX rotation = MatrixRotationAxisN(FLOAT3(0.0f, 0.0f, 1.0f), speed * deltaTime);
FLOAT3 position = _object->GetPosition() - _center;
position *= rotation;
_object->SetPosition(position + _center);
remainTime -= deltaTime;
}
}
}
catch (boost::thread_interrupted&)
{
return;
}
}
//----------------------------------------------------------------------------------------------------
bool EEProgressbar::Update()
{
if (!EEObject::Update())
return false;
UpdateObjectState();
if (m_isPositionDirty)
{
m_isPositionDirty = false;
}
if (m_isScaleDirty || m_isLocalZOrderDirty || m_isProgressDirty)
{
Rect_Float rect(
-m_quadWidth / 2,
-m_quadHeight / 2,
m_quadWidth / 2,
m_quadHeight / 2
);
//the value of the z depends on the progress (the scaled end - the scaled width * (1.0f - the progress)
rect.z -= (rect.z - rect.x) * (1.0f - m_progress);
EEQuad2DVertex vertices[4];
vertices[0].pos = FLOAT3(rect.x, rect.y, m_localZOrder * 0.0001f);
vertices[0].tex = FLOAT2(0, 0);
vertices[1].pos = FLOAT3(rect.z, rect.y, m_localZOrder * 0.0001f);
vertices[1].tex = FLOAT2(m_progress, 0);
vertices[2].pos = FLOAT3(rect.x, rect.w, m_localZOrder * 0.0001f);
vertices[2].tex = FLOAT2(0, 1);
vertices[3].pos = FLOAT3(rect.z, rect.w, m_localZOrder * 0.0001f);
vertices[3].tex = FLOAT2(m_progress, 1);
ID3D11DeviceContext *deviceContext = EECore::s_EECore->GetDeviceContext();
D3D11_MAPPED_SUBRESOURCE mappedResource;
ZeroMemory(&mappedResource, sizeof(D3D11_MAPPED_SUBRESOURCE));
deviceContext->Map(m_quadVB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
memcpy(mappedResource.pData, vertices, sizeof(vertices));
deviceContext->Unmap(m_quadVB, 0);
if (m_isProgressDirty)
{
if (m_callbackFunc)
{
m_callbackFunc(m_progress);
}
}
m_isScaleDirty = false;
m_isLocalZOrderDirty = false;
m_isProgressDirty = false;
}
m_progressFrame.Update();
return true;
}
//----------------------------------------------------------------------------------------------------
bool EECurve2D::Update()
{
if (!EEObject::Update())
return false;
UpdateObjectState();
if (m_isPositionDirty)
{
m_isPositionDirty = false;
}
if (m_isLocalZOrderDirty || m_isCurveDirty)
{
std::vector<EECurve2DVertex> vertices(m_curve.size() << 1);
if (m_curve.size() > 1)
{
float halfWidth = m_width / 2;
float deltaTex = 1.f / m_curve.size();
for (unsigned int i = 0; i < m_curve.size() - 1; ++i)
{
int index = i << 1;
FLOAT2 vertical = (m_curve[i + 1] - m_curve[i]).GetVertical();
vertices[index].pos = FLOAT3(m_curve[i] + vertical * halfWidth, m_localZOrder * 0.0001f);
vertices[index].tex = FLOAT2(m_texRect.x, m_texRect.y + i * deltaTex);
vertices[index + 1].pos = FLOAT3(m_curve[i] - vertical * halfWidth, m_localZOrder * 0.0001f);
vertices[index + 1].tex = FLOAT2(m_texRect.z, m_texRect.y + i * deltaTex);
}
FLOAT2 vertical = (m_curve[m_curve.size() - 1] - m_curve[m_curve.size() - 2]).GetVertical();
vertices[vertices.size() - 2].pos = FLOAT3(m_curve.back() + vertical * halfWidth, m_localZOrder * 0.0001f);
vertices[vertices.size() - 2].tex = FLOAT2(m_texRect.x, m_texRect.w);
vertices[vertices.size() - 1].pos = FLOAT3(m_curve.back() - vertical * halfWidth, m_localZOrder * 0.0001f);
vertices[vertices.size() - 1].tex = FLOAT2(m_texRect.z, m_texRect.w);
}
if (m_isCurveDirty)
CreateCurveVertexBuffer();
if (m_curveVB)
{
ID3D11DeviceContext *deviceContext = EECore::s_EECore->GetDeviceContext();
D3D11_MAPPED_SUBRESOURCE mappedResource;
ZeroMemory(&mappedResource, sizeof(D3D11_MAPPED_SUBRESOURCE));
deviceContext->Map(m_curveVB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
memcpy(mappedResource.pData, &vertices[0], sizeof(EECurve2DVertex)* vertices.size());
deviceContext->Unmap(m_curveVB, 0);
}
m_isLocalZOrderDirty = false;
m_isCurveDirty = false;
}
return true;
}
Hero::Hero(HERO_TYPE _heroType, int _playerId) : UnitEntity()
{
this->m_heroType = _heroType;
this->m_playerId = _playerId;
this->m_type = Type::HeroType;
this->m_obb = new BoundingOrientedBox(XMFLOAT3(this->m_position.x, this->m_position.y, this->m_position.z), XMFLOAT3(0.5f, 0.5f, 0.5f), XMFLOAT4(0.0f, 0.0f, 0.0f, 1.0f));
this->m_position = FLOAT3(0.0f, 0.0f, 0.0f);
this->m_nextPosition = this->m_position;
this->m_reachedPosition = true;
this->m_attackCooldown = 0.0f;
this->m_attackRange = 5.0f;
this->m_hasTarget = false;
this->m_startPos=FLOAT3(0.0,0.0,0.0);
this->m_weaponType = WEAPON_TYPE::NO_WEAPON;
this->m_alive = true;
}
//int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR pScmdline, int iCmdshow)
int main(int _argc, char** _argv)
{
EEDesc desc;
desc.applicationName = L"Emerald"; //窗口名称
desc.isFullScreen = false; //是否全屏
desc.width = 800; //窗口宽度
desc.height = 450; //窗口高度
desc.isSSAA = true; //是开启抗锯齿
desc.isVsync = false; //是否垂直同步
EEInitialize(desc);
EETexture bgTex(L"Texture\\主界面\\主界面背景.jpg");
EETexture button2Tex(L"Texture/主界面/模式标签/生涯模式.png");
EEFont helloworld(FLOAT3(100.0f, 100.0f, 0.0f), EEColor::YELLOW, L"hello world");
EELineEditer *lineEditer = new EELineEditer(Rect_Float(200.f, 300.f, 300.f, 350.f), bgTex, EEColor::BLACK);
EELineEditer *lineEditer2 = new EELineEditer(Rect_Float(400.f, 300.f, 500.f, 350.f), bgTex, EEColor::BLACK);
while (EERun())
{
EEBeginScene(EEColor::BLACK);
EEShowFPSInTitle(L"- -");
lineEditer->Process();
lineEditer2->Process();
helloworld.Process();
EEEndScene();
}
EEShutdown();
return 0;
}
//----------------------------------------------------------------------------------------------------
bool EEQuad2D::Update()
{
if (!EEObject::Update())
return false;
UpdateObjectState();
if (m_isPositionDirty)
{
m_isPositionDirty = false;
}
if (m_isScaleDirty || m_isLocalZOrderDirty || m_isTexRectDirty)
{
Rect_Float rect(
-m_quadWidth / 2,
-m_quadHeight / 2,
m_quadWidth / 2,
m_quadHeight / 2
);
EEQuad2DVertex quadVertices[4];
quadVertices[0].pos = FLOAT3(rect.x, rect.y, m_localZOrder * 0.0001f);
quadVertices[0].tex = FLOAT2(m_texRect.x, m_texRect.y);
quadVertices[1].pos = FLOAT3(rect.z, rect.y, m_localZOrder * 0.0001f);
quadVertices[1].tex = FLOAT2(m_texRect.z, m_texRect.y);
quadVertices[2].pos = FLOAT3(rect.x, rect.w, m_localZOrder * 0.0001f);
quadVertices[2].tex = FLOAT2(m_texRect.x, m_texRect.w);
quadVertices[3].pos = FLOAT3(rect.z, rect.w, m_localZOrder * 0.0001f);
quadVertices[3].tex = FLOAT2(m_texRect.z, m_texRect.w);
ID3D11DeviceContext *deviceContext = EECore::s_EECore->GetDeviceContext();
D3D11_MAPPED_SUBRESOURCE mappedResource;
ZeroMemory(&mappedResource, sizeof(D3D11_MAPPED_SUBRESOURCE));
deviceContext->Map(m_quadVB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
memcpy(mappedResource.pData, quadVertices, sizeof(quadVertices));
deviceContext->Unmap(m_quadVB, 0);
m_isScaleDirty = false;
m_isLocalZOrderDirty = false;
m_isTexRectDirty = false;
}
return true;
}
//----------------------------------------------------------------------------------------------------
void EEQuad2D::SetRect(const Rect_Float& _rect)
{
m_position = FLOAT3((_rect.x + _rect.z) / 2, (_rect.y + _rect.w) / 2, 0.0f);
m_quadRect = _rect;
m_quadWidth = _rect.z - _rect.x;
m_quadHeight = _rect.w - _rect.y;
m_isPositionDirty = true;
m_isScaleDirty = true;
}
//----------------------------------------------------------------------------------------------------
EEQuad2D::EEQuad2D(const Rect_Float &_rect)
:
EEObject2D(FLOAT3((_rect.x + _rect.z) / 2, (_rect.y + _rect.w) / 2, 0.0f)),
m_quadRect(_rect),
m_quadWidth(_rect.z - _rect.x),
m_quadHeight(_rect.w - _rect.y),
m_quadVB(NULL)
{
InitializeQuad2D();
CreateQuadVertexBuffer();
}
//int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR pScmdline, int iCmdshow)
int main(int _argc, char** _argv)
{
EEDesc desc;
desc.applicationName = L"Emerald"; //窗口名称
desc.isFullScreen = false; //是否全屏
desc.width = 800; //窗口宽度
desc.height = 450; //窗口高度
desc.isSSAA = true; //是开启抗锯齿
desc.isVsync = false; //是否垂直同步
EEInitialize(desc);
EEBitmap bitmap1 = EEGetFontBitmap(L'啊');
EEBitmap bitmap2 = EEGetFontBitmap(L'呀');
EEBitmap bitmap3 = EEGetFontBitmap(L'？');
EEBitmap bitmap = EEBitmapCombineHorizontal(bitmap1, bitmap2);
//bitmap = EEBitmapCombineHorizontal(bitmap, bitmap3);
//bitmap.Resize(500, 500);
//std::vector<EEBitmap> bitmaps;
//EEBitmapDivideVertical(bitmap, 3, bitmaps);
//EETexture fonttex(bitmaps[1]);
EEQuad2D quad0(Rect_Float(0, 0, (float)bitmap.GetWidth(), (float)bitmap.GetHeight()), bitmap);
quad0.SetLocalZOrder(10.0f);
EEBitmap bitmap11 = EEGetFontBitmap(L"大家好!呀\n呀\'呀呀?");
EEQuad2D quad1(Rect_Float(0, 200, (float)bitmap11.GetWidth(), (float)bitmap11.GetHeight() + 200), bitmap11);
quad1.SetLocalZOrder(10.0f);
EETexture bgTex(L"Texture\\Project Diva Freedom\\01\\选歌条.png");
EEFont helloworld(FLOAT3(100.0f, 100.0f, 0.0f), EEColor::YELLOW, L"hello world");
helloworld.AddText(L'1');
EELineEditor *lineEditor = new EELineEditor(Rect_Float(200.f, 300.f, 300.f, 350.f), bgTex, EEColor::BLACK);
EELineEditor *lineEditor2 = new EELineEditor(Rect_Float(400.f, 300.f, 500.f, 350.f), bgTex, EEColor::BLACK);
EETextEditor *textEditor = new EETextEditor(Rect_Float(300.f, 100.f, 400.f, 150.f), bgTex, EEColor::BLACK);
while (EERun())
{
EEBeginScene(EEColor::BLACK);
EEShowFPSInTitle(L"- -");
quad0.Process();
quad1.Process();
lineEditor->Process();
lineEditor2->Process();
helloworld.Process();
textEditor->Process();
EEEndScene();
}
EEShutdown();
return 0;
}
//----------------------------------------------------------------------------------------------------
EEQuad2D::EEQuad2D(const Rect_Float &_rect, ID3D11ShaderResourceView* _tex)
:
EEObject2D(FLOAT3((_rect.x + _rect.z) / 2, (_rect.y + _rect.w) / 2, 0.0f)),
m_quadRect(_rect),
m_quadWidth(_rect.z - _rect.x),
m_quadHeight(_rect.w - _rect.y),
m_quadVB(NULL)
{
InitializeQuad2D();
SetTexture(_tex);
SetIsUseColor(false);
SetIsUseTex(true);
CreateQuadVertexBuffer();
}
//----------------------------------------------------------------------------------------------------
EEFont::EEFont(const float _width, float height, const EEColor& _color, wchar_t* _text)
:
EEQuad2D(FLOAT3(0.f, 0.f, 0.f), _width, height, _color),
m_text(_text),
m_isTextDirty(true),
m_isDynamic(false),
m_isAdaptive(true),
m_adaptivePos(1.f, 1.f)
{
InitializeFont();
SetColor(_color);
SetIsUseColor(true);
SetIsUseTex(true);
}
DIVANote::DIVANote(const Note& _note, double _totalTime, double singleTime, EETexture& _nodeTex, EETexture& _stripTex)
:
EEQuad2D(FLOAT3((float)_note.x, (float)_note.y, 0.f), EEGetWidth() / 20.f, EEGetHeight() / 11.f, _nodeTex),
m_type(_note.key < NOTE_NUM ? NOTETYPE_NORMAL : NOTETYPE_STRIP),
m_key(_note.key),
m_x(_note.x),
m_y(_note.y),
m_tailx(_note.tailx),
m_taily(_note.taily),
m_note(FLOAT3((float)_note.tailx, (float)_note.taily, 0.f), EEGetWidth() / 20.f, EEGetHeight() / 11.f, _nodeTex),
m_stripNote(FLOAT3((float)_note.tailx, (float)_note.taily, 0.f), EEGetWidth() / 20.f, EEGetHeight() / 11.f, _nodeTex),
m_strip(_stripTex),
m_state(DIVA_NOTE_DEFAULT),
m_actionTime(0.1),
m_totalTime(_totalTime),
m_restTime(_totalTime),
m_totalDuration(_note.duration * singleTime),
m_restDuration(_note.duration * singleTime)
{
m_strip.SetWidth(EEGetWidth() / 30.f);
}
void Mission::createMission(string type, float x, float z, int startwave, int endwave,string missionName)
{
this->startWave=startwave;
this->endWave=endwave;
this->m_position=FLOAT3(x,0.0f,z);
this->missionName=missionName;
//if(EntityHandler::getServerEntity(this->bossId) != NULL)
{
if(type=="bigBadBoss")
{
this->missionType=MissionType::BBB;
}
if(type=="bigBadChar")
{
this->missionType=MissionType::BBC;
}
}
int k=0;
}
void DeathClientSkillEffect::update(float dt)
{
this->m_lifetime = this->m_lifetime - dt;
Entity *e = ClientEntityHandler::getEntity(this->m_masterId);
if(e != NULL)
{
if(e->m_type == ServerEntity::HeroType)
{
this->m_model->setGlowAlpha((LIFETIME - m_lifetime ) * 0.5f);
}
}
if(this->m_model != NULL)
{
if(this->m_sink == true)
{
if(this->m_lifetime < 1.5f)
{
FLOAT3 pos = this->m_model->getPosition();
pos.y = pos.y - dt;
this->m_model->setPosition(pos);
}
}
else
{
this->m_model->move(D3DXVECTOR3(0.0f, dt / 5.0f, 0.0f));
if(this->m_lifetime <= 5.0f)
{
this->m_model->setAlpha(max(this->m_model->getAlpha() - dt / 4.0f, 0.0f));
}
else if(this->m_lanternLight != NULL)
{
this->m_lanternLight->setPosition(this->m_model->getLeftHandPosition(), FLOAT3(0.0f, 1.0f, 0.0f));
this->m_lanternLight->setDiffuseColor(this->m_lanternLight->getDiffuseColor() - (this->m_originalDiffuse / 5.0f) * dt);
this->m_lanternLight->setSpecularColor(this->m_lanternLight->getSpecularColor() - (this->m_originalSpecular / 5.0f) * dt);
}
}
}
}
Hero::Hero() : UnitEntity()
{
this->m_type = Type::HeroType;
this->m_obb = new BoundingOrientedBox(XMFLOAT3(this->m_position.x, this->m_position.y, this->m_position.z), XMFLOAT3(0.5f, 0.5f, 0.5f), XMFLOAT4(0.0f, 0.0f, 0.0f, 1.0f));
this->m_nextPosition = this->m_position;
this->m_reachedPosition = true;
this->m_attackCooldown = 0.0f;
this->m_attackRange = 5.0f;
this->m_hasTarget = false;
this->m_baseMovementSpeed = 3.1f;
this->m_movementSpeed = this->m_baseMovementSpeed;
this->m_baseAttackSpeed = 1.0f;
this->m_attackSpeed = this->m_baseAttackSpeed;
this->increaseStrength(5);
this->increaseAgility(2);
this->increaseWits(1);
this->increaseFortitude(4);
this->m_startPos=FLOAT3(0.0,0.0,0.0);
this->m_weaponType = WEAPON_TYPE::NO_WEAPON;
this->m_alive = true;
}
//int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR pScmdline, int iCmdshow)
int main(int _argc, char** _argv)
{
EEDesc desc;
desc.applicationName = L"Emerald"; //窗口名称
desc.isFullScreen = false; //是否全屏
desc.width = 800; //窗口宽度
desc.height = 450; //窗口高度
desc.isSSAA = true; //是开启抗锯齿
desc.isVsync = false; //是否垂直同步
EEInitialize(desc);
EEAnimationEmitter *emitter = new EEAnimationEmitter();
std::vector<EEAnimationFrame*> target = emitter->GetAnimation()->GetFrames();
EETexture button1Tex(L"Texture/Project Diva Freedom\\主界面\\默认主题/自由模式.png");
EEButton addItem(EE_BUTTON_SCALE, Rect_Float((float)EEGetWidth() * 0.03f, (float)EEGetHeight() * 0.8489f, (float)EEGetWidth() * 0.1075f, (float)EEGetHeight() * 0.9856f), 1.3f, 0.2f, 0.2f, button1Tex);
EEComboBox *combo = new EEComboBox(Rect_Float(100.f, 300.f, 200.f, 320.f), EEColor::WHITE, EEColor::BLACK);
while (EERun())
{
EEBeginScene(EEColor::BLACK);
addItem.Process();
combo->Process();
if (EEIsMouseInput())
{
EEGetMouse();
emitter->Emit(FLOAT3(EEGetMousePosition(), 0.0f));
}
emitter->Process();
EEEndScene();
}
SAFE_DELETE(emitter);
EEShutdown();
return 0;
}
HypnoticStareEffect::HypnoticStareEffect(unsigned int _affectedUnit, unsigned int _casterId, int _wits)
{
m_affectedUnit = _affectedUnit;
this->m_obb = NULL;
this->m_bs = new BoundingSphere();
m_visible = false;
m_type = OtherType;
m_timer = _wits*2;
m_mentalDamage = _wits;
m_movementSpeed = EnigmaticPresenceEffect::MOVEMENT_SPEED_FACTOR*_wits;
ServerEntity* affectedUnit = EntityHandler::getServerEntity(m_affectedUnit);
if(affectedUnit)
{
((UnitEntity*)affectedUnit)->alterMentalDamage(m_mentalDamage);
((UnitEntity*)affectedUnit)->alterMovementSpeed(m_movementSpeed);
((Enemy*)affectedUnit)->setTargetType(UnitEntity::EnemyType);
this->m_messageQueue->pushOutgoingMessage(new CreateActionTargetMessage(
Skill::HYPNOTIC_STARE, _casterId, affectedUnit->getId(), FLOAT3(m_timer, 0, 0))); // Set position.x to the duration so we use it as that instead mohahhaha >:D
}
else
this->m_messageQueue->pushOutgoingMessage(new RemoveServerEntityMessage(0, EntityHandler::getId(), this->m_id));
}
//----------------------------------------------------------------------------------------------------
bool EEPoints2D::Update()
{
if (!EEObject::Update())
return false;
UpdateObjectState();
if (m_isPositionDirty)
{
m_isPositionDirty = false;
}
if (m_isScaleDirty || m_isLocalZOrderDirty || m_isPointsDirty)
{
std::vector<EEPoints2DVertex> vertices(m_points.size());
for (unsigned int i = 0; i < m_points.size(); ++i)
{
vertices[i].pos = FLOAT3(m_points[i], m_localZOrder * 0.0001f);
}
if (m_isPointsDirty)
CreatePointsVertexBuffer();
ID3D11DeviceContext *deviceContext = EECore::s_EECore->GetDeviceContext();
D3D11_MAPPED_SUBRESOURCE mappedResource;
ZeroMemory(&mappedResource, sizeof(D3D11_MAPPED_SUBRESOURCE));
deviceContext->Map(m_pointsVB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
memcpy(mappedResource.pData, &vertices[0], vertices.size() * sizeof(EEPoints2DVertex));
deviceContext->Unmap(m_pointsVB, 0);
m_isScaleDirty = false;
m_isLocalZOrderDirty = false;
m_isPointsDirty = false;
}
return true;
}
//----------------------------------------------------------------------------------------------------
bool EECylinder::CreateCylinderBuffer()
{
float radiusDelta = (m_bottomRadius - m_topRadius) / m_stack;
float heightDelta = m_height / m_stack;
int perRow = m_slice + 1;
int rows = m_stack + 1;
float topY = m_height * 0.5f;
m_vertexCount = perRow * rows + 2 * (m_slice + 2);
std::vector<EECylinderVertex> vertices(m_vertexCount);
int index = 0;
for (int i = 0; i < rows; ++i)
{
float tmpY = topY - heightDelta * i;
float tmpRadius = m_topRadius + i * radiusDelta;
for (int j = 0; j < perRow; ++j)
{
float theta = EE_2PI * j / m_slice;
index = i * perRow + j;
vertices[index].pos = FLOAT3(tmpRadius*cos(theta), tmpY, tmpRadius*sin(theta));
vertices[index].normal = FLOAT3(cos(theta), (m_bottomRadius - m_topRadius) / m_height, sin(theta)).GetNormalization();
vertices[index].tex = FLOAT2(1.f*j / m_slice, 1.f*i / m_stack);
}
}
// top
++index;
for (int i = 0; i < m_slice + 1; ++i)
{
float theta = EE_2PI * i / m_slice;
float x = m_topRadius * cosf(theta);
float y = m_height * 0.5f;
float z = m_topRadius * sinf(theta);
float u = x / m_height + 0.5f;
float v = z / m_height + 0.5f;
vertices[index].pos = FLOAT3(x, y, z);
vertices[index].normal = FLOAT3(0.f, 1.f, 0.f);
vertices[index++].tex = FLOAT2(u, v);
}
vertices[index].pos = FLOAT3(0.f, m_height * 0.5f, 0.f);
vertices[index].normal = FLOAT3(0.f, 1.f, 0.f);
vertices[index++].tex = FLOAT2(0.5f, 0.5f);
// bottom
for (int i = 0; i < m_slice + 1; ++i)
{
float theta = EE_2PI * i / m_slice;
float x = m_bottomRadius * cosf(theta);
float y = -m_height * 0.5f;
float z = m_bottomRadius * sinf(theta);
float u = x / m_height + 0.5f;
float v = z / m_height + 0.5f;
vertices[index].pos = FLOAT3(x, y, z);
vertices[index].normal = FLOAT3(0.f, -1.f, 0.f);
vertices[index++].tex = FLOAT2(u, v);
}
vertices[index].pos = FLOAT3(0.f, -m_height * 0.5f, 0.f);
vertices[index].normal = FLOAT3(0.f, -1.f, 0.f);
vertices[index++].tex = FLOAT2(0.5f, 0.5f);
SAFE_RELEASE(m_objectVB);
D3D11_BUFFER_DESC vbDesc = { 0 };
vbDesc.ByteWidth = sizeof(EECylinderVertex)* vertices.size();
vbDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
vbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
vbDesc.MiscFlags = 0;
vbDesc.StructureByteStride = 0;
vbDesc.Usage = D3D11_USAGE_DYNAMIC;
D3D11_SUBRESOURCE_DATA vbData;
vbData.pSysMem = &vertices[0];
vbData.SysMemPitch = 0;
vbData.SysMemSlicePitch = 0;
if (FAILED(EECore::s_EECore->GetDevice()->CreateBuffer(&vbDesc, &vbData, &m_objectVB)))
{
MessageBoxW(NULL, L"CreateVertexBuffer failed!", L"Error", MB_OK);
return false;
}
m_indexCount = m_slice * m_stack * 6 + m_slice * 6;
std::vector<unsigned int> indices(m_indexCount);
index = 0;
for (int i = 0; i < m_stack; ++i)
{
for (int j = 0; j < m_slice; ++j)
{
indices[index] = i * perRow + j;
indices[index + 1] = (i + 1) * perRow + j + 1;
indices[index + 2] = (i + 1) * perRow + j;
indices[index + 3] = i * perRow + j;
indices[index + 4] = i * perRow + j + 1;
indices[index + 5] = (i + 1) * perRow + j + 1;
index += 6;
}
}
// top
int start = perRow * rows;
int center = perRow * rows + m_slice + 1;
for (int i = 0; i < m_slice; ++i)
{
indices[index++] = center;
indices[index++] = start + i + 1;
indices[index++] = start + i;
}
// bottom
start = perRow * rows + m_slice + 2;
center = perRow * rows + 2 * (m_slice + 2) - 1;
for (int i = 0; i < m_slice; ++i)
{
indices[index++] = center;
indices[index++] = start + i;
indices[index++] = start + i + 1;
}
SAFE_RELEASE(m_objectIB);
D3D11_BUFFER_DESC ibDesc = { 0 };
ibDesc.ByteWidth = sizeof(UINT)* indices.size();
ibDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
ibDesc.CPUAccessFlags = 0;
ibDesc.MiscFlags = 0;
ibDesc.StructureByteStride = 0;
ibDesc.Usage = D3D11_USAGE_IMMUTABLE;
D3D11_SUBRESOURCE_DATA ibData;
ibData.pSysMem = &indices[0];
ibData.SysMemPitch = 0;
ibData.SysMemSlicePitch = 0;
if (FAILED(EECore::s_EECore->GetDevice()->CreateBuffer(&ibDesc, &ibData, &m_objectIB)))
{
MessageBoxW(NULL, L"CreateIndexBuffer failed!", L"Error", MB_OK);
return false;
}
return true;
}
void ArrowClientSkillEffect::update(float _dt)
{
Entity* target = ClientEntityHandler::getEntity(m_targetId);
if(target && target->m_health > 0)
{
D3DXVECTOR3 newPos = D3DXVECTOR3(m_graphicalEffect->getPosition().x, m_graphicalEffect->getPosition().y, m_graphicalEffect->getPosition().z);
this->m_particleSystem->setPosition(newPos);
FLOAT3 dist = target->m_model->getPosition()-m_graphicalEffect->getPosition();
FLOAT3 movement = dist/dist.length()*RangedAttack::VELOCITY*_dt;
if(dist.length() > movement.length())
{
m_graphicalEffect->move(movement);
m_graphicalEffect->setRotation(FLOAT3(atan2(-movement.x, -movement.z), 0.0f, 0.0f));
}
else
{
m_active = false;
if(target->m_type == UnitEntity::EnemyType)
{
int sound;
switch(random(0, 2))
{
case 0:
sound = createSoundHandle("enemy/Monster_Imp_Damage_0.wav", false, false);
break;
case 1:
sound = createSoundHandle("enemy/Monster_Imp_Damage_1.wav", false, false);
break;
case 2:
sound = createSoundHandle("enemy/Monster_Imp_Damage_2.wav", false, false);
break;
}
SpeechManager::speak(m_targetId, sound); // The unit must be killed on the client before on the server for this sound solution to actually work.
deactivateSound(sound);
}
else if(target->m_type == UnitEntity::HeroType)
{
int sound;
switch(target->m_subtype)
{
case Hero::RED_KNIGHT:
switch(random(0, 2))
{
case 0:
sound = createSoundHandle("red_knight/RedKnight_Damage_0.wav", false, false);
break;
case 1:
sound = createSoundHandle("red_knight/RedKnight_Damage_1.wav", false, false);
break;
case 2:
sound = createSoundHandle("red_knight/RedKnight_Damage_2.wav", false, false);
break;
}
break;
case Hero::ENGINEER:
switch(random(0, 2))
{
case 0:
sound = createSoundHandle("engineer/Engineer_Damage_0.wav", false, false);
break;
case 1:
sound = createSoundHandle("engineer/Engineer_Damage_1.wav", false, false);
break;
case 2:
sound = createSoundHandle("engineer/Engineer_Damage_2.wav", false, false);
break;
}
break;
case Hero::THE_MENTALIST:
switch(random(0, 2))
{
case 0:
sound = createSoundHandle("mentalist/Mentalist_Damage_0.wav", false, false);
break;
case 1:
sound = createSoundHandle("mentalist/Mentalist_Damage_1.wav", false, false);
break;
case 2:
sound = createSoundHandle("mentalist/Mentalist_Damage_2.wav", false, false);
break;
}
break;
case Hero::OFFICER:
switch(random(0, 2))
{
case 0:
sound = createSoundHandle("officer/Officer_Damage_0.wav", false, false);
break;
case 1:
sound = createSoundHandle("officer/Officer_Damage_1.wav", false, false);
break;
case 2:
sound = createSoundHandle("officer/Officer_Damage_2.wav", false, false);
break;
}
break;
case Hero::DOCTOR:
switch(random(0, 2))
{
case 0:
sound = createSoundHandle("doctor/Doctor_Damage_0.wav", false, false);
break;
case 1:
sound = createSoundHandle("doctor/Doctor_Damage_1.wav", false, false);
break;
case 2:
sound = createSoundHandle("doctor/Doctor_Damage_2.wav", false, false);
break;
}
break;
}
SpeechManager::speak(m_targetId, sound); // The unit must be killed on the client before on the server for this sound solution to actually work.
deactivateSound(sound);
}
}
}
else
{
m_active = false;
}
}
void ClientHandler::update(float _dt)
{
this->m_state->update(_dt);
if(this->m_state->isDone())
{
State* tempState = this->m_state;
switch(this->m_state->nextState())
{
case State::INTRO:
this->m_state = new IntroState();
break;
case State::MAIN_MENU:
if(tempState->getType() == State::END || tempState->getType() == State::LORE)
{
m_menuMusic = createSoundHandle("music/menu.wav", true, false);
loopSound(m_menuMusic);
}
else if(tempState->getType() == State::LOBBY)
{
ClientEntityHandler::removeAllEntities();
this->m_client->disconnect();
delete this->m_serverThread;
this->m_serverThread = NULL;
}
this->m_state = new MainMenuState();
break;
case State::CREATE_GAME:
this->m_state = new CreateGameState();
break;
case State::JOIN_GAME:
this->m_state = new JoinGameState(this->m_client);
break;
case State::LOBBY:
if(tempState->getType() == State::CREATE_GAME)
{
CreateGameState *tempCreateState = (CreateGameState*)tempState;
this->m_serverThread = new ServerThread(tempCreateState->getPort(), tempCreateState->getMapName());
this->m_serverThread->Launch();
this->m_client->connect(tempCreateState->getIP(), tempCreateState->getPort());
//sends le player name, code 1337, hardcoded
sf::Packet playerName;
playerName << (int)NetworkMessage::setPlayerName << tempCreateState->getPlayerName();
this->m_client->sendPacket(playerName);
}
else
{
JoinGameState *tempJoinState = (JoinGameState*)tempState;
//sends le player name, code 1337, hardcoreporn
sf::Packet playerName;
playerName << (int)NetworkMessage::setPlayerName << tempJoinState->getPlayerName();
this->m_client->sendPacket(playerName);
}
this->m_state = new LobbyState(this->m_client);
break;
case State::LORE:
stopSound(m_menuMusic);
deactivateSound(m_menuMusic);
this->m_state = new LoreState();
break;
case State::GAME:
if(tempState->getType() == State::LOADING)
{
LoadingState *tempLoadingState = (LoadingState*)tempState;
this->m_state = new GameState(this->m_client, tempLoadingState->getMapName());
}
else
{
this->m_state = new GameState(this->m_client, "levelone");
}
break;
case State::SETTINGS:
this->m_state = new SettingsState();
break;
case State::CREDITS:
this->m_state = new CreditState();
break;
case State::END:
ClientEntityHandler::removeAllEntities();
this->m_client->disconnect();
delete this->m_serverThread;
this->m_serverThread = NULL;
this->m_state = new EndState(((GameState*)tempState)->getEndGameMessage(),((GameState*)tempState)->getMissionEndMessage());
break;
case State::LOADING:
stopSound(m_menuMusic);
deactivateSound(m_menuMusic);
{
LobbyState *tempLobbyState = (LobbyState*)tempState;
string temp = tempLobbyState->getMapName();
delete tempState;
tempState = NULL;
this->m_state = new LoadingState(m_client, temp);
}
break;
case State::EXIT:
this->m_state = NULL;
PostQuitMessage(WM_QUIT);
break;
}
delete tempState;
}
D3DXVECTOR3 camPos = g_graphicsEngine->getCamera()->getPos();
updateSoundEngine(FLOAT3(camPos.x, camPos.y, camPos.z));
g_mouse->update(); // Must be last! WHY?! - Because otherwise the mouse buttons will NEVER be "pressed"
g_keyboard->update();
}
//-----------------------------------------------------------------------
bool FontClass::Print(FLOAT _posX, FLOAT _posY, const FLOAT4& _color, const char* _info)
{
float fontPosX = (_posX / (float)m_width) * 2.0f - 1.0f;
float fontPosY = 1.0f - (_posY / (float)m_height) * 2.0f;
float deltaX = 2.0f / (float)m_width;
float deltaY = -32.0f / (float)m_height;
float fontWidth = 0.0f;
float fontHeight = fontPosY + deltaY;
int length = (int)strlen(_info);
std::vector<FontVertex> vertices(6 * length);
int index(0), letter(0);
for (int i = 0; _info[i] != '\0'; ++i)
{
letter = ((int)_info[i]) - 32;
if (letter == 0)
{
fontPosX = fontPosX + 3 * deltaX;
}
else
{
fontWidth = fontPosX + m_fontData[letter].size * deltaX;
vertices[index].pos = FLOAT3(fontPosX, fontPosY, 0.0f);
vertices[index].tex = FLOAT2(m_fontData[letter].left, 0.0f);
index++;
vertices[index].pos = FLOAT3(fontWidth, fontHeight, 0.0f);
vertices[index].tex = FLOAT2(m_fontData[letter].right, 1.0f);
index++;
vertices[index].pos = FLOAT3(fontPosX, fontHeight, 0.0f);
vertices[index].tex = FLOAT2(m_fontData[letter].left, 1.0f);
index++;
vertices[index].pos = FLOAT3(fontPosX, fontPosY, 0.0f);
vertices[index].tex = FLOAT2(m_fontData[letter].left, 0.0f);
index++;
vertices[index].pos = FLOAT3(fontWidth, fontPosY, 0.0f);
vertices[index].tex = FLOAT2(m_fontData[letter].right, 0.0f);
index++;
vertices[index].pos = FLOAT3(fontWidth, fontHeight, 0.0f);
vertices[index].tex = FLOAT2(m_fontData[letter].right, 1.0f);
index++;
fontPosX = fontPosX + m_fontData[letter].size * deltaX + deltaX;
}
}
ID3D11Buffer *fontVB;
D3D11_BUFFER_DESC vbDesc = { 0 };
vbDesc.ByteWidth = sizeof(FontVertex) * vertices.size();
vbDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
vbDesc.CPUAccessFlags = 0;
vbDesc.MiscFlags = 0;
vbDesc.StructureByteStride = 0;
vbDesc.Usage = D3D11_USAGE_IMMUTABLE;
D3D11_SUBRESOURCE_DATA vbData;
vbData.pSysMem = &vertices[0];
vbData.SysMemPitch = 0;
vbData.SysMemSlicePitch = 0;
if (FAILED(m_device->CreateBuffer(&vbDesc, &vbData, &fontVB)))
{
MessageBox(NULL, L"CreateVertexBuffer failed!", L"Error", MB_OK);
return false;
}
SetFontParameters(_color);
m_deviceContext->PSSetShaderResources(0, 1, &m_fontTex);
m_deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
m_deviceContext->IASetInputLayout(m_fontIL);
UINT stride = sizeof(FontVertex);
UINT offset = 0;
m_deviceContext->IASetVertexBuffers(0, 1, &fontVB, &stride, &offset);
m_deviceContext->IASetIndexBuffer(NULL, DXGI_FORMAT_R32_UINT, 0);
m_deviceContext->VSSetShader(m_fontVS, NULL, 0);
m_deviceContext->PSSetShader(m_fontPS, NULL, 0);
m_deviceContext->Draw(vertices.size(), 0);
SAFE_RELEASE(fontVB);
return true;
}
void Hero::setNextPosition(FLOAT3 _nextPosition)
{
if(this->m_alive == true)
{
if(g_pathfinder->sameGridPosition(FLOAT2(this->m_position.x, this->m_position.z), FLOAT2(_nextPosition.x, _nextPosition.z)) == false)
{
this->m_path = g_pathfinder->getPath(FLOAT2(this->m_position.x, this->m_position.z), FLOAT2(_nextPosition.x, _nextPosition.z));
if(this->m_path.nrOfPoints > 1)
{
this->m_nextPosition = FLOAT3(this->m_path.points[1].x, 0.0f, this->m_path.points[1].y);
//this->m_startPos= FLOAT3(this->m_path.points[0].x, 0.0f, this->m_path.points[0].y);
this->m_goalPosition = _nextPosition;
this->m_pathCounter = 2;
this->m_reachedPosition = false;
this->m_hasTarget = false;
this->m_target = NULL;
this->m_reallyReachedPosition = false;
this->m_messageQueue->pushOutgoingMessage(this->getUpdateEntityMessage());
this->m_messageQueue->pushOutgoingMessage(new CreateActionMessage(Skill::MOVE, this->m_id, this->m_position));
}
else if(this->m_path.nrOfPoints == 1)
{
//this->m_startPos= this->m_nextPosition;
this->m_nextPosition = _nextPosition;
this->m_goalPosition = _nextPosition;
this->m_pathCounter = 1;
this->m_reachedPosition = false;
this->m_hasTarget = false;
this->m_target = NULL;
this->m_reallyReachedPosition = false;
this->m_messageQueue->pushOutgoingMessage(this->getUpdateEntityMessage());
this->m_messageQueue->pushOutgoingMessage(new CreateActionMessage(Skill::MOVE, this->m_id, this->m_position));
}
else
{
this->m_path = Path();
this->m_pathCounter = 0;
this->m_reachedPosition = true;
this->m_hasTarget = false;
this->m_target = NULL;
this->m_reallyReachedPosition = true;
this->m_messageQueue->pushOutgoingMessage(new CreateActionMessage(Skill::IDLE, this->m_id, this->m_position));
//this->m_startPos= m_nextPosition;
this->m_messageQueue->pushOutgoingMessage(this->getUpdateEntityMessage());
}
}
else
{
this->m_path = Path();
this->m_pathCounter = 0;
this->m_reachedPosition = true;
this->m_nextPosition = m_position;
this->m_hasTarget = false;
this->m_target = NULL;
this->m_reallyReachedPosition = true;
this->m_messageQueue->pushOutgoingMessage(new CreateActionMessage(Skill::IDLE, this->m_id, this->m_position));
//this->m_startPos= m_nextPosition;
this->m_messageQueue->pushOutgoingMessage(this->getUpdateEntityMessage());
}
}
}
void Hero::updateSpecificUnitEntity(float dt)
{
if(this->m_health > 0)
{
//Handle incoming messages
Message *m;
while(this->m_messageQueue->incomingQueueEmpty() == false)
{
m = this->m_messageQueue->pullIncomingMessage();
if(m->type == Message::Collision)
{
//this->m_position = FLOAT3(0.0f, 0.0f, 0.0f);
}
delete m;
}
if(this->m_attackCooldown > 0.0f)
{
this->m_attackCooldown = this->m_attackCooldown - dt;
}
if(this->m_hasTarget == true)
{
ServerEntity *se = EntityHandler::getServerEntity(this->m_target);
if(se == NULL)
{
this->m_hasTarget = false;
this->m_messageQueue->pushOutgoingMessage(new CreateActionMessage(Skill::IDLE, this->m_id, this->m_position));
}
else
{
FLOAT3 distance = se->getPosition() - this->m_position;
this->m_rotation.x = atan2(-distance.x, -distance.z);
//If the hero is in range, KILL IT!
if(se != NULL)
{
if((se->getPosition() - this->m_position).length() <= this->m_regularAttack->getRange())
{
if(this->m_attackCooldown <= 0.0f)
{
//this->m_messageQueue->pushOutgoingMessage(new CreateActionTargetMessage(Skill::ATTACK, this->m_id, se->getId(), this->m_position));
//EntityHandler::addEntity(new Arrow((m_position-se->getPosition()).length(), se->getId(), m_id));
//this->dealDamage(se, this->m_physicalDamage, this->m_mentalDamage); // dont
this->attack(this->m_target);
this->m_attackCooldown = this->m_attackSpeed;
this->m_nextPosition = this->m_position;
this->m_messageQueue->pushOutgoingMessage(this->getUpdateEntityMessage());
}
if(this->m_reachedPosition == false)
{
this->m_reachedPosition = true;
this->m_messageQueue->pushOutgoingMessage(new CreateActionMessage(Skill::IDLE, this->m_id, this->m_position));
}
}
else //Otherwise you should find a way to get to the enemy
{
if(this->m_reachedPosition == true)
{
this->m_path = g_pathfinder->getPath(FLOAT2(this->m_position.x, this->m_position.z), FLOAT2(se->getPosition().x, se->getPosition().z));
if(this->m_path.nrOfPoints > 0)
{
this->m_pathCounter = 1;
this->m_nextPosition = FLOAT3(this->m_path.points[0].x, 0.0f, this->m_path.points[0].y);
this->m_reachedPosition = false;
this->m_messageQueue->pushOutgoingMessage(new CreateActionMessage(Skill::MOVE, this->m_id, this->m_position));
this->m_messageQueue->pushOutgoingMessage(this->getUpdateEntityMessage());
}
}
else //Move along the path
{
distance = this->m_nextPosition - this->m_position;
if(distance.length() - 0.125f > this->m_movementSpeed * dt)
{
distance = distance / distance.length();
this->m_position = this->m_position + (distance * this->m_movementSpeed * dt);
this->m_rotation.x = atan2(-distance.x, -distance.z);
}
else
{
if(this->m_pathCounter < this->m_path.nrOfPoints)
{
this->m_nextPosition = FLOAT3(this->m_path.points[this->m_pathCounter].x, 0.0f, this->m_path.points[this->m_pathCounter].y);
this->m_pathCounter++;
this->m_messageQueue->pushOutgoingMessage(this->getUpdateEntityMessage());
}
else if(this->m_reachedPosition == false)
{
this->m_position = this->m_nextPosition;
this->m_reachedPosition = true;
this->m_messageQueue->pushOutgoingMessage(new CreateActionMessage(Skill::IDLE, this->m_id, this->m_position));
this->m_messageQueue->pushOutgoingMessage(this->getUpdateEntityMessage());
this->m_messageQueue->pushOutgoingMessage(new UpdateEntityMessage(this->getId(),this->getPosition().x,this->getPosition().z,this->getRotation().x,0.0f,0.0f,0.0f,0.0f,this->getMovementSpeed()));
}
this->m_obb->Center = XMFLOAT3(this->m_position.x, this->m_position.y, this->m_position.z);
}
}
}
}
else //The target doesn't exist
{
this->m_hasTarget = false;
this->m_reachedPosition = true;
this->m_messageQueue->pushOutgoingMessage(new CreateActionMessage(Skill::IDLE, this->m_id, this->m_position));
}
}
}
else if(this->m_reachedPosition == false)
{
FLOAT3 distance = this->m_nextPosition - this->m_position;
float lol = 0.0f;
if(this->m_reallyReachedPosition == false)
{
lol = 0.125f;
}
if(distance.length() - lol > this->m_movementSpeed * dt)
{
distance = distance / distance.length();
this->m_position = this->m_position + (distance * this->m_movementSpeed * dt);
}
else
{
if(this->m_pathCounter < this->m_path.nrOfPoints)
{
this->m_nextPosition = FLOAT3(this->m_path.points[this->m_pathCounter].x, 0.0f, this->m_path.points[this->m_pathCounter].y);
this->m_pathCounter++;
this->m_obb->Center = XMFLOAT3(this->m_position.x, this->m_position.y, this->m_position.z);
this->m_rotation.x = atan2(-distance.x, -distance.z);
this->m_messageQueue->pushOutgoingMessage(this->getUpdateEntityMessage());
}
else
{
this->m_nextPosition = this->m_position;
this->m_reachedPosition = true;
//this->m_startPos= m_nextPosition;
this->m_messageQueue->pushOutgoingMessage(this->getUpdateEntityMessage());
this->m_messageQueue->pushOutgoingMessage(new CreateActionMessage(Skill::IDLE, this->m_id, this->m_position));
}
}
this->m_obb->Center = XMFLOAT3(this->m_position.x, this->m_position.y, this->m_position.z);
this->m_rotation.x = atan2(-distance.x, -distance.z);
}
}
else if(this->m_alive == true)
{
this->m_messageQueue->pushOutgoingMessage(new CreateActionMessage(Skill::DEATH, this->m_id, this->m_position));
this->m_position = FLOAT3(-1000.0f, 0.0f, -1000.0f);
this->m_hasTarget = NULL;
this->m_reachedPosition = true;
this->m_messageQueue->pushOutgoingMessage(this->getUpdateEntityMessage());
this->m_messageQueue->pushOutgoingMessage(new HeroDiedMessage(this->m_id, this->m_playerId));
this->m_alive = false;
}
}
//----------------------------------------------------------------------------------------------------
void EERotateYXProcess(EEObject* _object, float _time, float _radiansYX, float _delay, bool _isInfinite, float _startTime)
{
try
{
float remainTime = _delay + _time;
float progress = _startTime;
float speed = _radiansYX / _time;
while (1)
{
EEThreadSleep(20);
std::lock_guard<std::mutex> mutex(_object->GetThreadMutex());
float currTime = (float)EECore::s_EECore->GetTotalTime();
float deltaTime = currTime - progress;
progress = currTime;
if (remainTime <= deltaTime + _time)
{
remainTime = _time;
break;
}
else
{
remainTime -= deltaTime;
}
}
while (1)
{
EEThreadSleep(20);
std::lock_guard<std::mutex> mutex(_object->GetThreadMutex());
float currTime = (float)EECore::s_EECore->GetTotalTime();
float deltaTime = currTime - progress;
progress = currTime;
if (remainTime <= deltaTime && !_isInfinite)
{
FLOAT3 finalCenter = _object->GetFinalCenter();
MATRIX centerToOrigin = MatrixTranslation(-finalCenter.x, -finalCenter.y, 0.0f);
MATRIX rotation = MatrixRotationAxisN(FLOAT3(0.0f, 0.0f, 1.0f), speed * remainTime);
MATRIX originToCenter = MatrixTranslation(finalCenter.x, finalCenter.y, 0.0f);
_object->SetRotation(_object->GetRotation() * centerToOrigin * rotation * originToCenter);
remainTime = 0.f;
return;
}
else
{
FLOAT3 finalCenter = _object->GetFinalCenter();
MATRIX centerToOrigin = MatrixTranslation(-finalCenter.x, -finalCenter.y, 0.0f);
MATRIX rotation = MatrixRotationAxisN(FLOAT3(0.0f, 0.0f, 1.0f), speed * deltaTime);
MATRIX originToCenter = MatrixTranslation(finalCenter.x, finalCenter.y, 0.0f);
_object->SetRotation(_object->GetRotation() * centerToOrigin * rotation * originToCenter);
remainTime -= deltaTime;
}
}
}
catch (boost::thread_interrupted&)
{
return;
}
}
//----------------------------------------------------------------------------------------------------
FLOAT3 Rand_FLOAT3()
{
return FLOAT3((float)(rand() / double(RAND_MAX)), (float)(rand() / double(RAND_MAX)), (float)(rand() / double(RAND_MAX)));
}
bool DIVANote::Update(double _deltaTime)
{
m_restTime -= _deltaTime;
// Normal
if (m_type == NOTETYPE_NORMAL)
{
// Hit time
if (abs(m_restTime) <= m_actionTime && m_state == DIVA_NOTE_DEFAULT)
{
if (EEGetKeyHit(DIVAConfig::GetKeyMap(m_key)))
{
m_state = DIVA_NOTE_COOL;
}
}
// Missed
else if (m_restTime + m_actionTime <= 0 && m_state == DIVA_NOTE_DEFAULT)
{
m_state = DIVA_NOTE_WORST;
}
float percent = (float)(m_totalTime - m_restTime) / m_totalTime;
m_note.SetPosition(FLOAT3(percent * (m_x - m_tailx) + m_tailx, percent * (m_y - m_taily) + m_taily, 0.f));
Process();
m_strip.Process();
m_note.Process();
}
// Strip
else
{
if (m_restTime < 0)
{
m_restDuration = m_totalDuration + m_restTime;
}
// Hit time
if (abs(m_restTime) <= m_actionTime && m_state == DIVA_NOTE_DEFAULT)
{
if (EEGetKeyHit(DIVAConfig::GetKeyMap(m_key)))
{
m_state = DIVA_NOTE_COOL;
}
}
// Missed
else if (m_restTime + m_actionTime <= 0 && m_state == DIVA_NOTE_DEFAULT)
{
m_state = DIVA_NOTE_WORST;
}
// Strip time
else if (m_restDuration > m_actionTime && m_state != DIVA_NOTE_DEFAULT)
{
m_state = DIVA_NOTE_STRIP_DEFAULT;
if (!EEIsKeyDown(DIVAConfig::GetKeyMap(m_key)))
m_state = DIVA_NOTE_STRIP_WORST;
}
// Release time
else if (abs(m_restDuration) <= m_actionTime && m_state != DIVA_NOTE_DEFAULT)
{
if (!EEIsKeyDown(DIVAConfig::GetKeyMap(m_key)))
m_state = DIVA_NOTE_STRIP_COOL;
}
// Missed
else if (m_restDuration + m_actionTime <= 0)
{
if (EEIsKeyDown(DIVAConfig::GetKeyMap(m_key)))
m_state = DIVA_NOTE_STRIP_WORST;
}
float percent = (float)(m_totalTime - m_restTime) / m_totalTime;
if (percent > 1.f)
percent = 1.f;
FLOAT2 vertical = (FLOAT2(m_x, m_y) - FLOAT2(m_tailx, m_taily)).GetVertical() * 30.f;
FLOAT2 center1 = (FLOAT2(m_x, m_y) - FLOAT2(m_tailx, m_taily)) / 3.f + FLOAT2(m_tailx, m_taily) - vertical;
FLOAT2 center2 = (FLOAT2(m_x, m_y) - FLOAT2(m_tailx, m_taily)) * 2 / 3.f + FLOAT2(m_tailx, m_taily) + vertical;
std::vector<FLOAT2> pointsData;
for (float t = percent - m_restDuration / m_totalTime; t < percent; t += 0.001f)
pointsData.push_back(EEBezier(FLOAT2(m_tailx, m_taily), center1, center2, FLOAT2(m_x, m_y), t));
if (pointsData.size())
{
m_stripNote.SetPositionXY(pointsData.front());
m_note.SetPositionXY(pointsData.back());
}
else
m_note.SetPositionXY(FLOAT2(m_x, m_y));
m_strip.SetCurve(pointsData);
Process();
m_strip.Process();
m_note.Process();
m_stripNote.Process();
}
return true;
}
DeathClientSkillEffect::DeathClientSkillEffect(unsigned int _masterId, FLOAT3 _position)
{
this->m_masterId = _masterId;
this->m_lifetime = LIFETIME;
this->m_sink = false;
this->m_model = NULL;
this->m_lanternLight = NULL;
Entity *e = ClientEntityHandler::getEntity(this->m_masterId);
//g_graphicsEngine->createPointLight(_position, FLOAT3(1.0f, 1.0f, 1.0f), FLOAT3(1.0f, 1.0f, 1.0f), FLOAT3(1.0f, 1.0f, 1.0f), 5.0f, true, false, FLOAT3(0.0f, 1.0f, 0.0f));
if(e != NULL)
{
this->m_model = g_graphicsEngine->createModel(e->m_model, false);
this->m_model->setPosition(_position);
this->m_model->setScale(e->m_model->getScale());
this->m_model->getAnimation()->Play("death", true);
this->m_model->setGlowIndex("glowIntensity1");
this->m_model->SetHat(e->m_model->getHat());
this->m_model->SetLeftHand(e->m_model->getLeftHand());
this->m_model->SetRightHand(e->m_model->getRightHand());
m_model->setColor(D3DXVECTOR4(0, 1, 1, 0.4f));
if(e->m_type == ServerEntity::EnemyType)
{
this->m_sink = true;
m_model->setColor(D3DXVECTOR4(1, 0, 0, 0.4f));
}
if(e->m_lanternLight != NULL)
{
this->m_lanternLight = g_graphicsEngine->createPointLight(this->m_model->getLeftHandPosition(), e->m_lanternLight->getAmbientColor(), e->m_lanternLight->getDiffuseColor(), e->m_lanternLight->getSpecularColor(), e->m_lanternLight->getRadius(), true, false, FLOAT3(0.0f, 1.0f, 0.0f));
this->m_originalDiffuse = this->m_lanternLight->getDiffuseColor();
this->m_originalSpecular = this->m_lanternLight->getSpecularColor();
}
// Play death sound.
int sound;
switch(e->m_type)
{
case ServerEntity::HeroType:
switch(e->m_subtype)
{
case Hero::RED_KNIGHT:
switch(random(0, 2))
{
case 0:
sound = createSoundHandle("red_knight/RedKnight_Death_0.wav", false, true, e->m_startPos);
break;
case 1:
sound = createSoundHandle("red_knight/RedKnight_Death_1.wav", false, true, e->m_startPos);
break;
case 2:
sound = createSoundHandle("red_knight/RedKnight_Death_2.wav", false, true, e->m_startPos);
break;
}
break;
case Hero::ENGINEER:
switch(random(0, 2))
{
case 0:
sound = createSoundHandle("engineer/Engineer_Death_0.wav", false, true, e->m_startPos);
break;
case 1:
sound = createSoundHandle("engineer/Engineer_Death_1.wav", false, true, e->m_startPos);
break;
case 2:
sound = createSoundHandle("engineer/Engineer_Death_2.wav", false, true, e->m_startPos);
break;
}
break;
case Hero::THE_MENTALIST:
switch(random(0, 2))
{
case 0:
sound = createSoundHandle("mentalist/Mentalist_Death_0.wav", false, true, e->m_startPos);
break;
case 1:
sound = createSoundHandle("mentalist/Mentalist_Death_1.wav", false, true, e->m_startPos);
break;
case 2:
sound = createSoundHandle("mentalist/Mentalist_Death_2.wav", false, true, e->m_startPos);
break;
}
break;
case Hero::OFFICER:
switch(random(0, 2))
{
case 0:
sound = createSoundHandle("officer/Officer_Death_0.wav", false, true, e->m_startPos);
break;
case 1:
sound = createSoundHandle("officer/Officer_Death_1.wav", false, true, e->m_startPos);
break;
case 2:
sound = createSoundHandle("officer/Officer_Death_2.wav", false, true, e->m_startPos);
break;
}
break;
case Hero::DOCTOR:
switch(random(0, 2))
{
case 0:
sound = createSoundHandle("doctor/Doctor_Death_0.wav", false, true, e->m_startPos);
break;
case 1:
sound = createSoundHandle("doctor/Doctor_Death_1.wav", false, true, e->m_startPos);
break;
case 2:
sound = createSoundHandle("doctor/Doctor_Death_2.wav", false, true, e->m_startPos);
break;
}
break;
}
break;
case ServerEntity::EnemyType:
switch(e->m_subtype)
{
case Enemy::IMP:
sound = createSoundHandle("enemy/Monster_Imp_Death_0.wav", false, true, e->m_startPos);
break;
case Enemy::SHADE:
sound = createSoundHandle("enemy/Monster_Shade_Death_0.wav", false, true, e->m_startPos);
break;
case Enemy::FROST_DEMON:
sound = createSoundHandle("enemy/Monster_Frost_Death_0.wav", false, true, e->m_startPos);
break;
case Enemy::SPITTING_DEMON:
sound = createSoundHandle("enemy/Monster_Spitting_Death_0.wav", false, true, e->m_startPos);
break;
case Enemy::HELLFIRE_STEED:
sound = createSoundHandle("enemy/Beast_Dying_0.wav", false, true, e->m_startPos);
break;
case Enemy::SOUL_EATER_STEED:
sound = createSoundHandle("enemy/Beast_Dying_0.wav", false, true, e->m_startPos);
break;
case Enemy::THUNDERSTEED:
sound = createSoundHandle("enemy/Beast_Dying_0.wav", false, true, e->m_startPos);
break;
case Enemy::BRUTE_STEED:
sound = createSoundHandle("enemy/Beast_Dying_0.wav", false, true, e->m_startPos);
break;
case Enemy::BOSS:
sound = createSoundHandle("enemy/Beast_Dying_0.wav", false, true, e->m_startPos);
break;
}
break;
}
SpeechManager::speakUltimate(_masterId, sound);
deactivateSound(sound);
}
}
