#include "Contents/Effects/Skills/StormKickEffect.h" #include "Contents/Effects/Core/EffectTypes.h" #include "Client/Mode/ModeMgr.h" #include "Contents/Actors/RenderObject.h" #include "Contents/Effects/Core/EffectMemoryMgr.h" #include "Contents/Effects/Particles/Particle.h" #include "Contents/World/World.h" #include "Utility/Math/AffineMatrix.h" #include #include #include namespace { // INLINED __forceinline int ClampedRandom(int range) { const int value = rand() % range; return value >= 0 ? value : 0; } } // OFFSET: 0x00B7B340 // FUNCTION: fn_19216 CStormKickEffect::CStormKickEffect() : CEffect(-1) { } // OFFSET: 0x00B7B4F0 // FUNCTION: fn_19218 void CStormKickEffect::CreateStorms(int layer) { for (int index = 0; index < 10; ++index) { CParticle* particle = CreateParticle(reinterpret_cast(this->position), 5); if (!particle) { continue; } particle->SetTexture("effect\\storm2.tga"); particle->effectId = this->id; particle->columnIndex = index; particle->rowIndex = 0; particle->groupIndex = 1; particle->speedParameter = 40.0f; particle->alpha = 0; *reinterpret_cast(&particle->angleBits) = static_cast(ClampedRandom(360)); particle->scale = 2.0f; particle->animationParameter = 50.0f; float* motion = reinterpret_cast(particle->animationParameters); motion[0] = 5.0f; motion[1] = static_cast(layer); switch (this->id) { case EF_STORMKICK: particle->SetColor(50, 50, 255); break; case EF_STORMKICK1: particle->SetColor(164, 136, 55); break; case EF_STORMKICK2: particle->SetColor(255, 255, 255); break; case EF_STORMKICK3: particle->SetColor(130, 130, 255); break; case EF_STORMKICK6: if (0.0f == motion[1]) { particle->SetColor(255, 255, 255); } else if (1.0f == motion[1]) { particle->SetColor(255, 55, 55); } break; case EF_STORMKICK7: particle->SetColor(155, 255, 155); break; case EF_STORMKICK8: particle->SetColor(255, 255, 50); break; } particle->InitParticleQuad(particle->vertices); this->storms.push_back(particle); this->UpdateStorm(particle); } } // OFFSET: 0x00B7B6C0 // FUNCTION: fn_19219 void CStormKickEffect::CreateClouds(int layer) { int ring = 0; for (int angle = 0; angle < 360; angle += 90) { for (int segment = 0; segment < 21; ++segment) { CParticle* particle = CreateParticle(reinterpret_cast(this->position), 5); if (!particle) { continue; } particle->SetTexture("effect\\cloud11.tga"); particle->effectId = this->id; particle->columnIndex = segment; particle->rowIndex = ring; particle->groupIndex = 1; particle->alpha = 0; particle->angleParameter = 30; *reinterpret_cast(&particle->angleBits) = static_cast(angle); particle->phaseParameter = ClampedRandom(21) + 80; particle->animationParameter = 1.0f; if (this->id != EF_STORMKICK8) { if (layer == 0) { particle->speedParameter = 48.0f - ring * 5.0f; particle->scale = 14.0f - ring * 2.0f; } else if (layer == 1) { particle->speedParameter = 28.0f - ring * 5.0f; particle->scale = 6.0f - ring; } } else if (layer == 0) { particle->speedParameter = 28.0f - ring * 5.0f; particle->scale = 10.0f - ring * 2.0f; } else if (layer == 1) { particle->speedParameter = 18.0f - ring * 5.0f; particle->scale = 5.0f - ring; } particle->InitParticleQuad(particle->vertices); this->clouds.push_back(particle); } ++ring; } } // OFFSET: 0x00B7B8D0 // FUNCTION: fn_19220 void CStormKickEffect::UpdateStorm(CParticle* particle) { if (!particle) { return; } const float* motion = reinterpret_cast(particle->animationParameters); const float depth = -particle->animationParameter; const int segment = particle->columnIndex; float radius = particle->speedParameter; const float height = segment * motion[0] + depth; int angle = static_cast(static_cast(segment * 45) + *reinterpret_cast(&particle->angleBits)); angle = angle % 360; for (int step = 1; step <= segment; ++step) { radius -= (2.2f - step * 0.2f) * particle->scale; } EffectPoint corners[4]; angle += 90; angle = angle % 360; float corner0X = radius * g_cosTable[angle]; float corner0Y = height - 1.0f; float corner0Z = radius * g_sinTable[angle]; angle += 90; angle = angle % 360; float corner1X = radius * g_cosTable[angle]; float corner1Y = height - 1.0f; float corner1Z = radius * g_sinTable[angle]; angle += 90; angle = angle % 360; float corner2X = radius * g_cosTable[angle]; float corner2Y = height - 1.0f; float corner2Z = radius * g_sinTable[angle]; angle += 90; angle = angle % 360; float corner3X = radius * g_cosTable[angle]; float corner3Y = height - 1.0f; float corner3Z = radius * g_sinTable[angle]; particle->vertices[0].x = corner2X; particle->vertices[0].y = corner2Y; particle->vertices[0].z = corner2Z; particle->vertices[1].x = corner1X; particle->vertices[1].y = corner1Y; particle->vertices[1].z = corner1Z; particle->vertices[2].x = corner3X; particle->vertices[2].y = corner3Y; particle->vertices[2].z = corner3Z; particle->vertices[3].x = corner0X; particle->vertices[3].y = corner0Y; particle->vertices[3].z = corner0Z; } // OFFSET: 0x00B7BC20 // FUNCTION: fn_19221 void CStormKickEffect::Close() { for (auto it = this->storms.begin(); it != this->storms.end(); ++it) { FreeParticle(*it); } this->storms.clear(); for (auto it = this->clouds.begin(); it != this->clouds.end(); ++it) { FreeParticle(*it); } this->clouds.clear(); } // OFFSET: 0x00B7BC90 // FUNCTION: fn_19222 void CStormKickEffect::Open() { g_modeMgr.GetGameMode(); switch (this->id) { case EF_STORMKICK6: this->CreateStorms(0); this->CreateStorms(1); this->CreateClouds(0); this->CreateClouds(1); break; case EF_STORMKICK: case EF_STORMKICK1: case EF_STORMKICK2: case EF_STORMKICK3: case EF_STORMKICK7: this->CreateStorms(0); this->CreateClouds(0); this->CreateClouds(1); break; case EF_STORMKICK8: this->CreateClouds(0); this->CreateClouds(1); break; } switch (this->id) { case EF_STORMKICK: case EF_STORMKICK1: case EF_STORMKICK2: case EF_STORMKICK3: case EF_STORMKICK6: this->effectLifetime = 100; break; case EF_STORMKICK7: this->effectLifetime = 1000; break; case EF_STORMKICK8: this->effectLifetime = 60; break; } } // OFFSET: 0x00B7BDD0 // FUNCTION: fn_19223 void CStormKickEffect::InitEvents() { switch (this->id) { case EF_STORMKICK: this->AddEvent(0, "effect\\T_회오리차기.wav", 5, 0); break; case EF_STORMKICK2: this->AddEvent(0, "ice_titan_attack.wav", 5, 0); break; case EF_STORMKICK6: this->AddEvent(0, "effect\\REVERBERATION.wav", 0, 0); break; } } // OFFSET: 0x00B7BF60 // FUNCTION: fn_19224 bool CStormKickEffect::IsAlive() { return !this->IsFinished(); } // OFFSET: 0x00B7BF70 // FUNCTION: fn_19225 void CStormKickEffect::OnProcess() { for (auto it = this->storms.begin(); it != this->storms.end(); ++it) { CParticle* particle = *it; vector3d& particlePosition = (*it)->position; particlePosition.x = this->position[0]; particlePosition.y = this->position[1]; particlePosition.z = this->position[2]; if (particle) { int alpha = particle->alpha; if (particle->elapsedFrames > 60 && this->id != EF_STORMKICK7) { alpha = std::max(alpha - 1, 0); } if (particle->elapsedFrames <= 40) { ++alpha; } particle->alpha = alpha; float& rotation = *reinterpret_cast(&particle->angleBits); const int jitter = rand() % 3; const int turned = static_cast(rotation - static_cast((jitter >= 0 ? jitter : 0) + 3)); rotation = static_cast(turned % 360); matrix transform; std::memcpy(transform.values, g_identityMatrix, sizeof(transform.values)); transform.MakeYRotation(rotation / 180.0f * 3.141592f); particle->transform = transform; } ++particle->elapsedFrames; } for (auto it = this->clouds.begin(); it != this->clouds.end(); ++it) { CParticle* particle = *it; vector3d& particlePosition = (*it)->position; particlePosition.x = this->position[0]; particlePosition.y = this->position[1]; particlePosition.z = this->position[2]; if (particle) { float& rotation = *reinterpret_cast(&particle->angleBits); const float nextRotation = static_cast(static_cast(rotation + 5.0f) % 360); const int spread = std::min(particle->angleParameter + 3, 180); particle->angleParameter = spread; const int frame = particle->elapsedFrames; int alpha = particle->alpha; rotation = nextRotation; if (this->id == EF_STORMKICK8) { if (frame > 30) { alpha -= 3; alpha = alpha >= 0 ? alpha : 0; } else { alpha += 3; } } else if (frame > 50) { alpha = std::max(alpha - 1, 0); } else if (frame < 12) { ++alpha; } particle->alpha = alpha; if (frame > 12) { particle->scale += 0.1f; } const int segment = particle->columnIndex; const float radius = particle->animationParameter; const int angle = static_cast(static_cast(static_cast(static_cast(spread) / 20.0f) * segment) + nextRotation) % 360; const int tilt = particle->phaseParameter; const float horizontal = radius * g_cosTable[tilt]; const float vertical = radius * g_sinTable[tilt]; EffectPoint corners[4]; float innerX = g_cosTable[angle] * particle->scale; float innerY = -particle->speedParameter; float innerZ = g_sinTable[angle] * particle->scale; float outerX = innerX + g_cosTable[angle] * horizontal; float outerY = innerY - vertical; float outerZ = innerZ + g_sinTable[angle] * horizontal; particle->vertices[3].x = innerX; particle->vertices[3].y = innerY; particle->vertices[3].z = innerZ; particle->vertices[1].x = outerX; particle->vertices[1].y = outerY; particle->vertices[1].z = outerZ; if (segment != 0) { particle->vertices[0].x = this->lastPoints[1].x; particle->vertices[0].y = this->lastPoints[1].y; particle->vertices[0].z = this->lastPoints[1].z; particle->vertices[2].x = this->lastPoints[0].x; particle->vertices[2].y = this->lastPoints[0].y; particle->vertices[2].z = this->lastPoints[0].z; } this->lastPoints[0].x = innerX; this->lastPoints[0].y = innerY; this->lastPoints[0].z = innerZ; this->lastPoints[1].x = outerX; this->lastPoints[1].y = outerY; this->lastPoints[1].z = outerZ; } ++particle->elapsedFrames; } CRenderObject* actor = FindRenderObject(this->actor); if (!actor) { return; } float angle; switch (this->id) { case EF_STORMKICK: case EF_STORMKICK8: if (this->frame > 47) { return; } angle = actor->render.angle + 30.0f; break; case EF_STORMKICK1: if (this->frame > 50) { return; } angle = actor->render.angle + 14.0f; break; default: return; } actor->render.angle = angle; if (angle > 360.0f) { actor->render.angle = angle - 360.0f; } } // OFFSET: 0x00B7C7D0 // FUNCTION: fn_19226 void CStormKickEffect::Render() { for (auto it = this->storms.begin(); it != this->storms.end(); ++it) { CParticle* particle = *it; const int alpha = particle->alpha; const float* motion = reinterpret_cast(particle->animationParameters); switch (this->id) { case EF_STORMKICK1: case EF_STORMKICK2: case EF_STORMKICK3: case EF_STORMKICK7: particle->destinationBlend = 6; break; case EF_STORMKICK6: if (0.0f == motion[1]) { particle->destinationBlend = 6; particle->alpha = alpha / 3; particle->Render(false, 0.0f, 1.0f, 0.0f, 1.0f, false, true); particle->alpha = alpha; continue; } if (1.0f != motion[1]) { continue; } default: particle->destinationBlend = 2; break; } particle->Render(false, 0.0f, 1.0f, 0.0f, 1.0f, false, true); } for (auto it = this->clouds.begin(); it != this->clouds.end(); ++it) { CParticle* particle = *it; if (!particle) { continue; } const int texPart = particle->columnIndex; if (texPart <= 0) { continue; } const ParticleQuad quad = {false, 0.0f, 1.0f, static_cast(texPart - 1) / 21.0f, static_cast(texPart) / 21.0f, false, true}; particle->Render(quad); } }