Debian Codegraph @

Sources/Jazz2/Actors/Enemies/Bosses/Queen.cpp

raw
1 #include "Queen.h"
2 #include "../../../ILevelHandler.h"
3 #include "../../Player.h"
4 #include "../../Environment/Spring.h"
5
6 #include "../../../../nCine/Base/Random.h"
7
8 #include <float.h>
9
10 using namespace Jazz2::Tiles;
11
12 namespace Jazz2::Actors::Bosses
13 {
14 Queen::Queen()
15 : _state(StateWaiting), _stateTime(0.0f), _endText(0), _queuedBackstep(false)
16 {
17 }
18
19 Queen::~Queen()
20 {
21 if (_block != nullptr) {
22 _block->SetState(ActorState::IsDestroyed, true);
23 _block = nullptr;
24 }
25 }
26
27 void Queen::Preload(const ActorActivationDetails& details)
28 {
29 PreloadMetadataAsync("Boss/Queen"_s);
30 }
31
32 Task<bool> Queen::OnActivatedAsync(const ActorActivationDetails& details)
33 {
34 _endText = details.Params[1];
35 _pos.Y -= 8.0f;
36 _originPos = _pos;
37
38 _canHurtPlayer = false;
39 SetState(ActorState::IsInvulnerable | ActorState::IsSolidObject | ActorState::SkipPerPixelCollisions, true);
40 SetState(ActorState::CanBeFrozen, false);
41 _health = INT32_MAX;
42 _maxHealth = INT32_MAX;
43 _scoreValue = 0;
44
45 _lastHealth = _health;
46
47 _stepSize = 0.3f;
48 switch (_levelHandler->GetDifficulty()) {
49 case GameDifficulty::Easy: _stepSize *= 1.3f; break;
50 case GameDifficulty::Hard: _stepSize *= 0.7f; break;
51 }
52
53 async_await RequestMetadataAsync("Boss/Queen"_s);
54 SetAnimation(AnimState::Idle);
55
56 // Invisible block above the queen
57 _block = std::make_shared<InvisibleBlock>();
58 _block->OnActivated(ActorActivationDetails(
59 _levelHandler,
60 Vector3i((std::int32_t)_pos.X, (std::int32_t)_pos.Y, _renderer.layer() + 1)
61 ));
62 _levelHandler->AddActor(_block);
63
64 async_return true;
65 }
66
67 bool Queen::OnActivatedBoss()
68 {
69 MoveInstantly(_originPos, MoveType::Absolute | MoveType::Force);
70 _state = StateWaiting;
71 return true;
72 }
73
74 void Queen::OnUpdate(float timeMult)
75 {
76 TileCollisionParams params = { TileDestructType::Weapon | TileDestructType::Speed, _speed.Y >= 0.0f, WeaponType::Blaster, 1 };
77 TryStandardMovement(timeMult, params);
78 OnUpdateHitbox();
79 if (params.TilesDestroyed > 0) {
80 _levelHandler->ShakeCameraViewNear(_pos, 20.0f);
81 }
82
83 HandleBlinking(timeMult);
84
85 if (_block != nullptr) {
86 _block->MoveInstantly(Vector2f(_pos.X, _pos.Y - 32.0f), MoveType::Absolute | MoveType::Force);
87 }
88
89 switch (_state) {
90 case StateWaiting: {
91 // Waiting for player to enter the arena
92 _levelHandler->FindCollisionActorsByAABB(this, AABBf(_pos.X - 300, _pos.Y - 120, _pos.X + 60, _pos.Y + 120), [this](ActorBase* actor) {
93 if (auto* player = runtime_cast<Player>(actor)) {
94 _state = StateIdleToScream;
95 _stateTime = 260.0f;
96 return false;
97 }
98 return true;
99 });
100 break;
101 }
102
103 case StateIdleToScream: {
104 // Scream towards the player
105 if (_stateTime <= 0.0f) {
106 _lastHealth = _health;
107 SetState(ActorState::IsInvulnerable, false);
108
109 _state = StateScreaming;
110 PlaySfx("Scream"_s);
111 SetTransition((AnimState)1073741824, false, [this]() {
112 _state = (Random().NextFloat() < 0.8f ? StateIdleToStomp : StateIdleToBackstep);
113 _stateTime = Random().NextFloat(65.0f, 85.0f);
114
115 SetState(ActorState::IsInvulnerable, true);
116
117 if (_lastHealth - _health >= 2) {
118 _queuedBackstep = true;
119 }
120 });
121 }
122 break;
123 }
124
125 case StateIdleToStomp: {
126 if (_stateTime <= 0.0f) {
127 _state = StateTransition;
128 SetTransition((AnimState)1073741825, false, [this]() {
129 PlaySfx("Stomp"_s);
130
131 SetTransition((AnimState)1073741830, false, [this]() {
132 _state = StateIdleToBackstep;
133 _stateTime = Random().NextFloat(70.0f, 80.0f);
134
135 auto players = _levelHandler->GetPlayers();
136 if (players.empty()) {
137 return;
138 }
139
140 Player* player;
141 for (std::int32_t i = 0; i < 5; i++) {
142 player = players[Random().Next(0, (std::uint32_t)players.size())];
143 if (player->GetHealth() > 0) {
144 break;
145 }
146 }
147
148 std::shared_ptr<Brick> brick = std::make_shared<Brick>();
149 brick->OnActivated(ActorActivationDetails(
150 _levelHandler,
151 Vector3i((std::int32_t)(player->GetPos().X + Random().NextFloat(-50.0f, 50.0f)), (std::int32_t)(_pos.Y - 200.0f), _renderer.layer() - 20)
152 ));
153 _levelHandler->AddActor(std::move(brick));
154
155 _levelHandler->ShakeCameraViewNear(_pos, 20.0f);
156 });
157 });
158 }
159 break;
160 }
161
162 case StateIdleToBackstep: {
163 if (_stateTime <= 0.0f) {
164 if (_queuedBackstep) {
165 _queuedBackstep = false;
166
167 // 2 hits by player while screaming, step backwards
168 _speed.X = _stepSize;
169
170 _state = StateTransition;
171 SetTransition((AnimState)1073741826, false, [this]() {
172 _speed.X = 0.0f;
173
174 // Check it it's on the ledge
175 AABBf aabb1 = AABBf(_pos.X - 10, _pos.Y + 24, _pos.X - 6, _pos.Y + 28);
176 AABBf aabb2 = AABBf(_pos.X + 6, _pos.Y + 24, _pos.X + 10, _pos.Y + 28);
177 TileCollisionParams params = { TileDestructType::None, true };
178 if (!_levelHandler->IsPositionEmpty(this, aabb1, params) && _levelHandler->IsPositionEmpty(this, aabb2, params)) {
179 _lastHealth = _health;
180 SetState(ActorState::IsInvulnerable, false);
181
182 // It's on the ledge
183 _state = StateTransition;
184 SetTransition((AnimState)1073741827, false, [this]() {
185 SetState(ActorState::IsInvulnerable, true);
186
187 // 1 hits by player
188 if (_lastHealth - _health >= 1) {
189 // Fall off the ledge
190 _speed.X = 2.2f;
191
192 SetAnimation(AnimState::Fall);
193 } else {
194 // Recover, step forward
195 SetTransition((AnimState)1073741828, false, [this]() {
196 _speed.X = _stepSize * -1.3f;
197
198 SetTransition((AnimState)1073741826, false, [this]() {
199 _speed.X = 0.0f;
200
201 _state = StateIdleToScream;
202 _stateTime = Random().NextFloat(150.0f, 180.0f);
203 });
204 });
205 }
206 });
207 } else {
208 _state = StateIdleToScream;
209 _stateTime = Random().NextFloat(160.0f, 200.0f);
210 }
211 });
212 } else {
213 _state = StateIdleToScream;
214 _stateTime = Random().NextFloat(150.0f, 180.0f);
215 }
216 }
217 break;
218 }
219
220 case StateDead: {
221 // Thrown away by spring
222 if (_stateTime <= 0.0f) {
223 DecreaseHealth(INT32_MAX);
224 }
225 break;
226 }
227
228 case StateScreaming: {
229 auto players = _levelHandler->GetPlayers();
230 for (auto* player : players) {
231 if (player->GetHealth() <= 0) {
232 continue;
233 }
234
235 //player->AddExternalForce(-1.5f * timeMult, 0.0f);
236 player->MoveInstantly(Vector2f(-1.5f * timeMult, 0.0f), MoveType::Relative);
237 }
238 break;
239 }
240 }
241
242 _stateTime -= timeMult;
243 }
244
245 bool Queen::OnHandleCollision(std::shared_ptr<ActorBase> other)
246 {
247 if (auto* spring = runtime_cast<Environment::Spring>(other.get())) {
248 // Collide only with hitbox
249 if (AABBInner.Overlaps(spring->AABBInner)) {
250 Vector2f force = spring->Activate();
251 int sign = ((force.X + force.Y) > 0.0f ? 1 : -1);
252 if (std::abs(force.X) > 0.0f) {
253 _speed.X = (4 + std::abs(force.X)) * sign;
254 _externalForce.X = force.X;
255 } else if (std::abs(force.Y) > 0.0f) {
256 _speed.Y = (4.0f + std::abs(force.Y)) * sign;
257 _externalForce.Y = force.Y;
258 } else {
259 return BossBase::OnHandleCollision(std::move(other));
260 }
261 SetState(ActorState::CanJump, false);
262
263 SetAnimation(AnimState::Fall);
264 PlaySfx("Spring"_s);
265
266 if (_state != StateDead) {
267 StringView text = _levelHandler->GetLevelText(_endText);
268 _levelHandler->ShowLevelText(text);
269
270 _state = StateDead;
271 _stateTime = 50.0f;
272 }
273 }
274 }
275
276 return BossBase::OnHandleCollision(std::move(other));
277 }
278
279 Task<bool> Queen::Brick::OnActivatedAsync(const ActorActivationDetails& details)
280 {
281 _timeLeft = 50.0f;
282
283 SetState(ActorState::IsInvulnerable | ActorState::SkipPerPixelCollisions, true);
284 SetState(ActorState::CollideWithTileset, false);
285
286 async_await RequestMetadataAsync("Boss/Queen"_s);
287 SetAnimation((AnimState)1073741829);
288
289 PlaySfx("BrickFalling"_s, 0.3f);
290
291 async_return true;
292 }
293
294 void Queen::Brick::OnUpdate(float timeMult)
295 {
296 EnemyBase::OnUpdate(timeMult);
297
298 if (_timeLeft <= 0.0f) {
299 DecreaseHealth(INT32_MAX);
300 } else {
301 _timeLeft -= timeMult;
302 }
303 }
304
305 bool Queen::Brick::OnPerish(ActorBase* collider)
306 {
307 if (collider != nullptr) {
308 CreateParticleDebrisOnPerish(collider);
309 }
310
311 return EnemyBase::OnPerish(collider);
312 }
313
314 Task<bool> Queen::InvisibleBlock::OnActivatedAsync(const ActorActivationDetails& details)
315 {
316 SetState(ActorState::IsSolidObject | ActorState::SkipPerPixelCollisions, true);
317 SetState(ActorState::CollideWithTileset, false);
318
319 _health = INT32_MAX;
320
321 async_await RequestMetadataAsync("Boss/Queen"_s);
322 SetAnimation(AnimState::Idle);
323
324 _renderer.setDrawEnabled(false);
325
326 async_return true;
327 }
328
329 void Queen::InvisibleBlock::OnUpdate(float timeMult)
330 {
331 // Nothing to update
332 }
333 }