|
2497
|
1 #define _CRTDBG_MAP_ALLOC
|
|
|
2 #include <stdlib.h>
|
|
|
3 #include <crtdbg.h>
|
|
|
4
|
|
|
5 #define _CRT_SECURE_NO_WARNINGS
|
|
|
6
|
|
2541
|
7 #include "Engine/Engine.h"
|
|
|
8
|
|
2499
|
9 #include "../Graphics/PaletteManager.h"
|
|
|
10 #include "../Graphics/DecalBuilder.h"
|
|
|
11 #include "../Graphics/Sprites.h"
|
|
|
12 #include "../../stru6.h"
|
|
2497
|
13 #include "Actor.h"
|
|
2499
|
14 #include "../OurMath.h"
|
|
|
15 #include "../Graphics/Outdoor.h"
|
|
2502
|
16 #include "Media/Audio/AudioPlayer.h"
|
|
2497
|
17 #include "ObjectList.h"
|
|
2499
|
18 #include "../Graphics/Overlays.h"
|
|
|
19 #include "../Tables/FactionTable.h"
|
|
|
20 #include "../TurnEngine/TurnEngine.h"
|
|
|
21 #include "../Spells/CastSpellInfo.h"
|
|
|
22 #include "../Timer.h"
|
|
|
23 #include "../LOD.h"
|
|
|
24 #include "../Party.h"
|
|
2502
|
25 #include "GUI/GUIWindow.h"
|
|
2497
|
26 #include "SpriteObject.h"
|
|
2499
|
27 #include "../stru298.h"
|
|
|
28 #include "../Texts.h"
|
|
|
29 #include "../Graphics/Level/Decoration.h"
|
|
|
30 #include "../Graphics/Viewport.h"
|
|
|
31 #include "../Graphics/Vis.h"
|
|
2497
|
32
|
|
|
33
|
|
|
34
|
|
|
35
|
|
|
36
|
|
|
37 std::array<Actor, 500> pActors;
|
|
|
38 size_t uNumActors;
|
|
|
39
|
|
|
40 stru319 stru_50C198; // idb
|
|
|
41
|
|
|
42
|
|
|
43 std::array<uint, 5> _4DF380_hostilityRanges = {0, 1024, 2560, 5120, 10240};
|
|
|
44
|
|
|
45
|
|
|
46
|
|
|
47
|
|
|
48 //----- (0042FB5C) --------------------------------------------------------
|
|
|
49 // True if monster should play attack animation when casting this spell.
|
|
|
50 bool ShouldMonsterPlayAttackAnim(signed int spell_id)
|
|
|
51 {
|
|
|
52 switch (spell_id)
|
|
|
53 {
|
|
|
54 case SPELL_FIRE_HASTE:
|
|
|
55 case SPELL_AIR_SHIELD:
|
|
|
56 case SPELL_EARTH_STONESKIN:
|
|
|
57 case SPELL_SPIRIT_BLESS:
|
|
|
58 case SPELL_SPIRIT_FATE:
|
|
|
59 case SPELL_SPIRIT_HEROISM:
|
|
|
60 case SPELL_BODY_HAMMERHANDS:
|
|
|
61 case SPELL_BODY_POWER_CURE:
|
|
|
62 case SPELL_LIGHT_DISPEL_MAGIC:
|
|
|
63 case SPELL_LIGHT_DAY_OF_PROTECTION:
|
|
|
64 case SPELL_LIGHT_HOUR_OF_POWER:
|
|
|
65 case SPELL_DARK_PAIN_REFLECTION:
|
|
|
66 return false;
|
|
|
67 }
|
|
|
68
|
|
|
69 return true;
|
|
|
70 }
|
|
|
71
|
|
|
72
|
|
|
73 //----- (0041AF52) --------------------------------------------------------
|
|
|
74 void Actor::DrawHealthBar(Actor *actor, GUIWindow *window)
|
|
|
75 {
|
|
|
76 unsigned int bar_length; // esi@1
|
|
|
77 unsigned int uX; // ebx@10
|
|
|
78 unsigned int v9; // [sp+14h] [bp-Ch]@4
|
|
|
79 unsigned int v10; // [sp+1Ch] [bp-4h]@4
|
|
|
80
|
|
|
81 if (actor->pMonsterInfo.uHP <= 25)
|
|
|
82 bar_length = 25;
|
|
|
83 else if ( actor->pMonsterInfo.uHP < 200 )
|
|
|
84 bar_length = actor->pMonsterInfo.uHP;
|
|
|
85 else
|
|
|
86 bar_length = 200;
|
|
|
87
|
|
|
88 v10 = bar_length;
|
|
|
89 if ( actor->sCurrentHP <= (0.34 * actor->pMonsterInfo.uHP) )
|
|
|
90 v9 = uTextureID_mhp_red;
|
|
|
91 else if ( actor->sCurrentHP <= ( 0.67 * actor->pMonsterInfo.uHP) )
|
|
|
92 v9 = uTextureID_mhp_yel;
|
|
|
93 else
|
|
|
94 v9 = uTextureID_mhp_grn;
|
|
|
95
|
|
|
96 if ( actor->sCurrentHP < (int)actor->pMonsterInfo.uHP )
|
|
|
97 v10 = bar_length / actor->pMonsterInfo.uHP * actor->sCurrentHP;
|
|
|
98
|
|
|
99 uX = window->uFrameX + (signed int)(window->uFrameWidth - bar_length) / 2;
|
|
|
100
|
|
2524
|
101 pRenderer->SetUIClipRect(uX, window->uFrameY + 32, uX + bar_length, window->uFrameY + 52);
|
|
2497
|
102 pRenderer->DrawTextureIndexed(uX, window->uFrameY + 32, pIcons_LOD->GetTexture(uTextureID_mhp_bd));
|
|
2524
|
103 pRenderer->SetUIClipRect(uX, window->uFrameY + 32, uX + v10, window->uFrameY + 52);
|
|
2497
|
104 pRenderer->DrawTextureIndexed(uX, window->uFrameY + 34, pIcons_LOD->GetTexture(v9));
|
|
|
105
|
|
2524
|
106 pRenderer->ResetUIClipRect();
|
|
2497
|
107 pRenderer->DrawTextureIndexed(uX - 5, window->uFrameY + 32, pIcons_LOD->GetTexture(uTextureID_mhp_capl));
|
|
|
108 pRenderer->DrawTextureIndexed(uX + bar_length, window->uFrameY + 32, pIcons_LOD->GetTexture(uTextureID_mhp_capr));
|
|
|
109 }
|
|
|
110
|
|
|
111 //----- (00448A40) --------------------------------------------------------
|
|
|
112 void Actor::ToggleFlag(signed int uActorID, unsigned int uFlag, int bToggle)
|
|
|
113 {
|
|
|
114 if ( uActorID >= 0 && uActorID <= (signed int)(uNumActors - 1) )
|
|
|
115 {
|
|
|
116 if ( bToggle )
|
|
|
117 pActors[uActorID].uAttributes |= uFlag;
|
|
|
118 else
|
|
|
119 {
|
|
|
120 if ( uFlag == 0x10000 )
|
|
|
121 {
|
|
|
122 if (pActors[uActorID].uAIState == Disabled )
|
|
|
123 pActors[uActorID].uAIState = Standing;
|
|
|
124 }
|
|
|
125 pActors[uActorID].uAttributes &= ~uFlag;
|
|
|
126 }
|
|
|
127 }
|
|
|
128 }
|
|
|
129
|
|
|
130 //----- (00448518) --------------------------------------------------------
|
|
|
131 void __fastcall sub_448518_npc_set_item(int npc, unsigned int item, int a3)
|
|
|
132 {
|
|
|
133 for (uint i = 0; i < uNumActors; i++)
|
|
|
134 {
|
|
|
135 if (pActors[uNumActors].sNPC_ID == npc)
|
|
|
136 Actor::GiveItem(i, item, a3);
|
|
|
137 }
|
|
|
138 }
|
|
|
139
|
|
|
140 //----- (004485A7) --------------------------------------------------------
|
|
|
141 void Actor::GiveItem(signed int uActorID, unsigned int uItemID, unsigned int bGive)
|
|
|
142 {
|
|
|
143 if ( (uActorID >= 0) && (signed int)uActorID <= (signed int)(uNumActors - 1) )
|
|
|
144 {
|
|
|
145 if ( bGive )
|
|
|
146 {
|
|
|
147 if ( pActors[uActorID].uCarriedItemID == 0)
|
|
|
148 pActors[uActorID].uCarriedItemID = uItemID;
|
|
|
149 else if ( pActors[uActorID].ActorHasItems[0].uItemID == 0)
|
|
|
150 pActors[uActorID].ActorHasItems[0].uItemID = uItemID;
|
|
|
151 else if ( pActors[uActorID].ActorHasItems[1].uItemID == 0)
|
|
|
152 pActors[uActorID].ActorHasItems[1].uItemID = uItemID;
|
|
|
153 }
|
|
|
154 else
|
|
|
155 {
|
|
|
156 if ( pActors[uActorID].uCarriedItemID == uItemID )
|
|
|
157 pActors[uActorID].uCarriedItemID = 0;
|
|
|
158 else if ( pActors[uActorID].ActorHasItems[0].uItemID == uItemID )
|
|
|
159 pActors[uActorID].ActorHasItems[0].Reset();
|
|
|
160 else if ( pActors[uActorID].ActorHasItems[1].uItemID == uItemID )
|
|
|
161 pActors[uActorID].ActorHasItems[1].Reset();
|
|
|
162 }
|
|
|
163 }
|
|
|
164 }
|
|
|
165
|
|
|
166 //----- (0040894B) --------------------------------------------------------
|
|
|
167 bool Actor::CanAct()
|
|
|
168 {
|
|
|
169 bool isparalyzed; // esi@1
|
|
|
170 bool isstoned; // edi@2
|
|
|
171
|
|
|
172 isstoned = (signed __int64)this->pActorBuffs[ACTOR_BUFF_STONED].uExpireTime > 0;// stoned
|
|
|
173 isparalyzed = (signed __int64)this->pActorBuffs[ACTOR_BUFF_PARALYZED].uExpireTime > 0;// paralyzed
|
|
|
174 return !(isstoned || isparalyzed || this->uAIState == Dying || this->uAIState == Dead
|
|
|
175 || this->uAIState == Removed || this->uAIState == Summoned || this->uAIState == Disabled);
|
|
|
176 }
|
|
|
177
|
|
|
178 //----- (004089C7) --------------------------------------------------------
|
|
|
179 bool Actor::IsNotAlive()
|
|
|
180 {
|
|
|
181 bool isstoned; // esi@1
|
|
|
182
|
|
|
183 isstoned = (signed __int64)this->pActorBuffs[ACTOR_BUFF_STONED].uExpireTime > 0;// stoned
|
|
|
184 return (isstoned || (uAIState == Dying) || (uAIState == Dead) || (uAIState == Removed) || (uAIState == Summoned) || (uAIState == Disabled));
|
|
|
185 }
|
|
|
186
|
|
|
187 //----- (004086E9) --------------------------------------------------------
|
|
|
188 void Actor::SetRandomGoldIfTheresNoItem()
|
|
|
189 {
|
|
|
190 int v2; // edi@1
|
|
|
191
|
|
|
192 v2 = 0;
|
|
|
193 if ( !this->ActorHasItems[3].uItemID )
|
|
|
194 {
|
|
|
195 if ( this->pMonsterInfo.uTreasureDiceRolls )
|
|
|
196 {
|
|
|
197 for (int i = 0; i < this->pMonsterInfo.uTreasureDiceRolls; i++)
|
|
|
198 v2 += rand() % this->pMonsterInfo.uTreasureDiceSides + 1;
|
|
|
199 if ( v2 )
|
|
|
200 {
|
|
|
201 this->ActorHasItems[3].uItemID = 197;
|
|
|
202 this->ActorHasItems[3].uSpecEnchantmentType = v2; //actual gold amount
|
|
|
203 }
|
|
|
204 }
|
|
|
205 }
|
|
|
206 if ( rand() % 100 < this->pMonsterInfo.uTreasureDropChance )
|
|
|
207 {
|
|
|
208 if ( this->pMonsterInfo.uTreasureLevel )
|
|
|
209 pItemsTable->GenerateItem(this->pMonsterInfo.uTreasureLevel, this->pMonsterInfo.uTreasureType, &this->ActorHasItems[2]);
|
|
|
210 }
|
|
|
211 this->uAttributes |= ACTOR_HAS_ITEM;
|
|
|
212 }
|
|
|
213
|
|
|
214 //----- (00404AC7) --------------------------------------------------------
|
|
|
215 void Actor::AI_SpellAttack(unsigned int uActorID, AIDirection *pDir, int uSpellID, int a4, unsigned int uSkillLevel)
|
|
|
216 {
|
|
|
217 Actor *actorPtr; // esi@1
|
|
|
218 unsigned int realPoints; // edi@1
|
|
|
219 unsigned int masteryLevel; // eax@1
|
|
|
220 int v8; // edi@16
|
|
|
221 signed int v10; // ecx@22
|
|
|
222 int v19; // edi@34
|
|
|
223 int v20; // eax@35
|
|
|
224 signed int v23; // eax@41
|
|
|
225 int v28; // st6@50
|
|
|
226 int v30; // esi@50
|
|
|
227 int v31; // ST3C_4@51
|
|
|
228 unsigned int v32; // edi@51
|
|
|
229 signed int v36; // eax@67
|
|
|
230 int v39; // ecx@75
|
|
|
231 int v42; // ecx@91
|
|
|
232 int v44; // ecx@100
|
|
|
233 int v48; // ecx@110
|
|
|
234 int v51; // ecx@130
|
|
|
235 int v54; // ecx@138
|
|
|
236 int v59; // edi@146
|
|
|
237 int v61; // edi@146
|
|
|
238 signed int v63; // edi@146
|
|
|
239 int v68; // edi@168
|
|
|
240 signed int v70; // ecx@172
|
|
|
241 int v79; // edx@185
|
|
|
242 int v80; // eax@185
|
|
|
243 signed int v91; // eax@200
|
|
|
244 int v94; // ecx@208
|
|
|
245 int v96; // ecx@217
|
|
|
246 int pitch; // [sp+2Ch] [bp-A4h]@51
|
|
|
247 int v114; // [sp+48h] [bp-88h]@41
|
|
|
248 SpriteObject a1; // [sp+4Ch] [bp-84h]@1
|
|
|
249 int v116; // [sp+BCh] [bp-14h]@49
|
|
|
250 int v118; // [sp+C4h] [bp-Ch]@29
|
|
|
251 int v119; // [sp+C8h] [bp-8h]@48
|
|
|
252 int v120; // [sp+CCh] [bp-4h]@1
|
|
|
253 int spellnuma; // [sp+D8h] [bp+8h]@29
|
|
|
254 int spellnumb; // [sp+D8h] [bp+8h]@48
|
|
|
255 int spellnumc; // [sp+D8h] [bp+8h]@50
|
|
|
256 int spellnume; // [sp+D8h] [bp+8h]@179
|
|
|
257 int a1a; // [sp+E0h] [bp+10h]@34
|
|
|
258 int a1c; // [sp+E0h] [bp+10h]@184
|
|
|
259
|
|
|
260
|
|
|
261 actorPtr = &pActors[uActorID];
|
|
|
262 realPoints = uSkillLevel & 0x3F;
|
|
|
263 masteryLevel = SkillToMastery(uSkillLevel);
|
|
|
264
|
|
|
265 switch (uSpellID)
|
|
|
266 {
|
|
|
267 case SPELL_FIRE_FIRE_BOLT:
|
|
|
268 case SPELL_FIRE_FIREBALL:
|
|
|
269 case SPELL_FIRE_INCINERATE:
|
|
|
270 case SPELL_AIR_LIGHNING_BOLT:
|
|
|
271 case SPELL_WATER_ICE_BOLT:
|
|
|
272 case SPELL_WATER_ACID_BURST:
|
|
|
273 case SPELL_EARTH_BLADES:
|
|
|
274 case SPELL_EARTH_ROCK_BLAST:
|
|
|
275 case SPELL_MIND_MIND_BLAST:
|
|
|
276 case SPELL_MIND_PSYCHIC_SHOCK:
|
|
|
277 case SPELL_BODY_HARM:
|
|
|
278 case SPELL_LIGHT_LIGHT_BOLT:
|
|
|
279 case SPELL_DARK_TOXIC_CLOUD:
|
|
|
280 case SPELL_DARK_DRAGON_BREATH:
|
|
|
281 a1.uType = stru_4E3ACC[uSpellID].uType;
|
|
|
282 a1.uObjectDescID = GetObjDescId(uSpellID);
|
|
|
283 a1.stru_24.Reset();
|
|
|
284 a1.spell_id = uSpellID;
|
|
|
285 a1.spell_level = uSkillLevel;
|
|
|
286 a1.vPosition.x = actorPtr->vPosition.x;
|
|
|
287 a1.spell_skill = 0;
|
|
|
288 a1.vPosition.y = actorPtr->vPosition.y;
|
|
|
289 a1.vPosition.z = actorPtr->vPosition.z + ((signed int)actorPtr->uActorHeight >> 1);
|
|
|
290 a1.uFacing = LOWORD(pDir->uYawAngle);
|
|
|
291 a1.uSoundID = 0;
|
|
|
292 a1.uAttributes = 0;
|
|
|
293 a1.uSectorID = pIndoor->GetSector(a1.vPosition.x, a1.vPosition.y, a1.vPosition.z);
|
|
|
294 a1.uSpriteFrameID = 0;
|
|
|
295 a1.spell_caster_pid = PID(OBJECT_Actor, uActorID);
|
|
|
296 a1.spell_target_pid = 0;
|
|
|
297 if ((double)pDir->uDistance < 307.2 )
|
|
|
298 a1.field_60_distance_related_prolly_lod = 0;
|
|
|
299 else if ( pDir->uDistance < 1024 )
|
|
|
300 a1.field_60_distance_related_prolly_lod = 1;
|
|
|
301 else if ( pDir->uDistance < 2560 )
|
|
|
302 a1.field_60_distance_related_prolly_lod = 2;
|
|
|
303 else
|
|
|
304 a1.field_60_distance_related_prolly_lod = 3;
|
|
|
305
|
|
|
306 a1.field_61 = 2;
|
|
|
307 v91 = a1.Create(pDir->uYawAngle, pDir->uPitchAngle, pObjectList->pObjects[(signed __int16)a1.uObjectDescID].uSpeed, 0);
|
|
|
308 if ( v91 != -1 )
|
|
|
309 {
|
|
|
310 pAudioPlayer->PlaySound((SoundID)word_4EE088_sound_ids[uSpellID], PID(OBJECT_Item, v91), 0, -1, 0, 0, 0, 0);
|
|
|
311 return;
|
|
|
312 }
|
|
|
313 return;
|
|
|
314 break;
|
|
|
315
|
|
|
316 case SPELL_FIRE_HASTE:
|
|
|
317 if (masteryLevel == 1 || masteryLevel == 2)
|
|
|
318 v39 = 60 * (realPoints + 60);
|
|
|
319 else if (masteryLevel == 3 )
|
|
|
320 v39 = 180 * (realPoints + 20);
|
|
|
321 else if (masteryLevel == 4 )
|
|
|
322 v39 = 240 * (realPoints + 15);
|
|
|
323 else
|
|
|
324 v39 = 0;
|
|
|
325 actorPtr->pActorBuffs[ACTOR_BUFF_HASTE].Apply(pParty->uTimePlayed + (signed int)(signed __int64)((double)(v39 << 7) * 0.033333335),
|
|
|
326 masteryLevel, 0, 0, 0);
|
|
2541
|
327 pEngine->pStru6Instance->_4A7E89_sparkles_on_actor_after_it_casts_buff(actorPtr, 0xFF3C1Eu);
|
|
2534
|
328 pAudioPlayer->PlaySound((SoundID)SOUND_Haste, PID(OBJECT_Actor, uActorID), 0, -1, 0, 0, 0, 0);
|
|
2497
|
329 return;
|
|
|
330
|
|
|
331 case SPELL_FIRE_METEOR_SHOWER:
|
|
|
332 if ( uCurrentlyLoadedLevelType == LEVEL_Indoor )
|
|
|
333 return;
|
|
|
334 v114 = pParty->vPosition.z + 2500;
|
|
|
335 v23 = 8;
|
|
|
336 if (masteryLevel == 2)
|
|
|
337 v23 = 10;
|
|
|
338 else if (masteryLevel == 3)
|
|
|
339 v23 = 12;
|
|
|
340 else if (masteryLevel == 4)
|
|
|
341 v23 = 14;
|
|
|
342 spellnumb = 0;
|
|
|
343 v28 = 0;
|
|
|
344 for ( int i = 0; i < v23; i++)
|
|
|
345 {
|
|
|
346 v30 = rand() % 1000;
|
|
|
347 spellnumc = v30 - 2500;
|
|
|
348 v120 = v28 * v28;
|
|
|
349 v119 = spellnumb * spellnumb;
|
|
|
350 if ( sqrt((float)(spellnumc * spellnumc + v119 + v120)) <= 1.0 )
|
|
|
351 {
|
|
|
352 v32 = 0;
|
|
|
353 pitch = 0;
|
|
|
354 }
|
|
|
355 else
|
|
|
356 {
|
|
|
357 v31 = (signed __int64)sqrt((float)(v119 + v120));
|
|
|
358 v32 = stru_5C6E00->Atan2(spellnumb, (int)v28);
|
|
|
359 pitch = stru_5C6E00->Atan2(v31, (int)spellnumc);
|
|
|
360 }
|
|
|
361 a1.stru_24.Reset();
|
|
|
362 a1.uType = stru_4E3ACC[uSpellID].uType;
|
|
|
363 a1.uObjectDescID = GetObjDescId(uSpellID);
|
|
|
364 a1.spell_level = uSkillLevel;
|
|
|
365 a1.vPosition.x = pParty->vPosition.x;
|
|
|
366 a1.vPosition.y = pParty->vPosition.y;
|
|
|
367 a1.vPosition.z = v30 + v114;
|
|
|
368 a1.spell_id = SPELL_FIRE_METEOR_SHOWER;
|
|
|
369 a1.spell_skill = 0;
|
|
|
370 a1.uAttributes = 0;
|
|
|
371 a1.uSectorID = 0;
|
|
|
372 a1.uSpriteFrameID = 0;
|
|
|
373 a1.spell_caster_pid = PID(OBJECT_Actor, uActorID);
|
|
|
374 a1.spell_target_pid = 0;
|
|
|
375 a1.field_60_distance_related_prolly_lod = stru_50C198._427546(v30 + 2500);
|
|
|
376 a1.uFacing = v32;
|
|
|
377 a1.uSoundID = 0;
|
|
|
378 if (pDir->uDistance < 307.2 )
|
|
|
379 a1.field_60_distance_related_prolly_lod = 0;
|
|
|
380 else if ( pDir->uDistance < 1024 )
|
|
|
381 a1.field_60_distance_related_prolly_lod = 1;
|
|
|
382 else if ( pDir->uDistance < 2560 )
|
|
|
383 a1.field_60_distance_related_prolly_lod = 2;
|
|
|
384 else
|
|
|
385 a1.field_60_distance_related_prolly_lod = 3;
|
|
|
386 a1.field_61 = 2;
|
|
|
387 v36 = a1.Create(v32, pitch, pObjectList->pObjects[(signed __int16)a1.uObjectDescID].uSpeed, 0);
|
|
|
388 if ( v36 != -1 )
|
|
|
389 pAudioPlayer->PlaySound((SoundID)word_4EE088_sound_ids[9], PID(OBJECT_Item, v36), 0, -1, 0, 0, 0, 0);
|
|
|
390 spellnumb = rand() % 1024 - 512;
|
|
|
391 v28 = rand() % 1024 - 512;
|
|
|
392 }
|
|
|
393 return;
|
|
|
394 break;
|
|
|
395
|
|
|
396 case SPELL_AIR_SPARKS:
|
|
|
397 if (masteryLevel == 2 )
|
|
|
398 v10 = 5;
|
|
|
399 else if (masteryLevel == 3 )
|
|
|
400 v10 = 7;
|
|
|
401 else if (masteryLevel == 4 )
|
|
|
402 v10 = 9;
|
|
|
403 else
|
|
|
404 v10 = 3;
|
|
|
405 spellnuma = (signed int)(60 * stru_5C6E00->uIntegerDoublePi) / 360;
|
|
|
406 a1.uType = stru_4E3ACC[uSpellID].uType;
|
|
|
407 v118 = (signed int)(60 * stru_5C6E00->uIntegerDoublePi) / 360 / (v10 - 1);
|
|
|
408 a1.uObjectDescID = GetObjDescId(uSpellID);
|
|
|
409
|
|
|
410 a1.stru_24.Reset();
|
|
|
411 a1.spell_id = SPELL_AIR_SPARKS;
|
|
|
412 a1.spell_level = uSkillLevel;
|
|
|
413 a1.vPosition.x = actorPtr->vPosition.x;
|
|
|
414 a1.spell_skill = 0;
|
|
|
415 a1.vPosition.y = actorPtr->vPosition.y;
|
|
|
416 a1.vPosition.z = actorPtr->vPosition.z + ((signed int)actorPtr->uActorHeight >> 1);
|
|
|
417 a1.uFacing = pDir->uYawAngle;
|
|
|
418 a1.uSoundID = 0;
|
|
|
419 a1.uAttributes = 0;
|
|
|
420 a1.uSectorID = pIndoor->GetSector(a1.vPosition.x, a1.vPosition.y, a1.vPosition.z);
|
|
|
421 a1.spell_caster_pid = PID(OBJECT_Actor, uActorID);
|
|
|
422 a1.uSpriteFrameID = 0;
|
|
|
423 a1.spell_target_pid = 0;
|
|
|
424 a1.field_60_distance_related_prolly_lod = 3;
|
|
|
425 v19 = spellnuma / -2;
|
|
|
426 a1a = spellnuma / 2;
|
|
|
427 if ( spellnuma / -2 > spellnuma / 2 )
|
|
|
428 v20 = spellnuma / 2;
|
|
|
429 else
|
|
|
430 {
|
|
|
431 do
|
|
|
432 {
|
|
|
433 a1.uFacing = v19 + LOWORD(pDir->uYawAngle);
|
|
|
434 v20 = a1.Create((signed __int16)a1.uFacing, pDir->uPitchAngle,
|
|
|
435 pObjectList->pObjects[(signed __int16)a1.uObjectDescID].uSpeed, 0);
|
|
|
436 v19 += v118;
|
|
|
437 }
|
|
|
438 while ( v19 <= a1a );
|
|
|
439 }
|
|
|
440 if ( v20 != -1 )
|
|
|
441 {
|
|
|
442 pAudioPlayer->PlaySound((SoundID)word_4EE088_sound_ids[15], PID(OBJECT_Item, v20), 0, -1, 0, 0, 0, 0);
|
|
|
443 return;
|
|
|
444 }
|
|
|
445 return;
|
|
|
446 break;
|
|
|
447
|
|
|
448 case SPELL_AIR_SHIELD:
|
|
|
449 if (masteryLevel == 1 || masteryLevel == 2)
|
|
|
450 v8 = 300 * realPoints + 3840;
|
|
|
451 else if (masteryLevel == 3 )
|
|
|
452 v8 = 900 * realPoints + 3840;
|
|
|
453 else if (masteryLevel == 4 )
|
|
|
454 v8 = 3600 * (realPoints + 64);
|
|
|
455 else
|
|
|
456 v8 = 0;
|
|
|
457 actorPtr->pActorBuffs[ACTOR_BUFF_SHIELD].Apply(
|
|
|
458 pParty->uTimePlayed + (signed int)(signed __int64)((double)(v8 << 7) * 0.033333335),
|
|
|
459 masteryLevel, 0, 0, 0);
|
|
|
460 return;
|
|
|
461
|
|
|
462 case SPELL_EARTH_STONESKIN:
|
|
|
463 if (masteryLevel == 1 || masteryLevel == 2)
|
|
|
464 v44 = 300 * realPoints + 3840;
|
|
|
465 else if (masteryLevel == 3 )
|
|
|
466 v44 = 900 * realPoints + 3840;
|
|
|
467 else if (masteryLevel == 4 )
|
|
|
468 v44 = 3600 * (realPoints + 64);
|
|
|
469 else
|
|
|
470 v44 = 0;
|
|
|
471 actorPtr->pActorBuffs[ACTOR_BUFF_STONESKIN].Apply(
|
|
|
472 pParty->uTimePlayed + (signed int)(signed __int64)((double)(v44 << 7) * 0.033333335),
|
|
|
473 masteryLevel, realPoints + 5, 0, 0);
|
|
2541
|
474 pEngine->pStru6Instance->_4A7E89_sparkles_on_actor_after_it_casts_buff(actorPtr,0x5C310Eu);
|
|
2534
|
475 pAudioPlayer->PlaySound((SoundID)SOUND_Stoneskin, PID(OBJECT_Actor,uActorID), 0, -1, 0, 0, 0, 0);
|
|
2497
|
476 return;
|
|
|
477
|
|
|
478 case SPELL_SPIRIT_BLESS:
|
|
|
479 if (masteryLevel == 1 || masteryLevel == 2)
|
|
|
480 v42 = 300 * realPoints + 3840;
|
|
|
481 else if (masteryLevel == 3 )
|
|
|
482 v42 = 900 * realPoints + 3840;
|
|
|
483 else if (masteryLevel == 4 )
|
|
|
484 v42 = 1200 * realPoints + 3840;
|
|
|
485 else
|
|
|
486 v42 = 0;
|
|
|
487 actorPtr->pActorBuffs[ACTOR_BUFF_BLESS].Apply(
|
|
|
488 pParty->uTimePlayed + (signed int)(signed __int64)((double)(v42 << 7) * 0.033333335),
|
|
|
489 masteryLevel, realPoints + 5, 0, 0);
|
|
2541
|
490 pEngine->pStru6Instance->_4A7E89_sparkles_on_actor_after_it_casts_buff(actorPtr,0xC8C805u);
|
|
2534
|
491 pAudioPlayer->PlaySound((SoundID)SOUND_Bless, PID(OBJECT_Actor,uActorID), 0, -1, 0, 0, 0, 0);
|
|
2497
|
492 return;
|
|
|
493 break;
|
|
|
494
|
|
|
495 case SPELL_SPIRIT_FATE:
|
|
|
496 if (masteryLevel == 1 || masteryLevel == 2)
|
|
|
497 v48 = 2 * realPoints + 40;
|
|
|
498 else if (masteryLevel == 3 )
|
|
|
499 v48 = 3 * realPoints + 60;
|
|
|
500 else if (masteryLevel == 4 )
|
|
|
501 v48 = 2 * (3 * realPoints + 60);
|
|
|
502 else
|
|
|
503 v48 = 0;
|
|
|
504 actorPtr->pActorBuffs[ACTOR_BUFF_FATE].Apply(pParty->uTimePlayed + 1280, masteryLevel, v48, 0, 0);
|
|
2541
|
505 pEngine->pStru6Instance->_4A7E89_sparkles_on_actor_after_it_casts_buff(actorPtr,0xC8C805u);
|
|
2534
|
506 pAudioPlayer->PlaySound((SoundID)SOUND_Fate, PID(OBJECT_Actor, uActorID), 0, -1, 0, 0, 0, 0);
|
|
2497
|
507 return;
|
|
|
508
|
|
|
509 case SPELL_SPIRIT_HEROISM:
|
|
|
510 if (masteryLevel == 1 || masteryLevel == 2)
|
|
|
511 v54 = 300 * realPoints + 3840;
|
|
|
512 else if (masteryLevel == 3 )
|
|
|
513 v54 = 900 * realPoints + 3840;
|
|
|
514 else if (masteryLevel == 4 )
|
|
|
515 v54 = 1200 * realPoints + 3840;
|
|
|
516 else
|
|
|
517 v54 = 0;
|
|
|
518 actorPtr->pActorBuffs[ACTOR_BUFF_HEROISM].Apply(
|
|
|
519 pParty->uTimePlayed + (signed int)(signed __int64)((double)(v54 << 7) * 0.033333335),
|
|
|
520 masteryLevel, realPoints + 5, 0, 0);
|
|
2541
|
521 pEngine->pStru6Instance->_4A7E89_sparkles_on_actor_after_it_casts_buff(actorPtr,0xC8C805u);
|
|
2534
|
522 pAudioPlayer->PlaySound((SoundID)SOUND_51heroism03, PID(OBJECT_Actor,uActorID), 0, -1, 0, 0, 0, 0);
|
|
2497
|
523 return;
|
|
|
524
|
|
|
525 case SPELL_BODY_HAMMERHANDS:
|
|
|
526 if ( (signed int)masteryLevel <= 0 || (signed int)masteryLevel > 4 )
|
|
|
527 v51 = 0;
|
|
|
528 else
|
|
|
529 v51 = 3600 * realPoints;
|
|
|
530 actorPtr->pActorBuffs[ACTOR_BUFF_PAIN_HAMMERHANDS].Apply(
|
|
|
531 pParty->uTimePlayed + (signed int)(signed __int64)((double)(v51 << 7) * 0.033333335),
|
|
|
532 masteryLevel,
|
|
|
533 realPoints,
|
|
|
534 0,
|
|
|
535 0);
|
|
2541
|
536 pEngine->pStru6Instance->_4A7E89_sparkles_on_actor_after_it_casts_buff(actorPtr, 0xA81376u);
|
|
2534
|
537 pAudioPlayer->PlaySound((SoundID)SOUND_51heroism03, PID(OBJECT_Actor, uActorID), 0, -1, 0, 0, 0, 0);
|
|
2497
|
538 return;
|
|
|
539
|
|
|
540 case SPELL_BODY_POWER_CURE:
|
|
|
541 actorPtr->sCurrentHP += 5 * realPoints + 10;
|
|
|
542 if ( actorPtr->sCurrentHP >= (signed int)actorPtr->pMonsterInfo.uHP )
|
|
|
543 actorPtr->sCurrentHP = LOWORD(actorPtr->pMonsterInfo.uHP);
|
|
2541
|
544 pEngine->pStru6Instance->_4A7E89_sparkles_on_actor_after_it_casts_buff(actorPtr, 0xA81376u);
|
|
2534
|
545 pAudioPlayer->PlaySound((SoundID)SOUND_Fate, PID(OBJECT_Actor, uActorID), 0, -1, 0, 0, 0, 0);
|
|
2497
|
546 return;
|
|
|
547
|
|
|
548 case SPELL_LIGHT_DISPEL_MAGIC:
|
|
|
549 for (int i = 0; i < 20; i++ )
|
|
|
550 pParty->pPartyBuffs[i].Reset();
|
|
|
551 for (int i = 1; i <= 4; i++)
|
|
|
552 {
|
|
|
553 v59 = pPlayers[i]->GetParameterBonus(pPlayers[i]->GetActualWillpower());
|
|
|
554 v61 = (pPlayers[i]->GetParameterBonus(pPlayers[i]->GetActualIntelligence()) + v59) / 2;
|
|
|
555 v63 = v61 + pPlayers[i]->GetParameterBonus(pPlayers[i]->GetActualLuck()) + 30;
|
|
|
556 if ( rand() % v63 < 30 )
|
|
|
557 {
|
|
|
558 for (uint k = 0; k < pPlayers[i]->pPlayerBuffs.size(); k++)
|
|
|
559 pPlayers[i]->pPlayerBuffs[k].Reset();
|
|
|
560 pOtherOverlayList->_4418B1(11210, i + 99, 0, 65536);
|
|
|
561 }
|
|
|
562 }
|
|
|
563 pAudioPlayer->PlaySound((SoundID)word_4EE088_sound_ids[80], PID(OBJECT_Actor, uActorID), 0, -1, 0, 0, 0, 0);
|
|
|
564 return;
|
|
|
565
|
|
|
566 case SPELL_LIGHT_DAY_OF_PROTECTION:
|
|
|
567 if (masteryLevel == 1 || masteryLevel == 2)
|
|
|
568 v96 = 300 * realPoints + 3840;
|
|
|
569 else if (masteryLevel == 3 )
|
|
|
570 {
|
|
|
571 LOWORD(realPoints) = 3 * realPoints;
|
|
|
572 v96 = 900 * (uSkillLevel & 0x3F) + 3840;
|
|
|
573 }
|
|
|
574 else if (masteryLevel == 4 )
|
|
|
575 {
|
|
|
576 v96 = 1200 * realPoints + 3840;
|
|
|
577 LOWORD(realPoints) = 4 * realPoints;
|
|
|
578 }
|
|
|
579 else
|
|
|
580 {
|
|
|
581 LOWORD(realPoints) = uSkillLevel;
|
|
|
582 v96 = 0;
|
|
|
583 }
|
|
|
584 actorPtr->pActorBuffs[ACTOR_BUFF_DAY_OF_PROTECTION].Apply(
|
|
|
585 pParty->uTimePlayed + (signed int)(signed __int64)((double)(v96 << 7) * 0.033333335),
|
|
|
586 masteryLevel, realPoints, 0, 0);
|
|
2541
|
587 pEngine->pStru6Instance->_4A7E89_sparkles_on_actor_after_it_casts_buff(actorPtr, 0xFFFFFFu);
|
|
2534
|
588 pAudioPlayer->PlaySound((SoundID)SOUND_94dayofprotection03, PID(OBJECT_Actor, uActorID), 0, -1, 0, 0, 0, 0);
|
|
2497
|
589 return;
|
|
|
590
|
|
|
591 case SPELL_LIGHT_HOUR_OF_POWER:
|
|
|
592 if (masteryLevel == 1 || masteryLevel == 2)
|
|
|
593 v94 = 300 * realPoints + 3840;
|
|
|
594 else if (masteryLevel == 3)
|
|
|
595 v94 = 900 * realPoints + 3840;
|
|
|
596 else if (masteryLevel == 4)
|
|
|
597 v94 = 1200 * realPoints + 3840;
|
|
|
598 else
|
|
|
599 v94 = 0;
|
|
|
600 actorPtr->pActorBuffs[ACTOR_BUFF_HOUR_OF_POWER].Apply(
|
|
|
601 pParty->uTimePlayed + (signed int)(signed __int64)((double)(v94 << 7) * 0.033333335),
|
|
|
602 masteryLevel, realPoints + 5, 0, 0);
|
|
2541
|
603 pEngine->pStru6Instance->_4A7E89_sparkles_on_actor_after_it_casts_buff(actorPtr, 0xFFFFFFu);
|
|
2534
|
604 pAudioPlayer->PlaySound((SoundID)SOUND_9armageddon01, PID(OBJECT_Actor, uActorID), 0, -1, 0, 0, 0, 0);
|
|
2497
|
605 return;
|
|
|
606
|
|
|
607 case SPELL_DARK_SHARPMETAL:
|
|
|
608 if (masteryLevel == 2)
|
|
|
609 v70 = 5;
|
|
|
610 else if (masteryLevel == 3)
|
|
|
611 v70 = 7;
|
|
|
612 else if (masteryLevel == 4)
|
|
|
613 v70 = 9;
|
|
|
614 else
|
|
|
615 v70 = 3;
|
|
|
616
|
|
|
617 spellnume = (signed int)(60 * stru_5C6E00->uIntegerDoublePi) / 360;
|
|
|
618 a1.uType = stru_4E3ACC[uSpellID].uType;
|
|
|
619 v116 = (signed int)(60 * stru_5C6E00->uIntegerDoublePi) / 360 / (v70 - 1);
|
|
|
620 a1.uObjectDescID = GetObjDescId(uSpellID);
|
|
|
621 a1.stru_24.Reset();
|
|
|
622 a1.spell_id = uSpellID;
|
|
|
623 a1.spell_level = uSkillLevel;
|
|
|
624 a1.vPosition.x = actorPtr->vPosition.x;
|
|
|
625 a1.spell_skill = 0;
|
|
|
626 a1.vPosition.y = actorPtr->vPosition.y;
|
|
|
627 a1.vPosition.z = actorPtr->vPosition.z + ((signed int)actorPtr->uActorHeight >> 1);
|
|
|
628 a1.uFacing = pDir->uYawAngle;
|
|
|
629 a1.uSoundID = 0;
|
|
|
630 a1.uAttributes = 0;
|
|
|
631 a1.uSectorID = pIndoor->GetSector(a1.vPosition.x, a1.vPosition.y, a1.vPosition.z);
|
|
|
632 a1.spell_caster_pid = PID(OBJECT_Actor, uActorID);
|
|
|
633 a1.uSpriteFrameID = 0;
|
|
|
634 a1.spell_target_pid = 0;
|
|
|
635 a1.field_60_distance_related_prolly_lod = 3;
|
|
|
636 a1c = spellnume / -2;
|
|
|
637 if ( spellnume / -2 > spellnume / 2 )
|
|
|
638 v80 = spellnume / -2;
|
|
|
639 else
|
|
|
640 {
|
|
|
641 do
|
|
|
642 {
|
|
|
643 v79 = pDir->uYawAngle;
|
|
|
644 a1.uFacing = a1c + LOWORD(pDir->uYawAngle);
|
|
|
645 v80 = a1.Create(v79, pDir->uPitchAngle,
|
|
|
646 pObjectList->pObjects[(signed __int16)a1.uObjectDescID].uSpeed, 0);
|
|
|
647 a1c += v116;
|
|
|
648 }
|
|
|
649 while ( a1c <= spellnume / 2 );
|
|
|
650 }
|
|
|
651 if ( v80 != -1 )
|
|
|
652 {
|
|
|
653 pAudioPlayer->PlaySound((SoundID)word_4EE088_sound_ids[93], PID(OBJECT_Item, v80), 0, -1, 0, 0, 0, 0);
|
|
|
654 return;
|
|
|
655 }
|
|
|
656 return;
|
|
|
657 break;
|
|
|
658
|
|
|
659 case SPELL_DARK_PAIN_REFLECTION:
|
|
|
660 if (masteryLevel == 0)
|
|
|
661 v68 = 0;
|
|
|
662 else if (masteryLevel == 1 || (masteryLevel == 2) || (masteryLevel == 3))
|
|
|
663 v68 = 300 * realPoints + 3840;
|
|
|
664 else
|
|
|
665 v68 = 900 * realPoints + 3840;
|
|
|
666 actorPtr->pActorBuffs[ACTOR_BUFF_PAIN_REFLECTION].Apply(
|
|
|
667 pParty->uTimePlayed + (signed int)(signed __int64)((double)(v68 << 7) * 0.033333335),
|
|
|
668 masteryLevel, 0, 0, 0);
|
|
2541
|
669 pEngine->pStru6Instance->_4A7E89_sparkles_on_actor_after_it_casts_buff(actorPtr,0x7E7E7Eu);
|
|
2534
|
670 pAudioPlayer->PlaySound((SoundID)SOUND_Sacrifice2, PID(OBJECT_Actor, uActorID), 0, -1, 0, 0, 0, 0);
|
|
2497
|
671 return;
|
|
|
672 }
|
|
|
673 }
|
|
|
674
|
|
|
675 //----- (new func) --------------------------------------------------------
|
|
|
676 unsigned short Actor::GetObjDescId( int spellId )
|
|
|
677 {
|
|
|
678 for (unsigned int i = 0; i < pObjectList->uNumObjects; i++)
|
|
|
679 {
|
|
|
680 if (stru_4E3ACC[spellId].uType == pObjectList->pObjects[i].uObjectID)
|
|
|
681 {
|
|
|
682 return i;
|
|
|
683 break;
|
|
|
684 }
|
|
|
685 }
|
|
|
686 return 0;
|
|
|
687 }
|
|
|
688
|
|
|
689
|
|
|
690 //----- (0043ABB0) --------------------------------------------------------
|
|
|
691 bool Actor::ArePeasantsOfSameFaction(Actor *a1, Actor *a2)
|
|
|
692 {
|
|
|
693 unsigned int v2; // esi@1
|
|
|
694 unsigned int v3; // edi@1
|
|
|
695
|
|
|
696 v2 = a1->uAlly;
|
|
|
697 if ( !a1->uAlly )
|
|
|
698 v2 = (a1->pMonsterInfo.uID - 1) / 3 + 1;
|
|
|
699
|
|
|
700 v3 = a2->uAlly;
|
|
|
701 if ( !a2->uAlly )
|
|
|
702 v3 = (a2->pMonsterInfo.uID - 1) / 3 + 1;
|
|
|
703
|
|
|
704 if ( v2 >= 39 && v2 <= 44 && v3 >= 39 && v3 <= 44
|
|
|
705 || v2 >= 45 && v2 <= 50 && v3 >= 45 && v3 <= 50
|
|
|
706 || v2 >= 51 && v2 <= 62 && v3 >= 51 && v3 <= 62
|
|
|
707 || v2 >= 78 && v2 <= 83 && v3 >= 78 && v3 <= 83
|
|
|
708 || v2 == v3
|
|
|
709 )
|
|
|
710 return true;
|
|
|
711 else
|
|
|
712 return false;
|
|
|
713 }
|
|
|
714
|
|
|
715 //----- (0043AC45) --------------------------------------------------------
|
|
|
716 void Actor::AggroSurroundingPeasants(unsigned int uActorID, int a2)
|
|
|
717 {
|
|
|
718 int v4; // ebx@8
|
|
|
719 int v5; // ST1C_4@8
|
|
|
720 int v6; // eax@8
|
|
|
721
|
|
|
722 int x = 0; x |= 0x80000;
|
|
|
723 int y = 0; y |= 0x80000;
|
|
|
724 Actor* victim = &pActors[uActorID];
|
|
|
725 if ( a2 == 1 )
|
|
|
726 victim->uAttributes |= ACTOR_AGGRESSOR;
|
|
|
727
|
|
|
728 for (uint i = 0; i < uNumActors; ++i)
|
|
|
729 {
|
|
|
730 Actor* actor = &pActors[i];
|
|
|
731 if (!actor->CanAct() || i == uActorID)
|
|
|
732 continue;
|
|
|
733
|
|
|
734 if (Actor::ArePeasantsOfSameFaction(victim, actor))
|
|
|
735 {
|
|
|
736 v4 = abs(actor->vPosition.x - victim->vPosition.x);
|
|
|
737 v5 = abs(actor->vPosition.y - victim->vPosition.y);
|
|
|
738 v6 = abs(actor->vPosition.z - victim->vPosition.z);
|
|
|
739 if (int_get_vector_length(v4, v5, v6) < 4096)
|
|
|
740 {
|
|
|
741 actor->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
|
|
|
742 if ( a2 == 1 )
|
|
|
743 actor->uAttributes |= ACTOR_AGGRESSOR;
|
|
|
744
|
|
|
745 }
|
|
|
746 }
|
|
|
747 }
|
|
|
748 }
|
|
|
749
|
|
|
750 //----- (00404874) --------------------------------------------------------
|
|
|
751 void Actor::AI_RangedAttack( unsigned int uActorID, struct AIDirection *pDir, int type, char a4 )
|
|
|
752 {
|
|
|
753 char specAb; // al@1
|
|
|
754 int v13; // edx@28
|
|
|
755
|
|
|
756 SpriteObject a1; // [sp+Ch] [bp-74h]@1
|
|
|
757
|
|
|
758 switch ( type )
|
|
|
759 {
|
|
|
760 case 1:
|
|
|
761 a1.uType = 545;
|
|
|
762 break;
|
|
|
763 case 2:
|
|
|
764 a1.uType = 550;
|
|
|
765 break;
|
|
|
766 case 3:
|
|
|
767 a1.uType = 510;
|
|
|
768 break;
|
|
|
769 case 4:
|
|
|
770 a1.uType = 500;
|
|
|
771 break;
|
|
|
772 case 5:
|
|
|
773 a1.uType = 515;
|
|
|
774 break;
|
|
|
775 case 6:
|
|
|
776 a1.uType = 505;
|
|
|
777 break;
|
|
|
778 case 7:
|
|
|
779 a1.uType = 530;
|
|
|
780 break;
|
|
|
781 case 8:
|
|
|
782 a1.uType = 525;
|
|
|
783 break;
|
|
|
784 case 9:
|
|
|
785 a1.uType = 520;
|
|
|
786 break;
|
|
|
787 case 10:
|
|
|
788 a1.uType = 535;
|
|
|
789 break;
|
|
|
790 case 11:
|
|
|
791 a1.uType = 540;
|
|
|
792 break;
|
|
|
793 case 13:
|
|
|
794 a1.uType = 555;
|
|
|
795 break;
|
|
|
796 default:
|
|
|
797 return;
|
|
|
798 }
|
|
|
799 bool found = false;
|
|
|
800 for ( uint i = 0; i < pObjectList->uNumObjects; i++)
|
|
|
801 {
|
|
|
802 if (pObjectList->pObjects[i].uObjectID == a1.uType)
|
|
|
803 {
|
|
|
804 a1.uObjectDescID = i;
|
|
|
805 found = true;
|
|
|
806 break;
|
|
|
807 }
|
|
|
808 }
|
|
|
809 if (!found)
|
|
|
810 {
|
|
|
811 Error("Item not found");
|
|
|
812 return;
|
|
|
813 }
|
|
|
814 a1.stru_24.Reset();
|
|
|
815 a1.spell_id = 0;
|
|
|
816 a1.vPosition.x = pActors[uActorID].vPosition.x;
|
|
|
817 a1.vPosition.y = pActors[uActorID].vPosition.y;
|
|
|
818 a1.vPosition.z = pActors[uActorID].vPosition.z - (unsigned int)(pActors[uActorID].uActorHeight * -0.75);
|
|
|
819 a1.spell_level = 0;
|
|
|
820 a1.spell_skill = 0;
|
|
|
821 a1.uFacing = pDir->uYawAngle;
|
|
|
822 a1.uSoundID = 0;
|
|
|
823 a1.uAttributes = 0;
|
|
|
824 a1.uSectorID = pIndoor->GetSector(a1.vPosition.x, a1.vPosition.y, a1.vPosition.z);
|
|
|
825 a1.uSpriteFrameID = 0;
|
|
|
826 a1.spell_caster_pid = PID(OBJECT_Actor, uActorID);
|
|
|
827 a1.spell_target_pid = 0;
|
|
|
828 if (pDir->uDistance < 307.2 )
|
|
|
829 a1.field_60_distance_related_prolly_lod = 0;
|
|
|
830 else if ( pDir->uDistance < 1024 )
|
|
|
831 a1.field_60_distance_related_prolly_lod = 1;
|
|
|
832 else if ( pDir->uDistance < 2560 )
|
|
|
833 a1.field_60_distance_related_prolly_lod = 2;
|
|
|
834 else
|
|
|
835 a1.field_60_distance_related_prolly_lod = 3;
|
|
|
836
|
|
|
837 a1.field_61 = a4;
|
|
|
838 a1.Create(pDir->uYawAngle, pDir->uPitchAngle, pObjectList->pObjects[(signed __int16)a1.uObjectDescID].uSpeed, 0);
|
|
|
839 if ( pActors[uActorID].pMonsterInfo.uSpecialAbilityType == 1 )
|
|
|
840 {
|
|
|
841 specAb = pActors[uActorID].pMonsterInfo.uSpecialAbilityDamageDiceBonus;
|
|
|
842 if ( specAb == 2 )
|
|
|
843 {
|
|
|
844 a1.vPosition.z += 40;
|
|
|
845 v13 = pDir->uYawAngle;
|
|
|
846 }
|
|
|
847 else
|
|
|
848 {
|
|
|
849 if ( specAb != 3 )
|
|
|
850 return;
|
|
|
851 a1.Create(pDir->uYawAngle + 30, //TODO find out why the YawAngle change
|
|
|
852 pDir->uPitchAngle, pObjectList->pObjects[(signed __int16)a1.uObjectDescID].uSpeed, 0);
|
|
|
853 v13 = pDir->uYawAngle - 30;
|
|
|
854 }
|
|
|
855 a1.Create(v13, pDir->uPitchAngle, pObjectList->pObjects[(signed __int16)a1.uObjectDescID].uSpeed, 0);
|
|
|
856 }
|
|
|
857 return;
|
|
|
858 }
|
|
|
859
|
|
|
860 //----- (00404736) --------------------------------------------------------
|
|
|
861 void Actor::Explode( unsigned int uActorID )
|
|
|
862 {
|
|
|
863 SpriteObject a1; // [sp+Ch] [bp-78h]@1
|
|
|
864
|
|
|
865 a1.uType = 600;
|
|
|
866 a1.uObjectDescID = GetObjDescId(a1.uType);
|
|
|
867 a1.stru_24.Reset();
|
|
|
868 a1.spell_id = 0;
|
|
|
869 a1.spell_level = 0;
|
|
|
870 a1.spell_skill = 0;
|
|
|
871 a1.vPosition.x = pActors[uActorID].vPosition.x;
|
|
|
872 a1.vPosition.y = pActors[uActorID].vPosition.y;
|
|
|
873 a1.vPosition.z = pActors[uActorID].vPosition.z - (unsigned int)(pActors[uActorID].uActorHeight * -0.75);
|
|
|
874 a1.uFacing = 0;
|
|
|
875 a1.uSoundID = 0;
|
|
|
876 a1.uAttributes = 0;
|
|
|
877 a1.uSectorID = pIndoor->GetSector(a1.vPosition.x, a1.vPosition.y, a1.vPosition.z);
|
|
|
878 a1.uSpriteFrameID = 0;
|
|
|
879 a1.spell_caster_pid = PID(OBJECT_Actor, uActorID);
|
|
|
880 a1.spell_target_pid = 0;
|
|
|
881 a1.field_60_distance_related_prolly_lod = 3;
|
|
|
882 a1.field_61 = 4;
|
|
|
883 a1.Create(0, 0, 0, 0);
|
|
|
884 return;
|
|
|
885 }
|
|
|
886
|
|
|
887 //----- (004040E9) --------------------------------------------------------
|
|
|
888 // // Get direction vector from object1 to object2,
|
|
|
889 // // distance from object1 to object2 and Euler angles of the direction vector
|
|
|
890 // //
|
|
|
891 // //
|
|
|
892 // // object1 & object2 format : objectType | (objectID << 3)
|
|
|
893 // // objectType == 2 - SpriteObject
|
|
|
894 // // objectType == 3 - Actor
|
|
|
895 // // objectType == 4 - Party
|
|
|
896 // // objectType == 5 - Decoration
|
|
|
897 // //
|
|
|
898 // // originally this function had following prototype:
|
|
|
899 // // struct DirectionInfo GetDirectionInfo(signed int object1, signed int object2, signed int a4)
|
|
|
900 // // but compiler converts functions returning structures by value in the such way
|
|
|
901 void Actor::GetDirectionInfo( unsigned int uObj1ID, unsigned int uObj2ID, struct AIDirection *pOut, int a4 )
|
|
|
902 {
|
|
|
903 signed int v4; // eax@1
|
|
|
904 signed int v5; // ecx@1
|
|
|
905 int v18; // edx@15
|
|
|
906 float v31; // st7@45
|
|
|
907 float v32; // st6@45
|
|
|
908 float v33; // st7@45
|
|
|
909 Vec3_int_ v37; // [sp-10h] [bp-5Ch]@15
|
|
|
910 AIDirection v41; // [sp+14h] [bp-38h]@46
|
|
|
911 float outy2; // [sp+38h] [bp-14h]@33
|
|
|
912 float outx2; // [sp+3Ch] [bp-10h]@33
|
|
|
913 int outz; // [sp+40h] [bp-Ch]@6
|
|
|
914 int outy; // [sp+44h] [bp-8h]@6
|
|
|
915 int outx; // [sp+48h] [bp-4h]@6
|
|
|
916 float a4a; // [sp+58h] [bp+Ch]@45
|
|
|
917
|
|
|
918 v4 = PID_ID(uObj1ID);
|
|
|
919 //v6 = uObj2ID;
|
|
|
920 v5 = PID_ID(uObj2ID);
|
|
|
921 switch( PID_TYPE(uObj1ID) )
|
|
|
922 {
|
|
|
923 case OBJECT_Item:
|
|
|
924 {
|
|
|
925 outx = pSpriteObjects[v4].vPosition.x;
|
|
|
926 outy = pSpriteObjects[v4].vPosition.y;
|
|
|
927 outz = pSpriteObjects[v4].vPosition.z;
|
|
|
928 break;
|
|
|
929 }
|
|
|
930 case OBJECT_Actor:
|
|
|
931 {
|
|
|
932 outx = pActors[v4].vPosition.x;
|
|
|
933 outy = pActors[v4].vPosition.y;
|
|
|
934 outz = pActors[v4].vPosition.z - (unsigned int)(signed __int64)((double)pActors[v4].uActorHeight * -0.75);
|
|
|
935 break;
|
|
|
936 }
|
|
|
937 case OBJECT_Player:
|
|
|
938 {
|
|
|
939 if ( !v4 )
|
|
|
940 {
|
|
|
941 outx = pParty->vPosition.x;
|
|
|
942 outy = pParty->vPosition.y;
|
|
|
943 outz = pParty->vPosition.z + (signed int)pParty->uPartyHeight / 3;
|
|
|
944 break;
|
|
|
945 }
|
|
|
946 if ( v4 == 4 )
|
|
|
947 {
|
|
|
948 v18 = pParty->sRotationY - stru_5C6E00->uIntegerHalfPi;
|
|
|
949 v37.z = pParty->vPosition.z + (signed int)pParty->uPartyHeight / 3;
|
|
|
950 v37.x = pParty->vPosition.x;
|
|
|
951 v37.y = pParty->vPosition.y;
|
|
|
952 Vec3_int_::Rotate(24, v18, 0, v37, &outx, &outy, &outz);
|
|
|
953 break;
|
|
|
954 }
|
|
|
955 if ( v4 == 3 )
|
|
|
956 {
|
|
|
957 v18 = pParty->sRotationY - stru_5C6E00->uIntegerHalfPi;
|
|
|
958 v37.z = pParty->vPosition.z + (signed int)pParty->uPartyHeight / 3;
|
|
|
959 v37.x = pParty->vPosition.x;
|
|
|
960 v37.y = pParty->vPosition.y;
|
|
|
961 Vec3_int_::Rotate(8, v18, 0, v37, &outx, &outy, &outz);
|
|
|
962 break;
|
|
|
963 }
|
|
|
964 if ( v4 == 2 )
|
|
|
965 {
|
|
|
966 v37.z = pParty->vPosition.z + (signed int)pParty->uPartyHeight / 3;
|
|
|
967 v18 = stru_5C6E00->uIntegerHalfPi + pParty->sRotationY;
|
|
|
968 v37.x = pParty->vPosition.x;
|
|
|
969 v37.y = pParty->vPosition.y;
|
|
|
970 Vec3_int_::Rotate(8, v18, 0, v37, &outx, &outy, &outz);
|
|
|
971 break;
|
|
|
972 }
|
|
|
973 if ( v4 == 1 )
|
|
|
974 {
|
|
|
975 v37.z = pParty->vPosition.z + (signed int)pParty->uPartyHeight / 3;
|
|
|
976 v18 = stru_5C6E00->uIntegerHalfPi + pParty->sRotationY;
|
|
|
977 v37.x = pParty->vPosition.x;
|
|
|
978 v37.y = pParty->vPosition.y;
|
|
|
979 Vec3_int_::Rotate(24, v18, 0, v37, &outx, &outy, &outz);
|
|
|
980 break;
|
|
|
981 }
|
|
|
982 }
|
|
|
983 case OBJECT_Decoration:
|
|
|
984 {
|
|
|
985 outx = pLevelDecorations[v4].vPosition.x;
|
|
|
986 outy = pLevelDecorations[v4].vPosition.y;
|
|
|
987 outz = pLevelDecorations[v4].vPosition.z;
|
|
|
988 break;
|
|
|
989 }
|
|
|
990 default:
|
|
|
991 {
|
|
|
992 outz = 0;
|
|
|
993 outy = 0;
|
|
|
994 outx = 0;
|
|
|
995 break;
|
|
|
996 }
|
|
|
997 case OBJECT_BModel:
|
|
|
998 {
|
|
|
999 if ( uCurrentlyLoadedLevelType == LEVEL_Indoor )
|
|
|
1000 {
|
|
|
1001 outx = (pIndoor->pFaces[v4].pBounding.x1 + pIndoor->pFaces[v4].pBounding.x2) >> 1;
|
|
|
1002 outy = (pIndoor->pFaces[v4].pBounding.y1 + pIndoor->pFaces[v4].pBounding.y2) >> 1;
|
|
|
1003 outz = (pIndoor->pFaces[v4].pBounding.z1 + pIndoor->pFaces[v4].pBounding.z2) >> 1;
|
|
|
1004 }
|
|
|
1005 break;
|
|
|
1006 }
|
|
|
1007 }
|
|
|
1008
|
|
|
1009 switch( PID_TYPE(uObj2ID) )
|
|
|
1010 {
|
|
|
1011 case OBJECT_Item:
|
|
|
1012 {
|
|
|
1013 outx2 = (float)pSpriteObjects[v5].vPosition.x;
|
|
|
1014 outy2 =(float) pSpriteObjects[v5].vPosition.y;
|
|
|
1015 a4 = pSpriteObjects[v5].vPosition.z;
|
|
|
1016 break;
|
|
|
1017 }
|
|
|
1018 case OBJECT_Actor:
|
|
|
1019 {
|
|
|
1020 outx2 = (float)pActors[v5].vPosition.x;
|
|
|
1021 outy2 = (float)pActors[v5].vPosition.y;
|
|
|
1022 a4 = pActors[v5].vPosition.z - (unsigned int)(signed __int64)((double)pActors[v5].uActorHeight * -0.75);
|
|
|
1023 break;
|
|
|
1024 }
|
|
|
1025 case OBJECT_Player:
|
|
|
1026 {
|
|
|
1027 outx2 = (float)pParty->vPosition.x;
|
|
|
1028 outy2 = (float)pParty->vPosition.y;
|
|
|
1029 if ( !a4 )
|
|
|
1030 a4 = pParty->sEyelevel;
|
|
|
1031 a4 = pParty->vPosition.z + a4;
|
|
|
1032 break;
|
|
|
1033 }
|
|
|
1034 case OBJECT_Decoration:
|
|
|
1035 {
|
|
|
1036 outx2 = (float)pLevelDecorations[v5].vPosition.x;
|
|
|
1037 outy2 = (float)pLevelDecorations[v5].vPosition.y;
|
|
|
1038 a4 = pLevelDecorations[v5].vPosition.z;
|
|
|
1039 break;
|
|
|
1040 }
|
|
|
1041 default:
|
|
|
1042 {
|
|
|
1043 outx2 = 0.0;
|
|
|
1044 outy2 = 0.0;
|
|
|
1045 a4 = 0;
|
|
|
1046 break;
|
|
|
1047 }
|
|
|
1048 case OBJECT_BModel:
|
|
|
1049 {
|
|
|
1050 if ( uCurrentlyLoadedLevelType == LEVEL_Indoor )
|
|
|
1051 {
|
|
|
1052 outx2 = (float)((pIndoor->pFaces[v5].pBounding.x1 + pIndoor->pFaces[v5].pBounding.x2) >> 1);
|
|
|
1053 outy2 = (float)((pIndoor->pFaces[v5].pBounding.y1 + pIndoor->pFaces[v5].pBounding.y2) >> 1);
|
|
|
1054 a4 = (pIndoor->pFaces[v5].pBounding.z1 + pIndoor->pFaces[v5].pBounding.z2) >> 1;
|
|
|
1055 }
|
|
|
1056 break;
|
|
|
1057 }
|
|
|
1058 }
|
|
|
1059
|
|
|
1060 v31 = (float)outx2 - (float)outx;
|
|
|
1061 v32 = (float)outy2 - (float)outy;
|
|
|
1062 a4a = (float)a4 - (float)outz;
|
|
|
1063 outx2 = v32 * v32;
|
|
|
1064 outy2 = v31 * v31;
|
|
|
1065 v33 = sqrt(a4a * a4a + outy2 + outx2);
|
|
|
1066 if ( v33 <= 1.0 )
|
|
|
1067 {
|
|
|
1068 pOut->vDirection.x = 65536;
|
|
|
1069 pOut->vDirection.y = 0;
|
|
|
1070 pOut->vDirection.z = 0;
|
|
|
1071 pOut->uDistance = 1;
|
|
|
1072 pOut->uDistanceXZ = 1;
|
|
|
1073 pOut->uYawAngle = 0;
|
|
|
1074 pOut->uPitchAngle = 0;
|
|
|
1075 }
|
|
|
1076 else
|
|
|
1077 {
|
|
|
1078 pOut->vDirection.x = (int32_t)(1.0 / v33 * v31 * 65536.0);
|
|
|
1079 pOut->vDirection.y = (int32_t)(1.0 / v33 * v32 * 65536.0);
|
|
|
1080 pOut->vDirection.z = (int32_t)(1.0 / v33 * a4a * 65536.0);
|
|
|
1081 pOut->uDistance = (uint)v33;
|
|
|
1082 pOut->uDistanceXZ = (uint)sqrt(outy2 + outx2);
|
|
|
1083 pOut->uYawAngle = stru_5C6E00->Atan2((signed __int64)v31, (signed __int64)v32);
|
|
|
1084 pOut->uPitchAngle = stru_5C6E00->Atan2(pOut->uDistanceXZ, (signed __int64)a4a);
|
|
|
1085 }
|
|
|
1086 }
|
|
|
1087
|
|
|
1088 //----- (00404030) --------------------------------------------------------
|
|
|
1089 void Actor::AI_FaceObject(unsigned int uActorID, unsigned int uObjID, int _48, AIDirection *a4)
|
|
|
1090 {
|
|
|
1091 AIDirection *v7; // eax@3
|
|
|
1092 AIDirection v1; // eax@3
|
|
|
1093 AIDirection a3; // [sp+8h] [bp-38h]@4
|
|
|
1094
|
|
|
1095 if ( rand() % 100 >= 5 )
|
|
|
1096 {
|
|
|
1097 //v9 = &pActors[uActorID];
|
|
|
1098 if ( !a4 )
|
|
|
1099 {
|
|
|
1100 Actor::GetDirectionInfo(PID(OBJECT_Actor, uActorID), uObjID, &v1, 0);
|
|
|
1101 v7 = &v1;
|
|
|
1102 }
|
|
|
1103 else
|
|
|
1104 v7 = a4;
|
|
|
1105 pActors[uActorID].uYawAngle = v7->uYawAngle;
|
|
|
1106 pActors[uActorID].uCurrentActionTime = 0;
|
|
|
1107 pActors[uActorID].vVelocity.z = 0;
|
|
|
1108 pActors[uActorID].vVelocity.y = 0;
|
|
|
1109 pActors[uActorID].vVelocity.x = 0;
|
|
|
1110 pActors[uActorID].uPitchAngle = v7->uPitchAngle;
|
|
|
1111 pActors[uActorID].uCurrentActionLength = 256;
|
|
|
1112 pActors[uActorID].uAIState = Interacting;
|
|
|
1113 pActors[uActorID].UpdateAnimation();
|
|
|
1114 }
|
|
|
1115 else
|
|
|
1116 Actor::AI_Bored(uActorID, uObjID, a4);
|
|
|
1117 }
|
|
|
1118
|
|
|
1119 //----- (00403F58) --------------------------------------------------------
|
|
|
1120 void Actor::AI_StandOrBored(unsigned int uActorID, signed int uObjID, int uActionLength, AIDirection *a4)
|
|
|
1121 {
|
|
|
1122 if (rand() % 2)//0 or 1
|
|
|
1123 AI_Bored(uActorID, uObjID, a4);
|
|
|
1124 else
|
|
|
1125 AI_Stand(uActorID, uObjID, uActionLength, a4);
|
|
|
1126 }
|
|
|
1127
|
|
|
1128 //----- (00403EB6) --------------------------------------------------------
|
|
|
1129 void Actor::AI_Stand(unsigned int uActorID, unsigned int object_to_face_pid, unsigned int uActionLength, AIDirection *a4)
|
|
|
1130 {
|
|
|
1131 assert(uActorID < uNumActors);
|
|
|
1132 // Actor* actor = &pActors[uActorID];
|
|
|
1133
|
|
|
1134 AIDirection a3;
|
|
|
1135 if (!a4)
|
|
|
1136 {
|
|
|
1137 Actor::GetDirectionInfo(PID(OBJECT_Actor, uActorID), object_to_face_pid, &a3, 0);
|
|
|
1138 a4 = &a3;
|
|
|
1139 }
|
|
|
1140
|
|
|
1141 pActors[uActorID].uAIState = Standing;
|
|
|
1142 if (!uActionLength)
|
|
|
1143 pActors[uActorID].uCurrentActionLength = rand() % 256 + 256;// от 256 до 256 + 256
|
|
|
1144 else
|
|
|
1145 pActors[uActorID].uCurrentActionLength = uActionLength;
|
|
|
1146 pActors[uActorID].uCurrentActionTime = 0;
|
|
|
1147 pActors[uActorID].uYawAngle = a4->uYawAngle;
|
|
|
1148 pActors[uActorID].uPitchAngle = a4->uPitchAngle;
|
|
|
1149 pActors[uActorID].vVelocity.z = 0;
|
|
|
1150 pActors[uActorID].vVelocity.y = 0;
|
|
|
1151 pActors[uActorID].vVelocity.x = 0;
|
|
|
1152 pActors[uActorID].UpdateAnimation();
|
|
|
1153 }
|
|
|
1154
|
|
|
1155 //----- (00403E61) --------------------------------------------------------
|
|
|
1156 void __fastcall Actor::StandAwhile(unsigned int uActorID)
|
|
|
1157 {
|
|
|
1158 pActors[uActorID].uCurrentActionLength = rand() % 128 + 128;
|
|
|
1159 pActors[uActorID].uCurrentActionTime = 0;
|
|
|
1160 pActors[uActorID].uAIState = Standing;
|
|
|
1161 pActors[uActorID].vVelocity.z = 0;
|
|
|
1162 pActors[uActorID].vVelocity.y = 0;
|
|
|
1163 pActors[uActorID].vVelocity.x = 0;
|
|
|
1164 pActors[uActorID].UpdateAnimation();
|
|
|
1165 }
|
|
|
1166
|
|
|
1167 //----- (00403C6C) --------------------------------------------------------
|
|
|
1168 void Actor::AI_MeleeAttack(unsigned int uActorID, signed int sTargetPid, struct AIDirection *arg0)
|
|
|
1169 {
|
|
|
1170 int16_t v6; // esi@6
|
|
|
1171 int16_t v7; // edi@6
|
|
|
1172 signed int v8; // eax@7
|
|
|
1173 Vec3_int_ v10; // ST04_12@9
|
|
|
1174 AIDirection *v12; // eax@11
|
|
|
1175 AIDirection a3; // [sp+Ch] [bp-48h]@12
|
|
|
1176 AIDirection v20; // [sp+28h] [bp-2Ch]@12
|
|
|
1177 int v23; // [sp+4Ch] [bp-8h]@6
|
|
|
1178 unsigned int v25; // [sp+5Ch] [bp+8h]@13
|
|
|
1179
|
|
|
1180 assert(uActorID < uNumActors);
|
|
|
1181
|
|
|
1182 if ( pActors[uActorID].pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_STAIONARY && pActors[uActorID].pMonsterInfo.uAIType == 1 )
|
|
|
1183 {
|
|
|
1184 Actor::AI_Stand(uActorID, sTargetPid, 0, arg0);
|
|
|
1185 return;
|
|
|
1186 }
|
|
|
1187
|
|
|
1188 if ( PID_TYPE(sTargetPid) == OBJECT_Actor)
|
|
|
1189 {
|
|
|
1190 v8 = PID_ID(sTargetPid);
|
|
|
1191 v6 = pActors[v8].vPosition.x;
|
|
|
1192 v7 = pActors[v8].vPosition.y;
|
|
|
1193 v23 = (int)(pActors[v8].uActorHeight * 0.75 + pActors[v8].vPosition.z);
|
|
|
1194 }
|
|
|
1195 else if ( PID_TYPE(sTargetPid) == OBJECT_Player)
|
|
|
1196 {
|
|
|
1197 v6 = pParty->vPosition.x;
|
|
|
1198 v7 = pParty->vPosition.y;
|
|
|
1199 v23 = pParty->vPosition.z + pParty->sEyelevel;
|
|
|
1200 }
|
|
|
1201 else
|
|
|
1202 {
|
|
|
1203 Error("Should not get here");
|
|
|
1204 return;
|
|
|
1205 }
|
|
|
1206
|
|
|
1207 v10.x = pActors[uActorID].vPosition.x;
|
|
|
1208 v10.y = pActors[uActorID].vPosition.y;
|
|
|
1209 v10.z = (int32_t)(pActors[uActorID].uActorHeight * 0.75 + pActors[uActorID].vPosition.z);
|
|
|
1210
|
|
|
1211 if ( sub_407A1C((int)v6, (int)v7, v23, v10) )
|
|
|
1212 {
|
|
|
1213 if (arg0 != nullptr)
|
|
|
1214 v12 = arg0;
|
|
|
1215 else
|
|
|
1216 {
|
|
|
1217 Actor::GetDirectionInfo(PID(OBJECT_Actor, uActorID), sTargetPid, &a3, 0);
|
|
|
1218 v12 = &a3;
|
|
|
1219 }
|
|
|
1220 pActors[uActorID].uYawAngle = LOWORD(v12->uYawAngle);
|
|
|
1221 pActors[uActorID].uCurrentActionLength = pSpriteFrameTable->pSpriteSFrames[pActors[uActorID].pSpriteIDs[ANIM_AtkMelee]].uAnimLength * 8;
|
|
|
1222 pActors[uActorID].uCurrentActionTime = 0;
|
|
|
1223 pActors[uActorID].uAIState = AttackingMelee;
|
|
|
1224 Actor::PlaySound(uActorID, 0);
|
|
|
1225 v25 = pMonsterStats->pInfos[pActors[uActorID].pMonsterInfo.uID].uRecoveryTime;
|
|
|
1226 if ( pActors[uActorID].pActorBuffs[ACTOR_BUFF_SLOWED].uExpireTime > 0 )
|
|
|
1227 v25 *= 2;
|
|
|
1228 if ( pParty->bTurnBasedModeOn != 1 )
|
|
|
1229 pActors[uActorID].pMonsterInfo.uRecoveryTime = (int)(flt_6BE3A8_debug_recmod2 * v25 * 2.133333333333333);
|
|
|
1230 else
|
|
|
1231 pActors[uActorID].pMonsterInfo.uRecoveryTime = v25;
|
|
|
1232 pActors[uActorID].vVelocity.z = 0;
|
|
|
1233 pActors[uActorID].vVelocity.y = 0;
|
|
|
1234 pActors[uActorID].vVelocity.x = 0;
|
|
|
1235 pActors[uActorID].UpdateAnimation();
|
|
|
1236 }
|
|
|
1237 else
|
|
|
1238 Actor::AI_Pursue1(uActorID, sTargetPid, rand() % 2, 64, arg0);
|
|
|
1239 }
|
|
|
1240
|
|
|
1241 //----- (00438CF3) --------------------------------------------------------
|
|
|
1242 void Actor::ApplyFineForKillingPeasant(unsigned int uActorID)
|
|
|
1243 {
|
|
|
1244 if ( uLevelMapStatsID == 0 || !pActors[uActorID].IsPeasant())
|
|
|
1245 return;
|
|
|
1246
|
|
|
1247 if ( (uLevelMapStatsID == 6 || uLevelMapStatsID == 7) && pParty->IsPartyEvil()) //celeste and bracada
|
|
|
1248 return;
|
|
|
1249
|
|
|
1250 if ( (uLevelMapStatsID == 5 || uLevelMapStatsID == 8) && pParty->IsPartyGood()) // the pit and deyja
|
|
|
1251 return;
|
|
|
1252
|
|
|
1253 pParty->uFine += 100 * (pMapStats->pInfos[uLevelMapStatsID]._steal_perm + pActors[uActorID].pMonsterInfo.uLevel + pParty->GetPartyReputation());
|
|
|
1254 if ( pParty->uFine < 0 )
|
|
|
1255 pParty->uFine = 0;
|
|
|
1256 if ( pParty->uFine > 4000000 )
|
|
|
1257 pParty->uFine = 4000000;
|
|
|
1258
|
|
|
1259 if (uCurrentlyLoadedLevelType == LEVEL_Outdoor)
|
|
|
1260 {
|
|
|
1261 if (pOutdoor->ddm.uReputation < 10000)
|
|
|
1262 pOutdoor->ddm.uReputation++;
|
|
|
1263 }
|
|
|
1264 else if (uCurrentlyLoadedLevelType == LEVEL_Indoor)
|
|
|
1265 {
|
|
|
1266 if (pIndoor->dlv.uReputation < 10000)
|
|
|
1267 pIndoor->dlv.uReputation++;
|
|
|
1268 }
|
|
|
1269 else assert(false);
|
|
|
1270
|
|
|
1271 if ( pParty->uFine )
|
|
|
1272 {
|
|
|
1273 for ( int i = 1; i <= 4; i++)
|
|
|
1274 {
|
|
|
1275 if ( !_449B57_test_bit(pPlayers[i]->_achieved_awards_bits, 1) )
|
|
|
1276 _449B7E_toggle_bit(pPlayers[i]->_achieved_awards_bits, 1, 1u);
|
|
|
1277 }
|
|
|
1278 }
|
|
|
1279 }
|
|
|
1280
|
|
|
1281 //----- (0043AE80) --------------------------------------------------------
|
|
|
1282 void Actor::AddBloodsplatOnDamageOverlay(unsigned int uActorID, int a2, signed int a3)
|
|
|
1283 {
|
|
|
1284 unsigned int v4; // esi@1
|
|
|
1285
|
|
|
1286 v4 = PID(OBJECT_Actor,uActorID);
|
|
|
1287 switch ( a2 )
|
|
|
1288 {
|
|
|
1289 case 1:
|
|
|
1290 if ( a3 )
|
|
|
1291 pOtherOverlayList->_4418B6(904, v4, 0, (int)(sub_43AE12(a3) * 65536.0), 0);
|
|
|
1292 return;
|
|
|
1293 case 2:
|
|
|
1294 if ( a3 )
|
|
|
1295 pOtherOverlayList->_4418B6(905, v4, 0, (int)(sub_43AE12(a3) * 65536.0), 0);
|
|
|
1296 return;
|
|
|
1297 case 3:
|
|
|
1298 if ( a3 )
|
|
|
1299 pOtherOverlayList->_4418B6(906, v4, 0, (int)(sub_43AE12(a3) * 65536.0), 0);
|
|
|
1300 return;
|
|
|
1301 case 4:
|
|
|
1302 if ( a3 )
|
|
|
1303 pOtherOverlayList->_4418B6(907, v4, 0, (int)(sub_43AE12(a3) * 65536.0), 0);
|
|
|
1304 return;
|
|
|
1305 case 5:
|
|
|
1306 pOtherOverlayList->_4418B6(901, v4, 0, PID(OBJECT_Actor,uActorID), 0);
|
|
|
1307 return;
|
|
|
1308 case 6:
|
|
|
1309 pOtherOverlayList->_4418B6(902, v4, 0, PID(OBJECT_Actor,uActorID), 0);
|
|
|
1310 return;
|
|
|
1311 case 7:
|
|
|
1312 pOtherOverlayList->_4418B6(903, v4, 0, PID(OBJECT_Actor,uActorID), 0);
|
|
|
1313 return;
|
|
|
1314 case 8:
|
|
|
1315 pOtherOverlayList->_4418B6(900, v4, 0, PID(OBJECT_Actor,uActorID), 0);
|
|
|
1316 return;
|
|
|
1317 case 9:
|
|
|
1318 pOtherOverlayList->_4418B6(909, v4, 0, PID(OBJECT_Actor,uActorID), 0);
|
|
|
1319 return;
|
|
|
1320 case 10:
|
|
|
1321 pOtherOverlayList->_4418B6(908, v4, 0, PID(OBJECT_Actor,uActorID), 0);
|
|
|
1322 return;
|
|
|
1323 default:
|
|
|
1324 return;
|
|
|
1325 }
|
|
|
1326 return;
|
|
|
1327 }
|
|
|
1328
|
|
|
1329 //----- (0043B3E0) --------------------------------------------------------
|
|
|
1330 int Actor::_43B3E0_CalcDamage( signed int dmgSource )
|
|
|
1331 {
|
|
|
1332 signed int v2; // ebp@1
|
|
|
1333 int v3; // eax@9
|
|
|
1334 signed int v4; // edi@9
|
|
|
1335 int v5; // esi@9
|
|
|
1336 unsigned __int16 v8; // si@21
|
|
|
1337 int v9; // edi@21
|
|
|
1338 signed int v10; // eax@23
|
|
|
1339 int v11; // [sp+10h] [bp-4h]@1
|
|
|
1340
|
|
|
1341 v2 = 0;
|
|
|
1342 v11 = 0;
|
|
|
1343
|
|
|
1344 switch( dmgSource )
|
|
|
1345 {
|
|
|
1346 case 0:
|
|
|
1347 if ( this->pActorBuffs[ACTOR_BUFF_HOUR_OF_POWER].uExpireTime > 0 )
|
|
|
1348 v2 = this->pActorBuffs[ACTOR_BUFF_HOUR_OF_POWER].uPower;
|
|
|
1349 if ( this->pActorBuffs[ACTOR_BUFF_HEROISM].uExpireTime > 0 && this->pActorBuffs[ACTOR_BUFF_HEROISM].uPower > v2 )
|
|
|
1350 v2 = this->pActorBuffs[ACTOR_BUFF_HEROISM].uPower;
|
|
|
1351 if ( this->pActorBuffs[ACTOR_BUFF_PAIN_HAMMERHANDS].uExpireTime > 0 )
|
|
|
1352 v2 += this->pActorBuffs[ACTOR_BUFF_PAIN_HAMMERHANDS].uPower;
|
|
|
1353 v3 = this->pMonsterInfo.uAttack1DamageDiceRolls;
|
|
|
1354 v4 = this->pMonsterInfo.uAttack1DamageDiceSides;
|
|
|
1355 v5 = this->pMonsterInfo.uAttack1DamageBonus;
|
|
|
1356 break;
|
|
|
1357 case 1:
|
|
|
1358 v3 = this->pMonsterInfo.uAttack2DamageDiceRolls;
|
|
|
1359 v4 = this->pMonsterInfo.uAttack2DamageDiceSides;
|
|
|
1360 v5 = this->pMonsterInfo.uAttack2DamageBonus;
|
|
|
1361 break;
|
|
|
1362 case 2:
|
|
|
1363 v8 = this->pMonsterInfo.uSpellSkillAndMastery1;
|
|
|
1364 v9 = this->pMonsterInfo.uSpell1ID;
|
|
|
1365 v10 = SkillToMastery(v8);
|
|
|
1366 return _43AFE3_calc_spell_damage(v9, v8 & 0x3F, v10, 0);
|
|
|
1367 break;
|
|
|
1368 case 3:
|
|
|
1369 v8 = this->pMonsterInfo.uSpellSkillAndMastery2;
|
|
|
1370 v9 = this->pMonsterInfo.uSpell2ID;
|
|
|
1371 v10 = SkillToMastery(v8);
|
|
|
1372 return _43AFE3_calc_spell_damage(v9, v8 & 0x3F, v10, 0);
|
|
|
1373 break;
|
|
|
1374 case 4:
|
|
|
1375 v3 = this->pMonsterInfo.uSpecialAbilityDamageDiceRolls;
|
|
|
1376 v4 = this->pMonsterInfo.uSpecialAbilityDamageDiceSides;
|
|
|
1377 v5 = this->pMonsterInfo.uSpecialAbilityDamageDiceBonus;
|
|
|
1378 default:
|
|
|
1379 return 0;
|
|
|
1380 }
|
|
|
1381 for ( int i = 0; i < v3; i++)
|
|
|
1382 v11 += rand() % v4 + 1;
|
|
|
1383 return v11 + v5 + v2;
|
|
|
1384 }
|
|
|
1385
|
|
|
1386 //----- (00438B9B) --------------------------------------------------------
|
|
|
1387 bool Actor::IsPeasant()
|
|
|
1388 {
|
|
|
1389 unsigned int InHostile_Id; // eax@1
|
|
|
1390
|
|
|
1391 InHostile_Id = this->uAlly;
|
|
|
1392 if ( !this->uAlly )
|
|
|
1393 InHostile_Id = (this->pMonsterInfo.uID - 1) / 3 + 1;
|
|
|
1394 return (signed int)InHostile_Id >= 39 && (signed int)InHostile_Id <= 44//Dwarfs peasants
|
|
|
1395 || (signed int)InHostile_Id >= 45 && (signed int)InHostile_Id <= 50//Elves peasants
|
|
|
1396 || (signed int)InHostile_Id >= 51 && (signed int)InHostile_Id <= 62//Humans peasants
|
|
|
1397 || (signed int)InHostile_Id >= 78 && (signed int)InHostile_Id <= 83;//Goblins peasants
|
|
|
1398 }
|
|
|
1399
|
|
|
1400 //----- (0042EBEE) --------------------------------------------------------
|
|
|
1401 void Actor::StealFrom( unsigned int uActorID )
|
|
|
1402 {
|
|
|
1403 Player *pPlayer; // edi@1
|
|
|
1404 int v4; // ebx@2
|
|
|
1405 unsigned int v5; // eax@2
|
|
|
1406 DDM_DLV_Header *v6; // esi@4
|
|
|
1407 int v8; // [sp+8h] [bp-4h]@6
|
|
|
1408
|
|
|
1409 pPlayer = &pParty->pPlayers[uActiveCharacter-1];
|
|
|
1410 if ( pPlayer->CanAct() )
|
|
|
1411 {
|
|
|
1412 CastSpellInfoHelpers::_427D48();
|
|
|
1413 v4 = 0;
|
|
|
1414 v5 = pMapStats->GetMapInfo(pCurrentMapName);
|
|
|
1415 if ( v5 )
|
|
|
1416 v4 = pMapStats->pInfos[v5]._steal_perm;
|
|
|
1417 v6 = &pOutdoor->ddm;
|
|
|
1418 if ( uCurrentlyLoadedLevelType != LEVEL_Outdoor)
|
|
|
1419 v6 = &pIndoor->dlv;
|
|
|
1420 pPlayer->StealFromActor(uActorID, v4, v6->uReputation++);
|
|
|
1421 v8 = pPlayer->GetAttackRecoveryTime(0);
|
|
|
1422 if ( v8 < 30 )
|
|
|
1423 v8 = 30;
|
|
|
1424 if ( !pParty->bTurnBasedModeOn )
|
|
|
1425 pPlayer->SetRecoveryTime((int)(flt_6BE3A4_debug_recmod1 * v8 * 2.133333333333333));
|
|
|
1426 pTurnEngine->ApplyPlayerAction();
|
|
|
1427 }
|
|
|
1428 return;
|
|
|
1429 }
|
|
|
1430
|
|
|
1431 //----- (00403A60) --------------------------------------------------------
|
|
|
1432 void Actor::AI_SpellAttack2(unsigned int uActorID, signed int edx0, AIDirection *pDir)
|
|
|
1433 {
|
|
|
1434 Actor *v3; // ebx@1
|
|
|
1435 int16_t v4; // esi@3
|
|
|
1436 int16_t v5; // edi@3
|
|
|
1437 signed int v6; // eax@4
|
|
|
1438 Vec3_int_ v7; // ST04_12@6
|
|
|
1439 AIDirection *v9; // eax@8
|
|
|
1440 __int16 v13; // ax@10
|
|
|
1441 AIDirection a3; // [sp+Ch] [bp-48h]@9
|
|
|
1442 AIDirection v18; // [sp+28h] [bp-2Ch]@9
|
|
|
1443 int v19; // [sp+44h] [bp-10h]@6
|
|
|
1444 signed int a2; // [sp+48h] [bp-Ch]@1
|
|
|
1445 int v21; // [sp+4Ch] [bp-8h]@3
|
|
|
1446 unsigned int pDira; // [sp+5Ch] [bp+8h]@10
|
|
|
1447
|
|
|
1448 v3 = &pActors[uActorID];
|
|
|
1449 a2 = edx0;
|
|
|
1450 if ( PID_TYPE(edx0) == OBJECT_Actor)
|
|
|
1451 {
|
|
|
1452 v6 = PID_ID(edx0);
|
|
|
1453 v4 = pActors[v6].vPosition.x;
|
|
|
1454 v5 = pActors[v6].vPosition.y;
|
|
|
1455 v21 = (int)(pActors[v6].uActorHeight * 0.75 + pActors[v6].vPosition.z);
|
|
|
1456 }
|
|
|
1457 else if ( PID_TYPE(edx0) == OBJECT_Player)
|
|
|
1458 {
|
|
|
1459 v4 = pParty->vPosition.x;
|
|
|
1460 v5 = pParty->vPosition.y;
|
|
|
1461 v21 = pParty->vPosition.z + pParty->sEyelevel;
|
|
|
1462 }
|
|
|
1463 else
|
|
|
1464 {
|
|
|
1465 Error("Should not get here");
|
|
|
1466 return;
|
|
|
1467 }
|
|
|
1468 v19 = v3->uActorHeight;
|
|
|
1469 v7.z = v3->vPosition.z - (int)(v19 * -0.75);
|
|
|
1470 v7.y = v3->vPosition.y;
|
|
|
1471 v7.x = v3->vPosition.x;
|
|
|
1472 if ( sub_407A1C(v4, v5, v21, v7) )
|
|
|
1473 {
|
|
|
1474 if ( pDir == nullptr)
|
|
|
1475 {
|
|
|
1476 Actor::GetDirectionInfo(PID(OBJECT_Actor,uActorID), a2, &a3, 0);
|
|
|
1477 v9 = &a3;
|
|
|
1478 }
|
|
|
1479 else
|
|
|
1480 v9 = pDir;
|
|
|
1481 v3->uYawAngle = LOWORD(v9->uYawAngle);
|
|
|
1482 v13 = pSpriteFrameTable->pSpriteSFrames[v3->pSpriteIDs[ANIM_AtkRanged]].uAnimLength;
|
|
|
1483 v3->uCurrentActionLength = 8 * v13;
|
|
|
1484 v3->uCurrentActionTime = 0;
|
|
|
1485 v3->uAIState = AttackingRanged4;
|
|
|
1486 Actor::PlaySound(uActorID, 0);
|
|
|
1487 pDira = pMonsterStats->pInfos[v3->pMonsterInfo.uID].uRecoveryTime;
|
|
|
1488 if (v3->pActorBuffs[ACTOR_BUFF_SLOWED].uExpireTime > 0)
|
|
|
1489 pDira *= 2;
|
|
|
1490 if ( pParty->bTurnBasedModeOn == 1 )
|
|
|
1491 v3->pMonsterInfo.uRecoveryTime = pDira;
|
|
|
1492 else
|
|
|
1493 v3->pMonsterInfo.uRecoveryTime = v3->uCurrentActionLength + (int)(flt_6BE3A8_debug_recmod2 * pDira * 2.133333333333333);
|
|
|
1494 v3->vVelocity.z = 0;
|
|
|
1495 v3->vVelocity.y = 0;
|
|
|
1496 v3->vVelocity.x = 0;
|
|
|
1497 if ( ShouldMonsterPlayAttackAnim(v3->pMonsterInfo.uSpell2ID) )
|
|
|
1498 {
|
|
|
1499 v3->uCurrentActionLength = 64;
|
|
|
1500 v3->uCurrentActionTime = 0;
|
|
|
1501 v3->uAIState = Fidgeting;
|
|
|
1502 v3->UpdateAnimation();
|
|
|
1503 v3->uAIState = AttackingRanged4;
|
|
|
1504 }
|
|
|
1505 else
|
|
|
1506 v3->UpdateAnimation();
|
|
|
1507 }
|
|
|
1508 else
|
|
|
1509 Actor::AI_Pursue1(uActorID, a2, uActorID, 64, pDir);
|
|
|
1510 }
|
|
|
1511
|
|
|
1512 //----- (00403854) --------------------------------------------------------
|
|
|
1513 void Actor::AI_SpellAttack1(unsigned int uActorID, signed int sTargetPid, AIDirection *pDir)
|
|
|
1514 {
|
|
|
1515 Actor *v3; // ebx@1
|
|
|
1516 int16_t v4; // esi@3
|
|
|
1517 int16_t v5; // edi@3
|
|
|
1518 signed int v6; // eax@4
|
|
|
1519 Vec3_int_ v7; // ST04_12@6
|
|
|
1520 AIDirection *v9; // eax@8
|
|
|
1521 __int16 v13; // ax@10
|
|
|
1522 signed int v16; // ecx@17
|
|
|
1523 AIDirection a3; // [sp+Ch] [bp-48h]@9
|
|
|
1524 AIDirection v18; // [sp+28h] [bp-2Ch]@9
|
|
|
1525 int v19; // [sp+44h] [bp-10h]@6
|
|
|
1526 int v21; // [sp+4Ch] [bp-8h]@3
|
|
|
1527 unsigned int pDira; // [sp+5Ch] [bp+8h]@10
|
|
|
1528
|
|
|
1529 v3 = &pActors[uActorID];
|
|
|
1530 if ( PID_TYPE(sTargetPid) == OBJECT_Actor)
|
|
|
1531 {
|
|
|
1532 v6 = PID_ID(sTargetPid);
|
|
|
1533 v4 = pActors[v6].vPosition.x;
|
|
|
1534 v5 = pActors[v6].vPosition.y;
|
|
|
1535 v21 = (int)(pActors[v6].uActorHeight * 0.75 + pActors[v6].vPosition.z);
|
|
|
1536 }
|
|
|
1537 else if ( PID_TYPE(sTargetPid) == OBJECT_Player)
|
|
|
1538 {
|
|
|
1539 v4 = pParty->vPosition.x;
|
|
|
1540 v5 = pParty->vPosition.y;
|
|
|
1541 v21 = pParty->vPosition.z + pParty->sEyelevel;
|
|
|
1542 }
|
|
|
1543 else
|
|
|
1544 {
|
|
|
1545 Error("Should not get here");
|
|
|
1546 return;
|
|
|
1547 }
|
|
|
1548 v19 = v3->uActorHeight;
|
|
|
1549 v7.z = v3->vPosition.z - (int)(v19 * -0.75);
|
|
|
1550 v7.y = v3->vPosition.y;
|
|
|
1551 v7.x = v3->vPosition.x;
|
|
|
1552 if ( sub_407A1C(v4, v5, v21, v7) )
|
|
|
1553 {
|
|
|
1554 if ( pDir == nullptr )
|
|
|
1555 {
|
|
|
1556 Actor::GetDirectionInfo(PID(OBJECT_Actor,uActorID), sTargetPid, &a3, 0);
|
|
|
1557 v9 = &a3;
|
|
|
1558 }
|
|
|
1559 else
|
|
|
1560 v9 = pDir;
|
|
|
1561 v3->uYawAngle = LOWORD(v9->uYawAngle);
|
|
|
1562 v13 = pSpriteFrameTable->pSpriteSFrames[v3->pSpriteIDs[ANIM_AtkRanged]].uAnimLength;
|
|
|
1563 v3->uCurrentActionLength = 8 * v13;
|
|
|
1564 v3->uCurrentActionTime = 0;
|
|
|
1565 v3->uAIState = AttackingRanged3;
|
|
|
1566 Actor::PlaySound(uActorID, 0);
|
|
|
1567 pDira = pMonsterStats->pInfos[v3->pMonsterInfo.uID].uRecoveryTime;
|
|
|
1568 if (v3->pActorBuffs[ACTOR_BUFF_SLOWED].uExpireTime > 0)
|
|
|
1569 pDira *= 2;
|
|
|
1570 if ( pParty->bTurnBasedModeOn == 1 )
|
|
|
1571 v3->pMonsterInfo.uRecoveryTime = pDira;
|
|
|
1572 else
|
|
|
1573 v3->pMonsterInfo.uRecoveryTime = v3->uCurrentActionLength + (int)(flt_6BE3A8_debug_recmod2 * pDira * 2.133333333333333);
|
|
|
1574 v16 = v3->pMonsterInfo.uSpell1ID;
|
|
|
1575 v3->vVelocity.z = 0;
|
|
|
1576 v3->vVelocity.y = 0;
|
|
|
1577 v3->vVelocity.x = 0;
|
|
|
1578 if ( ShouldMonsterPlayAttackAnim(v3->pMonsterInfo.uSpell1ID) )
|
|
|
1579 {
|
|
|
1580 v3->uCurrentActionLength = 64;
|
|
|
1581 v3->uCurrentActionTime = 0;
|
|
|
1582 v3->uAIState = Fidgeting;
|
|
|
1583 v3->UpdateAnimation();
|
|
|
1584 v3->uAIState = AttackingRanged3;
|
|
|
1585 }
|
|
|
1586 else
|
|
|
1587 v3->UpdateAnimation();
|
|
|
1588 }
|
|
|
1589 else
|
|
|
1590 Actor::AI_Pursue1(uActorID, sTargetPid, uActorID, 64, pDir);
|
|
|
1591 }
|
|
|
1592
|
|
|
1593 //----- (0040368B) --------------------------------------------------------
|
|
|
1594 void Actor::AI_MissileAttack2(unsigned int uActorID, signed int sTargetPid, AIDirection *pDir)
|
|
|
1595 {
|
|
|
1596 Actor *v3; // ebx@1
|
|
|
1597 int16_t v4; // esi@3
|
|
|
1598 int16_t v5; // edi@3
|
|
|
1599 signed int v6; // eax@4
|
|
|
1600 Vec3_int_ v7; // ST04_12@6
|
|
|
1601 AIDirection *v9; // eax@8
|
|
|
1602 __int16 v13; // ax@10
|
|
|
1603 AIDirection a3; // [sp+Ch] [bp-48h]@9
|
|
|
1604 AIDirection v17; // [sp+28h] [bp-2Ch]@9
|
|
|
1605 int v18; // [sp+44h] [bp-10h]@6
|
|
|
1606 int v20; // [sp+4Ch] [bp-8h]@3
|
|
|
1607 unsigned int pDira; // [sp+5Ch] [bp+8h]@10
|
|
|
1608
|
|
|
1609 v3 = &pActors[uActorID];
|
|
|
1610 if ( PID_TYPE(sTargetPid) == OBJECT_Actor)
|
|
|
1611 {
|
|
|
1612 v6 = PID_ID(sTargetPid);
|
|
|
1613 v4 = pActors[v6].vPosition.x;
|
|
|
1614 v5 = pActors[v6].vPosition.y;
|
|
|
1615 v20 = (int)(pActors[v6].uActorHeight * 0.75 + pActors[v6].vPosition.z);
|
|
|
1616 }
|
|
|
1617 else if ( PID_TYPE(sTargetPid) == OBJECT_Player)
|
|
|
1618 {
|
|
|
1619 v4 = pParty->vPosition.x;
|
|
|
1620 v5 = pParty->vPosition.y;
|
|
|
1621 v20 = pParty->vPosition.z + pParty->sEyelevel;
|
|
|
1622 }
|
|
|
1623 else
|
|
|
1624 {
|
|
|
1625 Error("Should not get here");
|
|
|
1626 return;
|
|
|
1627 }
|
|
|
1628 v18 = v3->uActorHeight;
|
|
|
1629 v7.z = v3->vPosition.z - (int)(v18 * -0.75);
|
|
|
1630 v7.y = v3->vPosition.y;
|
|
|
1631 v7.x = v3->vPosition.x;
|
|
|
1632 if ( sub_407A1C(v4, v5, v20, v7) )
|
|
|
1633 {
|
|
|
1634 if ( pDir == nullptr )
|
|
|
1635 {
|
|
|
1636 Actor::GetDirectionInfo(PID(OBJECT_Actor,uActorID), sTargetPid, &a3, 0);
|
|
|
1637 v9 = &a3;
|
|
|
1638 }
|
|
|
1639 else
|
|
|
1640 v9 = pDir;
|
|
|
1641 v3->uYawAngle = LOWORD(v9->uYawAngle);
|
|
|
1642 v13 = pSpriteFrameTable->pSpriteSFrames[v3->pSpriteIDs[ANIM_AtkRanged]].uAnimLength;
|
|
|
1643 v3->uCurrentActionLength = 8 * v13;
|
|
|
1644 v3->uCurrentActionTime = 0;
|
|
|
1645 v3->uAIState = AttackingRanged2;
|
|
|
1646 Actor::PlaySound(uActorID, 0);
|
|
|
1647 pDira = pMonsterStats->pInfos[v3->pMonsterInfo.uID].uRecoveryTime;
|
|
|
1648 if ( v3->pActorBuffs[ACTOR_BUFF_SLOWED].uExpireTime > 0 )
|
|
|
1649 pDira *= 2;
|
|
|
1650 if ( pParty->bTurnBasedModeOn != 1 )
|
|
|
1651 v3->pMonsterInfo.uRecoveryTime = (int)(flt_6BE3A8_debug_recmod2 * pDira * 2.133333333333333);
|
|
|
1652 else
|
|
|
1653 v3->pMonsterInfo.uRecoveryTime = pDira;
|
|
|
1654 v3->vVelocity.z = 0;
|
|
|
1655 v3->vVelocity.y = 0;
|
|
|
1656 v3->vVelocity.x = 0;
|
|
|
1657 v3->UpdateAnimation();
|
|
|
1658 }
|
|
|
1659 else
|
|
|
1660 Actor::AI_Pursue1(uActorID, sTargetPid, uActorID, 64, pDir);
|
|
|
1661 }
|
|
|
1662
|
|
|
1663 //----- (00403476) --------------------------------------------------------
|
|
|
1664 void Actor::AI_MissileAttack1(unsigned int uActorID, signed int sTargetPid, AIDirection *pDir)
|
|
|
1665 {
|
|
|
1666 Actor *v3; // ebx@1
|
|
|
1667 int v4; // esi@3
|
|
|
1668 int v5; // edi@3
|
|
|
1669 signed int v6; // eax@4
|
|
|
1670 Vec3_int_ v7; // ST04_12@6
|
|
|
1671 AIDirection *v10; // eax@9
|
|
|
1672 __int16 v14; // ax@11
|
|
|
1673 AIDirection a3; // [sp+Ch] [bp-48h]@10
|
|
|
1674 AIDirection v18; // [sp+28h] [bp-2Ch]@10
|
|
|
1675 int v19; // [sp+44h] [bp-10h]@6
|
|
|
1676 //signed int a2; // [sp+48h] [bp-Ch]@1
|
|
|
1677 int v22; // [sp+50h] [bp-4h]@3
|
|
|
1678 unsigned int pDira; // [sp+5Ch] [bp+8h]@11
|
|
|
1679
|
|
|
1680 v3 = &pActors[uActorID];
|
|
|
1681 //a2 = edx0;
|
|
|
1682 if ( PID_TYPE(sTargetPid) == OBJECT_Actor)
|
|
|
1683 {
|
|
|
1684 v6 = PID_ID(sTargetPid);
|
|
|
1685 v4 = pActors[v6].vPosition.x;
|
|
|
1686 v5 = pActors[v6].vPosition.y;
|
|
|
1687 v22 = (int)(pActors[v6].uActorHeight * 0.75 + pActors[v6].vPosition.z);
|
|
|
1688 }
|
|
|
1689 else
|
|
|
1690 {
|
|
|
1691 if ( PID_TYPE(sTargetPid) == OBJECT_Player)
|
|
|
1692 {
|
|
|
1693 v4 = pParty->vPosition.x;
|
|
|
1694 v5 = pParty->vPosition.y;
|
|
|
1695 v22 = pParty->vPosition.z + pParty->sEyelevel;
|
|
|
1696 }
|
|
|
1697 else
|
|
|
1698 {
|
|
|
1699 v4 = (int)pDir;
|
|
|
1700 v5 = (int)pDir;
|
|
|
1701 }
|
|
|
1702 }
|
|
|
1703 v19 = v3->uActorHeight;
|
|
|
1704 v7.z = v3->vPosition.z - (unsigned int)(signed __int64)((double)v19 * -0.75);
|
|
|
1705 v7.y = v3->vPosition.y;
|
|
|
1706 v7.x = v3->vPosition.x;
|
|
|
1707 if ( sub_407A1C(v4, v5, v22, v7) || sub_407A1C(v7.x, v7.y, v7.z, Vec3_int_(v4, v5, v22)))
|
|
|
1708 {
|
|
|
1709 if ( pDir == nullptr )
|
|
|
1710 {
|
|
|
1711 Actor::GetDirectionInfo(PID(OBJECT_Actor,uActorID), sTargetPid, &a3, 0);
|
|
|
1712 v10 = &a3;
|
|
|
1713 }
|
|
|
1714 else
|
|
|
1715 v10 = pDir;
|
|
|
1716 v3->uYawAngle = LOWORD(v10->uYawAngle);
|
|
|
1717 v14 = pSpriteFrameTable->pSpriteSFrames[v3->pSpriteIDs[ANIM_AtkRanged]].uAnimLength;
|
|
|
1718 v3->uCurrentActionLength = 8 * v14;
|
|
|
1719 v3->uCurrentActionTime = 0;
|
|
|
1720 v3->uAIState = AttackingRanged1;
|
|
|
1721 Actor::PlaySound(uActorID, 0);
|
|
|
1722 pDira = pMonsterStats->pInfos[v3->pMonsterInfo.uID].uRecoveryTime;
|
|
|
1723 if ( v3->pActorBuffs[ACTOR_BUFF_SLOWED].uExpireTime > 0 )
|
|
|
1724 pDira *= 2;
|
|
|
1725 if ( pParty->bTurnBasedModeOn == 1 )
|
|
|
1726 v3->pMonsterInfo.uRecoveryTime = pDira;
|
|
|
1727 else
|
|
|
1728 v3->pMonsterInfo.uRecoveryTime = v3->uCurrentActionLength - (int)(flt_6BE3A8_debug_recmod2 * pDira * -2.133333333333333);
|
|
|
1729 v3->vVelocity.z = 0;
|
|
|
1730 v3->vVelocity.y = 0;
|
|
|
1731 v3->vVelocity.x = 0;
|
|
|
1732 v3->UpdateAnimation();
|
|
|
1733 }
|
|
|
1734 else
|
|
|
1735 Actor::AI_Pursue1(uActorID, sTargetPid, uActorID, 64, pDir);
|
|
|
1736 }
|
|
|
1737
|
|
|
1738 //----- (004032B2) --------------------------------------------------------
|
|
|
1739 void Actor::AI_RandomMove( unsigned int uActor_id, unsigned int uTarget_id, int radius, int uActionLength )
|
|
|
1740 {
|
|
|
1741 int x; // ebx@1
|
|
|
1742 int absy; // eax@1
|
|
|
1743 unsigned int v9; // ebx@11
|
|
|
1744 int v10; // ebx@13
|
|
|
1745 AIDirection doNotInitializeBecauseShouldBeRandom; // [sp+Ch] [bp-30h]@7
|
|
|
1746 int y; // [sp+30h] [bp-Ch]@1
|
|
|
1747 int absx; // [sp+38h] [bp-4h]@1
|
|
|
1748
|
|
|
1749 x = pActors[uActor_id].vInitialPosition.x - pActors[uActor_id].vPosition.x;
|
|
|
1750 y = pActors[uActor_id].vInitialPosition.y - pActors[uActor_id].vPosition.y;
|
|
|
1751 absx = abs(x);
|
|
|
1752 absy = abs(y);
|
|
|
1753 if ( absx <= absy )
|
|
|
1754 absx = absy + (absx / 2 );
|
|
|
1755 else
|
|
|
1756 absx = absx + absy / 2;
|
|
|
1757 if ( MonsterStats::BelongsToSupertype(pActors[uActor_id].pMonsterInfo.uID, MONSTER_SUPERTYPE_TREANT) )
|
|
|
1758 {
|
|
|
1759 if ( !uActionLength )
|
|
|
1760 uActionLength = 256;
|
|
|
1761 Actor::AI_StandOrBored(uActor_id, OBJECT_Player, uActionLength, &doNotInitializeBecauseShouldBeRandom);
|
|
|
1762 return;
|
|
|
1763 }
|
|
|
1764 if ( pActors[uActor_id].pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_GLOBAL && absx < 128 )
|
|
|
1765 {
|
|
|
1766 Actor::AI_Stand(uActor_id, uTarget_id, 256, &doNotInitializeBecauseShouldBeRandom);
|
|
|
1767 return;
|
|
|
1768 }
|
|
|
1769 absx += ((rand() & 0xF) * radius) / 16;
|
|
|
1770 v9 = (stru_5C6E00->uIntegerDoublePi - 1) & stru_5C6E00->Atan2(x, y);
|
|
|
1771 if ( rand() % 100 < 25 )
|
|
|
1772 {
|
|
|
1773 Actor::StandAwhile(uActor_id);
|
|
|
1774 return;
|
|
|
1775 }
|
|
|
1776 v10 = v9 + rand() % 256 - 128;
|
|
|
1777 if ( abs(v10 - pActors[uActor_id].uYawAngle) > 256 && !(pActors[uActor_id].uAttributes & ACTOR_ANIMATION) )
|
|
|
1778 {
|
|
|
1779 Actor::AI_Stand(uActor_id, uTarget_id, 256, &doNotInitializeBecauseShouldBeRandom);
|
|
|
1780 return;
|
|
|
1781 }
|
|
|
1782 pActors[uActor_id].uYawAngle = v10;
|
|
|
1783 if ( pActors[uActor_id].uMovementSpeed)
|
|
|
1784 pActors[uActor_id].uCurrentActionLength = 32 * absx / pActors[uActor_id].uMovementSpeed;
|
|
|
1785 else
|
|
|
1786 pActors[uActor_id].uCurrentActionLength = 0;
|
|
|
1787 pActors[uActor_id].uCurrentActionTime = 0;
|
|
|
1788 pActors[uActor_id].uAIState = Tethered;
|
|
|
1789 if ( rand() % 100 < 2 )
|
|
|
1790 Actor::PlaySound(uActor_id, 3);
|
|
|
1791 pActors[uActor_id].UpdateAnimation();
|
|
|
1792 }
|
|
|
1793
|
|
|
1794 //----- (004031C1) --------------------------------------------------------
|
|
|
1795 char __fastcall Actor::_4031C1_update_job_never_gets_called(unsigned int uActorID, signed int a2, int a3) //attempted to implement something like jobs for actors, but apparently was never finished
|
|
|
1796 {
|
|
|
1797 return 0;
|
|
|
1798 /*unsigned int v3; // edi@1
|
|
|
1799 Actor *v4; // esi@1
|
|
|
1800 ActorJob *v5; // eax@1
|
|
|
1801 signed int v6; // edx@2
|
|
|
1802 ActorJob *v7; // eax@2
|
|
|
1803 signed int v8; // edi@2
|
|
|
1804 ActorJob *v9; // ecx@2
|
|
|
1805 __int16 v10; // cx@15
|
|
|
1806 signed int v12; // [sp+8h] [bp-4h]@1
|
|
|
1807
|
|
|
1808 v3 = uActorID;
|
|
|
1809 v12 = a2;
|
|
|
1810 v4 = &pActors[uActorID];
|
|
|
1811 v5 = (ActorJob *)pActors[uActorID].CanAct();
|
|
|
1812 if ( v5 )
|
|
|
1813 {
|
|
|
1814 v6 = 65535;
|
|
|
1815 v7 = &v4->pScheduledJobs[v3];
|
|
|
1816 v8 = 7;
|
|
|
1817 v9 = &v7[7];//(char *)&v7[7].uHour;
|
|
|
1818 while ( !(v9->uAttributes & 1) || v9->uHour > v12 )
|
|
|
1819 {
|
|
|
1820 --v8;
|
|
|
1821 --v9;
|
|
|
1822 if ( v8 < 0 )
|
|
|
1823 break;
|
|
|
1824 }
|
|
|
1825 if( v8 >= 0 )
|
|
|
1826 v6 = v8;
|
|
|
1827 if ( !v8 && v6 == 65535 )
|
|
|
1828 v6 = 7;
|
|
|
1829 v5 = &v7[v6];
|
|
|
1830 if ( v4->vInitialPosition.x != v5->vPos.x
|
|
|
1831 || v4->vInitialPosition.y != v5->vPos.y
|
|
|
1832 || v4->vInitialPosition.z != v5->vPos.z
|
|
|
1833 || v4->pMonsterInfo.uMovementType != v5->uAction )
|
|
|
1834 {
|
|
|
1835 v4->vInitialPosition.x = v5->vPos.x;
|
|
|
1836 v4->vInitialPosition.y = v5->vPos.y;
|
|
|
1837 v10 = v5->vPos.z;
|
|
|
1838 v4->vInitialPosition.z = v10;
|
|
|
1839 LOBYTE(v5) = v5->uAction;
|
|
|
1840 v4->pMonsterInfo.uMovementType = MONSTER_MOVEMENT_TYPE_STAIONARY;
|
|
|
1841 if ( a3 == 1 )
|
|
|
1842 {
|
|
|
1843 v4->vPosition.x = v4->vInitialPosition.x;
|
|
|
1844 v4->vPosition.y = v4->vInitialPosition.y;
|
|
|
1845 LOBYTE(v5) = v10;
|
|
|
1846 v4->vPosition.z = v10;
|
|
|
1847 }
|
|
|
1848 }
|
|
|
1849 }
|
|
|
1850 return (char)v5;*/
|
|
|
1851 }
|
|
|
1852
|
|
|
1853 //----- (004030AD) --------------------------------------------------------
|
|
|
1854 void Actor::AI_Stun(unsigned int uActorID, signed int edx0, int stunRegardlessOfState)
|
|
|
1855 {
|
|
|
1856 __int16 v7; // ax@16
|
|
|
1857 AIDirection a3; // [sp+Ch] [bp-40h]@16
|
|
|
1858
|
|
|
1859 if ( pActors[uActorID].uAIState == Fleeing )
|
|
|
1860 pActors[uActorID].uAttributes |= ACTOR_FLEEING;
|
|
|
1861 if ( pActors[uActorID].pMonsterInfo.uHostilityType != 4 )
|
|
|
1862 {
|
|
|
1863 pActors[uActorID].uAttributes &= 0xFFFFFFFB;//~0x4
|
|
|
1864 pActors[uActorID].pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
|
|
|
1865 }
|
|
|
1866 if ( pActors[uActorID].pActorBuffs[ACTOR_BUFF_CHARM].uExpireTime > 0 )
|
|
|
1867 pActors[uActorID].pActorBuffs[ACTOR_BUFF_CHARM].Reset();
|
|
|
1868 if ( pActors[uActorID].pActorBuffs[ACTOR_BUFF_AFRAID].uExpireTime > 0 )
|
|
|
1869 pActors[uActorID].pActorBuffs[ACTOR_BUFF_AFRAID].Reset();
|
|
|
1870 if ( stunRegardlessOfState || (pActors[uActorID].uAIState != Stunned
|
|
|
1871 && pActors[uActorID].uAIState != AttackingRanged1
|
|
|
1872 && pActors[uActorID].uAIState != AttackingRanged2
|
|
|
1873 && pActors[uActorID].uAIState != AttackingRanged3
|
|
|
1874 && pActors[uActorID].uAIState != AttackingRanged4
|
|
|
1875 && pActors[uActorID].uAIState != AttackingMelee))
|
|
|
1876 {
|
|
|
1877 Actor::GetDirectionInfo(PID(OBJECT_Actor,uActorID), edx0, &a3, 0);
|
|
|
1878 //v10 = &a3;
|
|
|
1879 pActors[uActorID].uYawAngle = LOWORD(a3.uYawAngle);
|
|
|
1880 v7 = pSpriteFrameTable->pSpriteSFrames[pActors[uActorID].pSpriteIDs[ANIM_GotHit]].uAnimLength;
|
|
|
1881 pActors[uActorID].uCurrentActionTime = 0;
|
|
|
1882 pActors[uActorID].uAIState = Stunned;
|
|
|
1883 pActors[uActorID].uCurrentActionLength = 8 * v7;
|
|
|
1884 Actor::PlaySound(uActorID, 2);
|
|
|
1885 pActors[uActorID].UpdateAnimation();
|
|
|
1886 }
|
|
|
1887 }
|
|
|
1888
|
|
|
1889 //----- (00402F87) --------------------------------------------------------
|
|
|
1890 void Actor::AI_Bored(unsigned int uActorID, unsigned int uObjID, AIDirection *a4)
|
|
|
1891 {
|
|
|
1892 unsigned int v7; // eax@3
|
|
|
1893 unsigned int v9; // eax@3
|
|
|
1894
|
|
|
1895 Actor* actor = &pActors[uActorID];
|
|
|
1896
|
|
|
1897 AIDirection a3; // [sp+Ch] [bp-5Ch]@2
|
|
|
1898 if (!a4)
|
|
|
1899 {
|
|
|
1900 Actor::GetDirectionInfo(PID(OBJECT_Actor,uActorID), uObjID, &a3, 0);
|
|
|
1901 a4 = &a3;
|
|
|
1902 }
|
|
|
1903
|
|
|
1904 actor->uCurrentActionLength = 8 * pSpriteFrameTable->pSpriteSFrames[actor->pSpriteIDs[ANIM_Bored]].uAnimLength;
|
|
|
1905
|
|
2541
|
1906 v7 = stru_5C6E00->Atan2(actor->vPosition.x - pEngine->pIndoorCameraD3D->vPartyPos.x, actor->vPosition.y - pEngine->pIndoorCameraD3D->vPartyPos.y);
|
|
2497
|
1907 v9 = stru_5C6E00->uIntegerPi + actor->uYawAngle + ((signed int)stru_5C6E00->uIntegerPi >> 3) - v7;
|
|
|
1908
|
|
|
1909 if ( v9 & 0x700 ) // turned away - just stand
|
|
|
1910 Actor::AI_Stand(uActorID, uObjID, actor->uCurrentActionLength, a4);
|
|
|
1911 else // facing player - play bored anim
|
|
|
1912 {
|
|
|
1913 actor->uAIState = Fidgeting;
|
|
|
1914 actor->uCurrentActionTime = 0;
|
|
|
1915 actor->uYawAngle = a4->uYawAngle;
|
|
|
1916 actor->vVelocity.z = 0;
|
|
|
1917 actor->vVelocity.y = 0;
|
|
|
1918 actor->vVelocity.x = 0;
|
|
|
1919 if ( rand() % 100 < 5 )
|
|
|
1920 Actor::PlaySound(uActorID, 3);
|
|
|
1921 actor->UpdateAnimation();
|
|
|
1922 }
|
|
|
1923 }
|
|
|
1924
|
|
|
1925 //----- (00402F27) --------------------------------------------------------
|
|
|
1926 void Actor::Resurrect(unsigned int uActorID)
|
|
|
1927 {
|
|
|
1928 Actor *pActor; // esi@1
|
|
|
1929
|
|
|
1930 pActor = &pActors[uActorID];
|
|
|
1931 pActor->uCurrentActionTime = 0;
|
|
|
1932 pActor->uAIState = Resurrected;
|
|
|
1933 pActor->uCurrentActionAnimation = ANIM_Dying;
|
|
|
1934 pActor->uCurrentActionLength = 8 * pSpriteFrameTable->pSpriteSFrames[pActor->pSpriteIDs[ANIM_Dying]].uAnimLength;
|
|
|
1935 pActor->sCurrentHP = LOWORD(pActor->pMonsterInfo.uHP);
|
|
|
1936 Actor::PlaySound(uActorID, 1);
|
|
|
1937 pActor->UpdateAnimation();
|
|
|
1938 }
|
|
|
1939
|
|
|
1940 //----- (00402D6E) --------------------------------------------------------
|
|
|
1941 void Actor::Die(unsigned int uActorID)
|
|
|
1942 {
|
|
|
1943 Actor* actor = &pActors[uActorID];
|
|
|
1944
|
|
|
1945 actor->uCurrentActionTime = 0;
|
|
|
1946 actor->uAIState = Dying;
|
|
|
1947 actor->uCurrentActionAnimation = ANIM_Dying;
|
|
|
1948 actor->sCurrentHP = 0;
|
|
|
1949 actor->uCurrentActionLength = 8 * pSpriteFrameTable->pSpriteSFrames[actor->pSpriteIDs[ANIM_Dying]].uAnimLength;
|
|
|
1950 actor->pActorBuffs[ACTOR_BUFF_PARALYZED].Reset();
|
|
|
1951 actor->pActorBuffs[ACTOR_BUFF_STONED].Reset();
|
|
|
1952 Actor::PlaySound(uActorID, 1);
|
|
|
1953 actor->UpdateAnimation();
|
|
|
1954
|
|
|
1955 for (uint i = 0; i < 5; ++i)
|
|
|
1956 if (pParty->monster_id_for_hunting[i] == actor->pMonsterInfo.uID)
|
|
|
1957 pParty->monster_for_hunting_killed[i] = true;
|
|
|
1958
|
|
|
1959 for (uint i = 0; i < 22; ++i)
|
|
|
1960 actor->pActorBuffs[i].Reset();
|
|
|
1961
|
|
|
1962 ItemGen drop;
|
|
|
1963 drop.Reset();
|
|
|
1964 switch (actor->pMonsterInfo.uID)
|
|
|
1965 {
|
|
|
1966 case MONSTER_HARPY_1: case MONSTER_HARPY_2: case MONSTER_HARPY_3:
|
|
|
1967 drop.uItemID = ITEM_HARPY_FEATHER;
|
|
|
1968 break;
|
|
|
1969
|
|
|
1970 case MONSTER_OOZE_1: case MONSTER_OOZE_2: case MONSTER_OOZE_3:
|
|
|
1971 drop.uItemID = ITEM_OOZE_ECTOPLASM_BOTTLE;
|
|
|
1972 break;
|
|
|
1973
|
|
|
1974 case MONSTER_TROLL_1: case MONSTER_TROLL_2: case MONSTER_TROLL_3:
|
|
|
1975 drop.uItemID = ITEM_TROLL_BLOOD;
|
|
|
1976 break;
|
|
|
1977
|
|
|
1978 case MONSTER_DEVIL_1: case MONSTER_DEVIL_2: case MONSTER_DEVIL_3:
|
|
|
1979 drop.uItemID = ITEM_DEVIL_ICHOR;
|
|
|
1980 break;
|
|
|
1981
|
|
|
1982 case MONSTER_DRAGON_1: case MONSTER_DRAGON_2: case MONSTER_DRAGON_3:
|
|
|
1983 drop.uItemID = ITEM_DRAGON_EYE;
|
|
|
1984 break;
|
|
|
1985 }
|
|
|
1986
|
|
|
1987 if (rand() % 100 < 20 && drop.uItemID != 0)
|
|
|
1988 {
|
|
|
1989 SpriteObject::sub_42F7EB_DropItemAt(pItemsTable->pItems[drop.uItemID].uSpriteID,
|
|
|
1990 actor->vPosition.x,
|
|
|
1991 actor->vPosition.y,
|
|
|
1992 actor->vPosition.z + 16,
|
|
|
1993 rand() % 200 + 200,
|
|
|
1994 1,
|
|
|
1995 1,
|
|
|
1996 0,
|
|
|
1997 &drop);
|
|
|
1998 }
|
|
|
1999
|
|
|
2000 if (actor->pMonsterInfo.uSpecialAbilityType == MONSTER_SPECIAL_ABILITY_EXPLODE)
|
|
|
2001 Actor::Explode(uActorID);
|
|
|
2002 }
|
|
|
2003
|
|
|
2004 //----- (00402CED) --------------------------------------------------------
|
|
|
2005 void Actor::PlaySound(unsigned int uActorID, unsigned int uSoundID)
|
|
|
2006 {
|
|
|
2007 unsigned __int16 v3; // dx@1
|
|
|
2008
|
|
|
2009 v3 = pActors[uActorID].pSoundSampleIDs[uSoundID];
|
|
|
2010 if ( v3 )
|
|
|
2011 {
|
|
|
2012 if ( pActors[uActorID].pActorBuffs[ACTOR_BUFF_SHRINK].uExpireTime <= 0 )
|
|
|
2013 pAudioPlayer->PlaySound((SoundID)v3, PID(OBJECT_Actor, uActorID), 0, -1, 0, 0, 0, 0);
|
|
|
2014 else
|
|
|
2015 {
|
|
|
2016 switch(pActors[uActorID].pActorBuffs[ACTOR_BUFF_SHRINK].uPower)
|
|
|
2017 {
|
|
|
2018 case 1:
|
|
|
2019 pAudioPlayer->PlaySound((SoundID)v3, PID(OBJECT_Actor, uActorID), 0, 0, 0, 0, 0, 33075);
|
|
|
2020 break;
|
|
|
2021 case 2:
|
|
|
2022 pAudioPlayer->PlaySound((SoundID)v3, PID(OBJECT_Actor, uActorID), 0, 0, 0, 0, 0, 33075);
|
|
|
2023 break;
|
|
|
2024 case 3:
|
|
|
2025 case 4:
|
|
|
2026 pAudioPlayer->PlaySound((SoundID)v3, PID(OBJECT_Actor, uActorID), 0, 0, 0, 0, 0, 33075);
|
|
|
2027 break;
|
|
|
2028 default:
|
|
|
2029 pAudioPlayer->PlaySound((SoundID)v3, PID(OBJECT_Actor, uActorID), 0, -1, 0, 0, 0, 0);
|
|
|
2030 break;
|
|
|
2031 }
|
|
|
2032 }
|
|
|
2033 }
|
|
|
2034 }
|
|
|
2035
|
|
|
2036 //----- (00402AD7) --------------------------------------------------------
|
|
|
2037 void Actor::AI_Pursue1(unsigned int uActorID, unsigned int a2, signed int arg0, signed int uActionLength, AIDirection *pDir)
|
|
|
2038 {
|
|
|
2039 int v6; // eax@1
|
|
|
2040 Actor *v7; // ebx@1
|
|
|
2041 unsigned int v8; // ecx@1
|
|
|
2042 AIDirection *v10; // esi@6
|
|
|
2043 AIDirection a3; // [sp+Ch] [bp-5Ch]@7
|
|
|
2044 unsigned int v18; // [sp+64h] [bp-4h]@1
|
|
|
2045
|
|
|
2046 v6 = 0;
|
|
|
2047 v7 = &pActors[uActorID];
|
|
|
2048 v8 = PID(OBJECT_Actor,uActorID);
|
|
|
2049 if ( v7->pMonsterInfo.uFlying != 0 && !pParty->bFlying ) //TODO: Does v6 have a point?
|
|
|
2050 {
|
|
|
2051 if ( v7->pMonsterInfo.uMissleAttack1Type )
|
|
|
2052 v6 = v7->uActorRadius + 512;
|
|
|
2053 else
|
|
|
2054 v6 = pParty->uPartyHeight;
|
|
|
2055 }
|
|
|
2056
|
|
|
2057 if ( pDir == nullptr )
|
|
|
2058 {
|
|
|
2059 Actor::GetDirectionInfo(v8, a2, &a3, v6);
|
|
|
2060 v10 = &a3;
|
|
|
2061 }
|
|
|
2062 else
|
|
|
2063 v10 = pDir;
|
|
|
2064 if ( MonsterStats::BelongsToSupertype(v7->pMonsterInfo.uID, MONSTER_SUPERTYPE_TREANT) )
|
|
|
2065 {
|
|
|
2066 if ( !uActionLength )
|
|
|
2067 uActionLength = 256;
|
|
|
2068 Actor::AI_StandOrBored(uActorID, 4, uActionLength, v10);
|
|
|
2069 return;
|
|
|
2070 }
|
|
|
2071 if ( v10->uDistance < 307.2 )
|
|
|
2072 {
|
|
|
2073 if ( !uActionLength )
|
|
|
2074 uActionLength = 256;
|
|
|
2075 Actor::AI_Stand(uActorID, a2, uActionLength, v10);
|
|
|
2076 return;
|
|
|
2077 }
|
|
|
2078 if ( v7->uMovementSpeed == 0 )
|
|
|
2079 {
|
|
|
2080 Actor::AI_Stand(uActorID, a2, uActionLength, v10);
|
|
|
2081 return;
|
|
|
2082 }
|
|
|
2083 if ( arg0 % 2 )
|
|
|
2084 v18 = -16;
|
|
|
2085 else
|
|
|
2086 v18 = 16;
|
|
|
2087
|
|
|
2088 v7->uYawAngle = stru_5C6E00->Atan2(
|
|
|
2089 pParty->vPosition.x + (int)fixpoint_mul(stru_5C6E00->Cos(v18 + stru_5C6E00->uIntegerPi + v10->uYawAngle), v10->uDistanceXZ) - v7->vPosition.x,
|
|
|
2090 pParty->vPosition.y + (int)fixpoint_mul(stru_5C6E00->Sin(v18 + stru_5C6E00->uIntegerPi + v10->uYawAngle), v10->uDistanceXZ) - v7->vPosition.y);
|
|
|
2091 if ( uActionLength )
|
|
|
2092 v7->uCurrentActionLength = uActionLength;
|
|
|
2093 else
|
|
|
2094 v7->uCurrentActionLength = 128;
|
|
|
2095 v7->uPitchAngle = LOWORD(v10->uPitchAngle);
|
|
|
2096 v7->uAIState = Pursuing;
|
|
|
2097 v7->UpdateAnimation();
|
|
|
2098 }
|
|
|
2099
|
|
|
2100 //----- (00402968) --------------------------------------------------------
|
|
|
2101 void Actor::AI_Flee(unsigned int uActorID, signed int sTargetPid, int uActionLength, AIDirection *a4)
|
|
|
2102 {
|
|
|
2103 Actor *v5; // ebx@1
|
|
|
2104 int v7; // ecx@2
|
|
|
2105 unsigned __int16 v9; // ax@15
|
|
|
2106 AIDirection v10; // [sp+8h] [bp-7Ch]@4
|
|
|
2107 AIDirection a3; // [sp+24h] [bp-60h]@3
|
|
|
2108 AIDirection* v13; // [sp+5Ch] [bp-28h]@4
|
|
|
2109
|
|
|
2110 v5 = &pActors[uActorID];
|
|
|
2111 if ( v5->CanAct() )
|
|
|
2112 {
|
|
|
2113 v7 = PID(OBJECT_Actor,uActorID);
|
|
|
2114 if ( !a4 )
|
|
|
2115 {
|
|
|
2116 Actor::GetDirectionInfo(v7, sTargetPid, &a3, v5->pMonsterInfo.uFlying);
|
|
|
2117 a4 = &a3;
|
|
|
2118 }
|
|
|
2119 Actor::GetDirectionInfo(v7, 4u, &v10, 0);
|
|
|
2120 v13 = &v10;
|
|
|
2121 if ( MonsterStats::BelongsToSupertype(v5->pMonsterInfo.uID, MONSTER_SUPERTYPE_TREANT)
|
|
|
2122 || PID_TYPE(sTargetPid) == OBJECT_Actor && v13->uDistance < 307.2 )
|
|
|
2123 {
|
|
|
2124 if ( !uActionLength )
|
|
|
2125 uActionLength = 256;
|
|
|
2126 Actor::AI_StandOrBored(uActorID, 4, uActionLength, v13);
|
|
|
2127 }
|
|
|
2128 else
|
|
|
2129 {
|
|
|
2130 if ( v5->uMovementSpeed )
|
|
|
2131 v5->uCurrentActionLength = (signed int)(a4->uDistanceXZ << 7) / v5->uMovementSpeed;
|
|
|
2132 else
|
|
|
2133 v5->uCurrentActionLength = 0;
|
|
|
2134 if ( v5->uCurrentActionLength > 256 )
|
|
|
2135 v5->uCurrentActionLength = 256;
|
|
|
2136 v5->uYawAngle = LOWORD(stru_5C6E00->uIntegerHalfPi) + LOWORD(a4->uYawAngle);
|
|
|
2137 v5->uYawAngle = LOWORD(stru_5C6E00->uDoublePiMask) & (v5->uYawAngle + rand() % (signed int)stru_5C6E00->uIntegerPi);
|
|
|
2138 v9 = LOWORD(a4->uPitchAngle);
|
|
|
2139 v5->uCurrentActionTime = 0;
|
|
|
2140 v5->uPitchAngle = v9;
|
|
|
2141 v5->uAIState = Fleeing;
|
|
|
2142 v5->UpdateAnimation();
|
|
|
2143 }
|
|
|
2144 }
|
|
|
2145 }
|
|
|
2146
|
|
|
2147 //----- (0040281C) --------------------------------------------------------
|
|
|
2148 void Actor::AI_Pursue2(unsigned int uActorID, unsigned int a2, signed int uActionLength, AIDirection *pDir, int a5)
|
|
|
2149 {
|
|
|
2150 int v6; // eax@1
|
|
|
2151 Actor *v7; // ebx@1
|
|
|
2152 unsigned int v8; // ecx@1
|
|
|
2153 AIDirection *v10; // esi@7
|
|
|
2154 signed __int16 v13; // cx@19
|
|
|
2155 unsigned __int16 v14; // ax@25
|
|
|
2156 AIDirection a3; // [sp+Ch] [bp-40h]@8
|
|
|
2157 AIDirection v18; // [sp+28h] [bp-24h]@8
|
|
|
2158
|
|
|
2159 v6 = 0;
|
|
|
2160 v7 = &pActors[uActorID];
|
|
|
2161 v8 = PID(OBJECT_Actor,uActorID);
|
|
|
2162 if ( v7->pMonsterInfo.uFlying != 0 && !pParty->bFlying )
|
|
|
2163 {
|
|
|
2164 if ( v7->pMonsterInfo.uMissleAttack1Type && uCurrentlyLoadedLevelType == LEVEL_Outdoor )
|
|
|
2165 v6 = v7->uActorRadius + 512;
|
|
|
2166 else
|
|
|
2167 v6 = pParty->uPartyHeight;
|
|
|
2168 }
|
|
|
2169 v10 = pDir;
|
|
|
2170 if ( !pDir )
|
|
|
2171 {
|
|
|
2172 Actor::GetDirectionInfo(v8, a2, &a3, v6);
|
|
|
2173 v10 = &a3;
|
|
|
2174 }
|
|
|
2175 if ( MonsterStats::BelongsToSupertype(v7->pMonsterInfo.uID, MONSTER_SUPERTYPE_TREANT) )
|
|
|
2176 {
|
|
|
2177 if ( !uActionLength )
|
|
|
2178 uActionLength = 256;
|
|
|
2179 Actor::AI_StandOrBored(uActorID, 4, uActionLength, v10);
|
|
|
2180 return;
|
|
|
2181 }
|
|
|
2182 if ( (signed int)v10->uDistance < a5 )
|
|
|
2183 {
|
|
|
2184 if ( !uActionLength )
|
|
|
2185 uActionLength = 256;
|
|
|
2186 Actor::AI_StandOrBored(uActorID, a2, uActionLength, v10);
|
|
|
2187 return;
|
|
|
2188 }
|
|
|
2189 if ( uActionLength )
|
|
|
2190 {
|
|
|
2191 v7->uCurrentActionLength = uActionLength;
|
|
|
2192 }
|
|
|
2193 else
|
|
|
2194 {
|
|
|
2195 v13 = v7->uMovementSpeed;
|
|
|
2196 if ( v13 )
|
|
|
2197 v7->uCurrentActionLength = (signed int)(v10->uDistanceXZ << 7) / v13;
|
|
|
2198 else
|
|
|
2199 v7->uCurrentActionLength = 0;
|
|
|
2200 if ( v7->uCurrentActionLength > 32 )
|
|
|
2201 v7->uCurrentActionLength = 32;
|
|
|
2202 }
|
|
|
2203 v7->uYawAngle = LOWORD(v10->uYawAngle);
|
|
|
2204 v14 = LOWORD(v10->uPitchAngle);
|
|
|
2205 v7->uCurrentActionTime = 0;
|
|
|
2206 v7->uPitchAngle = v14;
|
|
|
2207 v7->uAIState = Pursuing;
|
|
|
2208 v7->UpdateAnimation();
|
|
|
2209 }
|
|
|
2210
|
|
|
2211 //----- (00402686) --------------------------------------------------------
|
|
|
2212 void Actor::AI_Pursue3(unsigned int uActorID, unsigned int a2, signed int uActionLength, AIDirection *a4)
|
|
|
2213 {
|
|
|
2214 int v5; // eax@1
|
|
|
2215 Actor *v6; // ebx@1
|
|
|
2216 int v7; // ecx@1
|
|
|
2217 signed __int16 v12; // cx@19
|
|
|
2218 __int16 v14; // ax@25
|
|
|
2219 unsigned __int16 v16; // ax@28
|
|
|
2220 AIDirection a3; // [sp+Ch] [bp-40h]@8
|
|
|
2221 AIDirection* v20; // [sp+28h] [bp-24h]@8
|
|
|
2222
|
|
|
2223 v5 = 0;
|
|
|
2224 v6 = &pActors[uActorID];
|
|
|
2225 v7 = PID(OBJECT_Actor,uActorID);
|
|
|
2226 if ( v6->pMonsterInfo.uFlying != 0 && !pParty->bFlying )
|
|
|
2227 {
|
|
|
2228 if ( v6->pMonsterInfo.uMissleAttack1Type && uCurrentlyLoadedLevelType == LEVEL_Outdoor )
|
|
|
2229 v5 = v6->uActorRadius + 512;
|
|
|
2230 else
|
|
|
2231 v5 = pParty->uPartyHeight;
|
|
|
2232 }
|
|
|
2233 if ( !a4 )
|
|
|
2234 {
|
|
|
2235 Actor::GetDirectionInfo(v7, a2, &a3, v5);
|
|
|
2236 v20 = &a3;
|
|
|
2237 }
|
|
|
2238 if ( MonsterStats::BelongsToSupertype(v6->pMonsterInfo.uID, MONSTER_SUPERTYPE_TREANT) )
|
|
|
2239 {
|
|
|
2240 if ( !uActionLength )
|
|
|
2241 uActionLength = 256;
|
|
|
2242 return Actor::AI_StandOrBored(uActorID, 4, uActionLength, a4);
|
|
|
2243 }
|
|
|
2244 if ( a4->uDistance < 307.2 )
|
|
|
2245 {
|
|
|
2246 if ( !uActionLength )
|
|
|
2247 uActionLength = 256;
|
|
|
2248 return Actor::AI_StandOrBored(uActorID, a2, uActionLength, a4);
|
|
|
2249 }
|
|
|
2250 if ( uActionLength )
|
|
|
2251 v6->uCurrentActionLength = uActionLength + rand() % uActionLength;
|
|
|
2252 else
|
|
|
2253 {
|
|
|
2254 v12 = v6->uMovementSpeed;
|
|
|
2255 if ( v12 )
|
|
|
2256 v6->uCurrentActionLength = (signed int)(a4->uDistanceXZ << 7) / v12;
|
|
|
2257 else
|
|
|
2258 v6->uCurrentActionLength = 0;
|
|
|
2259 if ( v6->uCurrentActionLength > 128 )
|
|
|
2260 v6->uCurrentActionLength = 128;
|
|
|
2261 }
|
|
|
2262 v14 = LOWORD(a4->uYawAngle);
|
|
|
2263 if ( rand() % 2 )
|
|
|
2264 v14 += 256;
|
|
|
2265 else
|
|
|
2266 v14 -= 256;
|
|
|
2267 v6->uYawAngle = v14;
|
|
|
2268 v16 = LOWORD(a4->uPitchAngle);
|
|
|
2269 v6->uCurrentActionTime = 0;
|
|
|
2270 v6->uPitchAngle = v16;
|
|
|
2271 v6->uAIState = Pursuing;
|
|
|
2272 if ( rand() % 100 < 2 )
|
|
2506
|
2273 Actor::PlaySound(uActorID, 2);
|
|
2497
|
2274 v6->UpdateAnimation();
|
|
|
2275 }
|
|
|
2276
|
|
|
2277 //----- (00401221) --------------------------------------------------------
|
|
|
2278 void Actor::_SelectTarget(unsigned int uActorID, int *a2, bool can_target_party)
|
|
|
2279 {
|
|
|
2280 int v5; // ecx@1
|
|
|
2281 signed int v10; // eax@13
|
|
|
2282 uint v11; // ebx@16
|
|
|
2283 uint v12; // eax@16
|
|
|
2284 signed int v14; // eax@31
|
|
|
2285 uint v15; // edi@43
|
|
|
2286 uint v16; // ebx@45
|
|
|
2287 uint v17; // eax@45
|
|
|
2288 signed int closestId; // [sp+14h] [bp-1Ch]@1
|
|
|
2289 uint v23; // [sp+1Ch] [bp-14h]@16
|
|
|
2290 unsigned int lowestRadius; // [sp+24h] [bp-Ch]@1
|
|
|
2291 uint v27; // [sp+2Ch] [bp-4h]@16
|
|
|
2292 uint v28; // [sp+2Ch] [bp-4h]@45
|
|
|
2293
|
|
|
2294 lowestRadius = UINT_MAX;
|
|
|
2295 v5 = 0;
|
|
|
2296 *a2 = 0;
|
|
|
2297 closestId = 0;
|
|
|
2298 assert(uActorID < uNumActors);
|
|
|
2299 Actor* thisActor = &pActors[uActorID];
|
|
|
2300
|
|
|
2301 for (uint i = 0; i < uNumActors; ++i)
|
|
|
2302 {
|
|
|
2303 Actor* actor = &pActors[i];
|
|
|
2304 if (actor->uAIState == Dead || actor->uAIState == Dying ||
|
|
|
2305 actor->uAIState == Removed || actor->uAIState == Summoned || actor->uAIState == Disabled || uActorID == i )
|
|
|
2306 continue;
|
|
|
2307
|
|
|
2308 if (thisActor->uLastCharacterIDToHit == 0 || PID(OBJECT_Actor,v5) != thisActor->uLastCharacterIDToHit )
|
|
|
2309 {
|
|
|
2310 v10 = thisActor->GetActorsRelation(actor);
|
|
|
2311 if ( v10 == 0 )
|
|
|
2312 continue;
|
|
|
2313 }
|
|
|
2314 else if (thisActor->IsNotAlive())
|
|
|
2315 {
|
|
|
2316 thisActor->uLastCharacterIDToHit = 0;
|
|
|
2317 v10 = thisActor->GetActorsRelation(actor);
|
|
|
2318 if ( v10 == 0 )
|
|
|
2319 continue;
|
|
|
2320 }
|
|
|
2321 else
|
|
|
2322 {
|
|
|
2323 if ( (actor->uGroup != 0 || thisActor->uGroup != 0) && actor->uGroup == thisActor->uGroup )
|
|
|
2324 continue;
|
|
|
2325 v10 = 4;
|
|
|
2326 }
|
|
|
2327 if ( thisActor->pMonsterInfo.uHostilityType )
|
|
|
2328 v10 = pMonsterStats->pInfos[thisActor->pMonsterInfo.uID].uHostilityType;
|
|
|
2329 v11 = _4DF380_hostilityRanges[v10];
|
|
|
2330 v23 = abs(thisActor->vPosition.x - actor->vPosition.x);
|
|
|
2331 v27 = abs(thisActor->vPosition.y - actor->vPosition.y);
|
|
|
2332 v12 = abs(thisActor->vPosition.z - actor->vPosition.z);
|
|
|
2333 if ( v23 <= v11
|
|
|
2334 && v27 <= v11
|
|
|
2335 && v12 <= v11
|
|
|
2336 && sub_4070EF_prolly_detect_player(PID(OBJECT_Actor, i), PID(OBJECT_Actor, uActorID))
|
|
|
2337 && v23 * v23 + v27 * v27 + v12 * v12 < lowestRadius )
|
|
|
2338 {
|
|
|
2339 lowestRadius = v23 * v23 + v27 * v27 + v12 * v12;
|
|
|
2340 closestId = i;
|
|
|
2341 }
|
|
|
2342 }
|
|
|
2343
|
|
|
2344 if ( lowestRadius != UINT_MAX )
|
|
|
2345 {
|
|
|
2346 *a2 = PID(OBJECT_Actor, closestId);
|
|
|
2347 }
|
|
|
2348
|
|
|
2349 if (can_target_party && !pParty->Invisible())
|
|
|
2350 {
|
|
|
2351 if ( thisActor->ActorEnemy()
|
|
|
2352 && thisActor->pActorBuffs[ACTOR_BUFF_ENSLAVED].uExpireTime <= 0
|
|
|
2353 && thisActor->pActorBuffs[ACTOR_BUFF_CHARM].uExpireTime <= 0
|
|
|
2354 && thisActor->pActorBuffs[ACTOR_BUFF_SUMMONED].uExpireTime <= 0 )
|
|
|
2355 v14 = 4;
|
|
|
2356 else
|
|
|
2357 v14 = thisActor->GetActorsRelation(0);
|
|
|
2358 if ( v14 != 0 )
|
|
|
2359 {
|
|
|
2360 if ( !thisActor->pMonsterInfo.uHostilityType )
|
|
|
2361 v15 = _4DF380_hostilityRanges[v14];
|
|
|
2362 else
|
|
|
2363 v15 = _4DF380_hostilityRanges[4];
|
|
|
2364 v16 = abs(thisActor->vPosition.x - pParty->vPosition.x);
|
|
|
2365 v28 = abs(thisActor->vPosition.y - pParty->vPosition.y);
|
|
|
2366 v17 = abs(thisActor->vPosition.z - pParty->vPosition.z);
|
|
|
2367 if ( v16 <= v15 && v28 <= v15 && v17 <= v15 && (v16 * v16 + v28 * v28 + v17 * v17 < lowestRadius))
|
|
|
2368 {
|
|
|
2369 *a2 = OBJECT_Player;
|
|
|
2370 }
|
|
|
2371 }
|
|
|
2372 }
|
|
|
2373 }
|
|
|
2374 // 4DF380: using guessed type int dword_4DF380[];
|
|
|
2375 // 4DF390: using guessed type int dword_4DF390;
|
|
|
2376
|
|
|
2377 //----- (0040104C) --------------------------------------------------------
|
|
|
2378 signed int Actor::GetActorsRelation(Actor *otherActPtr)
|
|
|
2379 {
|
|
|
2380 unsigned int thisGroup; // ebp@19
|
|
|
2381 int otherGroup; // eax@22
|
|
|
2382 unsigned int thisAlly; // edx@25
|
|
|
2383 unsigned int otherAlly; // edx@33
|
|
|
2384
|
|
|
2385 if ( otherActPtr)
|
|
|
2386 {
|
|
|
2387 if ( otherActPtr->uGroup != 0 && this->uGroup != 0 && otherActPtr->uGroup == this->uGroup )
|
|
|
2388 return 0;
|
|
|
2389 }
|
|
|
2390
|
|
|
2391 if (this->pActorBuffs[ACTOR_BUFF_BERSERK].uExpireTime > 0)
|
|
|
2392 return 4;
|
|
|
2393 thisAlly = this->uAlly;
|
|
|
2394 if ( this->pActorBuffs[ACTOR_BUFF_ENSLAVED].uExpireTime > 0 || thisAlly == 9999)
|
|
|
2395 thisGroup = 0;
|
|
|
2396 else if ( thisAlly > 0 )
|
|
|
2397 thisGroup = thisAlly;
|
|
|
2398 else
|
|
|
2399 thisGroup = (this->pMonsterInfo.uID - 1) / 3 + 1;
|
|
|
2400
|
|
|
2401 if ( otherActPtr )
|
|
|
2402 {
|
|
|
2403 if (otherActPtr->pActorBuffs[ACTOR_BUFF_BERSERK].uExpireTime > 0)
|
|
|
2404 return 4;
|
|
|
2405 otherAlly = otherActPtr->uAlly;
|
|
|
2406 if ( otherActPtr->pActorBuffs[ACTOR_BUFF_ENSLAVED].uExpireTime > 0 || otherAlly == 9999)
|
|
|
2407 otherGroup = 0;
|
|
|
2408 else if ( otherAlly > 0 )
|
|
|
2409 otherGroup = otherAlly;
|
|
|
2410 else
|
|
|
2411 otherGroup = (otherActPtr->pMonsterInfo.uID - 1) / 3 + 1;
|
|
|
2412 }
|
|
|
2413 else
|
|
|
2414 otherGroup = 0;
|
|
|
2415
|
|
|
2416 if ( this->pActorBuffs[ACTOR_BUFF_CHARM].uExpireTime > 0 && !otherGroup
|
|
|
2417 || otherActPtr && otherActPtr->pActorBuffs[ACTOR_BUFF_CHARM].uExpireTime > 0 && !thisGroup )
|
|
|
2418 return 0;
|
|
|
2419 if ( this->pActorBuffs[ACTOR_BUFF_ENSLAVED].uExpireTime <= 0 && this->ActorEnemy() && !otherGroup )
|
|
|
2420 return 4;
|
|
|
2421 if (thisGroup >= 89 || otherGroup >= 89)
|
|
|
2422 return 0;
|
|
|
2423
|
|
|
2424 if ( thisGroup == 0 )
|
|
|
2425 {
|
|
|
2426 if ( (!otherActPtr || this->pActorBuffs[ACTOR_BUFF_ENSLAVED].uExpireTime > 0 && otherActPtr->ActorFriend()) && !pFactionTable->relations[otherGroup][0])
|
|
|
2427 return pFactionTable->relations[0][otherGroup];
|
|
|
2428 else
|
|
|
2429 return 4;
|
|
|
2430 }
|
|
|
2431 else
|
|
|
2432 return pFactionTable->relations[thisGroup][otherGroup];
|
|
|
2433 }
|
|
|
2434
|
|
|
2435 //----- (0045976D) --------------------------------------------------------
|
|
|
2436 void Actor::UpdateAnimation()
|
|
|
2437 {
|
|
|
2438 ResetAnimation();
|
|
|
2439 switch (uAIState)
|
|
|
2440 {
|
|
|
2441 case Tethered:
|
|
|
2442 uCurrentActionAnimation = ANIM_Walking;
|
|
|
2443 break;
|
|
|
2444
|
|
|
2445 case AttackingMelee:
|
|
|
2446 uCurrentActionAnimation = ANIM_AtkMelee;
|
|
|
2447 uAttributes |= ACTOR_ANIMATION;
|
|
|
2448 break;
|
|
|
2449
|
|
|
2450 case AttackingRanged1:
|
|
|
2451 case AttackingRanged2:
|
|
|
2452 case AttackingRanged3:
|
|
|
2453 case AttackingRanged4:
|
|
|
2454 uCurrentActionAnimation = ANIM_AtkRanged;
|
|
|
2455 uAttributes |= ACTOR_ANIMATION;
|
|
|
2456 break;
|
|
|
2457
|
|
|
2458 case Dying:
|
|
|
2459 case Resurrected:
|
|
|
2460 uCurrentActionAnimation = ANIM_Dying;
|
|
|
2461 uAttributes |= ACTOR_ANIMATION;
|
|
|
2462 break;
|
|
|
2463
|
|
|
2464 case Pursuing:
|
|
|
2465 case Fleeing:
|
|
|
2466 uCurrentActionAnimation = ANIM_Walking;
|
|
|
2467 uAttributes |= ACTOR_ANIMATION;
|
|
|
2468 break;
|
|
|
2469
|
|
|
2470 case Stunned:
|
|
|
2471 uCurrentActionAnimation = ANIM_GotHit;
|
|
|
2472 uAttributes |= ACTOR_ANIMATION;
|
|
|
2473 break;
|
|
|
2474
|
|
|
2475 case Fidgeting:
|
|
|
2476 uCurrentActionAnimation = ANIM_Bored;
|
|
|
2477 uAttributes |= ACTOR_ANIMATION;
|
|
|
2478 break;
|
|
|
2479
|
|
|
2480 case Standing:
|
|
|
2481 case Interacting:
|
|
|
2482 case Summoned:
|
|
|
2483 uCurrentActionAnimation = ANIM_Standing;
|
|
|
2484 uAttributes |= ACTOR_ANIMATION;
|
|
|
2485 break;
|
|
|
2486
|
|
|
2487 case Dead:
|
|
|
2488 if (pSpriteFrameTable->pSpriteSFrames[pSpriteIDs[ANIM_Dead]].pHwSpriteIDs[0] <= 0)
|
|
|
2489 uAIState = Removed;
|
|
|
2490 else
|
|
|
2491 uCurrentActionAnimation = ANIM_Dead;
|
|
|
2492 break;
|
|
|
2493
|
|
|
2494 case Removed:
|
|
|
2495 case Disabled:
|
|
|
2496 return;
|
|
|
2497
|
|
|
2498 default:
|
|
|
2499 assert(false);
|
|
|
2500 }
|
|
|
2501 }
|
|
|
2502
|
|
|
2503 //----- (00459671) --------------------------------------------------------
|
|
|
2504 void Actor::Reset()
|
|
|
2505 {
|
|
|
2506 this->pActorName[0] = 0;
|
|
|
2507 this->word_000086_some_monster_id = 0;
|
|
|
2508 this->sNPC_ID = 0;
|
|
|
2509 this->vPosition.z = 0;
|
|
|
2510 this->vPosition.y = 0;
|
|
|
2511 this->vPosition.x = 0;
|
|
|
2512 this->vVelocity.z = 0;
|
|
|
2513 this->vVelocity.y = 0;
|
|
|
2514 this->vVelocity.x = 0;
|
|
|
2515 this->uYawAngle = 0;
|
|
|
2516 this->uPitchAngle = 0;
|
|
|
2517 this->uAttributes = 0;
|
|
|
2518 this->uSectorID = 0;
|
|
|
2519 this->uCurrentActionTime = 0;
|
|
|
2520 this->vInitialPosition.z = 0;
|
|
|
2521 this->vInitialPosition.y = 0;
|
|
|
2522 this->vInitialPosition.x = 0;
|
|
|
2523 this->vGuardingPosition.z = 0;
|
|
|
2524 this->vGuardingPosition.y = 0;
|
|
|
2525 this->vGuardingPosition.x = 0;
|
|
|
2526 this->uTetherDistance = 256;
|
|
|
2527 this->uActorRadius = 32;
|
|
|
2528 this->uActorHeight = 128;
|
|
|
2529 this->uAIState = Standing;
|
|
|
2530 this->uCurrentActionAnimation = ANIM_Standing;
|
|
|
2531 this->uMovementSpeed = 200;
|
|
|
2532 this->uCarriedItemID = 0;
|
|
|
2533 this->uGroup = 0;
|
|
|
2534 this->uAlly = 0;
|
|
|
2535 this->uSummonerID = 0;
|
|
|
2536 this->uLastCharacterIDToHit = 0;
|
|
|
2537 this->dword_000334_unique_name = 0;
|
|
|
2538 memset(this->pSpriteIDs, 0, sizeof(pSpriteIDs));
|
|
|
2539 memset(this->pActorBuffs, 0, 0x160u);
|
|
|
2540 }
|
|
|
2541
|
|
|
2542 //----- (0045959A) --------------------------------------------------------
|
|
|
2543 void Actor::PrepareSprites(char load_sounds_if_bit1_set)
|
|
|
2544 {
|
|
|
2545
|
|
|
2546 MonsterDesc *v3; // esi@1
|
|
|
2547 MonsterInfo *v9; // [sp+84h] [bp-10h]@1
|
|
|
2548
|
|
|
2549 v3 = &pMonsterList->pMonsters[pMonsterInfo.uID - 1];
|
|
|
2550 v9 = &pMonsterStats->pInfos[pMonsterInfo.uID - 1 + 1];
|
|
|
2551 //v12 = pSpriteIDs;
|
|
|
2552 //Source = (char *)v3->pSpriteNames;
|
|
|
2553 //do
|
|
|
2554 for (uint i = 0; i < 8; ++i)
|
|
|
2555 {
|
|
|
2556 //strcpy(pSpriteName, v3->pSpriteNames[i]);
|
|
|
2557 pSpriteIDs[i] = pSpriteFrameTable->FastFindSprite(v3->pSpriteNames[i]);
|
|
|
2558 pSpriteFrameTable->InitializeSprite(pSpriteIDs[i]);
|
|
|
2559 }
|
|
|
2560 uActorHeight = v3->uMonsterHeight;
|
|
|
2561 uActorRadius = v3->uMonsterRadius;
|
|
|
2562 uMovementSpeed = v9->uBaseSpeed;
|
|
|
2563 if ( !(load_sounds_if_bit1_set & 1) )
|
|
|
2564 {
|
|
|
2565 for ( int i = 0; i < 4; ++i )
|
|
|
2566 pSoundSampleIDs[i] = v3->pSoundSampleIDs[i];
|
|
|
2567 }
|
|
|
2568 }
|
|
|
2569
|
|
|
2570 //----- (00459667) --------------------------------------------------------
|
|
|
2571 void Actor::Remove()
|
|
|
2572 {
|
|
|
2573 this->uAIState = Removed;
|
|
|
2574 }
|
|
|
2575
|
|
|
2576
|
|
|
2577 //----- (0043B1B0) --------------------------------------------------------
|
|
|
2578 void Actor::ActorDamageFromMonster(signed int attacker_id, unsigned int actor_id, Vec3_int_ *pVelocity, signed int a4)
|
|
|
2579 {
|
|
|
2580 int v4; // ebx@1
|
|
|
2581 int dmgToRecv; // qax@8
|
|
|
2582 signed int v12; // ecx@20
|
|
|
2583 int finalDmg; // edi@30
|
|
|
2584 int pushDistance; // [sp+20h] [bp+Ch]@34
|
|
|
2585
|
|
|
2586 v4 = 0;
|
|
|
2587 if ( PID_TYPE(attacker_id) == OBJECT_Item)
|
|
|
2588 {
|
|
|
2589 v4 = pSpriteObjects[PID_ID(attacker_id)].field_60_distance_related_prolly_lod;
|
|
|
2590 attacker_id = pSpriteObjects[PID_ID(attacker_id)].spell_caster_pid;
|
|
|
2591 }
|
|
|
2592 if ( PID_TYPE(attacker_id) == OBJECT_Actor)
|
|
|
2593 {
|
|
|
2594 if ( !pActors[actor_id].IsNotAlive() )
|
|
|
2595 {
|
|
|
2596 pActors[actor_id].uLastCharacterIDToHit = attacker_id;
|
|
|
2597 if ( pActors[actor_id].uAIState == Fleeing )
|
|
|
2598 pActors[actor_id].uAttributes |= ACTOR_FLEEING;
|
|
|
2599 if ( pActors[PID_ID(attacker_id)]._4273BB_DoesHitOtherActor(&pActors[actor_id], v4, 0) )
|
|
|
2600 {
|
|
|
2601 dmgToRecv = pActors[PID_ID(attacker_id)]._43B3E0_CalcDamage(a4);
|
|
|
2602 if ( pActors[PID_ID(attacker_id)].pActorBuffs[ACTOR_BUFF_SHRINK].uExpireTime > 0 )
|
|
|
2603 {
|
|
|
2604 if ( pActors[PID_ID(attacker_id)].pActorBuffs[ACTOR_BUFF_SHRINK].uPower )
|
|
|
2605 dmgToRecv = dmgToRecv / pActors[PID_ID(attacker_id)].pActorBuffs[ACTOR_BUFF_SHRINK].uPower;
|
|
|
2606 }
|
|
|
2607 if ( pActors[actor_id].pActorBuffs[ACTOR_BUFF_STONED].uExpireTime > 0 )
|
|
|
2608 dmgToRecv = 0;
|
|
|
2609 if ( a4 == 0 )
|
|
|
2610 v12 = pActors[PID_ID(attacker_id)].pMonsterInfo.uAttack1Type;
|
|
|
2611 else if ( a4 == 1 )
|
|
|
2612 {
|
|
|
2613 v12 = pActors[PID_ID(attacker_id)].pMonsterInfo.uAttack2Type;
|
|
|
2614 if ( SHIDWORD(pActors[actor_id].pActorBuffs[ACTOR_BUFF_SHIELD].uExpireTime) > 0 )
|
|
|
2615 dmgToRecv = dmgToRecv / 2;
|
|
|
2616 }
|
|
|
2617 else if ( a4 == 2 )
|
|
|
2618 v12 = pSpellStats->pInfos[pActors[actor_id].pMonsterInfo.uSpell1ID].uSchool;
|
|
|
2619 else if ( a4 == 3 )
|
|
|
2620 v12 = pSpellStats->pInfos[pActors[actor_id].pMonsterInfo.uSpell2ID].uSchool;
|
|
|
2621 else if ( a4 == 4 )
|
|
|
2622 v12 = pActors[PID_ID(attacker_id)].pMonsterInfo.field_3C_some_special_attack;
|
|
|
2623 else
|
|
|
2624 v12 = 4;
|
|
|
2625 finalDmg = pActors[actor_id].CalcMagicalDamageToActor((DAMAGE_TYPE)v12, dmgToRecv);
|
|
|
2626 pActors[actor_id].sCurrentHP -= finalDmg;
|
|
|
2627 if ( finalDmg )
|
|
|
2628 {
|
|
|
2629 if ( pActors[actor_id].sCurrentHP > 0 )
|
|
|
2630 Actor::AI_Stun(actor_id, attacker_id, 0);
|
|
|
2631 else
|
|
|
2632 Actor::Die(actor_id);
|
|
|
2633 Actor::AggroSurroundingPeasants(actor_id, 0);
|
|
|
2634 pushDistance = 20 * finalDmg / pActors[actor_id].pMonsterInfo.uHP;
|
|
|
2635 if ( pushDistance > 10 )
|
|
|
2636 pushDistance = 10;
|
|
|
2637 if ( !MonsterStats::BelongsToSupertype(pActors[actor_id].pMonsterInfo.uID, MONSTER_SUPERTYPE_TREANT) )
|
|
|
2638 {
|
|
|
2639 pVelocity->x = (int32)fixpoint_mul(pushDistance, pVelocity->x);
|
|
|
2640 pVelocity->y = (int32)fixpoint_mul(pushDistance, pVelocity->y);
|
|
|
2641 pVelocity->z = (int32)fixpoint_mul(pushDistance, pVelocity->z);
|
|
|
2642 pActors[actor_id].vVelocity.x = 50 * LOWORD(pVelocity->x);
|
|
|
2643 pActors[actor_id].vVelocity.y = 50 * LOWORD(pVelocity->y);
|
|
|
2644 pActors[actor_id].vVelocity.z = 50 * LOWORD(pVelocity->z);
|
|
|
2645 }
|
|
|
2646 Actor::AddBloodsplatOnDamageOverlay(actor_id, 1, finalDmg);
|
|
|
2647 }
|
|
|
2648 else
|
|
|
2649 Actor::AI_Stun(actor_id, attacker_id, 0);
|
|
|
2650 return;
|
|
|
2651 }
|
|
|
2652 }
|
|
|
2653 }
|
|
|
2654 }
|
|
|
2655
|
|
|
2656 //----- (0044FD29) --------------------------------------------------------
|
|
|
2657 void Actor::SummonMinion( int summonerId )
|
|
|
2658 {
|
|
|
2659 unsigned __int8 extraSummonLevel; // al@1
|
|
|
2660 int summonMonsterBaseType; // esi@1
|
|
|
2661 int v5; // edx@2
|
|
|
2662 int v7; // edi@10
|
|
|
2663 Actor *actor; // esi@10
|
|
|
2664 MonsterInfo *v9; // ebx@10
|
|
|
2665 //MonsterDesc *v10; // edi@10
|
|
|
2666 int v13; // ebx@10
|
|
|
2667 int v15; // edi@10
|
|
|
2668 int v17; // ebx@10
|
|
|
2669 unsigned int v19; // qax@10
|
|
|
2670 int result; // eax@13
|
|
|
2671 unsigned int monsterId; // [sp+10h] [bp-18h]@8
|
|
|
2672 int v27; // [sp+18h] [bp-10h]@10
|
|
|
2673 int actorSector; // [sp+1Ch] [bp-Ch]@8
|
|
|
2674
|
|
|
2675
|
|
|
2676 actorSector = 0;
|
|
|
2677 if ( uCurrentlyLoadedLevelType == LEVEL_Indoor )
|
|
|
2678 actorSector = pIndoor->GetSector(this->vPosition.x, this->vPosition.y, this->vPosition.z);
|
|
|
2679
|
|
|
2680 v19 = this->uAlly;
|
|
|
2681 if ( !this->uAlly )
|
|
|
2682 {
|
|
|
2683 monsterId = this->pMonsterInfo.uID - 1;
|
|
|
2684 v19 = (uint)(monsterId * 0.33333334);
|
|
|
2685 }
|
|
|
2686 v27 = uCurrentlyLoadedLevelType == LEVEL_Outdoor ? 128 : 64;
|
|
|
2687 v13 = rand() % 2048;
|
|
|
2688 v15 = fixpoint_mul(stru_5C6E00->Cos(v13), v27) + this->vPosition.x;
|
|
|
2689 v17 = fixpoint_mul(stru_5C6E00->Sin(v13), v27) + this->vPosition.y;
|
|
|
2690
|
|
|
2691 if (uCurrentlyLoadedLevelType == LEVEL_Indoor)
|
|
|
2692 {
|
|
|
2693 result = pIndoor->GetSector(v15, v17, this->vPosition.z);
|
|
|
2694 if (result != actorSector)
|
|
|
2695 return;
|
|
|
2696 result = BLV_GetFloorLevel(v15, v17, v27, result, &monsterId);
|
|
|
2697 if (result != -30000)
|
|
|
2698 return;
|
|
|
2699 if (abs(result - v27) > 1024)
|
|
|
2700 return;
|
|
|
2701 }
|
|
|
2702
|
|
|
2703 extraSummonLevel = this->pMonsterInfo.uSpecialAbilityDamageDiceRolls;
|
|
|
2704 summonMonsterBaseType = this->pMonsterInfo.field_3C_some_special_attack;
|
|
|
2705 if ( extraSummonLevel )
|
|
|
2706 {
|
|
|
2707 if ( extraSummonLevel >= 1 && extraSummonLevel <= 3 )
|
|
|
2708 summonMonsterBaseType = summonMonsterBaseType + extraSummonLevel - 1;
|
|
|
2709 }
|
|
|
2710 else
|
|
|
2711 {
|
|
|
2712 v5 = rand() % 100;
|
|
|
2713 if ( v5 >= 90 )
|
|
|
2714 summonMonsterBaseType += 2;
|
|
|
2715 else if ( v5 >= 60 )
|
|
|
2716 summonMonsterBaseType += 1;
|
|
|
2717 }
|
|
|
2718 v7 = summonMonsterBaseType - 1;
|
|
|
2719 actor = &pActors[uNumActors];
|
|
|
2720 v9 = &pMonsterStats->pInfos[v7 + 1];
|
|
|
2721 pActors[uNumActors].Reset();
|
|
|
2722 strcpy(actor->pActorName, v9->pName);
|
|
|
2723 actor->sCurrentHP = LOWORD(v9->uHP);
|
|
|
2724 memcpy(&actor->pMonsterInfo, v9, sizeof(actor->pMonsterInfo));
|
|
|
2725 actor->word_000086_some_monster_id = summonMonsterBaseType;
|
|
|
2726 actor->uActorRadius = pMonsterList->pMonsters[v7].uMonsterRadius;
|
|
|
2727 actor->uActorHeight = pMonsterList->pMonsters[v7].uMonsterHeight;
|
|
|
2728 actor->pMonsterInfo.uTreasureDiceRolls = 0;
|
|
|
2729 actor->pMonsterInfo.uTreasureType = 0;
|
|
|
2730 actor->pMonsterInfo.uExp = 0;
|
|
|
2731 actor->uMovementSpeed = pMonsterList->pMonsters[v7].uMovementSpeed;
|
|
|
2732
|
|
|
2733 actor->vInitialPosition.x = v15;
|
|
|
2734 actor->vInitialPosition.y = v17;
|
|
|
2735 actor->vInitialPosition.z = this->vPosition.z;
|
|
|
2736 actor->vPosition.x = v15;
|
|
|
2737 actor->vPosition.y = v17;
|
|
|
2738 actor->vPosition.z = this->vPosition.z;
|
|
|
2739
|
|
|
2740 actor->uTetherDistance = 256;
|
|
|
2741 actor->uSectorID = actorSector;
|
|
|
2742 actor->PrepareSprites(0);
|
|
|
2743 actor->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Friendly;
|
|
|
2744 actor->uAlly = v19;
|
|
|
2745 actor->uCurrentActionTime = 0;
|
|
|
2746 actor->uGroup = this->uGroup;
|
|
|
2747 actor->uAIState = Summoned;
|
|
|
2748 actor->uCurrentActionLength = 256;
|
|
|
2749 actor->UpdateAnimation();
|
|
|
2750
|
|
|
2751 ++uNumActors;
|
|
|
2752 ++this->pMonsterInfo.uSpecialAbilityDamageDiceBonus;
|
|
|
2753 if ( ActorEnemy())
|
|
|
2754 actor->uAttributes |= ACTOR_AGGRESSOR;
|
|
|
2755 actor->uSummonerID = PID(OBJECT_Actor,summonerId);
|
|
|
2756
|
|
|
2757 }
|
|
|
2758 // 46DF1A: using guessed type int __fastcall 46DF1A_collide_against_actor(int, int);
|
|
|
2759 //----- (0046DF1A) --------------------------------------------------------
|
|
|
2760 bool Actor::_46DF1A_collide_against_actor( int a1, int a2 )
|
|
|
2761 {
|
|
|
2762 Actor *v2; // edi@1
|
|
|
2763 unsigned __int16 v3; // ax@1
|
|
|
2764 int v4; // esi@6
|
|
|
2765 int v8; // ecx@14
|
|
|
2766 int v9; // eax@14
|
|
|
2767 int v10; // ebx@14
|
|
|
2768 int v11; // esi@14
|
|
|
2769 int v12; // ebx@15
|
|
|
2770 int v13; // ebx@17
|
|
|
2771
|
|
|
2772 v2 = &pActors[a1];
|
|
|
2773 v3 = v2->uAIState;
|
|
|
2774 if ( v3 == Removed || v3 == Dying || v3 == Disabled || v3 == Dead || v3 == Summoned )
|
|
|
2775 return 0;
|
|
|
2776 v4 = v2->uActorRadius;
|
|
|
2777 if ( a2 )
|
|
|
2778 v4 = a2;
|
|
|
2779
|
|
|
2780 if (stru_721530.sMaxX > v2->vPosition.x + v4 ||
|
|
|
2781 stru_721530.sMinX < v2->vPosition.x - v4 ||
|
|
|
2782 stru_721530.sMaxY > v2->vPosition.y + v4 ||
|
|
|
2783 stru_721530.sMinY < v2->vPosition.y - v4 ||
|
|
|
2784 stru_721530.sMaxZ > v2->vPosition.z + v2->uActorHeight ||
|
|
|
2785 stru_721530.sMinZ < v2->vPosition.z)
|
|
|
2786 {
|
|
|
2787 return false;
|
|
|
2788 }
|
|
|
2789 v8 = v2->vPosition.x - stru_721530.normal.x;
|
|
|
2790 v9 = v2->vPosition.y - stru_721530.normal.y;
|
|
|
2791 v10 = stru_721530.prolly_normal_d + v4;
|
|
|
2792 v11 = (v8 * stru_721530.direction.y - v9 * stru_721530.direction.x) >> 16;
|
|
|
2793 v12 = (v8 * stru_721530.direction.x + v9 * stru_721530.direction.y) >> 16;
|
|
|
2794 if ( abs(v11) > v10 || v12 <= 0)
|
|
|
2795 return false;
|
|
|
2796 if (fixpoint_mul(stru_721530.direction.z, v12) + stru_721530.normal.z < v2->vPosition.z)
|
|
|
2797 return false;
|
|
|
2798
|
|
|
2799 v13 = v12 - integer_sqrt(v10 * v10 - v11 * v11);
|
|
|
2800 if ( v13 < 0 )
|
|
|
2801 v13 = 0;
|
|
|
2802 if ( v13 < stru_721530.field_7C )
|
|
|
2803 {
|
|
|
2804 stru_721530.field_7C = v13;
|
|
|
2805 stru_721530.uFaceID = PID(OBJECT_Actor,a1);
|
|
|
2806 }
|
|
|
2807 return true;
|
|
|
2808 }
|
|
|
2809 //----- (00401A91) --------------------------------------------------------
|
|
|
2810 void Actor::UpdateActorAI()
|
|
|
2811 {
|
|
|
2812 signed int v4; // edi@10
|
|
|
2813 signed int sDmg; // eax@14
|
|
|
2814 Player *pPlayer; // ecx@21
|
|
|
2815 Actor *pActor; // esi@34
|
|
|
2816 //unsigned __int16 v22; // ax@86
|
|
|
2817 unsigned int v27; // ecx@123
|
|
|
2818 unsigned int v28; // eax@123
|
|
|
2819 int v33; // eax@144
|
|
|
2820 int v34; // eax@147
|
|
|
2821 char v35; // al@150
|
|
|
2822 unsigned int v36; // edi@152
|
|
|
2823 signed int v37; // eax@154
|
|
|
2824 double v42; // st7@176
|
|
|
2825 double v43; // st6@176
|
|
|
2826 int v45; // eax@192
|
|
|
2827 unsigned __int8 v46; // cl@197
|
|
|
2828 signed int v47; // st7@206
|
|
|
2829 uint v58; // st7@246
|
|
|
2830 unsigned int v65; // [sp-10h] [bp-C0h]@144
|
|
|
2831 int v70; // [sp-10h] [bp-C0h]@213
|
|
|
2832 AIDirection v72; // [sp+0h] [bp-B0h]@246
|
|
|
2833 AIDirection a3; // [sp+1Ch] [bp-94h]@129
|
|
|
2834 int target_pid_type; // [sp+70h] [bp-40h]@83
|
|
|
2835 signed int a1; // [sp+74h] [bp-3Ch]@129
|
|
|
2836 int v78; // [sp+78h] [bp-38h]@79
|
|
|
2837 AIDirection* pDir; // [sp+7Ch] [bp-34h]@129
|
|
|
2838 float radiusMultiplier; // [sp+98h] [bp-18h]@33
|
|
|
2839 int v81; // [sp+9Ch] [bp-14h]@100
|
|
|
2840 signed int target_pid; // [sp+ACh] [bp-4h]@83
|
|
|
2841 AIState uAIState;
|
|
|
2842 uint v38;
|
|
|
2843
|
|
|
2844 //Build AI array
|
|
|
2845 if ( uCurrentlyLoadedLevelType == LEVEL_Outdoor)
|
|
|
2846 Actor::MakeActorAIList_ODM();
|
|
|
2847 else
|
|
|
2848 Actor::MakeActorAIList_BLV();
|
|
|
2849
|
|
|
2850 //Armageddon damage mechanic
|
|
|
2851 if ( uCurrentlyLoadedLevelType != LEVEL_Indoor && pParty->armageddon_timer > 0 )
|
|
|
2852 {
|
|
|
2853 if ( pParty->armageddon_timer > 417 )
|
|
|
2854 pParty->armageddon_timer = 0;
|
|
|
2855 else
|
|
|
2856 {
|
|
|
2857 pParty->sRotationY = (stru_5C6E00->uIntegerDoublePi - 1) & (pParty->sRotationY + rand() % 16 - 8);
|
|
|
2858 pParty->sRotationX = pParty->sRotationX + rand() % 16 - 8;
|
|
|
2859 if ( pParty->sRotationX > 128)
|
|
|
2860 pParty->sRotationX = 128;
|
|
|
2861 else if ( pParty->sRotationX < -128 )
|
|
|
2862 pParty->sRotationX = -128;
|
|
|
2863
|
|
|
2864 pParty->uFlags |= 2u;
|
|
|
2865 pParty->armageddon_timer -= pMiscTimer->uTimeElapsed;
|
|
|
2866 v4 = pParty->armageddonDamage + 50;
|
|
|
2867 if ( pParty->armageddon_timer <= 0 )
|
|
|
2868 {
|
|
|
2869 pParty->armageddon_timer = 0;
|
|
|
2870 for(size_t i = 0; i < uNumActors; i++)
|
|
|
2871 {
|
|
|
2872 pActor=&pActors[i];
|
|
|
2873 if ( pActor->CanAct() )
|
|
|
2874 {
|
|
|
2875 sDmg = pActor->CalcMagicalDamageToActor((DAMAGE_TYPE)5, v4);
|
|
|
2876 pActor->sCurrentHP -= sDmg;
|
|
|
2877 if ( sDmg )
|
|
|
2878 {
|
|
|
2879 if ( pActor->sCurrentHP >= 0 )
|
|
|
2880 Actor::AI_Stun(i, 4, 0);
|
|
|
2881 else
|
|
|
2882 {
|
|
|
2883 Actor::Die(i);
|
|
|
2884 if ( pActor->pMonsterInfo.uExp )
|
|
|
2885 pParty->GivePartyExp(pMonsterStats->pInfos[pActor->pMonsterInfo.uID].uExp);
|
|
|
2886 }
|
|
|
2887 }
|
|
|
2888 }
|
|
|
2889 }
|
|
|
2890 for(int i = 1; i <= 4; i++)
|
|
|
2891 {
|
|
|
2892 pPlayer = pPlayers[i];
|
|
|
2893 if ( !pPlayer->pConditions[Condition_Dead] && !pPlayer->pConditions[Condition_Pertified] && !pPlayer->pConditions[Condition_Eradicated] )
|
|
|
2894 pPlayer->ReceiveDamage(v4, DMGT_MAGICAL);
|
|
|
2895 }
|
|
|
2896 }
|
|
|
2897 if (pTurnEngine->pending_actions)
|
|
|
2898 --pTurnEngine->pending_actions;
|
|
|
2899 }
|
|
|
2900 }
|
|
|
2901
|
|
|
2902 //Turn-based mode: return
|
|
|
2903 if (pParty->bTurnBasedModeOn)
|
|
|
2904 {
|
|
|
2905 pTurnEngine->AITurnBasedAction();
|
|
|
2906 return;
|
|
|
2907 }
|
|
|
2908
|
|
|
2909 for (uint i = 0; i < uNumActors; ++i)
|
|
|
2910 {
|
|
|
2911 pActor = &pActors[i];
|
|
|
2912 ai_near_actors_targets_pid[i] = OBJECT_Player;
|
|
|
2913
|
|
|
2914 //Skip actor if: Dead / Removed / Disabled / uAttributes & 0x0400
|
|
|
2915 if (pActor->uAIState == Dead || pActor->uAIState == Removed || pActor->uAIState == Disabled || pActor->uAttributes & ACTOR_ALIVE)
|
|
|
2916 continue;
|
|
|
2917
|
|
|
2918 //Kill actor if HP == 0
|
|
|
2919 if (!pActor->sCurrentHP && pActor->uAIState != Dying)
|
|
|
2920 Actor::Die(i);
|
|
|
2921
|
|
|
2922 //Kill buffs if expired
|
|
|
2923 for (uint j = 0; j < 22; ++j)
|
|
|
2924 {
|
|
|
2925 if (j != 10)
|
|
|
2926 pActor->pActorBuffs[j].IsBuffExpiredToTime(pParty->uTimePlayed);
|
|
|
2927 }
|
|
|
2928
|
|
|
2929 //If shrink expired: reset height
|
|
|
2930 if (pActor->pActorBuffs[ACTOR_BUFF_SHRINK].uExpireTime < 0)
|
|
|
2931 pActor->uActorHeight = pMonsterList->pMonsters[pActor->pMonsterInfo.uID - 1].uMonsterHeight;
|
|
|
2932
|
|
|
2933 //If Charm still active: make actor friendly
|
|
|
2934 if (pActor->pActorBuffs[ACTOR_BUFF_CHARM].uExpireTime > 0)
|
|
|
2935 pActor->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Friendly;
|
|
|
2936 //Else: reset hostilty
|
|
|
2937 else if (pActor->pActorBuffs[ACTOR_BUFF_CHARM].uExpireTime < 0)
|
|
|
2938 pActor->pMonsterInfo.uHostilityType = pMonsterStats->pInfos[pActor->pMonsterInfo.uID].uHostilityType;
|
|
|
2939
|
|
|
2940 //If actor Paralyzed or Stoned: skip
|
|
|
2941 if (pActor->pActorBuffs[ACTOR_BUFF_PARALYZED].uExpireTime > 0 || pActor->pActorBuffs[ACTOR_BUFF_STONED].uExpireTime > 0)
|
|
|
2942 continue;
|
|
|
2943
|
|
|
2944 //Calculate RecoveryTime
|
|
|
2945 pActor->pMonsterInfo.uRecoveryTime = max(pActor->pMonsterInfo.uRecoveryTime - pMiscTimer->uTimeElapsed, 0);
|
|
|
2946
|
|
|
2947 pActor->uCurrentActionTime += pMiscTimer->uTimeElapsed;
|
|
|
2948 if (pActor->uCurrentActionTime < pActor->uCurrentActionLength)
|
|
|
2949 continue;
|
|
|
2950
|
|
|
2951 if (pActor->uAIState == Dying)
|
|
|
2952 pActor->uAIState = Dead;
|
|
|
2953 else
|
|
|
2954 {
|
|
|
2955 if (pActor->uAIState != Summoned)
|
|
|
2956 {
|
|
|
2957 Actor::AI_StandOrBored(i, OBJECT_Player, 256, nullptr);
|
|
|
2958 continue;
|
|
|
2959 }
|
|
|
2960 pActor->uAIState = Standing;
|
|
|
2961 }
|
|
|
2962
|
|
|
2963 pActor->uCurrentActionTime = 0;
|
|
|
2964 pActor->uCurrentActionLength = 0;
|
|
|
2965 pActor->UpdateAnimation();
|
|
|
2966 }
|
|
|
2967
|
|
|
2968 for(v78 = 0; v78 < ai_arrays_size; ++v78)
|
|
|
2969 {
|
|
|
2970 uint actor_id = ai_near_actors_ids[v78];
|
|
|
2971 assert(actor_id < uNumActors);
|
|
|
2972
|
|
|
2973 pActor = &pActors[actor_id];
|
|
|
2974
|
|
|
2975 v47 = (signed int)(pActor->pMonsterInfo.uRecoveryTime * 2.133333333333333);
|
|
|
2976
|
|
|
2977 Actor::_SelectTarget(actor_id, &ai_near_actors_targets_pid[actor_id], true);
|
|
|
2978
|
|
|
2979 if (pActor->pMonsterInfo.uHostilityType && !ai_near_actors_targets_pid[actor_id])
|
|
|
2980 pActor->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Friendly;
|
|
|
2981
|
|
|
2982 target_pid = ai_near_actors_targets_pid[actor_id];
|
|
|
2983 target_pid_type = PID_TYPE(target_pid);
|
|
|
2984
|
|
|
2985 if ( target_pid_type == OBJECT_Actor)
|
|
|
2986 radiusMultiplier = 0.5;
|
|
|
2987 else
|
|
|
2988 radiusMultiplier = 1.0;
|
|
|
2989
|
|
|
2990 //v22 = pActor->uAIState;
|
|
|
2991 if ( pActor->uAIState == Dying || pActor->uAIState == Dead || pActor->uAIState == Removed
|
|
|
2992 || pActor->uAIState == Disabled || pActor->uAIState == Summoned)
|
|
|
2993 continue;
|
|
|
2994
|
|
|
2995 if ( !pActor->sCurrentHP )
|
|
|
2996 Actor::Die(actor_id);
|
|
|
2997
|
|
|
2998 for( int i = 0;i < 22; i++ )
|
|
|
2999 {
|
|
|
3000 if ( i != 10 )
|
|
|
3001 pActor->pActorBuffs[i].IsBuffExpiredToTime(pParty->uTimePlayed);
|
|
|
3002 }
|
|
|
3003
|
|
|
3004 if ( pActor->pActorBuffs[ACTOR_BUFF_SHRINK].uExpireTime < 0 )
|
|
|
3005 pActor->uActorHeight = pMonsterList->pMonsters[pActor->pMonsterInfo.uID - 1].uMonsterHeight;
|
|
|
3006 if ( pActor->pActorBuffs[ACTOR_BUFF_CHARM].uExpireTime > 0 )
|
|
|
3007 pActor->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Friendly;
|
|
|
3008 else if ( pActor->pActorBuffs[ACTOR_BUFF_CHARM].uExpireTime < 0 )
|
|
|
3009 pActor->pMonsterInfo.uHostilityType = pMonsterStats->pInfos[pActor->pMonsterInfo.uID].uHostilityType;
|
|
|
3010
|
|
|
3011 //If actor is summoned and buff expired: continue and set state to Removed
|
|
|
3012 if ( pActor->pActorBuffs[ACTOR_BUFF_SUMMONED].uExpireTime < 0 )
|
|
|
3013 {
|
|
|
3014 pActor->uAIState = Removed;
|
|
|
3015 continue;
|
|
|
3016 }
|
|
|
3017
|
|
|
3018 if ( (signed __int64)pActor->pActorBuffs[ACTOR_BUFF_STONED].uExpireTime > 0 || (signed __int64)pActor->pActorBuffs[ACTOR_BUFF_PARALYZED].uExpireTime > 0)
|
|
|
3019 {
|
|
|
3020 continue;
|
|
|
3021 }
|
|
|
3022
|
|
|
3023 v27 = pMiscTimer->uTimeElapsed;
|
|
|
3024 v28 = pActor->pMonsterInfo.uRecoveryTime;
|
|
|
3025 pActor->uCurrentActionTime += pMiscTimer->uTimeElapsed;
|
|
|
3026
|
|
|
3027 if ( (signed int)v28 > 0 )
|
|
|
3028 pActor->pMonsterInfo.uRecoveryTime = v28 - v27;
|
|
|
3029 if ( pActor->pMonsterInfo.uRecoveryTime < 0 )
|
|
|
3030 pActor->pMonsterInfo.uRecoveryTime = 0;
|
|
|
3031 if ( !pActor->ActorNearby() )
|
|
|
3032 pActor->uAttributes |= ACTOR_NEARBY;
|
|
|
3033
|
|
|
3034 a1 = PID(OBJECT_Actor,actor_id);
|
|
|
3035 Actor::GetDirectionInfo(PID(OBJECT_Actor,actor_id), target_pid, &a3, 0);
|
|
|
3036 pDir = &a3;
|
|
|
3037 uAIState = pActor->uAIState;
|
|
|
3038
|
|
|
3039 if ( pActor->pMonsterInfo.uHostilityType == MonsterInfo::Hostility_Friendly
|
|
|
3040 || (signed int)pActor->pMonsterInfo.uRecoveryTime > 0
|
|
|
3041 || radiusMultiplier * 307.2 < pDir->uDistance
|
|
|
3042 || uAIState != Pursuing && uAIState != Standing && uAIState != Tethered && uAIState != Fidgeting
|
|
|
3043 && !pActor->pMonsterInfo.uMissleAttack1Type || uAIState != Stunned )
|
|
|
3044 {
|
|
|
3045 if ( (signed int)pActor->uCurrentActionTime < pActor->uCurrentActionLength )
|
|
|
3046 continue;
|
|
|
3047 else if ( pActor->uAIState == AttackingMelee )
|
|
|
3048 {
|
|
|
3049 v35 = pActor->special_ability_use_check(actor_id);
|
|
|
3050 AttackerInfo.Add(a1, 5120, pActor->vPosition.x, pActor->vPosition.y, pActor->vPosition.z + ((signed int)pActor->uActorHeight >> 1), v35, 1 );
|
|
|
3051 }
|
|
|
3052 else if ( pActor->uAIState == AttackingRanged1 )
|
|
|
3053 {
|
|
|
3054 v34 = pActor->pMonsterInfo.uMissleAttack1Type;
|
|
|
3055 Actor::AI_RangedAttack(actor_id, pDir, v34, 0);
|
|
|
3056 }
|
|
|
3057 else if ( pActor->uAIState == AttackingRanged2 )
|
|
|
3058 {
|
|
|
3059 v34 = pActor->pMonsterInfo.uMissleAttack2Type;
|
|
|
3060 Actor::AI_RangedAttack(actor_id, pDir, v34, 1);
|
|
|
3061 }
|
|
|
3062 else if ( pActor->uAIState == AttackingRanged3 )
|
|
|
3063 {
|
|
|
3064 v65 = pActor->pMonsterInfo.uSpellSkillAndMastery1;
|
|
|
3065 v33 = pActor->pMonsterInfo.uSpell1ID;
|
|
|
3066 Actor::AI_SpellAttack(actor_id, pDir, v33, 2, v65);
|
|
|
3067 }
|
|
|
3068 else if ( pActor->uAIState == AttackingRanged4 )
|
|
|
3069 {
|
|
|
3070 v65 = pActor->pMonsterInfo.uSpellSkillAndMastery2;
|
|
|
3071 v33 = pActor->pMonsterInfo.uSpell2ID;
|
|
|
3072 Actor::AI_SpellAttack(actor_id, pDir, v33, 3, v65);
|
|
|
3073 }
|
|
|
3074 }
|
|
|
3075
|
|
|
3076 v36 = pDir->uDistance;
|
|
|
3077
|
|
|
3078 if ( pActor->pMonsterInfo.uHostilityType == MonsterInfo::Hostility_Friendly)
|
|
|
3079 {
|
|
|
3080 if ( target_pid_type == OBJECT_Actor )
|
|
|
3081 {
|
|
|
3082 v36 = pDir->uDistance;
|
|
|
3083 v37 =pFactionTable->relations[(pActor->pMonsterInfo.uID-1) / 3 + 1][(pActors[PID_ID(target_pid)].pMonsterInfo.uID - 1) / 3 + 1];
|
|
|
3084 }
|
|
|
3085 else
|
|
|
3086 v37 = 4;
|
|
|
3087 v38 = 0;
|
|
|
3088 if ( v37 == 2 )
|
|
|
3089 v38 = 1024;
|
|
|
3090 else if ( v37 == 3 )
|
|
|
3091 v38 = 2560;
|
|
|
3092 else if ( v37 == 4 )
|
|
|
3093 v38 = 5120;
|
|
|
3094 if ( v37 >= 1 && v37 <= 4 && v36 < v38 || v37 == 1 )
|
|
|
3095 pActor->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
|
|
|
3096 }
|
|
|
3097
|
|
|
3098 //If actor afraid: flee or if out of range random move
|
|
|
3099 if (pActor->pActorBuffs[ACTOR_BUFF_AFRAID].uExpireTime > 0)
|
|
|
3100 {
|
|
|
3101 if ( (signed int)v36 >= 10240 )
|
|
|
3102 Actor::AI_RandomMove(actor_id, target_pid, 1024, 0);
|
|
|
3103 else
|
|
|
3104 Actor::AI_Flee(actor_id, target_pid, 0, pDir);
|
|
|
3105 continue;
|
|
|
3106 }
|
|
|
3107
|
|
|
3108 if ( pActor->pMonsterInfo.uHostilityType == MonsterInfo::Hostility_Long && target_pid )
|
|
|
3109 {
|
|
|
3110 if ( pActor->pMonsterInfo.uAIType == 1 )
|
|
|
3111 {
|
|
|
3112 if ( pActor->pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_STAIONARY )
|
|
|
3113 Actor::AI_Stand(actor_id, target_pid, (uint)(pActor->pMonsterInfo.uRecoveryTime * 2.133333333333333), pDir);
|
|
|
3114 else
|
|
|
3115 {
|
|
|
3116 Actor::AI_Flee(actor_id, target_pid, 0, pDir);
|
|
|
3117 continue;
|
|
|
3118 }
|
|
|
3119
|
|
|
3120 }
|
|
|
3121 if ( !(pActor->uAttributes & ACTOR_FLEEING) )
|
|
|
3122 {
|
|
|
3123 if ( pActor->pMonsterInfo.uAIType == 2 || pActor->pMonsterInfo.uAIType == 3)
|
|
|
3124 {
|
|
|
3125 if ( pActor->pMonsterInfo.uAIType == 2 )
|
|
|
3126 v43 = (double)(signed int)pActor->pMonsterInfo.uHP * 0.2;
|
|
|
3127 if ( pActor->pMonsterInfo.uAIType == 3 )
|
|
|
3128 v43 = (double)(signed int)pActor->pMonsterInfo.uHP * 0.1;
|
|
|
3129 v42 = (double)pActor->sCurrentHP;
|
|
|
3130 if ( v43 > v42 && (signed int)v36 < 10240 )
|
|
|
3131 {
|
|
|
3132 Actor::AI_Flee(actor_id, target_pid, 0, pDir);
|
|
|
3133 continue;
|
|
|
3134 }
|
|
|
3135 }
|
|
|
3136 }
|
|
|
3137
|
|
|
3138 v81 = v36 - pActor->uActorRadius;
|
|
|
3139 if ( target_pid_type == OBJECT_Actor )
|
|
|
3140 v81 -= pActors[PID_ID(target_pid)].uActorRadius;
|
|
|
3141 if ( v81 < 0 )
|
|
|
3142 v81 = 0;
|
|
|
3143 rand();
|
|
|
3144 pActor->uAttributes &= ~ACTOR_UNKNOW5;//~0x40000
|
|
|
3145 if ( v81 < 5120 )
|
|
|
3146 {
|
|
|
3147 v45 = pActor->special_ability_use_check(actor_id);
|
|
|
3148 if ( v45 == 0 )
|
|
|
3149 {
|
|
|
3150 if ( pActor->pMonsterInfo.uMissleAttack1Type )
|
|
|
3151 {
|
|
|
3152 if ( (signed int)pActor->pMonsterInfo.uRecoveryTime <= 0 )
|
|
|
3153 Actor::AI_MissileAttack1(actor_id, target_pid, pDir);
|
|
|
3154 else if ( pActor->pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_STAIONARY )
|
|
|
3155 Actor::AI_Stand(actor_id, target_pid, v47, pDir);
|
|
|
3156 else
|
|
|
3157 {
|
|
|
3158 if ( radiusMultiplier * 307.2 > (double)v81 )
|
|
|
3159 Actor::AI_Stand(actor_id, target_pid, v47, pDir);
|
|
|
3160 else
|
|
|
3161 Actor::AI_Pursue1(actor_id, target_pid, actor_id, v47, pDir);
|
|
|
3162 }
|
|
|
3163 }
|
|
|
3164 else
|
|
|
3165 {
|
|
|
3166 if ( (double)v81 >= radiusMultiplier * 307.2 )
|
|
|
3167 {
|
|
|
3168 if (pActor->pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_STAIONARY)
|
|
|
3169 Actor::AI_Stand(actor_id, target_pid, v47, pDir);
|
|
|
3170 else if ( v81 >= 1024 )//monsters
|
|
|
3171 Actor::AI_Pursue3(actor_id, target_pid, 0, pDir);
|
|
|
3172 else
|
|
|
3173 {
|
|
|
3174 v70 = (signed int)(radiusMultiplier * 307.2);
|
|
|
3175 //monsters
|
|
|
3176 //guard after player runs away
|
|
|
3177 // follow player
|
|
|
3178 Actor::AI_Pursue2(actor_id, target_pid, 0, pDir, v70);
|
|
|
3179 }
|
|
|
3180 }
|
|
|
3181 else if ( (signed int)pActor->pMonsterInfo.uRecoveryTime > 0 )
|
|
|
3182 {
|
|
|
3183 Actor::AI_Stand(actor_id, target_pid, v47, pDir);
|
|
|
3184 }
|
|
|
3185 else
|
|
|
3186 {
|
|
|
3187 //monsters
|
|
|
3188 Actor::AI_MeleeAttack(actor_id, target_pid, pDir);
|
|
|
3189 }
|
|
|
3190 }
|
|
|
3191 continue;
|
|
|
3192 }
|
|
|
3193 else if ( v45 == 2 || v45 == 3 )
|
|
|
3194 {
|
|
|
3195 if ( v45 == 2 )
|
|
|
3196 v46 = pActor->pMonsterInfo.uSpell1ID;
|
|
|
3197 else
|
|
|
3198 v46 = pActor->pMonsterInfo.uSpell2ID;
|
|
|
3199 if ( v46 )
|
|
|
3200 {
|
|
|
3201 if ( (signed int)pActor->pMonsterInfo.uRecoveryTime <= 0 )
|
|
|
3202 {
|
|
|
3203 if ( v45 == 2 )
|
|
|
3204 Actor::AI_SpellAttack1(actor_id, target_pid, pDir);
|
|
|
3205 else
|
|
|
3206 Actor::AI_SpellAttack2(actor_id, target_pid, pDir);
|
|
|
3207 }
|
|
|
3208 else if ( radiusMultiplier * 307.2 > (double)v81 || pActor->pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_STAIONARY )
|
|
|
3209 Actor::AI_Stand(actor_id, target_pid, v47, pDir);
|
|
|
3210 else
|
|
|
3211 Actor::AI_Pursue1(actor_id, target_pid, actor_id, v47, pDir);
|
|
|
3212 }
|
|
|
3213 else
|
|
|
3214 {
|
|
|
3215 if ( (double)v81 >= radiusMultiplier * 307.2 )
|
|
|
3216 {
|
|
|
3217 if ( pActor->pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_STAIONARY )
|
|
|
3218 Actor::AI_Stand(actor_id, target_pid, v47, pDir);
|
|
|
3219 else if ( v81 >= 1024 )
|
|
|
3220 Actor::AI_Pursue3(actor_id, target_pid, 256, pDir);
|
|
|
3221 else
|
|
|
3222 {
|
|
|
3223 v70 = (signed int)(radiusMultiplier * 307.2);
|
|
|
3224 Actor::AI_Pursue2(actor_id, target_pid, 0, pDir, v70);
|
|
|
3225 }
|
|
|
3226 }
|
|
|
3227 else if ( (signed int)pActor->pMonsterInfo.uRecoveryTime > 0 )
|
|
|
3228 {
|
|
|
3229 Actor::AI_Stand(actor_id, target_pid, v47, pDir);
|
|
|
3230 }
|
|
|
3231 else
|
|
|
3232 {
|
|
|
3233 Actor::AI_MeleeAttack(actor_id, target_pid, pDir);
|
|
|
3234 }
|
|
|
3235 }
|
|
|
3236 continue;
|
|
|
3237 }
|
|
|
3238 }
|
|
|
3239 }
|
|
|
3240
|
|
|
3241 if ( pActor->pMonsterInfo.uHostilityType != MonsterInfo::Hostility_Long || !target_pid || v81 >= 5120 || v45 != 1 )
|
|
|
3242 {
|
|
|
3243 if ( pActor->pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_SHORT )
|
|
|
3244 Actor::AI_RandomMove(actor_id, 4, 1024, 0);
|
|
|
3245 else if ( pActor->pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_MEDIUM )
|
|
|
3246 Actor::AI_RandomMove(actor_id, 4, 2560, 0);
|
|
|
3247 else if ( pActor->pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_LONG )
|
|
|
3248 Actor::AI_RandomMove(actor_id, 4, 5120, 0);
|
|
|
3249 else if ( pActor->pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_FREE )
|
|
|
3250 Actor::AI_RandomMove(actor_id, 4, 10240, 0);
|
|
|
3251 else if ( pActor->pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_STAIONARY )
|
|
|
3252 {
|
|
|
3253 Actor::GetDirectionInfo(a1, 4, &v72, 0);
|
|
|
3254 v58 = (uint)(pActor->pMonsterInfo.uRecoveryTime * 2.133333333333333);
|
|
|
3255 Actor::AI_Stand(actor_id, 4, v58, &v72);
|
|
|
3256 }
|
|
|
3257 }
|
|
|
3258 else if ( !pActor->pMonsterInfo.uMissleAttack2Type )
|
|
|
3259 {
|
|
|
3260 if ( (double)v81 >= radiusMultiplier * 307.2 )
|
|
|
3261 {
|
|
|
3262 if ( pActor->pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_STAIONARY )
|
|
|
3263 Actor::AI_Stand(actor_id, target_pid, v47, pDir);
|
|
|
3264 else if ( v81 >= 1024 )
|
|
|
3265 Actor::AI_Pursue3(actor_id, target_pid, 256, pDir);
|
|
|
3266 else
|
|
|
3267 {
|
|
|
3268 v70 = (int)(radiusMultiplier * 307.2);
|
|
|
3269 Actor::AI_Pursue2(actor_id, target_pid, 0, pDir, v70);
|
|
|
3270 }
|
|
|
3271 }
|
|
|
3272 else if ( (signed int)pActor->pMonsterInfo.uRecoveryTime > 0 )
|
|
|
3273 Actor::AI_Stand(actor_id, target_pid, v47, pDir);
|
|
|
3274 else
|
|
|
3275 Actor::AI_MeleeAttack(actor_id, target_pid, pDir);
|
|
|
3276 }
|
|
|
3277 else if ( (signed int)pActor->pMonsterInfo.uRecoveryTime > 0 )
|
|
|
3278 {
|
|
|
3279 if ( radiusMultiplier * 307.2 > (double)v81 || pActor->pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_STAIONARY )
|
|
|
3280 Actor::AI_Stand(actor_id, target_pid, v47, pDir);
|
|
|
3281 else
|
|
|
3282 Actor::AI_Pursue1(actor_id, target_pid, actor_id, v47, pDir);
|
|
|
3283 }
|
|
|
3284 else
|
|
|
3285 Actor::AI_MissileAttack2(actor_id, target_pid, pDir);
|
|
|
3286 }
|
|
|
3287 }
|
|
|
3288 //----- (0044665D) --------------------------------------------------------
|
|
|
3289 // uType: 0 -> any monster
|
|
|
3290 // 1 -> uParam is GroupID
|
|
|
3291 // 2 -> uParam is MonsterID
|
|
|
3292 // 3 -> uParam is ActorID
|
|
|
3293 // uNumAlive: 0 -> all must be alive
|
|
|
3294 int __fastcall IsActorAlive(unsigned int uType, unsigned int uParam, unsigned int uNumAlive)
|
|
|
3295 {
|
|
|
3296 unsigned int uAliveActors; // eax@6
|
|
|
3297 unsigned int uTotalActors; // [sp+0h] [bp-4h]@1
|
|
|
3298
|
|
|
3299 uTotalActors = 0;
|
|
|
3300 if ( uType )
|
|
|
3301 {
|
|
|
3302 if ( uType == 1 )
|
|
|
3303 uAliveActors = Actor::SearchActorByGroup(&uTotalActors, uParam);
|
|
|
3304 else
|
|
|
3305 {
|
|
|
3306 if ( uType == 2 )
|
|
|
3307 uAliveActors = Actor::SearchActorByMonsterID(&uTotalActors, uParam);
|
|
|
3308 else
|
|
|
3309 {
|
|
|
3310 if ( uType != 3 )
|
|
|
3311 return 0;
|
|
|
3312 uAliveActors = Actor::SearchActorByID(&uTotalActors, uParam);
|
|
|
3313 }
|
|
|
3314 }
|
|
|
3315 }
|
|
|
3316 else
|
|
|
3317 uAliveActors = Actor::SearchAliveActors(&uTotalActors);
|
|
|
3318
|
|
|
3319 if (uNumAlive)
|
|
|
3320 return uAliveActors >= uNumAlive;
|
|
|
3321 else
|
|
|
3322 return uTotalActors == uAliveActors;
|
|
|
3323 }
|
|
|
3324 //----- (00408B54) --------------------------------------------------------
|
|
|
3325 unsigned int Actor::SearchActorByID(unsigned int *pTotalActors, unsigned int a2)
|
|
|
3326 {
|
|
|
3327 //int v4; // eax@1
|
|
|
3328 unsigned int result; // ebx@1
|
|
|
3329
|
|
|
3330 //v4 = GetAlertStatus();
|
|
|
3331 *pTotalActors = 0;
|
|
|
3332 result = 0;
|
|
|
3333 if ( (pActors[a2].uAttributes & ACTOR_UNKNOW7) == GetAlertStatus() )
|
|
|
3334 {
|
|
|
3335 *pTotalActors = 1;
|
|
|
3336 if ( pActors[a2].IsNotAlive() == 1 )
|
|
|
3337 result = 1;
|
|
|
3338 }
|
|
|
3339 return result;
|
|
|
3340 }
|
|
|
3341 //----- (00408AE7) --------------------------------------------------------
|
|
|
3342 unsigned int Actor::SearchActorByGroup(unsigned int *pTotalActors, unsigned int uGroup)
|
|
|
3343 {
|
|
|
3344 unsigned int result; // [sp+10h] [bp-4h]@1
|
|
|
3345
|
|
|
3346 int v8 = GetAlertStatus();
|
|
|
3347 *pTotalActors = 0;
|
|
|
3348 result = 0;
|
|
|
3349 for ( uint i = 0; i < uNumActors; i++)
|
|
|
3350 {
|
|
|
3351 if ( (pActors[i].uAttributes & ACTOR_UNKNOW7) == v8 && pActors[i].uGroup == uGroup)
|
|
|
3352 {
|
|
|
3353 ++*pTotalActors;
|
|
|
3354 if ( pActors[i].IsNotAlive() == 1 )
|
|
|
3355 ++result;
|
|
|
3356 }
|
|
|
3357 }
|
|
|
3358 return result;
|
|
|
3359 }
|
|
|
3360 //----- (00408A7E) --------------------------------------------------------
|
|
|
3361 unsigned int Actor::SearchActorByMonsterID(unsigned int *pTotalActors, int uMonsterID)
|
|
|
3362 {
|
|
|
3363 int v8; // [sp+Ch] [bp-8h]@1
|
|
|
3364 unsigned int result; // [sp+10h] [bp-4h]@1
|
|
|
3365
|
|
|
3366 v8 = GetAlertStatus();
|
|
|
3367 *pTotalActors = 0;
|
|
|
3368 result = 0;
|
|
|
3369 for ( uint i = 0; i < uNumActors; i++)
|
|
|
3370 {
|
|
|
3371 if ( (pActors[i].uAttributes & ACTOR_UNKNOW7) == v8 && pActors[i].pMonsterInfo.field_33 == uMonsterID)
|
|
|
3372 {
|
|
|
3373 ++*pTotalActors;
|
|
|
3374 if ( pActors[i].IsNotAlive() == 1 )
|
|
|
3375 ++result;
|
|
|
3376 }
|
|
|
3377 }
|
|
|
3378 return result;
|
|
|
3379 }
|
|
|
3380 //----- (00408A27) --------------------------------------------------------
|
|
|
3381 unsigned int Actor::SearchAliveActors(unsigned int *pTotalActors)
|
|
|
3382 {
|
|
|
3383 int v2; // eax@1
|
|
|
3384 unsigned int result; // ebp@1
|
|
|
3385
|
|
|
3386 v2 = GetAlertStatus();
|
|
|
3387 result = 0;
|
|
|
3388 *pTotalActors = 0;
|
|
|
3389 for ( uint i = 0; i < uNumActors; i++)
|
|
|
3390 {
|
|
|
3391 if ( (pActors[i].uAttributes & ACTOR_UNKNOW7) == v2 )
|
|
|
3392 {
|
|
|
3393 ++*pTotalActors;
|
|
|
3394 if ( pActors[i].IsNotAlive() == 1 )
|
|
|
3395 ++result;
|
|
|
3396 }
|
|
|
3397 }
|
|
|
3398 return result;
|
|
|
3399 }
|
|
|
3400 //----- (00408768) --------------------------------------------------------
|
|
|
3401 void Actor::InitializeActors()
|
|
|
3402 {
|
|
|
3403 bool evil; // [sp+Ch] [bp-10h]@1
|
|
|
3404 bool bPit; // [sp+10h] [bp-Ch]@1
|
|
|
3405 bool good; // [sp+14h] [bp-8h]@1
|
|
|
3406 bool bCelestia; // [sp+18h] [bp-4h]@1
|
|
|
3407
|
|
|
3408 bCelestia = false;
|
|
|
3409 bPit = false;
|
|
|
3410 good = false;
|
|
|
3411 evil = false;
|
|
|
3412 if ( !_stricmp(pCurrentMapName, "d25.blv") )//the Celestia
|
|
|
3413 bCelestia = true;
|
|
|
3414 if ( !_stricmp(pCurrentMapName, "d26.blv") )//the Pit
|
|
|
3415 bPit = true;
|
|
|
3416 if (pParty->IsPartyGood())
|
|
|
3417 good = true;
|
|
|
3418 if (pParty->IsPartyEvil())
|
|
|
3419 evil = true;
|
|
|
3420
|
|
|
3421 Log::Warning(L"%S %S %u", __FILE__, __FUNCTION__, __LINE__); // ai_near_actors_targets_pid[i] for AI_Stand seems always 0; original code behaviour is identical
|
|
|
3422 for (uint i = 0; i < uNumActors; ++i)
|
|
|
3423 {
|
|
|
3424 Actor* actor = &pActors[i];
|
|
|
3425
|
|
|
3426 if (actor->CanAct() || actor->uAIState == Disabled)
|
|
|
3427 {
|
|
|
3428 actor->vPosition.x = actor->vInitialPosition.x;
|
|
|
3429 actor->vPosition.y = actor->vInitialPosition.y;
|
|
|
3430 actor->vPosition.z = actor->vInitialPosition.z;
|
|
|
3431 actor->sCurrentHP = actor->pMonsterInfo.uHP;
|
|
|
3432 if (actor->uAIState != Disabled)
|
|
|
3433 {
|
|
|
3434 Actor::AI_Stand(i, ai_near_actors_targets_pid[i], actor->pMonsterInfo.uRecoveryTime, 0);
|
|
|
3435 }
|
|
|
3436 }
|
|
|
3437
|
|
|
3438 actor->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Friendly;
|
|
|
3439
|
|
|
3440 if (!bCelestia || good)
|
|
|
3441 if (!bPit || evil)
|
|
|
3442 if (actor->IsPeasant())
|
|
|
3443 actor->ResetAggressor();//~0x80000
|
|
|
3444
|
|
|
3445 actor->ResetHasItem();//~0x800000
|
|
|
3446 if (actor->uAttributes & ACTOR_UNKNOW9)
|
|
|
3447 Actor::_4031C1_update_job_never_gets_called(i, pParty->uCurrentHour, 1);
|
|
|
3448 }
|
|
|
3449 }
|
|
|
3450 //----- (00439474) --------------------------------------------------------
|
|
|
3451 void Actor::DamageMonsterFromParty(signed int a1, unsigned int uActorID_Monster, Vec3_int_ *pVelocity)
|
|
|
3452 {
|
|
|
3453 SpriteObject *projectileSprite; // ebx@1
|
|
|
3454 Actor *pMonster; // esi@7
|
|
|
3455 unsigned __int16 v16; // cx@25
|
|
|
3456 int v33; // eax@100
|
|
|
3457 int v40; // ebx@107
|
|
|
3458 int extraRecoveryTime; // qax@125
|
|
|
3459 unsigned __int16 v43; // ax@132
|
|
|
3460 unsigned __int16 v45; // ax@132
|
|
|
3461 unsigned __int64 v46; // [sp+Ch] [bp-60h]@6
|
|
|
3462 char *pPlayerName; // [sp+18h] [bp-54h]@12
|
|
|
3463 char *pMonsterName; // [sp+1Ch] [bp-50h]@6
|
|
|
3464 signed int a4; // [sp+44h] [bp-28h]@1
|
|
|
3465 bool IsAdditionalDamagePossible; // [sp+50h] [bp-1Ch]@1
|
|
|
3466 int v61; // [sp+58h] [bp-14h]@1
|
|
|
3467 bool isLifeStealing; // [sp+5Ch] [bp-10h]@1
|
|
|
3468 int uDamageAmount; // [sp+60h] [bp-Ch]@1
|
|
|
3469 DAMAGE_TYPE attackElement; // [sp+64h] [bp-8h]@27
|
|
|
3470
|
|
|
3471 projectileSprite = 0;
|
|
|
3472 uDamageAmount = 0;
|
|
|
3473 a4 = 0;
|
|
|
3474 v61 = 0;
|
|
|
3475 IsAdditionalDamagePossible = false;
|
|
|
3476 isLifeStealing = 0;
|
|
|
3477 if ( PID_TYPE(a1) == OBJECT_Item)
|
|
|
3478 {
|
|
|
3479 projectileSprite = &pSpriteObjects[PID_ID(a1)];
|
|
|
3480 v61 = projectileSprite->field_60_distance_related_prolly_lod;
|
|
|
3481 a1 = projectileSprite->spell_caster_pid;
|
|
|
3482 }
|
|
|
3483 if (PID_TYPE(a1) != OBJECT_Player)
|
|
|
3484 return;
|
|
|
3485
|
|
|
3486 assert(PID_ID(abs(a1)) < 4);
|
|
|
3487 Player* player = &pParty->pPlayers[PID_ID(a1)];
|
|
|
3488 pMonster = &pActors[uActorID_Monster];
|
|
|
3489 if (pMonster->IsNotAlive())
|
|
|
3490 return;
|
|
|
3491
|
|
|
3492 pMonster->uAttributes |= 0xC000;
|
|
|
3493 if ( pMonster->uAIState == Fleeing )
|
|
|
3494 pMonster->uAttributes |= ACTOR_FLEEING;
|
|
|
3495 bool hit_will_stun = false,
|
|
|
3496 hit_will_paralyze = false;
|
|
|
3497 if ( !projectileSprite )
|
|
|
3498 {
|
|
|
3499 int main_hand_idx = player->pEquipment.uMainHand;
|
|
|
3500 IsAdditionalDamagePossible = true;
|
|
|
3501 if ( player->HasItemEquipped(EQUIP_TWO_HANDED) )
|
|
|
3502 {
|
|
|
3503 uint main_hand_skill = player->GetMainHandItem()->GetPlayerSkillType();
|
|
|
3504 uint main_hand_mastery = SkillToMastery(player->pActiveSkills[main_hand_skill]);
|
|
|
3505 switch (main_hand_skill)
|
|
|
3506 {
|
|
|
3507 case PLAYER_SKILL_STAFF:
|
|
|
3508 if (main_hand_mastery >= 3)
|
|
|
3509 {
|
|
|
3510 if (rand() % 100 < (player->GetActualSkillLevel(PLAYER_SKILL_STAFF) & 0x3F)) // stun chance when mastery >= 3
|
|
|
3511 hit_will_stun = true;
|
|
|
3512 }
|
|
|
3513 break;
|
|
|
3514
|
|
|
3515 case PLAYER_SKILL_MACE:
|
|
|
3516 if (main_hand_mastery >= 3)
|
|
|
3517 {
|
|
|
3518 if (rand() % 100 < (player->GetActualSkillLevel(PLAYER_SKILL_MACE) & 0x3F))
|
|
|
3519 hit_will_stun = true;
|
|
|
3520 }
|
|
|
3521 if (main_hand_mastery >= 4)
|
|
|
3522 {
|
|
|
3523 if (rand() % 100 < (player->GetActualSkillLevel(PLAYER_SKILL_MACE) & 0x3F))
|
|
|
3524 hit_will_paralyze = true;
|
|
|
3525 }
|
|
|
3526 break;
|
|
|
3527 }
|
|
|
3528 }
|
|
|
3529 attackElement = DMGT_PHISYCAL;
|
|
|
3530 uDamageAmount = player->CalculateMeleeDamageTo(false, false, pMonster->pMonsterInfo.uID);
|
|
|
3531 if ( !player->PlayerHitOrMiss(pMonster, v61, a4) )
|
|
|
3532 {
|
|
|
3533 player->PlaySound(SPEECH_52, 0);
|
|
|
3534 return;
|
|
|
3535 }
|
|
|
3536 }
|
|
|
3537 else
|
|
|
3538 {
|
|
|
3539 v61 = projectileSprite->field_60_distance_related_prolly_lod;
|
|
|
3540 if ( projectileSprite->spell_id != SPELL_DARK_SOULDRINKER )
|
|
|
3541 {
|
|
|
3542 int d1 = abs(pParty->vPosition.x - projectileSprite->vPosition.x);
|
|
|
3543 int d2 = abs(pParty->vPosition.y - projectileSprite->vPosition.y);
|
|
|
3544 int d3 = abs(pParty->vPosition.z - projectileSprite->vPosition.z);
|
|
|
3545 v61 = int_get_vector_length(d1, d2, d3);
|
|
|
3546
|
|
|
3547 if ( v61 >= 5120 && !(pMonster->uAttributes & ACTOR_ALIVE) )//0x400
|
|
|
3548 return;
|
|
|
3549 else if ( v61 >= 2560 )
|
|
|
3550 v61 = 2;
|
|
|
3551 else
|
|
|
3552 v61 = 1;
|
|
|
3553 }
|
|
|
3554
|
|
|
3555 switch (projectileSprite->spell_id)
|
|
|
3556 {
|
|
|
3557 case SPELL_LASER_PROJECTILE:
|
|
|
3558 v16 = player->pActiveSkills[PLAYER_SKILL_BLASTER];
|
|
|
3559 v61 = 1;
|
|
|
3560 if ( SkillToMastery(v16) >= 3 )
|
|
|
3561 a4 = player->pActiveSkills[PLAYER_SKILL_BLASTER] & 0x3F;
|
|
|
3562 attackElement = DMGT_PHISYCAL;
|
|
|
3563 uDamageAmount = player->CalculateMeleeDamageTo(true, true, 0);
|
|
|
3564 if ( !player->PlayerHitOrMiss(pMonster, v61, a4) )
|
|
|
3565 {
|
|
|
3566 player->PlaySound(SPEECH_52, 0);
|
|
|
3567 return;
|
|
|
3568 }
|
|
|
3569 break;
|
|
|
3570 case SPELL_101:
|
|
|
3571 attackElement = DMGT_FIRE;
|
|
|
3572 uDamageAmount = player->CalculateRangedDamageTo(0);
|
|
|
3573 if ( pMonster->pActorBuffs[ACTOR_BUFF_SHIELD].uExpireTime > 0 )
|
|
|
3574 uDamageAmount >>= 1;
|
|
|
3575 IsAdditionalDamagePossible = true;
|
|
|
3576 if ( !player->PlayerHitOrMiss(pMonster, v61, a4) )
|
|
|
3577 {
|
|
|
3578 player->PlaySound(SPEECH_52, 0);
|
|
|
3579 return;
|
|
|
3580 }
|
|
|
3581 break;
|
|
|
3582 case SPELL_EARTH_BLADES:
|
|
|
3583 a4 = 5 * projectileSprite->spell_level;
|
|
|
3584 attackElement = (DAMAGE_TYPE)player->GetSpellSchool(SPELL_EARTH_BLADES);
|
|
|
3585 uDamageAmount = _43AFE3_calc_spell_damage(39, projectileSprite->spell_level, projectileSprite->spell_skill, pMonster->sCurrentHP);
|
|
|
3586 if ( pMonster->pActorBuffs[ACTOR_BUFF_SHIELD].uExpireTime > 0 )
|
|
|
3587 uDamageAmount >>= 1;
|
|
|
3588 IsAdditionalDamagePossible = false;
|
|
|
3589 if ( !player->PlayerHitOrMiss( pMonster, v61, a4) )
|
|
|
3590 {
|
|
|
3591 player->PlaySound(SPEECH_52, 0);
|
|
|
3592 return;
|
|
|
3593 }
|
|
|
3594 break;
|
|
|
3595 case SPELL_EARTH_STUN:
|
|
|
3596 uDamageAmount = 0;
|
|
|
3597 attackElement = DMGT_PHISYCAL;
|
|
|
3598 hit_will_stun = 1;
|
|
|
3599 if ( !player->PlayerHitOrMiss( pMonster, v61, a4) )
|
|
|
3600 {
|
|
|
3601 player->PlaySound(SPEECH_52, 0);
|
|
|
3602 return;
|
|
|
3603 }
|
|
|
3604 break;
|
|
|
3605 case SPELL_BOW_ARROW:
|
|
|
3606 attackElement = DMGT_PHISYCAL;
|
|
|
3607 uDamageAmount = player->CalculateRangedDamageTo(pMonster->word_000086_some_monster_id);
|
|
|
3608 if ( pMonster->pActorBuffs[ACTOR_BUFF_SHIELD].uExpireTime > 0 )
|
|
|
3609 uDamageAmount /= 2;
|
|
|
3610 IsAdditionalDamagePossible = true;
|
|
|
3611 if ( projectileSprite->stru_24.uItemID != 0 && projectileSprite->stru_24.uSpecEnchantmentType == 3 ) //of carnage
|
|
|
3612 {
|
|
|
3613 attackElement = DMGT_FIRE;
|
|
|
3614 }
|
|
|
3615 else if ( !player->PlayerHitOrMiss( pMonster, v61, a4) )
|
|
|
3616 {
|
|
|
3617 player->PlaySound(SPEECH_52, 0);
|
|
|
3618 return;
|
|
|
3619 }
|
|
|
3620 break;
|
|
|
3621
|
|
|
3622 default:
|
|
|
3623 attackElement = (DAMAGE_TYPE)player->GetSpellSchool(projectileSprite->spell_id);
|
|
|
3624 IsAdditionalDamagePossible = false;
|
|
|
3625 uDamageAmount = _43AFE3_calc_spell_damage(projectileSprite->spell_id, projectileSprite->spell_level, projectileSprite->spell_skill, pMonster->sCurrentHP);
|
|
|
3626 break;
|
|
|
3627 }
|
|
|
3628 }
|
|
|
3629
|
|
|
3630 if (player->IsWeak())
|
|
|
3631 uDamageAmount /= 2;
|
|
|
3632 if ( pMonster->pActorBuffs[ACTOR_BUFF_STONED].uExpireTime > 0 )
|
|
|
3633 uDamageAmount = 0;
|
|
|
3634 v61 = pMonster->CalcMagicalDamageToActor(attackElement, uDamageAmount);
|
|
|
3635 if ( !projectileSprite && player->IsUnarmed() && player->pPlayerBuffs[PLAYER_BUFF_HAMMERHANDS].uExpireTime > 0 )
|
|
|
3636 {
|
|
|
3637 v61 += pMonster->CalcMagicalDamageToActor((DAMAGE_TYPE)8, player->pPlayerBuffs[PLAYER_BUFF_HAMMERHANDS].uPower);
|
|
|
3638 }
|
|
|
3639 uDamageAmount = v61;
|
|
|
3640 if ( IsAdditionalDamagePossible )
|
|
|
3641 {
|
|
|
3642 if ( projectileSprite )
|
|
|
3643 {
|
|
|
3644 a4 = projectileSprite->stru_24._439DF3_get_additional_damage((int*)&attackElement, &isLifeStealing);
|
|
|
3645 if ( isLifeStealing && pMonster->sCurrentHP > 0 )
|
|
|
3646 {
|
|
|
3647 player->sHealth += v61 / 5;
|
|
|
3648 if ( player->sHealth > player->GetMaxHealth() )
|
|
|
3649 player->sHealth = player->GetMaxHealth();
|
|
|
3650 }
|
|
|
3651 uDamageAmount += pMonster->CalcMagicalDamageToActor(attackElement, a4);
|
|
|
3652 }
|
|
|
3653 else
|
|
|
3654 {
|
|
|
3655 for (int i = 0; i < 2; i++)
|
|
|
3656 {
|
|
|
3657 if ( player->HasItemEquipped((ITEM_EQUIP_TYPE)i) )
|
|
|
3658 {
|
|
|
3659 ItemGen* item;
|
|
|
3660 if (i == 0)
|
|
|
3661 item = player->GetOffHandItem();
|
|
|
3662 else
|
|
|
3663 item = player->GetMainHandItem();
|
|
|
3664 a4 = item->_439DF3_get_additional_damage((int*)&attackElement, &isLifeStealing);
|
|
|
3665 if ( isLifeStealing && pMonster->sCurrentHP > 0 )
|
|
|
3666 {
|
|
|
3667 player->sHealth += v61 / 5;
|
|
|
3668 if ( player->sHealth > player->GetMaxHealth() )
|
|
|
3669 player->sHealth = player->GetMaxHealth();
|
|
|
3670 }
|
|
|
3671 uDamageAmount += pMonster->CalcMagicalDamageToActor(attackElement, a4);
|
|
|
3672 }
|
|
|
3673 }
|
|
|
3674 }
|
|
|
3675 }
|
|
|
3676 pMonster->sCurrentHP -= uDamageAmount;
|
|
|
3677 if ( uDamageAmount == 0 && !hit_will_stun )
|
|
|
3678 {
|
|
|
3679 player->PlaySound(SPEECH_52, 0);
|
|
|
3680 return;
|
|
|
3681 }
|
|
|
3682 if ( pMonster->sCurrentHP > 0 )
|
|
|
3683 {
|
|
|
3684 Actor::AI_Stun(uActorID_Monster, a1, 0);
|
|
|
3685 Actor::AggroSurroundingPeasants(uActorID_Monster, 1);
|
|
|
3686 if ( bShowDamage )
|
|
|
3687 {
|
|
|
3688 if ( projectileSprite )
|
|
|
3689 sprintfex(pTmpBuf.data(), pGlobalTXT_LocalizationStrings[189], player->pName, pMonster->pActorName, uDamageAmount);// "%s shoots %s for %lu points"
|
|
|
3690 else
|
|
|
3691 sprintfex(pTmpBuf.data(), pGlobalTXT_LocalizationStrings[164], player->pName, pMonster->pActorName, uDamageAmount);// "%s hits %s for %lu damage"
|
|
|
3692 ShowStatusBarString(pTmpBuf.data(), 2u);
|
|
|
3693 }
|
|
|
3694 }
|
|
|
3695 else
|
|
|
3696 {
|
|
|
3697 if ( pMonsterStats->pInfos[pMonster->pMonsterInfo.uID].bQuestMonster & 1 )
|
|
|
3698 {
|
|
2541
|
3699 if ( /*pRenderer->pRenderD3D &&*/ pEngine->uFlags2 & GAME_FLAGS_2_DRAW_BLOODSPLATS )
|
|
2497
|
3700 {
|
|
2541
|
3701 v33 = byte_4D864C && pEngine->uFlags & 0x80000 ? 10 * pMonster->uActorRadius : pMonster->uActorRadius;
|
|
2497
|
3702 pDecalBuilder->AddBloodsplat((float)pMonster->vPosition.x, (float)pMonster->vPosition.y, (float)pMonster->vPosition.z, 1.0, 0.0, 0.0, (float)v33, 0, 0);
|
|
|
3703 }
|
|
|
3704 }
|
|
|
3705 Actor::Die(uActorID_Monster);
|
|
|
3706 Actor::ApplyFineForKillingPeasant(uActorID_Monster);
|
|
|
3707 Actor::AggroSurroundingPeasants(uActorID_Monster, 1);
|
|
|
3708 if ( pMonster->pMonsterInfo.uExp )
|
|
|
3709 pParty->GivePartyExp(pMonsterStats->pInfos[pMonster->pMonsterInfo.uID].uExp);
|
|
|
3710 v40 = SPEECH_51;
|
|
|
3711 if ( rand() % 100 < 20 )
|
|
|
3712 v40 = ((signed int)pMonster->pMonsterInfo.uHP >= 100) + 1;
|
|
|
3713 player->PlaySound((PlayerSpeech)v40, 0);
|
|
|
3714 if ( bShowDamage )
|
|
|
3715 {
|
|
|
3716 pMonsterName = (char *)uDamageAmount;
|
|
|
3717 pPlayerName = player->pName; // "%s inflicts %lu points killing %s"
|
|
|
3718 sprintfex(pTmpBuf.data(), pGlobalTXT_LocalizationStrings[175], player->pName, uDamageAmount, pMonster);
|
|
|
3719 ShowStatusBarString(pTmpBuf.data(), 2u);
|
|
|
3720 }
|
|
|
3721 }
|
|
|
3722 if ( pMonster->pActorBuffs[ACTOR_BUFF_PAIN_REFLECTION].uExpireTime > 0
|
|
|
3723 && uDamageAmount != 0 )
|
|
|
3724 player->ReceiveDamage(uDamageAmount, attackElement);
|
|
|
3725 int knockbackValue = 20 * v61 / (signed int)pMonster->pMonsterInfo.uHP;
|
|
|
3726 if ( (player->GetSpecialItemBonus(24) || hit_will_stun) && pMonster->DoesDmgTypeDoDamage(DMGT_EARTH) )
|
|
|
3727 {
|
|
|
3728 extraRecoveryTime = 20;
|
|
|
3729 knockbackValue = 10;
|
|
|
3730 if ( !pParty->bTurnBasedModeOn )
|
|
|
3731 extraRecoveryTime = (int)(flt_6BE3A8_debug_recmod2 * 42.66666666666666);
|
|
|
3732 pMonster->pMonsterInfo.uRecoveryTime += extraRecoveryTime;
|
|
|
3733 if ( bShowDamage )
|
|
|
3734 {
|
|
|
3735 pMonsterName = player->pName; // "%s stuns %s"
|
|
|
3736 sprintfex(pTmpBuf.data(), pGlobalTXT_LocalizationStrings[635], player->pName, pMonster);
|
|
|
3737 ShowStatusBarString(pTmpBuf.data(), 2u);
|
|
|
3738 }
|
|
|
3739 }
|
|
|
3740 if ( hit_will_paralyze && pMonster->CanAct() && pMonster->DoesDmgTypeDoDamage(DMGT_EARTH))
|
|
|
3741 {
|
|
|
3742 v43 = player->GetActualSkillLevel(PLAYER_SKILL_MACE);
|
|
|
3743 v45 = SkillToMastery(v43);
|
|
|
3744 v46 = pParty->uTimePlayed + (signed int)(signed __int64)((double)(signed int)(7680 * (v43 & 0x3F)) * 0.033333335);
|
|
|
3745 pMonster->pActorBuffs[ACTOR_BUFF_PARALYZED].Apply(v46, v45, 0, 0, 0);
|
|
|
3746 if ( bShowDamage )
|
|
|
3747 {
|
|
|
3748 pMonsterName = player->pName; // "%s paralyzes %s"
|
|
|
3749 sprintfex(pTmpBuf.data(), pGlobalTXT_LocalizationStrings[636], player->pName, pMonster);
|
|
|
3750 ShowStatusBarString(pTmpBuf.data(), 2u);
|
|
|
3751 }
|
|
|
3752 }
|
|
|
3753 if ( knockbackValue > 10 )
|
|
|
3754 knockbackValue = 10;
|
|
|
3755 if ( !MonsterStats::BelongsToSupertype(pMonster->pMonsterInfo.uID, MONSTER_SUPERTYPE_TREANT) )
|
|
|
3756 {
|
|
|
3757 pVelocity->x = fixpoint_mul(knockbackValue, pVelocity->x);
|
|
|
3758 pVelocity->y = fixpoint_mul(knockbackValue, pVelocity->y);
|
|
|
3759 pVelocity->z = fixpoint_mul(knockbackValue, pVelocity->z);
|
|
|
3760 pMonster->vVelocity.x = 50 * LOWORD(pVelocity->x);
|
|
|
3761 pMonster->vVelocity.y = 50 * LOWORD(pVelocity->y);
|
|
|
3762 pMonster->vVelocity.z = 50 * LOWORD(pVelocity->z);
|
|
|
3763 }
|
|
|
3764 Actor::AddBloodsplatOnDamageOverlay(uActorID_Monster, 1, v61);
|
|
|
3765 }
|
|
|
3766 //----- (004BBF61) --------------------------------------------------------
|
|
|
3767 void Actor::Arena_summon_actor( int monster_id, __int16 x, int y, int z )
|
|
|
3768 {
|
|
|
3769 int v12; // ebx@7
|
|
|
3770 int v13; // eax@8
|
|
|
3771 __int16 v16; // [sp+10h] [bp-4h]@3
|
|
|
3772
|
|
|
3773 if (uNumActors < 500)
|
|
|
3774 {
|
|
|
3775 v16 = 0;
|
|
|
3776 if ( uCurrentlyLoadedLevelType == LEVEL_Indoor )
|
|
|
3777 v16 = pIndoor->GetSector(x, y, z);
|
|
|
3778 pActors[uNumActors].Reset();
|
|
|
3779 strcpy(pActors[uNumActors].pActorName, pMonsterStats->pInfos[monster_id].pName);
|
|
|
3780 pActors[uNumActors].sCurrentHP = LOWORD(pMonsterStats->pInfos[monster_id].uHP);
|
|
|
3781 memcpy(&pActors[uNumActors].pMonsterInfo, &pMonsterStats->pInfos[monster_id], 0x58u);
|
|
|
3782 pActors[uNumActors].word_000086_some_monster_id = monster_id;
|
|
|
3783 pActors[uNumActors].uActorRadius = pMonsterList->pMonsters[monster_id - 1].uMonsterRadius;
|
|
|
3784 pActors[uNumActors].uActorHeight = pMonsterList->pMonsters[monster_id - 1].uMonsterHeight;
|
|
|
3785 pActors[uNumActors].uMovementSpeed = pMonsterList->pMonsters[monster_id - 1].uMovementSpeed;
|
|
|
3786 pActors[uNumActors].vInitialPosition.x = x;
|
|
|
3787 pActors[uNumActors].vPosition.x = x;
|
|
|
3788 pActors[uNumActors].uAttributes |= ACTOR_AGGRESSOR;
|
|
|
3789 pActors[uNumActors].pMonsterInfo.uTreasureType = 0;
|
|
|
3790 pActors[uNumActors].pMonsterInfo.uTreasureLevel = 0;
|
|
|
3791 pActors[uNumActors].pMonsterInfo.uTreasureDiceSides = 0;
|
|
|
3792 pActors[uNumActors].pMonsterInfo.uTreasureDiceRolls = 0;
|
|
|
3793 pActors[uNumActors].pMonsterInfo.uTreasureDropChance = 0;
|
|
|
3794 pActors[uNumActors].vInitialPosition.y = y;
|
|
|
3795 pActors[uNumActors].vPosition.y = y;
|
|
|
3796 pActors[uNumActors].vInitialPosition.z = z;
|
|
|
3797 pActors[uNumActors].vPosition.z = z;
|
|
|
3798 pActors[uNumActors].uTetherDistance = 256;
|
|
|
3799 pActors[uNumActors].uSectorID = v16;
|
|
|
3800 pActors[uNumActors].uGroup = 1;
|
|
|
3801 pActors[uNumActors].pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
|
|
|
3802 pActors[uNumActors].PrepareSprites(0);
|
|
|
3803 for ( int i = 0; i < 4; i++)
|
|
|
3804 pSoundList->LoadSound(pMonsterList->pMonsters[monster_id - 1].pSoundSampleIDs[i], 0);
|
|
|
3805 v12 = 0;
|
|
|
3806 do
|
|
|
3807 {
|
|
|
3808 v13 = pSoundList->LoadSound(v12 + word_4EE088_sound_ids[pMonsterStats->pInfos[monster_id].uSpell1ID], 1);
|
|
|
3809 v12++;
|
|
|
3810 }
|
|
|
3811 while ( v13 );
|
|
|
3812 ++uNumActors;
|
|
|
3813 }
|
|
|
3814 }
|
|
|
3815 //----- (00426E10) --------------------------------------------------------
|
|
|
3816 int stru319::which_player_to_attack(Actor *pActor)
|
|
|
3817 {
|
|
|
3818 signed int v2; // ebx@1
|
|
|
3819 bool flag; // edi@37
|
|
|
3820 int v22; // [sp+8h] [bp-140h]@3
|
|
|
3821 int Victims_list[60]; // [sp+48h] [bp-100h]@48
|
|
|
3822 int for_sex; // [sp+13Ch] [bp-Ch]@1
|
|
|
3823 int for_race; // [sp+140h] [bp-8h]@1
|
|
|
3824 int for_class; // [sp+144h] [bp-4h]@1
|
|
|
3825
|
|
|
3826 for_class = -1;
|
|
|
3827 for_race = -1;
|
|
|
3828 for_sex = -1;
|
|
|
3829 v2 = 0;
|
|
|
3830 if ( pActor->pMonsterInfo.uAttackPreference )
|
|
|
3831 {
|
|
|
3832 for ( uint i = 0; i < 16; i++ )
|
|
|
3833 {
|
|
|
3834 v22 = pActor->pMonsterInfo.uAttackPreference & (1 << i);
|
|
|
3835 if ( v22 )
|
|
|
3836 {
|
|
|
3837 switch ( v22 )
|
|
|
3838 {
|
|
|
3839 case 1:
|
|
|
3840 for_class = 0;
|
|
|
3841 break;
|
|
|
3842 case 2:
|
|
|
3843 for_class = 12;
|
|
|
3844 break;
|
|
|
3845 case 4:
|
|
|
3846 for_class = 16;
|
|
|
3847 break;
|
|
|
3848 case 8:
|
|
|
3849 for_class = 28;
|
|
|
3850 break;
|
|
|
3851 case 16:
|
|
|
3852 for_class = 24;
|
|
|
3853 break;
|
|
|
3854 case 32:
|
|
|
3855 for_class = 32;
|
|
|
3856 break;
|
|
|
3857 case 64:
|
|
|
3858 for_class = 20;
|
|
|
3859 break;
|
|
|
3860 case 128:
|
|
|
3861 for_class = 4;
|
|
|
3862 break;
|
|
|
3863 case 256:
|
|
|
3864 for_class = 8;
|
|
|
3865 break;
|
|
|
3866 case 512:
|
|
|
3867 for_sex = 0;
|
|
|
3868 break;
|
|
|
3869 case 1024:
|
|
|
3870 for_sex = 1;
|
|
|
3871 break;
|
|
|
3872 case 2048:
|
|
|
3873 for_race = 0;
|
|
|
3874 break;
|
|
|
3875 case 4096:
|
|
|
3876 for_race = 1;
|
|
|
3877 break;
|
|
|
3878 case 8192:
|
|
|
3879 for_race = 3;
|
|
|
3880 break;
|
|
|
3881 case 16384:
|
|
|
3882 for_race = 2;
|
|
|
3883 break;
|
|
|
3884 }
|
|
|
3885 v2 = 0;
|
|
|
3886 for ( uint j = 0; j < 4; ++j )
|
|
|
3887 {
|
|
|
3888 flag = 0;
|
|
|
3889 if ( for_class != -1 && for_class == pPlayers[j + 1]->classType )
|
|
|
3890 flag = true;
|
|
|
3891 if ( for_sex != -1 && for_sex == pPlayers[j + 1]->uSex )
|
|
|
3892 flag = true;
|
|
|
3893 if ( for_race != -1 && for_race == pPlayers[j + 1]->GetRace() )
|
|
|
3894 flag = true;
|
|
|
3895 if ( flag == true )
|
|
|
3896 {
|
|
|
3897 if ( !(pPlayers[j + 1]->pConditions[Condition_Paralyzed] | pPlayers[j + 1]->pConditions[Condition_Unconcious]
|
|
|
3898 | pPlayers[j + 1]->pConditions[Condition_Dead] | pPlayers[j + 1]->pConditions[Condition_Pertified] | pPlayers[j + 1]->pConditions[Condition_Eradicated]) )
|
|
|
3899 Victims_list[v2++] = j;
|
|
|
3900 }
|
|
|
3901 }
|
|
|
3902 }
|
|
|
3903 }
|
|
|
3904 if ( v2 )
|
|
|
3905 return Victims_list[rand() % v2];
|
|
|
3906 }
|
|
|
3907 for ( uint i = 0; i < 4; ++i )
|
|
|
3908 {
|
|
|
3909 if ( !(pPlayers[i + 1]->pConditions[Condition_Paralyzed] | pPlayers[i + 1]->pConditions[Condition_Unconcious]
|
|
|
3910 | pPlayers[i + 1]->pConditions[Condition_Dead] | pPlayers[i + 1]->pConditions[Condition_Pertified] | pPlayers[i + 1]->pConditions[Condition_Eradicated]) )
|
|
|
3911 Victims_list[v2++] = i;
|
|
|
3912 }
|
|
|
3913 if ( v2 )
|
|
|
3914 return Victims_list[rand() % v2];
|
|
|
3915 else
|
|
|
3916 return 0;
|
|
|
3917 }
|
|
|
3918 //----- (00427546) --------------------------------------------------------
|
|
|
3919 int stru319::_427546(int a2)
|
|
|
3920 {
|
|
|
3921 int result; // eax@2
|
|
|
3922
|
|
|
3923 if (a2 >= 0)
|
|
|
3924 {
|
|
|
3925 if (a2 >= 1)
|
|
|
3926 result = (a2 >= 2) + 2;
|
|
|
3927 else
|
|
|
3928 result = 1;
|
|
|
3929 }
|
|
|
3930 else
|
|
|
3931 {
|
|
|
3932 result = 0;
|
|
|
3933 }
|
|
|
3934 return result;
|
|
|
3935 }
|
|
|
3936 //----- (0042F184) --------------------------------------------------------
|
|
|
3937 int stru319::FindClosestActor(int pick_depth, int a3, int a4)
|
|
|
3938 {
|
|
|
3939 int v4; // edi@1
|
|
|
3940 stru319 *v5; // esi@1
|
|
|
3941 int v6; // eax@2
|
|
|
3942 int v7; // eax@4
|
|
|
3943 // int result; // eax@5
|
|
|
3944 // int *v9; // edx@8
|
|
|
3945 // signed int v10; // ebx@10
|
|
|
3946 // int v11; // edi@11
|
|
|
3947 //Actor *v12; // esi@12
|
|
|
3948 //unsigned __int16 v13; // ax@12
|
|
|
3949 // int v14; // eax@22
|
|
|
3950 //char v15; // zf@30
|
|
|
3951 // int v16; // esi@32
|
|
|
3952 // int v17; // ecx@34
|
|
|
3953 // stru319 *v18; // eax@39
|
|
|
3954 // int v19; // edx@39
|
|
|
3955 // int v20; // ecx@41
|
|
|
3956 // unsigned __int16 v21; // ax@42
|
|
|
3957 // unsigned int v22; // [sp+8h] [bp-24h]@11
|
|
|
3958 //unsigned int v23; // [sp+Ch] [bp-20h]@7
|
|
|
3959 stru319 *v24; // [sp+10h] [bp-1Ch]@1
|
|
|
3960 // unsigned int v25; // [sp+14h] [bp-18h]@8
|
|
|
3961 // int *v26; // [sp+18h] [bp-14h]@8
|
|
|
3962 // int v27; // [sp+1Ch] [bp-10h]@10
|
|
|
3963 // int *v28; // [sp+20h] [bp-Ch]@10
|
|
|
3964 //unsigned int v29; // [sp+24h] [bp-8h]@7
|
|
|
3965 // int v30; // [sp+28h] [bp-4h]@6
|
|
|
3966 // int i; // [sp+38h] [bp+Ch]@33
|
|
|
3967 // signed int v32; // [sp+3Ch] [bp+10h]@32
|
|
|
3968
|
|
|
3969 v4 = 0;
|
|
|
3970 v5 = this;
|
|
|
3971 v24 = this;
|
|
|
3972 //if ( pRenderer->pRenderD3D )
|
|
|
3973 {
|
|
|
3974 v6 = a3 != 0;
|
|
|
3975 if (a4)
|
|
|
3976 LOBYTE(v6) = v6 | 8;
|
|
2541
|
3977 v7 = pEngine->pVisInstance->PickClosestActor(OBJECT_Actor, pick_depth, v6, 657456, -1);
|
|
2497
|
3978 if (v7 != -1)
|
|
|
3979 return (unsigned __int16)v7;
|
|
|
3980 else return 0;
|
|
|
3981 }
|
|
|
3982 /*else // software impl
|
|
|
3983 {
|
|
|
3984 v30 = 0;
|
|
|
3985 if ( pRenderer->pActiveZBuffer )
|
|
|
3986 {
|
|
|
3987 if ( (signed int)viewparams->uScreen_topL_Y < (signed int)viewparams->uScreen_BttmR_Y )
|
|
|
3988 {
|
|
|
3989 v9 = &pRenderer->pActiveZBuffer[viewparams->uScreen_topL_X + 640 * viewparams->uScreen_topL_Y];
|
|
|
3990 v26 = &pRenderer->pActiveZBuffer[viewparams->uScreen_topL_X + 640 * viewparams->uScreen_topL_Y];
|
|
|
3991 for ( v25 = viewparams->uScreen_BttmR_Y - viewparams->uScreen_topL_Y; v25; --v25 )
|
|
|
3992 {
|
|
|
3993 if ( (signed int)viewparams->uScreen_topL_X < (signed int)viewparams->uScreen_BttmR_X )
|
|
|
3994 {
|
|
|
3995 v28 = v9;
|
|
|
3996 v10 = v4;
|
|
|
3997 for ( v27 = viewparams->uScreen_BttmR_X - viewparams->uScreen_topL_X; v27; --v27 )
|
|
|
3998 {
|
|
|
3999 v22 = *v28;
|
|
|
4000 v11 = *v28 & 0xFFFF;
|
|
|
4001 if (PID_TYPE(v11) == OBJECT_Actor)
|
|
|
4002 {
|
|
|
4003 if ( pActors[PID_ID(v11)].uAIState != Dead )
|
|
|
4004 {
|
|
|
4005 if ( pActors[PID_ID(v11)].uAIState != Dying && pActors[PID_ID(v11)].uAIState != Removed
|
|
|
4006 && pActors[PID_ID(v11)].uAIState != Summoned && pActors[PID_ID(v11)].uAIState != Disabled
|
|
|
4007 && (!a3 || pActors[PID_ID(v11)].GetActorsRelation(0)) )
|
|
|
4008 {
|
|
|
4009 if ( (!a4 || MonsterStats::BelongsToSupertype(pActors[PID_ID(v11)].pMonsterInfo.uID, MONSTER_SUPERTYPE_UNDEAD))
|
|
|
4010 && v22 <= pick_depth << 16 )
|
|
|
4011 {
|
|
|
4012 v14 = 0;
|
|
|
4013 if ( v10 > 0 )
|
|
|
4014 {
|
|
|
4015 for ( v14; v14 < v30; ++v14 )
|
|
|
4016 {
|
|
|
4017 if ( dword_50BDA0[v14] == v11 )
|
|
|
4018 break;
|
|
|
4019 }
|
|
|
4020 }
|
|
|
4021 if ( v14 == v30 && v10 < 100 )
|
|
|
4022 {
|
|
|
4023 ++v30;
|
|
|
4024 dword_50BC10[v10] = v22;
|
|
|
4025 dword_50BDA0[v10] = v11;
|
|
|
4026 ++v10;
|
|
|
4027 }
|
|
|
4028 }
|
|
|
4029 }
|
|
|
4030 }
|
|
|
4031 }
|
|
|
4032 ++v28;
|
|
|
4033 }
|
|
|
4034 v4 = v30;
|
|
|
4035 v5 = v24;
|
|
|
4036 }
|
|
|
4037 v9 = v26 + 640;
|
|
|
4038 v26 += 640;
|
|
|
4039 }
|
|
|
4040 }
|
|
|
4041 if ( v4 > 0 )
|
|
|
4042 {
|
|
|
4043 v16 = (int)dword_50BC10.data();
|
|
|
4044 for ( v32 = 1; v32 - 1 < v4; ++v32 )
|
|
|
4045 {
|
|
|
4046 for ( i = v32; i < v4; ++i )
|
|
|
4047 {
|
|
|
4048 v17 = dword_50BC10[i];
|
|
|
4049 if ( dword_50BC10[i] < *(int *)v16 )
|
|
|
4050 {
|
|
|
4051 dword_50BC10[i] = *(int *)v16;
|
|
|
4052 *(int *)v16 = v17;
|
|
|
4053 }
|
|
|
4054 }
|
|
|
4055 v16 += 4;
|
|
|
4056 }
|
|
|
4057 v5 = v24;
|
|
|
4058 if ( v4 > 0 )
|
|
|
4059 {
|
|
|
4060 v18 = v24;
|
|
|
4061 for ( v19 = v4; v19; --v19 )
|
|
|
4062 {
|
|
|
4063 *(int *)&v18->field_0 = (*(int *)&v18[(char *)dword_50BC10.data() - (char *)v24].field_0 >> 3) & 0x1FFF;
|
|
|
4064 v18 += 4;
|
|
|
4065 }
|
|
|
4066 }
|
|
|
4067 }
|
|
|
4068 v20 = 0;
|
|
|
4069 for ( *(int *)&v5[2000].field_0 = v4; v20 < v4; ++v20 )
|
|
|
4070 {
|
|
|
4071 v21 = pActors[*(int *)&v5[4 * v20].field_0].uAIState;
|
|
|
4072 if ( v21 != 4 && v21 != 5 )
|
|
|
4073 break;
|
|
|
4074 }
|
|
|
4075 if ( v20 != v4 )
|
|
|
4076 {
|
|
|
4077 result = 8 * *(int *)&v5[4 * v20].field_0;
|
|
|
4078 LOBYTE(result) = result | 3;
|
|
|
4079 return result;
|
|
|
4080 }
|
|
|
4081 }
|
|
|
4082 }
|
|
|
4083 return 0;*/
|
|
|
4084 }
|
|
|
4085
|
|
|
4086 //----- (0042F4DA) --------------------------------------------------------
|
|
|
4087 bool CheckActors_proximity()
|
|
|
4088 {
|
|
|
4089 signed int distance; // edi@1
|
|
|
4090 int for_x; // ebx@5
|
|
|
4091 int for_y; // [sp+Ch] [bp-10h]@5
|
|
|
4092 int for_z; // [sp+10h] [bp-Ch]@5
|
|
|
4093
|
|
|
4094
|
|
|
4095 distance = 5120;
|
|
|
4096 if ( uCurrentlyLoadedLevelType == LEVEL_Indoor)
|
|
|
4097 distance = 2560;
|
|
|
4098
|
|
|
4099 if ( (signed int)uNumActors <= 0 )
|
|
|
4100 return false;
|
|
|
4101 for ( uint i = 0; i < (signed int)uNumActors; ++i )
|
|
|
4102 {
|
|
|
4103 for_x = abs(pActors[i].vInitialPosition.x - pParty->vPosition.x);
|
|
|
4104 for_y = abs(pActors[i].vInitialPosition.y - pParty->vPosition.y);
|
|
|
4105 for_z = abs(pActors[i].vInitialPosition.z - pParty->vPosition.z);
|
|
|
4106 if ( int_get_vector_length(for_x, for_y, for_z) < distance )
|
|
|
4107 {
|
|
|
4108 if ( pActors[i].uAIState != Dead )
|
|
|
4109 {
|
|
|
4110 if ( pActors[i].uAIState != Dying && pActors[i].uAIState != Removed
|
|
|
4111 && pActors[i].uAIState != Disabled && pActors[i].uAIState != Summoned
|
|
|
4112 && (pActors[i].ActorEnemy() || pActors[i].GetActorsRelation(0) ) )
|
|
|
4113 return true;
|
|
|
4114 }
|
|
|
4115 }
|
|
|
4116 }
|
|
|
4117 return false;
|
|
|
4118 }
|
|
|
4119
|
|
|
4120
|
|
|
4121 //----- (00426A5A) --------------------------------------------------------
|
|
|
4122 void Actor::LootActor()
|
|
|
4123 {
|
|
|
4124 signed int v2; // edi@1
|
|
|
4125 unsigned __int8 v7; // al@30
|
|
|
4126 char *v9; // [sp-4h] [bp-3Ch]@10
|
|
|
4127 char *v10; // [sp-4h] [bp-3Ch]@31
|
|
|
4128 char *v11; // [sp-4h] [bp-3Ch]@38
|
|
|
4129 ItemGen Dst; // [sp+Ch] [bp-2Ch]@1
|
|
|
4130 bool itemFound; // [sp+30h] [bp-8h]@1
|
|
|
4131 int v14; // [sp+34h] [bp-4h]@1
|
|
|
4132
|
|
|
4133 pParty->sub_421B2C_PlaceInInventory_or_DropPickedItem();
|
|
|
4134 Dst.Reset();
|
|
|
4135 v2 = 0;
|
|
|
4136 itemFound = false;
|
|
|
4137 v14 = 0;
|
|
|
4138 if ( !ActorHasItem() )
|
|
|
4139 {
|
|
|
4140 for (uchar i = 0; i < this->pMonsterInfo.uTreasureDiceRolls; i++ )
|
|
|
4141 v14 += rand() % this->pMonsterInfo.uTreasureDiceSides + 1;
|
|
|
4142 if ( v14 )
|
|
|
4143 {
|
|
|
4144 pParty->PartyFindsGold(v14, 0);
|
|
|
4145 viewparams->bRedrawGameUI = 1;
|
|
|
4146 }
|
|
|
4147 }
|
|
|
4148 else
|
|
|
4149 {
|
|
|
4150 if ( this->ActorHasItems[3].uItemID != 0 && this->ActorHasItems[3].GetItemEquipType() == EQUIP_GOLD )
|
|
|
4151 {
|
|
|
4152 v14 = this->ActorHasItems[3].uSpecEnchantmentType;
|
|
|
4153 this->ActorHasItems[3].Reset();
|
|
|
4154 if ( v14 )
|
|
|
4155 {
|
|
|
4156 pParty->PartyFindsGold(v14, 0);
|
|
|
4157 viewparams->bRedrawGameUI = 1;
|
|
|
4158 }
|
|
|
4159 }
|
|
|
4160 }
|
|
|
4161 if ( this->uCarriedItemID )
|
|
|
4162 {
|
|
|
4163 Dst.Reset();
|
|
|
4164 Dst.uItemID = this->uCarriedItemID;
|
|
|
4165 v9 = pItemsTable->pItems[Dst.uItemID].pUnidentifiedName;
|
|
|
4166 if ( v14 )
|
|
|
4167 sprintfex(pTmpBuf2.data(), pGlobalTXT_LocalizationStrings[490], v14, v9);
|
|
|
4168 else
|
|
|
4169 sprintfex(pTmpBuf2.data(), pGlobalTXT_LocalizationStrings[471], v9);
|
|
|
4170 ShowStatusBarString(pTmpBuf2.data(), 2);
|
|
|
4171 if ( Dst.GetItemEquipType() == 12 )
|
|
|
4172 {
|
|
|
4173 Dst.uNumCharges = rand() % 6 + Dst.GetDamageMod() + 1;
|
|
|
4174 Dst.uMaxCharges = Dst.uNumCharges;
|
|
|
4175 }
|
|
|
4176 if ( pItemsTable->pItems[Dst.uItemID].uEquipType == 14 && Dst.uItemID != 220 )
|
|
|
4177 Dst.uEnchantmentType = 2 * rand() % 4 + 2;
|
|
|
4178 pItemsTable->SetSpecialBonus(&Dst);
|
|
|
4179 if ( !pParty->AddItemToParty(&Dst) )
|
|
|
4180 pParty->SetHoldingItem(&Dst);
|
|
|
4181 this->uCarriedItemID = 0;
|
|
|
4182 if ( this->ActorHasItems[0].uItemID )
|
|
|
4183 {
|
|
|
4184 if ( !pParty->AddItemToParty(this->ActorHasItems) )
|
|
|
4185 {
|
|
|
4186 pParty->sub_421B2C_PlaceInInventory_or_DropPickedItem();
|
|
|
4187 pParty->SetHoldingItem(this->ActorHasItems);
|
|
|
4188 }
|
|
|
4189 this->ActorHasItems[0].Reset();
|
|
|
4190 }
|
|
|
4191 if ( this->ActorHasItems[1].uItemID )
|
|
|
4192 {
|
|
|
4193 if ( !pParty->AddItemToParty(&this->ActorHasItems[1]) )
|
|
|
4194 {
|
|
|
4195 pParty->sub_421B2C_PlaceInInventory_or_DropPickedItem();
|
|
|
4196 pParty->SetHoldingItem(&this->ActorHasItems[1]);
|
|
|
4197 }
|
|
|
4198 this->ActorHasItems[1].Reset();
|
|
|
4199 }
|
|
|
4200 this->Remove();
|
|
|
4201 return;
|
|
|
4202 }
|
|
|
4203 if ( this->ActorHasItem() )
|
|
|
4204 {
|
|
|
4205 if ( this->ActorHasItems[3].uItemID )
|
|
|
4206 {
|
|
|
4207 memcpy(&Dst, &this->ActorHasItems[3], sizeof(Dst));
|
|
|
4208 this->ActorHasItems[3].Reset();
|
|
|
4209 //v11 = pItemsTable->pItems[Dst.uItemID].pUnidentifiedName;
|
|
|
4210 if ( v14 )
|
|
|
4211 sprintfex(pTmpBuf2.data(), pGlobalTXT_LocalizationStrings[490], v14, pItemsTable->pItems[Dst.uItemID].pUnidentifiedName);
|
|
|
4212 else
|
|
|
4213 sprintfex(pTmpBuf2.data(), pGlobalTXT_LocalizationStrings[471], pItemsTable->pItems[Dst.uItemID].pUnidentifiedName);
|
|
|
4214 ShowStatusBarString(pTmpBuf2.data(), 2);
|
|
|
4215 if ( !pParty->AddItemToParty(&Dst) )
|
|
|
4216 pParty->SetHoldingItem(&Dst);
|
|
|
4217 itemFound = true;
|
|
|
4218 }
|
|
|
4219 }
|
|
|
4220 else
|
|
|
4221 {
|
|
|
4222 if ( rand() % 100 < this->pMonsterInfo.uTreasureDropChance && (v7 = this->pMonsterInfo.uTreasureLevel) != 0 )
|
|
|
4223 {
|
|
|
4224 pItemsTable->GenerateItem(v7, this->pMonsterInfo.uTreasureType, &Dst);
|
|
|
4225 v10 = pItemsTable->pItems[Dst.uItemID].pUnidentifiedName;
|
|
|
4226 if ( v14 )
|
|
|
4227 sprintfex(pTmpBuf2.data(), pGlobalTXT_LocalizationStrings[490], v14, v10);//Вы нашли ^I[%d] золот^L[ой;ых;ых] и предмет (%s)!
|
|
|
4228 else
|
|
|
4229 sprintfex(pTmpBuf2.data(), pGlobalTXT_LocalizationStrings[471], v10);//Вы нашли ^Pv[%s]!
|
|
|
4230 ShowStatusBarString(pTmpBuf2.data(), 2);
|
|
|
4231 if ( !pParty->AddItemToParty(&Dst) )
|
|
|
4232 pParty->SetHoldingItem(&Dst);
|
|
|
4233 itemFound = true;
|
|
|
4234 }
|
|
|
4235 }
|
|
|
4236 if ( this->ActorHasItems[0].uItemID )
|
|
|
4237 {
|
|
|
4238 if ( !pParty->AddItemToParty(this->ActorHasItems) )
|
|
|
4239 {
|
|
|
4240 pParty->sub_421B2C_PlaceInInventory_or_DropPickedItem();
|
|
|
4241 pParty->SetHoldingItem(this->ActorHasItems);
|
|
|
4242 itemFound = true;
|
|
|
4243 }
|
|
|
4244 this->ActorHasItems[0].Reset();
|
|
|
4245 }
|
|
|
4246 if ( this->ActorHasItems[1].uItemID )
|
|
|
4247 {
|
|
|
4248 if ( !pParty->AddItemToParty(&this->ActorHasItems[1]) )
|
|
|
4249 {
|
|
|
4250 pParty->sub_421B2C_PlaceInInventory_or_DropPickedItem();
|
|
|
4251 pParty->SetHoldingItem(&this->ActorHasItems[1]);
|
|
|
4252 itemFound = true;
|
|
|
4253 }
|
|
|
4254 this->ActorHasItems[1].Reset();
|
|
|
4255 }
|
|
|
4256 if ( !itemFound || rand() % 100 < 90 )//for repeatedly get gold and item
|
|
|
4257 this->Remove();
|
|
|
4258 }
|
|
|
4259
|
|
|
4260
|
|
|
4261 //----- (00427102) --------------------------------------------------------
|
|
|
4262 bool Actor::_427102_IsOkToCastSpell( signed int a2 )
|
|
|
4263 {
|
|
|
4264 switch(a2)
|
|
|
4265 {
|
|
|
4266 case SPELL_BODY_POWER_CURE:
|
|
|
4267 {
|
|
|
4268 if ( this->sCurrentHP >= (signed int)this->pMonsterInfo.uHP )
|
|
|
4269 return false;
|
|
|
4270 return true;
|
|
|
4271 }
|
|
|
4272 case SPELL_LIGHT_DISPEL_MAGIC:
|
|
|
4273 {
|
|
|
4274 for (int i = 0; i < 20; i++)
|
|
|
4275 {
|
|
|
4276 if (pParty->pPartyBuffs[i].uExpireTime > 0)
|
|
|
4277 return true;
|
|
|
4278 }
|
|
|
4279 for ( int i = 1; i <= 4; i++ )
|
|
|
4280 {
|
|
|
4281 for ( int j = 0; j < 22; j++ )
|
|
|
4282 {
|
|
|
4283 if (pPlayers[i]->pPlayerBuffs[j].uExpireTime > 0)
|
|
|
4284 return true;
|
|
|
4285 }
|
|
|
4286 }
|
|
|
4287 return false;
|
|
|
4288 }
|
|
|
4289 case SPELL_LIGHT_DAY_OF_PROTECTION:
|
|
|
4290 {
|
|
|
4291 return this->pActorBuffs[ACTOR_BUFF_DAY_OF_PROTECTION].uExpireTime <= 0;
|
|
|
4292 break;
|
|
|
4293 }
|
|
|
4294 case SPELL_LIGHT_HOUR_OF_POWER:
|
|
|
4295 {
|
|
|
4296 return this->pActorBuffs[ACTOR_BUFF_HOUR_OF_POWER].uExpireTime <= 0;
|
|
|
4297 break;
|
|
|
4298 }
|
|
|
4299 case SPELL_DARK_PAIN_REFLECTION:
|
|
|
4300 {
|
|
|
4301 return this->pActorBuffs[ACTOR_BUFF_PAIN_REFLECTION].uExpireTime <= 0;
|
|
|
4302 break;
|
|
|
4303 }
|
|
|
4304 case SPELL_BODY_HAMMERHANDS:
|
|
|
4305 {
|
|
|
4306 return this->pActorBuffs[ACTOR_BUFF_PAIN_HAMMERHANDS].uExpireTime <= 0;
|
|
|
4307 break;
|
|
|
4308 }
|
|
|
4309 case SPELL_FIRE_HASTE:
|
|
|
4310 {
|
|
|
4311 return this->pActorBuffs[ACTOR_BUFF_HASTE].uExpireTime <= 0;
|
|
|
4312 break;
|
|
|
4313 }
|
|
|
4314 case SPELL_AIR_SHIELD:
|
|
|
4315 {
|
|
|
4316 return this->pActorBuffs[ACTOR_BUFF_SHIELD].uExpireTime <= 0;
|
|
|
4317 break;
|
|
|
4318 }
|
|
|
4319 case SPELL_EARTH_STONESKIN:
|
|
|
4320 {
|
|
|
4321 return this->pActorBuffs[ACTOR_BUFF_STONESKIN].uExpireTime <= 0;
|
|
|
4322 break;
|
|
|
4323 }
|
|
|
4324 case SPELL_SPIRIT_BLESS:
|
|
|
4325 {
|
|
|
4326 return this->pActorBuffs[ACTOR_BUFF_BLESS].uExpireTime <= 0;
|
|
|
4327 break;
|
|
|
4328 }
|
|
|
4329 case SPELL_SPIRIT_FATE:
|
|
|
4330 {
|
|
|
4331 return this->pActorBuffs[ACTOR_BUFF_FATE].uExpireTime <= 0;
|
|
|
4332 break;
|
|
|
4333 }
|
|
|
4334 case SPELL_SPIRIT_HEROISM:
|
|
|
4335 {
|
|
|
4336 return this->pActorBuffs[ACTOR_BUFF_HEROISM].uExpireTime <= 0;
|
|
|
4337 break;
|
|
|
4338 }
|
|
|
4339 default:
|
|
|
4340 return true;
|
|
|
4341 }
|
|
|
4342 }
|
|
|
4343
|
|
|
4344
|
|
|
4345 //----- (0042704B) --------------------------------------------------------
|
|
|
4346 ABILITY_INDEX Actor::special_ability_use_check( int a2 )
|
|
|
4347 {
|
|
|
4348 signed int okToCastSpell1; // ebx@5
|
|
|
4349 signed int okToCastSpell2; // edi@5
|
|
|
4350
|
|
|
4351 if ( this->pMonsterInfo.uSpecialAbilityType == 2
|
|
|
4352 && this->pMonsterInfo.uSpecialAbilityDamageDiceBonus < 3
|
|
|
4353 && rand() % 100 < 5 )
|
|
|
4354 this->SummonMinion(a2);
|
|
|
4355 okToCastSpell1 = this->_427102_IsOkToCastSpell(this->pMonsterInfo.uSpell1ID);
|
|
|
4356 okToCastSpell2 = this->_427102_IsOkToCastSpell(this->pMonsterInfo.uSpell2ID);
|
|
|
4357 if ( okToCastSpell1 && this->pMonsterInfo.uSpell1UseChance && rand() % 100 < this->pMonsterInfo.uSpell1UseChance )
|
|
|
4358 return ABILITY_SPELL1;
|
|
|
4359 if ( okToCastSpell2 && this->pMonsterInfo.uSpell2UseChance && rand() % 100 < this->pMonsterInfo.uSpell2UseChance )
|
|
|
4360 return ABILITY_SPELL2;
|
|
|
4361 if (this->pMonsterInfo.uAttack2Chance && rand() % 100 < this->pMonsterInfo.uAttack2Chance)
|
|
|
4362 return ABILITY_ATTACK2;
|
|
|
4363 return ABILITY_ATTACK1;
|
|
|
4364 }
|
|
|
4365
|
|
|
4366
|
|
|
4367
|
|
|
4368 //----- (004273BB) --------------------------------------------------------
|
|
|
4369 bool Actor::_4273BB_DoesHitOtherActor( Actor *defender, int a3, int a4 )
|
|
|
4370 {
|
|
|
4371 signed int v6; // ebx@1
|
|
|
4372 signed int v7; // esi@1
|
|
|
4373 int armorSum; // ebx@10
|
|
|
4374 signed int a2a; // [sp+18h] [bp+Ch]@1
|
|
|
4375
|
|
|
4376 v6 = defender->pMonsterInfo.uAC;
|
|
|
4377 v7 = 0;
|
|
|
4378 a2a = 0;
|
|
|
4379 if ( defender->pActorBuffs[ACTOR_BUFF_SOMETHING_THAT_HALVES_AC].uExpireTime > 0 )
|
|
|
4380 v6 /= 2;
|
|
|
4381 if ( defender->pActorBuffs[ACTOR_BUFF_HOUR_OF_POWER].uExpireTime > 0 )
|
|
|
4382 v7 = defender->pActorBuffs[ACTOR_BUFF_HOUR_OF_POWER].uPower;
|
|
|
4383 if ( defender->pActorBuffs[ACTOR_BUFF_STONESKIN].uExpireTime > 0 && defender->pActorBuffs[ACTOR_BUFF_STONESKIN].uPower > v7 )
|
|
|
4384 v7 = defender->pActorBuffs[ACTOR_BUFF_STONESKIN].uPower;
|
|
|
4385 armorSum = v7 + v6;
|
|
|
4386 if ( this->pActorBuffs[ACTOR_BUFF_HOUR_OF_POWER].uExpireTime > 0 )
|
|
|
4387 a2a = this->pActorBuffs[ACTOR_BUFF_HOUR_OF_POWER].uPower;
|
|
|
4388 if ( this->pActorBuffs[ACTOR_BUFF_BLESS].uExpireTime > 0 && this->pActorBuffs[ACTOR_BUFF_BLESS].uPower > a2a )
|
|
|
4389 a2a = this->pActorBuffs[ACTOR_BUFF_BLESS].uPower;
|
|
|
4390 if ( this->pActorBuffs[ACTOR_BUFF_FATE].uExpireTime > 0 )
|
|
|
4391 {
|
|
|
4392 a2a += this->pActorBuffs[ACTOR_BUFF_FATE].uPower;
|
|
|
4393 this->pActorBuffs[ACTOR_BUFF_FATE].Reset();
|
|
|
4394 }
|
|
|
4395 return rand() % (armorSum + 2 * this->pMonsterInfo.uLevel + 10) + a2a + 1 > armorSum + 5;
|
|
|
4396 }
|
|
|
4397
|
|
|
4398 //----- (004274AD) --------------------------------------------------------
|
|
|
4399 bool Actor::ActorHitOrMiss(Player *pPlayer)
|
|
|
4400 {
|
|
|
4401 signed int v3; // edi@1
|
|
|
4402 signed int v4; // esi@8
|
|
|
4403 int v5; // esi@8
|
|
|
4404
|
|
|
4405 v3 = 0;
|
|
|
4406 if ( this->pActorBuffs[ACTOR_BUFF_HOUR_OF_POWER].uExpireTime > 0 )
|
|
|
4407 v3 = this->pActorBuffs[ACTOR_BUFF_HOUR_OF_POWER].uPower;
|
|
|
4408 if ( this->pActorBuffs[ACTOR_BUFF_BLESS].uExpireTime > 0 && this->pActorBuffs[ACTOR_BUFF_BLESS].uPower > v3 )
|
|
|
4409 v3 = this->pActorBuffs[ACTOR_BUFF_BLESS].uPower;
|
|
|
4410 if ( this->pActorBuffs[ACTOR_BUFF_FATE].uExpireTime > 0 )
|
|
|
4411 {
|
|
|
4412 v3 += this->pActorBuffs[ACTOR_BUFF_FATE].uPower;
|
|
|
4413 this->pActorBuffs[ACTOR_BUFF_FATE].Reset();
|
|
|
4414 }
|
|
|
4415 v4 = pPlayer->GetActualAC() + 2 * this->pMonsterInfo.uLevel + 10;
|
|
|
4416 v5 = rand() % v4 + 1;
|
|
|
4417 return (v3 + v5 > pPlayer->GetActualAC() + 5);
|
|
|
4418 }
|
|
|
4419
|
|
|
4420
|
|
|
4421 //----- (0042756B) --------------------------------------------------------
|
|
|
4422 int Actor::CalcMagicalDamageToActor(DAMAGE_TYPE dmgType, signed int incomingDmg)
|
|
|
4423 {
|
|
|
4424 int v4; // edx@1
|
|
|
4425 int v5; // ecx@1
|
|
|
4426 signed int v6; // eax@4
|
|
|
4427 signed int result; // eax@17
|
|
|
4428 signed int v8; // esi@18
|
|
|
4429
|
|
|
4430 v4 = 0;
|
|
|
4431 v5 = 0;
|
|
|
4432 if ( this->pActorBuffs[ACTOR_BUFF_HOUR_OF_POWER].uExpireTime > 0 )
|
|
|
4433 v5 = this->pActorBuffs[ACTOR_BUFF_HOUR_OF_POWER].uPower;
|
|
|
4434 switch ( dmgType )
|
|
|
4435 {
|
|
|
4436 case DMGT_FIRE:
|
|
|
4437 v6 = this->pMonsterInfo.uResFire;
|
|
|
4438 v4 = v5;
|
|
|
4439 break;
|
|
|
4440 case DMGT_ELECTR:
|
|
|
4441 v6 = this->pMonsterInfo.uResAir;
|
|
|
4442 v4 = v5;
|
|
|
4443 break;
|
|
|
4444 case DMGT_COLD:
|
|
|
4445 v6 = this->pMonsterInfo.uResWater;
|
|
|
4446 v4 = v5;
|
|
|
4447 break;
|
|
|
4448 case DMGT_EARTH:
|
|
|
4449 v6 = this->pMonsterInfo.uResEarth;
|
|
|
4450 v4 = v5;
|
|
|
4451 break;
|
|
|
4452 case DMGT_PHISYCAL:
|
|
|
4453 v6 = this->pMonsterInfo.uResPhysical;
|
|
|
4454 break;
|
|
|
4455 case DMGT_SPIRIT:
|
|
|
4456 v6 = this->pMonsterInfo.uResSpirit;
|
|
|
4457 break;
|
|
|
4458 case DMGT_MIND:
|
|
|
4459 v6 = this->pMonsterInfo.uResMind;
|
|
|
4460 v4 = v5;
|
|
|
4461 break;
|
|
|
4462 case DMGT_BODY:
|
|
|
4463 v6 = this->pMonsterInfo.uResBody;
|
|
|
4464 v4 = v5;
|
|
|
4465 break;
|
|
|
4466 case DMGT_LIGHT:
|
|
|
4467 v6 = this->pMonsterInfo.uResLight;
|
|
|
4468 break;
|
|
|
4469 case DMGT_DARK:
|
|
|
4470 v6 = this->pMonsterInfo.uResDark;
|
|
|
4471 break;
|
|
|
4472 default:
|
|
|
4473 v6 = 0;
|
|
|
4474 break;
|
|
|
4475 }
|
|
|
4476 if ( v6 < 200 )
|
|
|
4477 {
|
|
|
4478 v8 = v4 + v6 + 30;
|
|
|
4479 for (int i = 0; i < 4; i++)
|
|
|
4480 {
|
|
|
4481 if ( rand() % v8 < 30 )
|
|
|
4482 break;
|
|
|
4483 incomingDmg /= 2;
|
|
|
4484 }
|
|
|
4485 result = incomingDmg;
|
|
|
4486 }
|
|
|
4487 else
|
|
|
4488 result = 0;
|
|
|
4489 return result;
|
|
|
4490 }
|
|
|
4491
|
|
|
4492 //----- (00427662) --------------------------------------------------------
|
|
|
4493 bool Actor::DoesDmgTypeDoDamage(DAMAGE_TYPE uType)
|
|
|
4494 {
|
|
|
4495 signed int resist; // esi@2
|
|
|
4496 bool result; // eax@13
|
|
|
4497
|
|
|
4498 switch ( uType )
|
|
|
4499 {
|
|
|
4500 case 0:
|
|
|
4501 resist = this->pMonsterInfo.uResFire;
|
|
|
4502 break;
|
|
|
4503 case 1:
|
|
|
4504 resist = this->pMonsterInfo.uResAir;
|
|
|
4505 break;
|
|
|
4506 case 2:
|
|
|
4507 resist = this->pMonsterInfo.uResWater;
|
|
|
4508 break;
|
|
|
4509 case 3:
|
|
|
4510 resist = this->pMonsterInfo.uResEarth;
|
|
|
4511 break;
|
|
|
4512 case 4:
|
|
|
4513 resist = this->pMonsterInfo.uResPhysical;
|
|
|
4514 break;
|
|
|
4515 case 6:
|
|
|
4516 resist = this->pMonsterInfo.uResSpirit;
|
|
|
4517 break;
|
|
|
4518 case 7:
|
|
|
4519 resist = this->pMonsterInfo.uResMind;
|
|
|
4520 case 8:
|
|
|
4521 resist = this->pMonsterInfo.uResBody;
|
|
|
4522 break;
|
|
|
4523 case 9:
|
|
|
4524 resist = this->pMonsterInfo.uResLight;
|
|
|
4525 break;
|
|
|
4526 case 10:
|
|
|
4527 resist = this->pMonsterInfo.uResDark;
|
|
|
4528 break;
|
|
|
4529 default:
|
|
|
4530 return 1;
|
|
|
4531 }
|
|
|
4532 if ( resist < 200 )
|
|
|
4533 result = rand() % ((this->pMonsterInfo.uLevel >> 2) + resist + 30) < 30;
|
|
|
4534 else
|
|
|
4535 result = 0;
|
|
|
4536 return result;
|
|
|
4537 }
|
|
|
4538
|
|
|
4539 //----- (00448A98) --------------------------------------------------------
|
|
|
4540 void __fastcall ToggleActorGroupFlag(unsigned int uGroupID, unsigned int uFlag, unsigned int bToggle)
|
|
|
4541 {
|
|
|
4542 if ( uGroupID )
|
|
|
4543 {
|
|
|
4544 if ( bToggle )
|
|
|
4545 {
|
|
|
4546 for ( uint i = 0; i < (unsigned int)uNumActors; ++i )
|
|
|
4547 {
|
|
|
4548 if ( pActors[i].uGroup == uGroupID )
|
|
|
4549 {
|
|
|
4550 pActors[i].uAttributes |= uFlag;
|
|
|
4551 if ( uFlag == 0x10000 )
|
|
|
4552 {
|
|
|
4553 pActors[i].uAIState = Disabled;
|
|
|
4554 pActors[i].UpdateAnimation();
|
|
|
4555 }
|
|
|
4556 }
|
|
|
4557 }
|
|
|
4558 }
|
|
|
4559 else
|
|
|
4560 {
|
|
|
4561 for ( uint i = 0; i < (unsigned int)uNumActors; ++i )
|
|
|
4562 {
|
|
|
4563 if ( pActors[i].uGroup == uGroupID )
|
|
|
4564 {
|
|
|
4565 if ( uFlag == 0x10000 )
|
|
|
4566 {
|
|
|
4567 if ( pActors[i].uAIState != Dead )
|
|
|
4568 {
|
|
|
4569 if ( pActors[i].uAIState != 4 && pActors[i].uAIState != 11 )
|
|
|
4570 pActors[i].uAIState = Standing;
|
|
|
4571 }
|
|
|
4572 }
|
|
|
4573 LODWORD(pActors[i].uAttributes) &= ~uFlag;
|
|
|
4574 }
|
|
|
4575 }
|
|
|
4576 }
|
|
|
4577 }
|
|
|
4578 }
|
|
|
4579
|
|
|
4580 //----- (004014E6) --------------------------------------------------------
|
|
|
4581 void Actor::MakeActorAIList_ODM()
|
|
|
4582 {
|
|
|
4583 int v1; // eax@4
|
|
|
4584 unsigned int v7; // ST20_4@10
|
|
|
4585 int distance; // edi@10
|
|
|
4586 int v10; // ebx@14
|
|
|
4587 int v21; // [sp+Ch] [bp-14h]@4
|
|
|
4588 int v22; // [sp+10h] [bp-10h]@4
|
|
|
4589
|
|
|
4590 pParty->uFlags &= 0xFFFFFFCF;//~0x30
|
|
|
4591
|
|
|
4592 ai_arrays_size = 0;
|
|
|
4593 for (uint i = 0; i < uNumActors; ++i)
|
|
|
4594 {
|
|
|
4595 Actor* actor = &pActors[i];
|
|
|
4596
|
|
|
4597 actor->ResetAlive();//~0x400
|
|
|
4598 if (!actor->CanAct())
|
|
|
4599 {
|
|
|
4600 actor->ResetActive();
|
|
|
4601 continue;
|
|
|
4602 }
|
|
|
4603
|
|
|
4604 v22 = abs(pParty->vPosition.z - actor->vPosition.z);
|
|
|
4605 v21 = abs(pParty->vPosition.y - actor->vPosition.y);
|
|
|
4606 v1 = abs(pParty->vPosition.x - actor->vPosition.x);
|
|
|
4607 v7 = int_get_vector_length(v22, v21, v1);
|
|
|
4608 distance = v7 - actor->uActorRadius;
|
|
|
4609 if ( distance < 0 )
|
|
|
4610 distance = 0;
|
|
|
4611
|
|
|
4612 if (distance < 5632)
|
|
|
4613 {
|
|
|
4614 actor->ResetHostile();
|
|
|
4615 if ( actor->ActorEnemy() || actor->GetActorsRelation(0) )
|
|
|
4616 {
|
|
|
4617 //v11 = (pParty->uFlags & 0x10) == 0;
|
|
|
4618 actor->uAttributes |= ACTOR_HOSTILE;
|
|
|
4619 if (distance < 5120 )
|
|
|
4620 pParty->SetYellowAlert();
|
|
|
4621 if (distance < 307)
|
|
|
4622 pParty->SetRedAlert();
|
|
|
4623 }
|
|
|
4624 actor->uAttributes |= ACTOR_ACTIVE;
|
|
|
4625 ai_near_actors_distances[ai_arrays_size] = distance;
|
|
|
4626 ai_near_actors_ids[ai_arrays_size++] = i;
|
|
|
4627 }
|
|
|
4628 else
|
|
|
4629 actor->ResetActive();
|
|
|
4630 }
|
|
|
4631
|
|
|
4632 /*
|
|
|
4633 result = v27;
|
|
|
4634 if ( v27 > 0 )
|
|
|
4635 {
|
|
|
4636 v14 = 0;
|
|
|
4637 v15 = 1;
|
|
|
4638 v26 = 1;
|
|
|
4639 do
|
|
|
4640 {
|
|
|
4641 while ( 1 )
|
|
|
4642 {
|
|
|
4643 v24 = v15;
|
|
|
4644 if ( v15 >= result )
|
|
|
4645 break;
|
|
|
4646 v16 = ai_near_actors_distances[v14];
|
|
|
4647 if ( v16 > ai_near_actors_distances[v15] )
|
|
|
4648 {
|
|
|
4649 v17 = &ai_near_actors_ids[v15];
|
|
|
4650 v18 = ai_near_actors_ids[v14];
|
|
|
4651 ai_near_actors_ids[v14] = *v17;
|
|
|
4652 *v17 = v18;
|
|
|
4653 v15 = v24;
|
|
|
4654 ai_near_actors_distances[v14] = ai_near_actors_distances[v24];
|
|
|
4655 ai_near_actors_distances[v24] = v16;
|
|
|
4656 }
|
|
|
4657 result = v27;
|
|
|
4658 ++v15;
|
|
|
4659 }
|
|
|
4660 ++v14;
|
|
|
4661 v15 = v26 + 1;
|
|
|
4662 v26 = v15;
|
|
|
4663 }
|
|
|
4664 while ( v15 - 1 < result );
|
|
|
4665 }*/
|
|
|
4666
|
|
|
4667 for (uint i = 0; i < ai_arrays_size; ++i)
|
|
|
4668 for (uint j = 0; j < i; ++j)
|
|
|
4669 if (ai_near_actors_distances[j] > ai_near_actors_distances[i])
|
|
|
4670 {
|
|
|
4671 int tmp = ai_near_actors_distances[j];
|
|
|
4672 ai_near_actors_distances[j] = ai_near_actors_distances[i];
|
|
|
4673 ai_near_actors_distances[i] = tmp;
|
|
|
4674
|
|
|
4675 tmp = ai_near_actors_ids[j];
|
|
|
4676 ai_near_actors_ids[j] = ai_near_actors_ids[i];
|
|
|
4677 ai_near_actors_ids[i] = tmp;
|
|
|
4678 }
|
|
|
4679
|
|
|
4680
|
|
|
4681 if (ai_arrays_size > 30)
|
|
|
4682 ai_arrays_size = 30;
|
|
|
4683
|
|
|
4684 for (uint i = 0; i < ai_arrays_size; ++i)
|
|
|
4685 pActors[ai_near_actors_ids[i]].uAttributes |= ACTOR_ALIVE;//0x400
|
|
|
4686 }
|
|
|
4687
|
|
|
4688 //----- (004016FA) --------------------------------------------------------
|
|
|
4689 int Actor::MakeActorAIList_BLV()
|
|
|
4690 {
|
|
|
4691 int v1; // eax@4
|
|
|
4692 int distance; // edi@10
|
|
|
4693 int v13; // edx@24
|
|
|
4694 int v15; // ebx@26
|
|
|
4695 unsigned int v17; // esi@27
|
|
|
4696 int v18; // ecx@31
|
|
|
4697 signed int v19; // edi@31
|
|
|
4698 signed int v25; // eax@40
|
|
|
4699 int j; // edi@45
|
|
|
4700 int v30; // eax@48
|
|
|
4701 int v37; // [sp+Ch] [bp-18h]@1
|
|
|
4702 int v38; // [sp+10h] [bp-14h]@4
|
|
|
4703 int v39; // [sp+14h] [bp-10h]@4
|
|
|
4704 int i; // [sp+18h] [bp-Ch]@31
|
|
|
4705 uint v45; // [sp+20h] [bp-4h]@1
|
|
|
4706
|
|
|
4707 // __debugbreak(); // refactor for blv ai
|
|
|
4708 pParty->uFlags &= 0xFFFFFFCF;//~0x30
|
|
|
4709 v37 = pIndoor->GetSector(pParty->vPosition.x, pParty->vPosition.y, pParty->vPosition.z);
|
|
|
4710 v45 = 0;
|
|
|
4711 for ( uint i = 0; i < (signed int)uNumActors; ++i )
|
|
|
4712 {
|
|
|
4713 pActors[i].ResetAlive();//~0x0400
|
|
|
4714 if ( !pActors[i].CanAct() )
|
|
|
4715 {
|
|
|
4716 pActors[i].ResetActive();
|
|
|
4717 continue;
|
|
|
4718 }
|
|
|
4719 v1 = abs(pParty->vPosition.x - pActors[i].vPosition.x);
|
|
|
4720 v38 = abs(pParty->vPosition.y - pActors[i].vPosition.y);
|
|
|
4721 v39 = abs(pParty->vPosition.z - pActors[i].vPosition.z);
|
|
|
4722
|
|
|
4723 distance = int_get_vector_length(v39, v38, v1) - pActors[i].uActorRadius;
|
|
|
4724 if ( distance < 0 )
|
|
|
4725 distance = 0;
|
|
|
4726 if ( distance < 10240 )
|
|
|
4727 {
|
|
|
4728 pActors[i].ResetHostile();//~0x01000000
|
|
|
4729 if ( pActors[i].ActorEnemy() || pActors[i].GetActorsRelation(0) )
|
|
|
4730 {
|
|
|
4731 pActors[i].uAttributes |= ACTOR_HOSTILE;
|
|
|
4732 if ( !(pParty->uFlags & 0x10) && (double)distance < 307.2 )
|
|
|
4733 pParty->SetRedAlert();
|
|
|
4734 if ( !(pParty->uFlags & 0x20) && distance < 5120 )
|
|
|
4735 pParty->SetYellowAlert();
|
|
|
4736 }
|
|
|
4737 ai_near_actors_distances[v45] = distance;
|
|
|
4738 ai_near_actors_ids[v45] = i;
|
|
|
4739 v45++;
|
|
|
4740 }
|
|
|
4741 else
|
|
|
4742 pActors[i].ResetActive();
|
|
|
4743 }
|
|
|
4744 v13 = 0;
|
|
|
4745 if ( v45 > 0 )
|
|
|
4746 {
|
|
|
4747 for ( uint i = 1; i < v45; i++ )
|
|
|
4748 {
|
|
|
4749 for ( uint j = 1; j < v45; ++j )
|
|
|
4750 {
|
|
|
4751 v15 = ai_near_actors_distances[v13];
|
|
|
4752 if ( ai_near_actors_distances[v13] > ai_near_actors_distances[j] )
|
|
|
4753 {
|
|
|
4754 v17 = ai_near_actors_ids[v13];
|
|
|
4755 ai_near_actors_ids[v13] = ai_near_actors_ids[j];
|
|
|
4756 ai_near_actors_ids[j] = v17;
|
|
|
4757 ai_near_actors_distances[v13] = ai_near_actors_distances[j];
|
|
|
4758 ai_near_actors_distances[j] = v15;
|
|
|
4759 }
|
|
|
4760 }
|
|
|
4761 ++v13;
|
|
|
4762 }
|
|
|
4763 }
|
|
|
4764 v18 = 0;
|
|
|
4765 v19 = 0;
|
|
|
4766 for ( i = 0; i < v45; i++ )
|
|
|
4767 {
|
|
|
4768 if ( pActors[ai_near_actors_ids[i]].ActorNearby()
|
|
|
4769 || sub_4070EF_prolly_detect_player(PID(OBJECT_Actor,ai_near_actors_ids[i]), 4) )
|
|
|
4770 {
|
|
|
4771 pActors[ai_near_actors_ids[i]].uAttributes |= ACTOR_NEARBY;
|
|
|
4772 ai_array_4F6638_actor_ids[v19] = ai_near_actors_ids[i];
|
|
|
4773 ai_array_4F5E68[v19++] = ai_near_actors_distances[i];
|
|
|
4774 if ( v19 >= 30 )
|
|
|
4775 break;
|
|
|
4776 }
|
|
|
4777 }
|
|
|
4778 ai_arrays_size = v19;
|
|
|
4779 if ( (signed int)uNumActors > 0 )
|
|
|
4780 {
|
|
|
4781 for ( uint i = 0; i < (signed int)uNumActors; ++i )
|
|
|
4782 {
|
|
|
4783 if ( pActors[i].CanAct() && pActors[i].uSectorID == v37 )
|
|
|
4784 {
|
|
|
4785 v25 = 0;
|
|
|
4786 if ( v19 <= 0 )
|
|
|
4787 {
|
|
|
4788 pActors[i].uAttributes |= ACTOR_ACTIVE;
|
|
|
4789 ai_array_4F6638_actor_ids[ai_arrays_size++] = i;
|
|
|
4790 }
|
|
|
4791 else
|
|
|
4792 {
|
|
|
4793 while ( ai_array_4F6638_actor_ids[v25] != i )
|
|
|
4794 {
|
|
|
4795 ++v25;
|
|
|
4796 if ( v25 >= v19 )
|
|
|
4797 {
|
|
|
4798 pActors[i].uAttributes |= ACTOR_ACTIVE;
|
|
|
4799 ai_array_4F6638_actor_ids[ai_arrays_size++] = i;
|
|
|
4800 break;
|
|
|
4801 }
|
|
|
4802 }
|
|
|
4803 }
|
|
|
4804 }
|
|
|
4805 }
|
|
|
4806 }
|
|
|
4807 for ( j = 0; j < v45; ++j )
|
|
|
4808 {
|
|
|
4809 if ( pActors[ai_near_actors_ids[j]].uAttributes & 0xC000 && pActors[ai_near_actors_ids[j]].CanAct() )
|
|
|
4810 {
|
|
|
4811 v30 = 0;
|
|
|
4812 if ( ai_arrays_size <= 0 )
|
|
|
4813 ai_array_4F6638_actor_ids[ai_arrays_size++] = ai_near_actors_ids[j];
|
|
|
4814 else
|
|
|
4815 {
|
|
|
4816 while ( ai_array_4F6638_actor_ids[v30] != ai_near_actors_ids[j] )
|
|
|
4817 {
|
|
|
4818 ++v30;
|
|
|
4819 if ( v30 >= ai_arrays_size )
|
|
|
4820 {
|
|
|
4821 ai_array_4F6638_actor_ids[ai_arrays_size++] = ai_near_actors_ids[j];
|
|
|
4822 break;
|
|
|
4823 }
|
|
|
4824 }
|
|
|
4825 }
|
|
|
4826 }
|
|
|
4827 }
|
|
|
4828 if ( ai_arrays_size > 30 )
|
|
|
4829 ai_arrays_size = 30;
|
|
|
4830 memcpy(ai_near_actors_ids.data(), ai_array_4F6638_actor_ids.data(), 4 * ai_arrays_size);
|
|
|
4831 memcpy(ai_near_actors_distances.data(), ai_array_4F5E68.data(), 4 * ai_arrays_size);
|
|
|
4832 for ( uint i = 0; i < ai_arrays_size; i++ )
|
|
|
4833 pActors[ai_near_actors_ids[i]].uAttributes |= ACTOR_ALIVE;//0x400
|
|
|
4834 return ai_arrays_size;
|
|
|
4835 }
|
|
|
4836
|
|
|
4837
|
|
|
4838 //----- (004070EF) --------------------------------------------------------
|
|
|
4839 bool __fastcall sub_4070EF_prolly_detect_player(unsigned int uObjID, unsigned int uObj2ID)
|
|
|
4840 {
|
|
|
4841 signed int v2; // eax@1
|
|
|
4842 int obj1_sector; // eax@4
|
|
|
4843 float v8; // ST24_4@5
|
|
|
4844 signed int v12; // eax@7
|
|
|
4845 int obj2_z; // edi@11
|
|
|
4846 int obj2_x; // esi@11
|
|
|
4847 int obj2_sector; // eax@13
|
|
|
4848 float v20; // ST24_4@14
|
|
|
4849 int dist_x; // ebx@16
|
|
|
4850 signed int dist_3d; // ecx@16
|
|
|
4851 int v25; // eax@18
|
|
|
4852 BLVFace *v29; // ebx@32
|
|
|
4853 Vec3_short_ *v30; // esi@32
|
|
|
4854 int v31; // eax@32
|
|
|
4855 int v32; // ST50_4@44
|
|
|
4856 int v33; // ST54_4@44
|
|
|
4857 int v34; // eax@44
|
|
|
4858 signed int v38; // esi@45
|
|
|
4859 __int16 next_sector; // bx@58
|
|
|
4860 int v47; // [sp+18h] [bp-50h]@20
|
|
|
4861 int v48; // [sp+1Ch] [bp-4Ch]@20
|
|
|
4862 int v49; // [sp+20h] [bp-48h]@20
|
|
|
4863 int dist_z; // [sp+24h] [bp-44h]@16
|
|
|
4864 signed int higher_z; // [sp+24h] [bp-44h]@27
|
|
|
4865 signed int lower_z; // [sp+28h] [bp-40h]@26
|
|
|
4866 signed int higher_y; // [sp+2Ch] [bp-3Ch]@23
|
|
|
4867 signed int lower_y; // [sp+30h] [bp-38h]@22
|
|
|
4868 signed int higher_x; // [sp+34h] [bp-34h]@21
|
|
|
4869 signed int lower_x; // [sp+38h] [bp-30h]@20
|
|
|
4870 signed int sectors_visited; // [sp+3Ch] [bp-2Ch]@28
|
|
|
4871 int v58; // [sp+44h] [bp-24h]@50
|
|
|
4872 int v59; // [sp+48h] [bp-20h]@44
|
|
|
4873 int obj2_y; // [sp+50h] [bp-18h]@11
|
|
|
4874 int obj1_x; // [sp+58h] [bp-10h]@4
|
|
|
4875 int obj1_y; // [sp+5Ch] [bp-Ch]@4
|
|
|
4876 int obj1_z; // [sp+60h] [bp-8h]@4
|
|
|
4877 int current_sector; // [sp+64h] [bp-4h]@7
|
|
|
4878 int dist_y;
|
|
|
4879 int v70;
|
|
|
4880
|
|
|
4881 v2 = PID_ID(uObjID);
|
|
|
4882 switch( PID_TYPE(uObjID) )
|
|
|
4883 {
|
|
|
4884 case OBJECT_Decoration:
|
|
|
4885 obj1_x = pLevelDecorations[v2].vPosition.x;
|
|
|
4886 obj1_y = pLevelDecorations[v2].vPosition.y;
|
|
|
4887 obj1_z = pLevelDecorations[v2].vPosition.z;
|
|
|
4888 obj1_sector = pIndoor->GetSector(obj1_x, obj1_y, obj1_z);
|
|
|
4889 break;
|
|
|
4890 case OBJECT_Actor:
|
|
|
4891 obj1_x = pActors[v2].vPosition.x;
|
|
|
4892 obj1_y = pActors[v2].vPosition.y;
|
|
|
4893 v8 = (double)pActors[v2].uActorHeight * 0.69999999;
|
|
|
4894 //v9 = v8 + 6.7553994e15;
|
|
|
4895 //obj1_z = LODWORD(v9) + pActors[v2].vPosition.z;
|
|
|
4896 obj1_z = (int)v8 + pActors[v2].vPosition.z;
|
|
|
4897 obj1_sector = pActors[v2].uSectorID;
|
|
|
4898 break;
|
|
|
4899 case OBJECT_Item:
|
|
|
4900 obj1_x = pSpriteObjects[v2].vPosition.x;
|
|
|
4901 obj1_y = pSpriteObjects[v2].vPosition.y;
|
|
|
4902 obj1_z = pSpriteObjects[v2].vPosition.z;
|
|
|
4903 obj1_sector = pSpriteObjects[v2].uSectorID;
|
|
|
4904 break;
|
|
|
4905 default:
|
|
|
4906 return 0;
|
|
|
4907 }
|
|
|
4908 v12 = PID_ID(uObj2ID);
|
|
|
4909 switch( PID_TYPE(uObj2ID) )
|
|
|
4910 {
|
|
|
4911 case OBJECT_Decoration:
|
|
|
4912 obj2_z = pLevelDecorations[v12].vPosition.z;
|
|
|
4913 obj2_x = pLevelDecorations[v12].vPosition.x;
|
|
|
4914 obj2_y = pLevelDecorations[v12].vPosition.y;
|
|
|
4915 obj2_sector = pIndoor->GetSector(obj2_x, obj2_y, obj2_z);
|
|
|
4916 break;
|
|
|
4917 case OBJECT_Player:
|
|
|
4918 obj2_x = pParty->vPosition.x;
|
|
|
4919 obj2_z = pParty->sEyelevel + pParty->vPosition.z;
|
|
|
4920 obj2_y = pParty->vPosition.y;
|
|
|
4921 obj2_sector = pIndoor->GetSector(pParty->vPosition.x, pParty->vPosition.y, pParty->sEyelevel + pParty->vPosition.z);
|
|
|
4922 break;
|
|
|
4923 case OBJECT_Actor:
|
|
|
4924 obj2_y = pActors[v12].vPosition.y;
|
|
|
4925 obj2_x = pActors[v12].vPosition.x;
|
|
|
4926 v20 = (double)pActors[v12].uActorHeight * 0.69999999;
|
|
|
4927 //v21 = v20 + 6.7553994e15;
|
|
|
4928 //obj2_z = LODWORD(v21) + pActors[v12].vPosition.z;
|
|
|
4929 obj2_z = (int)v20 + pActors[v12].vPosition.z;
|
|
|
4930 obj2_sector = pActors[v12].uSectorID;
|
|
|
4931 break;
|
|
|
4932 case OBJECT_Item:
|
|
|
4933 obj2_x = pSpriteObjects[v12].vPosition.x;
|
|
|
4934 obj2_z = pSpriteObjects[v12].vPosition.z;
|
|
|
4935 obj2_y = pSpriteObjects[v12].vPosition.y;
|
|
|
4936 obj2_sector = pSpriteObjects[v12].uSectorID;
|
|
|
4937 break;
|
|
|
4938 default:
|
|
|
4939 return 0;
|
|
|
4940 }
|
|
|
4941 dist_x = obj2_x - obj1_x;
|
|
|
4942 dist_z = obj2_z - obj1_z;
|
|
|
4943 dist_y = obj2_y - obj1_y;
|
|
|
4944 dist_3d = integer_sqrt(dist_x * dist_x + dist_y * dist_y + dist_z * dist_z);
|
|
|
4945 //range check
|
|
|
4946 if ( dist_3d > 5120 )
|
|
|
4947 return 0;
|
|
|
4948 if ( uCurrentlyLoadedLevelType == LEVEL_Outdoor)
|
|
|
4949 return 1;
|
|
|
4950 v25 = 65536;
|
|
|
4951 if ( dist_3d )
|
|
|
4952 v25 = 65536 / dist_3d;
|
|
|
4953 v49 = dist_x * v25;
|
|
|
4954 v47 = dist_z * v25;
|
|
|
4955 v48 = dist_y * v25;
|
|
|
4956 if ( obj1_x < obj2_x )
|
|
|
4957 {
|
|
|
4958 lower_x = obj1_x;
|
|
|
4959 higher_x = obj2_x;
|
|
|
4960 }
|
|
|
4961 else
|
|
|
4962 {
|
|
|
4963 lower_x = obj2_x;
|
|
|
4964 higher_x = obj1_x;
|
|
|
4965 }
|
|
|
4966 if ( obj1_y < obj2_y )
|
|
|
4967 {
|
|
|
4968 lower_y = obj1_y;
|
|
|
4969 higher_y = obj2_y;
|
|
|
4970 }
|
|
|
4971 else
|
|
|
4972 {
|
|
|
4973 lower_y = obj2_y;
|
|
|
4974 higher_y = obj1_y;
|
|
|
4975 }
|
|
|
4976 if ( obj1_z < obj2_z )
|
|
|
4977 {
|
|
|
4978 lower_z = obj1_z;
|
|
|
4979 higher_z = obj2_z;
|
|
|
4980 }
|
|
|
4981 else
|
|
|
4982 {
|
|
|
4983 lower_z = obj2_z;
|
|
|
4984 higher_z = obj1_z;
|
|
|
4985 }
|
|
|
4986 sectors_visited = 0;
|
|
|
4987 //monster in same sector with player
|
|
|
4988 if ( obj1_sector == obj2_sector )
|
|
|
4989 return 1;
|
|
|
4990 //search starts from monster
|
|
|
4991 current_sector = obj1_sector;
|
|
|
4992 for( int current_portal = 0; current_portal < pIndoor->pSectors[current_sector].uNumPortals; current_portal++ )
|
|
|
4993 {
|
|
|
4994 v29 = &pIndoor->pFaces[pIndoor->pSectors[current_sector].pPortals[current_portal]];
|
|
|
4995 v30 = &pIndoor->pVertices[*v29->pVertexIDs];
|
|
|
4996 v31 = v29->pFacePlane_old.vNormal.z * (v30->z - obj1_z)
|
|
|
4997 + v29->pFacePlane_old.vNormal.y * (v30->y - obj1_y)
|
|
|
4998 + v29->pFacePlane_old.vNormal.x * (v30->x - obj1_x);
|
|
|
4999
|
|
|
5000 if ( current_sector != v29->uSectorID )
|
|
|
5001 v31 = -v31;
|
|
|
5002
|
|
|
5003 if ( v31 >= 0 && v30->x != obj1_x && v30->y != obj1_y && v30->z != obj1_z)
|
|
|
5004 continue;
|
|
|
5005
|
|
|
5006 if( lower_x > v29->pBounding.x2
|
|
|
5007 || higher_x < v29->pBounding.x1
|
|
|
5008 || lower_y > v29->pBounding.y2
|
|
|
5009 || higher_y < v29->pBounding.y1
|
|
|
5010 || lower_z > v29->pBounding.z2
|
|
|
5011 || higher_z < v29->pBounding.z1 )
|
|
|
5012 {
|
|
|
5013 continue;
|
|
|
5014 }
|
|
|
5015
|
|
|
5016 v32 = fixpoint_mul(v29->pFacePlane_old.vNormal.x,v49);
|
|
|
5017 v34 = fixpoint_mul(v29->pFacePlane_old.vNormal.y,v48);
|
|
|
5018 v33 = fixpoint_mul(v29->pFacePlane_old.vNormal.z,v47);
|
|
|
5019
|
|
|
5020 v59 = v32 + v33 + v34;
|
|
|
5021 if ( v59 )
|
|
|
5022 {
|
|
|
5023 v70 = v29->pFacePlane_old.dist
|
|
|
5024 + obj1_z * v29->pFacePlane_old.vNormal.z
|
|
|
5025 + obj1_x * v29->pFacePlane_old.vNormal.x
|
|
|
5026 + obj1_y * v29->pFacePlane_old.vNormal.y;
|
|
|
5027 v38 = -v70;
|
|
|
5028
|
|
|
5029 // if ( v59 <= 0 ^ v70 <= 0 )
|
|
|
5030
|
|
|
5031 /* TEMPORARY
|
|
|
5032 if ( v59 <= 0 && v70 <= 0 )
|
|
|
5033 {
|
|
|
5034 continue;
|
|
|
5035 }
|
|
|
5036 if ( !(v59 <= 0 && v70 <= 0) )
|
|
|
5037 {
|
|
|
5038 continue;
|
|
|
5039 }
|
|
|
5040 */
|
|
|
5041
|
|
|
5042 if( abs(v38) >> 14 > abs(v59) )
|
|
|
5043 continue;
|
|
|
5044
|
|
|
5045 v58 = fixpoint_div(v38,v59);
|
|
|
5046
|
|
|
5047 if( v58 < 0 )
|
|
|
5048 continue;
|
|
|
5049
|
|
|
5050 if(!sub_4075DB(obj1_x + ((fixpoint_mul(v49,v58) + 32768) >> 16), obj1_y + ((fixpoint_mul(v48,v58) + 32768) >> 16),
|
|
|
5051 obj1_z + ((fixpoint_mul(v47,v58) + 32768) >> 16), v29) )
|
|
|
5052 {
|
|
|
5053 continue;
|
|
|
5054 }
|
|
|
5055
|
|
|
5056 //if there is no next sector turn back
|
|
|
5057 if ( v29->uSectorID == current_sector )
|
|
|
5058 next_sector = v29->uBackSectorID;
|
|
|
5059 else
|
|
|
5060 next_sector = v29->uSectorID;
|
|
|
5061
|
|
|
5062 //no more portals, quit
|
|
|
5063 if ( next_sector == current_sector )
|
|
|
5064 break;
|
|
|
5065
|
|
|
5066 ++sectors_visited;
|
|
|
5067 current_sector = next_sector;
|
|
|
5068
|
|
|
5069 //found player, quit
|
|
|
5070 if ( next_sector == obj2_sector )
|
|
|
5071 return 1;
|
|
|
5072
|
|
|
5073 current_sector = next_sector;
|
|
|
5074
|
|
|
5075 //did we hit limit for portals?
|
|
|
5076 //does the next room have portals?
|
|
|
5077 if ( sectors_visited < 30 && pIndoor->pSectors[current_sector].uNumPortals > 0)
|
|
|
5078 {
|
|
|
5079 current_portal=-1;
|
|
|
5080 continue;
|
|
|
5081 }
|
|
|
5082 else
|
|
|
5083 break;
|
|
|
5084 }
|
|
|
5085 }
|
|
|
5086 //did we stop in the sector where player is?
|
|
|
5087 if ( current_sector != obj2_sector )
|
|
|
5088 return 0;
|
|
|
5089 return 1;
|
|
|
5090 }
|
|
|
5091
|
|
|
5092
|
|
|
5093 //----- (00450B0A) --------------------------------------------------------
|
|
|
5094 bool __fastcall SpawnActor(unsigned int uMonsterID)
|
|
|
5095 {
|
|
|
5096 unsigned int v1; // ebx@1
|
|
|
5097 bool result; // eax@2
|
|
|
5098 unsigned int v6; // ecx@5
|
|
|
5099 Actor actor; // [sp+4h] [bp-350h]@5
|
|
|
5100 Vec3_int_ pOut; // [sp+348h] [bp-Ch]@5
|
|
|
5101
|
|
|
5102 v1 = uMonsterID;
|
|
|
5103 if ( uNumActors == 499 )
|
|
|
5104 result = 0;
|
|
|
5105 else
|
|
|
5106 {
|
|
|
5107 if ( (signed int)uMonsterID >= (signed int)pMonsterList->uNumMonsters )
|
|
|
5108 v1 = 0;
|
|
|
5109 memset(&actor, 0, sizeof(Actor));
|
|
|
5110 strcpy(actor.pActorName, pMonsterStats->pInfos[v1 + 1].pName);
|
|
|
5111 actor.sCurrentHP = LOWORD(pMonsterStats->pInfos[v1 + 1].uHP);
|
|
|
5112 memcpy(&actor.pMonsterInfo, &pMonsterStats->pInfos[v1 + 1], sizeof(MonsterInfo));
|
|
|
5113 actor.word_000086_some_monster_id = v1 + 1;
|
|
|
5114 actor.uActorRadius = pMonsterList->pMonsters[v1].uMonsterRadius;
|
|
|
5115 actor.uActorHeight = pMonsterList->pMonsters[v1].uMonsterHeight;
|
|
|
5116 actor.uMovementSpeed = pMonsterList->pMonsters[v1].uMovementSpeed;
|
|
|
5117
|
|
|
5118 Vec3_int_::Rotate(200, pParty->sRotationY, 0, pParty->vPosition, &pOut.x, &pOut.z, &pOut.y);
|
|
|
5119 actor.vInitialPosition.x = pOut.x;
|
|
|
5120 actor.vPosition.x = pOut.x;
|
|
|
5121 actor.uTetherDistance = 256;
|
|
|
5122 actor.vInitialPosition.y = LOWORD(pOut.z);
|
|
|
5123 actor.vPosition.y = LOWORD(pOut.z);
|
|
|
5124 actor.vInitialPosition.z = LOWORD(pOut.y);
|
|
|
5125 actor.vPosition.z = LOWORD(pOut.y);
|
|
|
5126 pSprites_LOD->DeleteSomeSprites();
|
|
|
5127 pPaletteManager->ResetNonTestLocked();
|
|
|
5128 v6 = uNumActors - 1;
|
|
|
5129 if ( dword_5C6DF8 == 1 )
|
|
|
5130 {
|
|
|
5131 dword_5C6DF8 = 0;
|
|
|
5132 v6 = uNumActors++;
|
|
|
5133 }
|
|
|
5134 memcpy(&pActors[v6], &actor, sizeof(Actor));
|
|
|
5135 pActors[v6].PrepareSprites(1);
|
|
|
5136 result = 1;
|
|
|
5137 }
|
|
|
5138 return result;
|
|
|
5139 }
|
|
|
5140 // 5C6DF8: using guessed type int dword_5C6DF8;
|
|
|
5141
|
|
|
5142
|
|
|
5143 //----- (0044FA4C) --------------------------------------------------------
|
|
|
5144 signed int __fastcall sub_44FA4C_spawn_light_elemental(int a1, int a2, int a3)
|
|
|
5145 {
|
|
|
5146 signed int result; // eax@13
|
|
|
5147 int v10; // ebx@16
|
|
|
5148 const char *v15; // [sp-4h] [bp-24h]@2
|
|
|
5149 unsigned int uFaceID; // [sp+8h] [bp-18h]@16
|
|
|
5150 int v19; // [sp+Ch] [bp-14h]@16
|
|
|
5151 size_t v20; // [sp+10h] [bp-10h]@6
|
|
|
5152 int v21; // [sp+14h] [bp-Ch]@14
|
|
|
5153 unsigned int v23; // [sp+1Ch] [bp-4h]@6
|
|
|
5154
|
|
|
5155 if ( a2 == 4 )
|
|
|
5156 v15 = "Elemental Light C";
|
|
|
5157 else if ( a2 == 3 )
|
|
|
5158 v15 = "Elemental Light B";
|
|
|
5159 else
|
|
|
5160 v15 = "Elemental Light A";
|
|
|
5161
|
|
|
5162 v23 = pMonsterList->GetMonsterIDByName(v15);
|
|
|
5163 v20 = 0;
|
|
|
5164 for ( v20; v20 < uNumActors; v20++ )
|
|
|
5165 {
|
|
|
5166 if ( pActors[v20].uAIState == Removed )
|
|
|
5167 break;
|
|
|
5168 }
|
|
|
5169
|
|
|
5170 result = uNumActors + 1;
|
|
|
5171 if ( v20 != uNumActors || result < 500 )
|
|
|
5172 {
|
|
|
5173 v21 = 0;
|
|
|
5174 if ( uCurrentlyLoadedLevelType == LEVEL_Indoor )
|
|
|
5175 v21 = pIndoor->GetSector(pParty->vPosition.x, pParty->vPosition.y, pParty->vPosition.z);
|
|
|
5176 v19 = (((uCurrentlyLoadedLevelType != LEVEL_Outdoor) - 1) & 0x40) + 64;
|
|
|
5177 pActors[v20].Reset();
|
|
|
5178 strcpy(pActors[v20].pActorName, pMonsterStats->pInfos[v23 + 1].pName);
|
|
|
5179 pActors[v20].sCurrentHP = pMonsterStats->pInfos[v23 + 1].uHP;
|
|
|
5180 memcpy(&pActors[v20].pMonsterInfo, &pMonsterStats->pInfos[v23 + 1], sizeof(MonsterInfo));
|
|
|
5181 pActors[v20].word_000086_some_monster_id = v23 + 1;
|
|
|
5182 pActors[v20].uActorRadius = pMonsterList->pMonsters[v23].uMonsterRadius;
|
|
|
5183 pActors[v20].uActorHeight = pMonsterList->pMonsters[v23].uMonsterHeight;
|
|
|
5184 pActors[v20].pMonsterInfo.uTreasureDiceRolls = 0;
|
|
|
5185 pActors[v20].pMonsterInfo.uTreasureType = 0;
|
|
|
5186 pActors[v20].pMonsterInfo.uExp = 0;
|
|
|
5187 pActors[v20].uMovementSpeed = pMonsterList->pMonsters[v23].uMovementSpeed;
|
|
|
5188 v10 = rand() % 2048;
|
|
|
5189 pActors[v20].vInitialPosition.x = pParty->vPosition.x + fixpoint_mul(stru_5C6E00->Cos(v10), v19);
|
|
|
5190 pActors[v20].vPosition.x = pActors[v20].vInitialPosition.x;
|
|
|
5191 pActors[v20].vInitialPosition.y = pParty->vPosition.y + fixpoint_mul(stru_5C6E00->Sin(v10), v19);
|
|
|
5192 pActors[v20].vPosition.y = pActors[v20].vInitialPosition.y;
|
|
|
5193 pActors[v20].vInitialPosition.z = pParty->vPosition.z;
|
|
|
5194 pActors[v20].vPosition.z = pActors[v20].vInitialPosition.z;
|
|
|
5195 pActors[v20].uTetherDistance = 256;
|
|
|
5196 pActors[v20].uSectorID = v21;
|
|
|
5197 pActors[v20].PrepareSprites(0);
|
|
|
5198 pActors[v20].pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Friendly;
|
|
|
5199 pActors[v20].uAlly = 9999;
|
|
|
5200 pActors[v20].uGroup = 0;
|
|
|
5201 pActors[v20].uCurrentActionTime = 0;
|
|
|
5202 pActors[v20].uAIState = Summoned;
|
|
|
5203 pActors[v20].uCurrentActionLength = 256;
|
|
|
5204 pActors[v20].UpdateAnimation();
|
|
|
5205
|
|
|
5206 result = pIndoor->GetSector(pActors[v20].vPosition.x, pActors[v20].vPosition.y, pActors[v20].vPosition.z);
|
|
|
5207 if ( uCurrentlyLoadedLevelType == LEVEL_Outdoor
|
|
|
5208 || result == v21
|
|
|
5209 && (result = BLV_GetFloorLevel(pActors[v20].vPosition.x, pActors[v20].vPosition.y, pActors[v20].vPosition.z, result, &uFaceID), result != -30000)
|
|
|
5210 && (result = abs(result - pParty->vPosition.z), result <= 1024) )
|
|
|
5211 {
|
|
|
5212 if ( v20 == uNumActors )
|
|
|
5213 ++uNumActors;
|
|
|
5214 pActors[v20].uSummonerID = PID(OBJECT_Player, a1);
|
|
|
5215 result = pActors[v20].pActorBuffs[ACTOR_BUFF_SUMMONED].Apply(pParty->uTimePlayed + (a3 * 128) / 30.0f, a2, a1, 0, 0);
|
|
|
5216 }
|
|
|
5217 }
|
|
|
5218 return result;
|
|
|
5219 }
|
|
|
5220
|
|
|
5221 //----- (0044F57C) --------------------------------------------------------
|
|
|
5222 void SpawnEncounter(MapInfo *pMapInfo, SpawnPointMM7 *spawn, int a3, int a4, int a5)
|
|
|
5223 {
|
|
|
5224 int v7; // eax@2
|
|
|
5225 char v8; // zf@5
|
|
|
5226 int v12; // edx@9
|
|
|
5227 int v18; // esi@31
|
|
|
5228 Actor *pMonster; // esi@35
|
|
|
5229 int v23; // edx@36
|
|
|
5230 signed int v24; // edi@36
|
|
|
5231 int v25; // ecx@36
|
|
|
5232 MonsterDesc *v27; // edi@48
|
|
|
5233 signed int v28; // eax@48
|
|
|
5234 int v32; // eax@50
|
|
|
5235 int v37; // eax@51
|
|
|
5236 int v38; // eax@52
|
|
|
5237 int v39; // edi@52
|
|
|
5238 std::string v40; // [sp-18h] [bp-100h]@60
|
|
|
5239 const char *v44; // [sp-8h] [bp-F0h]@13
|
|
|
5240 char *pTexture; // [sp-4h] [bp-ECh]@9
|
|
|
5241 char Str[32]; // [sp+Ch] [bp-DCh]@60
|
|
|
5242 char Str2[120]; // [sp+2Ch] [bp-BCh]@29
|
|
|
5243 unsigned int uFaceID; // [sp+A4h] [bp-44h]@52
|
|
|
5244 MonsterInfo *Src; // [sp+A8h] [bp-40h]@50
|
|
|
5245 int v50; // [sp+ACh] [bp-3Ch]@47
|
|
|
5246 char Source[32]; // [sp+B0h] [bp-38h]@20
|
|
|
5247 int v52; // [sp+D0h] [bp-18h]@34
|
|
|
5248 int v53; // [sp+D4h] [bp-14h]@34
|
|
|
5249 int pSector; // [sp+D8h] [bp-10h]@32
|
|
|
5250 int pPosX; // [sp+DCh] [bp-Ch]@32
|
|
|
5251 int v56; // [sp+E0h] [bp-8h]@8
|
|
|
5252 int v57; // [sp+E4h] [bp-4h]@1
|
|
|
5253
|
|
|
5254 //auto a2 = spawn;
|
|
|
5255 v57 = 0;
|
|
|
5256 //v5 = pMapInfo;
|
|
|
5257 //v6 = spawn;
|
|
|
5258 if ( uCurrentlyLoadedLevelType == LEVEL_Indoor )
|
|
|
5259 v7 = pOutdoor->ddm.field_C_alert;
|
|
|
5260 else if (uCurrentlyLoadedLevelType == LEVEL_Outdoor)
|
|
|
5261 v7 = pIndoor->dlv.field_C_alert;
|
|
|
5262 else
|
|
|
5263 v7 = 0;
|
|
|
5264 if (v7)
|
|
|
5265 v8 = (spawn->uAttributes & 1) == 0;
|
|
|
5266 else
|
|
|
5267 v8 = (spawn->uAttributes & 1) == 1;
|
|
|
5268 if (v8)
|
|
|
5269 return;
|
|
|
5270 //result = (void *)(spawn->uIndex - 1);
|
|
|
5271 v56 = 1;
|
|
|
5272 switch (spawn->uIndex - 1)
|
|
|
5273 {
|
|
|
5274 case 0:
|
|
|
5275 //v9 = pMapInfo->uEncounterMonster1AtLeast;
|
|
|
5276 //v10 = rand();
|
|
|
5277 //v11 = pMapInfo->uEncounterMonster1AtMost;
|
|
|
5278 //pTexture = pMapInfo->pEncounterMonster1Texture;
|
|
|
5279 v12 = rand() % (pMapInfo->uEncounterMonster1AtMost - pMapInfo->uEncounterMonster1AtLeast + 1);
|
|
|
5280 //v13 = pMapInfo->Dif_M1;
|
|
|
5281 v57 = pMapInfo->Dif_M1;
|
|
|
5282 v56 = pMapInfo->uEncounterMonster1AtLeast + v12;
|
|
|
5283 strcpy(Source, pMapInfo->pEncounterMonster1Texture);
|
|
|
5284 break;
|
|
|
5285 case 3:
|
|
|
5286 //pTexture = pMapInfo->pEncounterMonster1Texture;
|
|
|
5287 //v44 = "%s A";
|
|
|
5288 sprintf(Source, "%s A", pMapInfo->pEncounterMonster1Texture);
|
|
|
5289 break;
|
|
|
5290 case 4:
|
|
|
5291 //pTexture = pMapInfo->pEncounterMonster2Texture;
|
|
|
5292 //v44 = "%s A";
|
|
|
5293 sprintf(Source, "%s A", pMapInfo->pEncounterMonster2Texture);
|
|
|
5294 break;
|
|
|
5295 case 5:
|
|
|
5296 //pTexture = pMapInfo->pEncounterMonster3Texture;
|
|
|
5297 //v44 = "%s A";
|
|
|
5298 sprintf(Source, "%s A", pMapInfo->pEncounterMonster3Texture);
|
|
|
5299 break;
|
|
|
5300 case 1:
|
|
|
5301 //v9 = pMapInfo->uEncounterMonster2AtLeast;
|
|
|
5302 //v14 = rand();
|
|
|
5303 //v15 = pMapInfo->uEncounterMonster2AtMost;
|
|
|
5304 //pTexture = pMapInfo->pEncounterMonster2Texture;
|
|
|
5305 v12 = rand() % (pMapInfo->uEncounterMonster2AtMost - pMapInfo->uEncounterMonster2AtLeast + 1);
|
|
|
5306 //v13 = pMapInfo->Dif_M2;
|
|
|
5307 v57 = pMapInfo->Dif_M2;
|
|
|
5308 v56 = pMapInfo->uEncounterMonster2AtLeast + v12;
|
|
|
5309 strcpy(Source, pMapInfo->pEncounterMonster2Texture);
|
|
|
5310 break;
|
|
|
5311 case 6:
|
|
|
5312 //pTexture = pMapInfo->pEncounterMonster1Texture;
|
|
|
5313 //v44 = "%s B";
|
|
|
5314 sprintf(Source, "%s B", pMapInfo->pEncounterMonster1Texture);
|
|
|
5315 break;
|
|
|
5316 case 7:
|
|
|
5317 //pTexture = pMapInfo->pEncounterMonster2Texture;
|
|
|
5318 //v44 = "%s B";
|
|
|
5319 sprintf(Source, "%s B", pMapInfo->pEncounterMonster2Texture);
|
|
|
5320 break;
|
|
|
5321 case 8:
|
|
|
5322 //pTexture = pMapInfo->pEncounterMonster3Texture;
|
|
|
5323 //v44 = "%s B";
|
|
|
5324 sprintf(Source, "%s B", pMapInfo->pEncounterMonster3Texture);
|
|
|
5325 break;
|
|
|
5326 case 2:
|
|
|
5327 //v9 = pMapInfo->uEncounterMonster3AtLeast;
|
|
|
5328 //v16 = rand();
|
|
|
5329 //v17 = pMapInfo->uEncounterMonster3AtMost;
|
|
|
5330 //pTexture = pMapInfo->pEncounterMonster3Texture;
|
|
|
5331 v12 = rand() % (pMapInfo->uEncounterMonster3AtMost - pMapInfo->uEncounterMonster3AtLeast + 1);
|
|
|
5332 //v13 = pMapInfo->Dif_M3;
|
|
|
5333 v57 = pMapInfo->Dif_M3;
|
|
|
5334 v56 = pMapInfo->uEncounterMonster3AtLeast + v12;
|
|
|
5335 strcpy(Source, pMapInfo->pEncounterMonster3Texture);
|
|
|
5336 break;
|
|
|
5337 case 9:
|
|
|
5338 //pTexture = pMapInfo->pEncounterMonster1Texture;
|
|
|
5339 //v44 = "%s C";
|
|
|
5340 sprintf(Source, "%s C", pMapInfo->pEncounterMonster1Texture);
|
|
|
5341 break;
|
|
|
5342 case 10:
|
|
|
5343 //pTexture = pMapInfo->pEncounterMonster2Texture;
|
|
|
5344 //v44 = "%s C";
|
|
|
5345 sprintf(Source, "%s C", pMapInfo->pEncounterMonster2Texture);
|
|
|
5346 break;
|
|
|
5347 case 11:
|
|
|
5348 //pTexture = pMapInfo->pEncounterMonster3Texture;
|
|
|
5349 //v44 = "%s C";
|
|
|
5350 sprintf(Source, "%s C", pMapInfo->pEncounterMonster3Texture);
|
|
|
5351 break;
|
|
|
5352 default:
|
|
|
5353 return;
|
|
|
5354 }
|
|
|
5355 if (Source[0] == '0')
|
|
|
5356 return;
|
|
|
5357 v57 += a3;
|
|
|
5358 if ( v57 > 4 )
|
|
|
5359 v57 = 4;
|
|
|
5360 strcpy(Str2, Source);
|
|
|
5361 if ( a4 )
|
|
|
5362 v56 = a4;
|
|
|
5363 v18 = v56;
|
|
|
5364 if ( (signed int)(v56 + uNumActors) >= 500 )
|
|
|
5365 return;
|
|
|
5366 pSector = 0;
|
|
|
5367 pPosX = spawn->vPosition.x;
|
|
|
5368 a4 = spawn->vPosition.y;
|
|
|
5369 a3 = spawn->vPosition.z;
|
|
|
5370 if ( uCurrentlyLoadedLevelType == LEVEL_Indoor )
|
|
|
5371 pSector = pIndoor->GetSector(spawn->vPosition.x, spawn->vPosition.y, spawn->vPosition.z);
|
|
|
5372 v53 = 0;
|
|
|
5373 v52 = (((uCurrentlyLoadedLevelType != LEVEL_Outdoor) - 1) & 0x40) + 64;
|
|
|
5374 if ( v18 <= 0 )
|
|
|
5375 return;
|
|
|
5376 for (uint i = v53; i < v56; ++i)
|
|
|
5377 {
|
|
|
5378 pMonster = &pActors[uNumActors];
|
|
|
5379 pActors[uNumActors].Reset();
|
|
|
5380 if ( v57 )
|
|
|
5381 {
|
|
|
5382 v23 = rand() % 100;
|
|
|
5383 v24 = 3;
|
|
|
5384 v25 = (unsigned __int16)word_4E8152[3 * v57];
|
|
|
5385 if ( v23 >= v25 )
|
|
|
5386 {
|
|
|
5387 if ( v23 < v25 + (unsigned __int16)word_4E8152[3 * v57 + 1] )
|
|
|
5388 v24 = 2;
|
|
|
5389 }
|
|
|
5390 else
|
|
|
5391 v24 = 1;
|
|
|
5392 if ( v24 == 1 )
|
|
|
5393 {
|
|
|
5394 pTexture = Source;
|
|
|
5395 v44 = "%s A";
|
|
|
5396 }
|
|
|
5397 else
|
|
|
5398 {
|
|
|
5399 if ( v24 == 2 )
|
|
|
5400 {
|
|
|
5401 pTexture = Source;
|
|
|
5402 v44 = "%s B";
|
|
|
5403 }
|
|
|
5404 else
|
|
|
5405 {
|
|
|
5406 if ( v24 != 3 )
|
|
|
5407 continue;
|
|
|
5408 pTexture = Source;
|
|
|
5409 v44 = "%s C";
|
|
|
5410 }
|
|
|
5411 }
|
|
|
5412 sprintf(Str2, v44, pTexture);
|
|
|
5413 }
|
|
|
5414 v50 = pMonsterList->GetMonsterIDByName(Str2);
|
|
|
5415 pTexture = Str2;
|
|
|
5416 if ( (signed __int16)v50 == -1 )
|
|
|
5417 {
|
|
|
5418 sprintf(Str, "Can't create random monster: '%s'! See MapStats.txt and Monsters.txt!", pTexture);
|
|
|
5419 MessageBoxA(nullptr, Str, nullptr, 0);
|
|
|
5420 ExitProcess(0);
|
|
|
5421 }
|
|
|
5422 v27 = &pMonsterList->pMonsters[(signed __int16)v50];
|
|
|
5423 v28 = pMonsterStats->FindMonsterByTextureName(pTexture);
|
|
|
5424 if ( !v28 )
|
|
|
5425 v28 = 1;
|
|
|
5426 Src = &pMonsterStats->pInfos[v28];
|
|
|
5427 strcpy(pMonster->pActorName, Src->pName);
|
|
|
5428 pMonster->sCurrentHP = Src->uHP;
|
|
|
5429 assert(sizeof(MonsterInfo) == 88);
|
|
|
5430 memcpy(&pMonster->pMonsterInfo, Src, sizeof(MonsterInfo));//Uninitialized portail memory access
|
|
|
5431 pMonster->word_000086_some_monster_id = v50 + 1;
|
|
|
5432 pMonster->uActorRadius = v27->uMonsterRadius;
|
|
|
5433 pMonster->uActorHeight = v27->uMonsterHeight;
|
|
|
5434 pMonster->uMovementSpeed = v27->uMovementSpeed;
|
|
|
5435 pMonster->vInitialPosition.x = spawn->vPosition.x;
|
|
|
5436 pMonster->vPosition.x = spawn->vPosition.x;
|
|
|
5437 pMonster->uTetherDistance = 256;
|
|
|
5438 pMonster->vInitialPosition.y = a4;
|
|
|
5439 pMonster->vPosition.y = a4;
|
|
|
5440 pMonster->vInitialPosition.z = a3;
|
|
|
5441 pMonster->vPosition.z = a3;
|
|
|
5442 pMonster->uSectorID = pSector;
|
|
|
5443 pMonster->uGroup = spawn->uGroup;
|
|
|
5444 pMonster->PrepareSprites(0);
|
|
|
5445 pMonster->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Friendly;
|
|
|
5446 v32 = rand();
|
|
|
5447 a3 = fixpoint_mul(stru_5C6E00->Cos(v32 % 2048), v52);
|
|
|
5448 pPosX = a3 + spawn->vPosition.x;
|
|
|
5449 a3 = fixpoint_mul(stru_5C6E00->Sin(v32 % 2048), v52);
|
|
|
5450 a4 = a3 + spawn->vPosition.y;
|
|
|
5451 a3 = spawn->vPosition.z;
|
|
|
5452 if ( uCurrentlyLoadedLevelType == LEVEL_Outdoor )
|
|
|
5453 {
|
|
|
5454 if ( a5 )
|
|
|
5455 pMonster->uAttributes |= ACTOR_AGGRESSOR;
|
|
|
5456 ++uNumActors;
|
|
|
5457 continue;
|
|
|
5458 }
|
|
|
5459 v37 = pIndoor->GetSector(pPosX, a4, spawn->vPosition.z);
|
|
|
5460 if ( v37 == pSector )
|
|
|
5461 {
|
|
|
5462 v38 = BLV_GetFloorLevel(pPosX, a4, a3, v37, &uFaceID);
|
|
|
5463 v39 = v38;
|
|
|
5464 if ( v38 != -30000 )
|
|
|
5465 {
|
|
|
5466 if ( abs(v38 - a3) <= 1024 )
|
|
|
5467 {
|
|
|
5468 a3 = v39;
|
|
|
5469 if ( a5 )
|
|
|
5470 pMonster->uAttributes |= ACTOR_AGGRESSOR;
|
|
|
5471 ++uNumActors;
|
|
|
5472 continue;
|
|
|
5473 }
|
|
|
5474 }
|
|
|
5475 }
|
|
|
5476 ;
|
|
|
5477 //v53 = (char *)v53 + 1;
|
|
|
5478 //result = v53;
|
|
|
5479 }
|
|
|
5480 //while ( (signed int)v53 < v56 );
|
|
|
5481 }
|
|
|
5482
|
|
|
5483 //----- (00438F8F) --------------------------------------------------------
|
|
|
5484 void area_of_effect__damage_evaluate()
|
|
|
5485 {
|
|
|
5486 int attacker_type; // ecx@3
|
|
|
5487 signed int v3; // eax@3
|
|
|
5488 unsigned int target_id; // edi@6
|
|
|
5489 int target_type; // eax@6
|
|
|
5490 int v10; // edi@8
|
|
|
5491 Vec3_int_ attacker_coord; // ST04_12@9
|
|
|
5492 // int v12; // ST0C_4@10
|
|
|
5493 int v15; // edx@15
|
|
|
5494 int v19; // edi@15
|
|
|
5495 int v23; // edx@18
|
|
|
5496 int v24; // eax@18
|
|
|
5497 // int v30; // eax@29
|
|
|
5498 int v31; // edx@29
|
|
|
5499 int v32; // eax@29
|
|
|
5500 int v33; // ST24_4@29
|
|
|
5501 SpriteObject *v36; // [sp+0h] [bp-28h]@0
|
|
|
5502 int attacker_id; // [sp+10h] [bp-18h]@1
|
|
|
5503 int v44; // [sp+14h] [bp-14h]@15
|
|
|
5504 //Vec3_int_ *pVelocity; // [sp+1Ch] [bp-Ch]@2
|
|
|
5505 signed int a1; // [sp+20h] [bp-8h]@8
|
|
|
5506 int v48; // [sp+24h] [bp-4h]@8
|
|
|
5507
|
|
|
5508
|
|
|
5509 for (attacker_id = 0; attacker_id < AttackerInfo.count; ++attacker_id)
|
|
|
5510 {
|
|
|
5511 attacker_type = PID_TYPE(AttackerInfo.pIDs[attacker_id]);
|
|
|
5512 v3 = PID_ID(AttackerInfo.pIDs[attacker_id]);
|
|
|
5513
|
|
|
5514 if (attacker_type == 2)
|
|
|
5515 {
|
|
|
5516 v36 = &pSpriteObjects[v3];
|
|
|
5517 attacker_type = PID_TYPE(pSpriteObjects[v3].spell_caster_pid);
|
|
|
5518 v3 = PID_ID(pSpriteObjects[v3].spell_caster_pid);
|
|
|
5519 }
|
|
|
5520
|
|
|
5521 if (AttackerInfo.field_3EC[attacker_id] & 1)
|
|
|
5522 {
|
|
|
5523 target_id = PID_ID(ai_near_actors_targets_pid[v3]);
|
|
|
5524 target_type = PID_TYPE(ai_near_actors_targets_pid[v3]) - 3;
|
|
|
5525 if (target_type)
|
|
|
5526 {
|
|
|
5527 if (target_type == 1)//party damage from monsters(повреждения группе от монстров)
|
|
|
5528 {
|
|
|
5529 v10 = pParty->vPosition.y - AttackerInfo.pYs[attacker_id];
|
|
|
5530 a1 = pParty->vPosition.x - AttackerInfo.pXs[attacker_id];
|
|
|
5531 v48 = pParty->vPosition.y - AttackerInfo.pYs[attacker_id];
|
|
|
5532 if (a1 * a1 + v10 * v10
|
|
|
5533 + ((signed int)(pParty->vPosition.z + pParty->uPartyHeight) >> (1 - AttackerInfo.pZs[attacker_id]))
|
|
|
5534 * ((signed int)(pParty->vPosition.z + pParty->uPartyHeight) >> (1 - AttackerInfo.pZs[attacker_id]))
|
|
|
5535 < (unsigned int)((AttackerInfo.field_324[attacker_id] + 32) * (AttackerInfo.field_324[attacker_id] + 32)))
|
|
|
5536 {
|
|
|
5537 attacker_coord.x = AttackerInfo.pXs[attacker_id];
|
|
|
5538 attacker_coord.y = AttackerInfo.pYs[attacker_id];
|
|
|
5539 attacker_coord.z = AttackerInfo.pZs[attacker_id];
|
|
|
5540 if (sub_407A1C(pParty->vPosition.x, pParty->vPosition.y, pParty->vPosition.z + pParty->sEyelevel, attacker_coord))
|
|
|
5541 DamagePlayerFromMonster(AttackerInfo.pIDs[attacker_id], AttackerInfo.field_450[attacker_id], &AttackerInfo.vec_4B4[attacker_id], stru_50C198.which_player_to_attack(&pActors[v3]));
|
|
|
5542 }
|
|
|
5543 }
|
|
|
5544 }
|
|
|
5545 else//Actor damage from monsters(повреждение местного жителя)
|
|
|
5546 {
|
|
|
5547 if (SHIDWORD(pActors[target_id].pActorBuffs[ACTOR_BUFF_PARALYZED].uExpireTime) > 0
|
|
|
5548 || SHIDWORD(pActors[target_id].pActorBuffs[ACTOR_BUFF_PARALYZED].uExpireTime) >= 0
|
|
|
5549 && LODWORD(pActors[target_id].pActorBuffs[ACTOR_BUFF_PARALYZED].uExpireTime)
|
|
|
5550 || pActors[target_id].CanAct())
|
|
|
5551 {
|
|
|
5552 v15 = pActors[target_id].vPosition.y - AttackerInfo.pYs[attacker_id];
|
|
|
5553 a1 = pActors[target_id].vPosition.x - AttackerInfo.pXs[attacker_id];
|
|
|
5554 v44 = pActors[target_id].vPosition.z;
|
|
|
5555 v19 = AttackerInfo.field_324[attacker_id] + pActors[target_id].uActorRadius;
|
|
|
5556 v48 = v15;
|
|
|
5557 if (a1 * a1 + v15 * v15 + (pActors[target_id].vPosition.z + (pActors[target_id].uActorHeight >> 1) - AttackerInfo.pZs[attacker_id])
|
|
|
5558 * (pActors[target_id].vPosition.z + (pActors[target_id].uActorHeight >> 1) - AttackerInfo.pZs[attacker_id]) < (unsigned int)(v19 * v19))
|
|
|
5559 {
|
|
|
5560 attacker_coord.x = AttackerInfo.pXs[attacker_id];
|
|
|
5561 attacker_coord.y = AttackerInfo.pYs[attacker_id];
|
|
|
5562 attacker_coord.z = AttackerInfo.pZs[attacker_id];
|
|
|
5563 if (sub_407A1C(pActors[target_id].vPosition.x, pActors[target_id].vPosition.y, pActors[target_id].vPosition.z + 50, attacker_coord))
|
|
|
5564 {
|
|
|
5565 Vec3_int_::Normalize(&a1, &v48, &v44);
|
|
|
5566 AttackerInfo.vec_4B4[attacker_id].x = a1;
|
|
|
5567 AttackerInfo.vec_4B4[attacker_id].y = v48;
|
|
|
5568 AttackerInfo.vec_4B4[attacker_id].z = v44;
|
|
|
5569 Actor::ActorDamageFromMonster(AttackerInfo.pIDs[attacker_id], target_id, &AttackerInfo.vec_4B4[attacker_id], AttackerInfo.field_450[attacker_id]);
|
|
|
5570 }
|
|
|
5571 }
|
|
|
5572 }
|
|
|
5573 }
|
|
|
5574 }
|
|
|
5575 else //damage from spells(повреждения от заклов(метеоритный дождь))
|
|
|
5576 {
|
|
|
5577 v23 = pParty->vPosition.y - AttackerInfo.pYs[attacker_id];
|
|
|
5578 v24 = ((signed int)pParty->uPartyHeight / 2) - AttackerInfo.pZs[attacker_id];
|
|
|
5579 a1 = pParty->vPosition.x - AttackerInfo.pXs[attacker_id];
|
|
|
5580 v48 = pParty->vPosition.y - AttackerInfo.pYs[attacker_id];
|
|
|
5581 if (a1 * a1 + v23 * v23 + (pParty->vPosition.z + v24) * (pParty->vPosition.z + v24) < (unsigned int)((AttackerInfo.field_324[attacker_id] + 32) * (AttackerInfo.field_324[attacker_id] + 32)))
|
|
|
5582 {//party damage (повреждения группе)
|
|
|
5583 attacker_coord.x = AttackerInfo.pXs[attacker_id];
|
|
|
5584 attacker_coord.y = AttackerInfo.pYs[attacker_id];
|
|
|
5585 attacker_coord.z = AttackerInfo.pZs[attacker_id];
|
|
|
5586 if (sub_407A1C(pParty->vPosition.x, pParty->vPosition.y, pParty->vPosition.z + pParty->sEyelevel, attacker_coord))
|
|
|
5587 {
|
|
|
5588 for (uint i = 0; i < 4; ++i)
|
|
|
5589 {
|
|
|
5590 if (!(HIDWORD(pParty->pPlayers[i].pConditions[Condition_Dead]) | LODWORD(pParty->pPlayers[i].pConditions[Condition_Dead]))
|
|
|
5591 && !pParty->pPlayers[i].pConditions[Condition_Pertified] && !pParty->pPlayers[i].pConditions[Condition_Eradicated])
|
|
|
5592 DamagePlayerFromMonster(AttackerInfo.pIDs[attacker_id], AttackerInfo.field_450[attacker_id], &AttackerInfo.vec_4B4[attacker_id], i);
|
|
|
5593 }
|
|
|
5594 }
|
|
|
5595 }
|
|
|
5596 if ((signed int)uNumActors > 0)
|
|
|
5597 {//actors damage(повреждения другим участникам)
|
|
|
5598 for (int actorID = 0; (signed int)actorID < (signed int)uNumActors; ++actorID)
|
|
|
5599 {
|
|
|
5600 if (pActors[actorID].CanAct())
|
|
|
5601 {
|
|
|
5602 //v30 = pActors[actorID].vPosition.y - AttackerInfo.pYs[attacker_id];
|
|
|
5603 a1 = pActors[actorID].vPosition.x - AttackerInfo.pXs[attacker_id];
|
|
|
5604 v31 = pActors[actorID].vPosition.z;
|
|
|
5605 v48 = pActors[actorID].vPosition.y - AttackerInfo.pYs[attacker_id];
|
|
|
5606 v44 = pActors[actorID].vPosition.z;
|
|
|
5607 v32 = (pActors[actorID].uActorHeight / 2) - AttackerInfo.pZs[attacker_id];
|
|
|
5608 v33 = pActors[actorID].uActorRadius + AttackerInfo.field_324[attacker_id];
|
|
|
5609 if (a1 * a1 + v48 * v48 + (v31 + v32) * (v31 + v32) < (unsigned int)(v33 * v33))
|
|
|
5610 {
|
|
|
5611 attacker_coord.x = AttackerInfo.pXs[attacker_id];
|
|
|
5612 attacker_coord.y = AttackerInfo.pYs[attacker_id];
|
|
|
5613 attacker_coord.z = AttackerInfo.pZs[attacker_id];
|
|
|
5614 if (sub_407A1C(pActors[actorID].vPosition.x, pActors[actorID].vPosition.y, pActors[actorID].vPosition.z + 50, attacker_coord))//что делает ф-ция?
|
|
|
5615 {
|
|
|
5616 Vec3_int_::Normalize(&a1, &v48, &v44);
|
|
|
5617 AttackerInfo.vec_4B4[attacker_id].x = a1;
|
|
|
5618 AttackerInfo.vec_4B4[attacker_id].y = v48;
|
|
|
5619 AttackerInfo.vec_4B4[attacker_id].z = v44;
|
|
|
5620 switch (attacker_type)
|
|
|
5621 {
|
|
|
5622 case OBJECT_Player:
|
|
|
5623 Actor::DamageMonsterFromParty(AttackerInfo.pIDs[attacker_id], actorID, &AttackerInfo.vec_4B4[attacker_id]);
|
|
|
5624 break;
|
|
|
5625 case OBJECT_Actor:
|
|
|
5626 if (v36 && pActors[v3].GetActorsRelation(&pActors[actorID]))
|
|
|
5627 Actor::ActorDamageFromMonster(AttackerInfo.pIDs[attacker_id], actorID, &AttackerInfo.vec_4B4[attacker_id], v36->field_61);
|
|
|
5628 break;
|
|
|
5629 case OBJECT_Item:
|
|
|
5630 ItemDamageFromActor(AttackerInfo.pIDs[attacker_id], actorID, &AttackerInfo.vec_4B4[attacker_id]);
|
|
|
5631 break;
|
|
|
5632 }
|
|
|
5633 }
|
|
|
5634 }
|
|
|
5635 }
|
|
|
5636 }
|
|
|
5637 }
|
|
|
5638 }
|
|
|
5639 }
|
|
|
5640 AttackerInfo.count = 0;
|
|
|
5641 }
|
|
|
5642
|
|
|
5643 //----- (0043AE12) --------------------------------------------------------
|
|
|
5644 double __fastcall sub_43AE12(signed int a1)
|
|
|
5645 {
|
|
|
5646 //signed int v1; // ST00_4@1
|
|
|
5647 signed int v2; // ecx@1
|
|
|
5648 double v3; // st7@1
|
|
|
5649 double result; // st7@6
|
|
|
5650
|
|
|
5651 v3 = (double)a1;
|
|
|
5652 for (v2 = 0; v2 < 5; ++v2)
|
|
|
5653 {
|
|
|
5654 if (v3 < flt_4E4A80[v2 + 5])
|
|
|
5655 break;
|
|
|
5656 }
|
|
|
5657 if (v2 <= 0 || v2 >= 5)
|
|
|
5658 {
|
|
|
5659 if (v2)
|
|
|
5660 result = flt_4E4A80[4];
|
|
|
5661 else
|
|
|
5662 result = flt_4E4A80[0];
|
|
|
5663 }
|
|
|
5664 else
|
|
|
5665 result = (flt_4E4A80[v2] - flt_4E4A80[v2 - 1]) * (v3 - flt_4E4A80[v2 + 4]) / (flt_4E4A80[v2 + 5] - flt_4E4A80[v2 + 4]) + flt_4E4A80[v2];
|
|
|
5666 return result;
|
|
|
5667 }
|
|
|
5668
|
|
|
5669 //----- (0043B057) --------------------------------------------------------
|
|
|
5670 void ItemDamageFromActor(unsigned int uObjID, unsigned int uActorID, Vec3_int_ *pVelocity)
|
|
|
5671 {
|
|
|
5672 int v6; // eax@4
|
|
|
5673 int damage; // edi@4
|
|
|
5674 int a2a; // [sp+Ch] [bp-4h]@8
|
|
|
5675
|
|
|
5676 if (!pActors[uActorID].IsNotAlive())
|
|
|
5677 {
|
|
|
5678 if (PID_TYPE(uObjID) == OBJECT_Item)
|
|
|
5679 {
|
|
|
5680 if (pSpriteObjects[PID_ID(uObjID)].spell_id)
|
|
|
5681 {
|
|
|
5682 v6 = _43AFE3_calc_spell_damage(pSpriteObjects[PID_ID(uObjID)].spell_id, pSpriteObjects[PID_ID(uObjID)].spell_level, pSpriteObjects[PID_ID(uObjID)].spell_skill, pActors[uActorID].sCurrentHP);
|
|
|
5683 damage = pActors[uActorID].CalcMagicalDamageToActor((DAMAGE_TYPE)0, v6);
|
|
|
5684 pActors[uActorID].sCurrentHP -= damage;
|
|
|
5685 if (damage)
|
|
|
5686 {
|
|
|
5687 if (pActors[uActorID].sCurrentHP > 0)
|
|
|
5688 Actor::AI_Stun(uActorID, uObjID, 0);
|
|
|
5689 else
|
|
|
5690 Actor::Die(uActorID);
|
|
|
5691 a2a = 20 * damage / (signed int)pActors[uActorID].pMonsterInfo.uHP;
|
|
|
5692 if (20 * damage / (signed int)pActors[uActorID].pMonsterInfo.uHP > 10)
|
|
|
5693 a2a = 10;
|
|
|
5694 if (!MonsterStats::BelongsToSupertype(pActors[uActorID].pMonsterInfo.uID, MONSTER_SUPERTYPE_TREANT))
|
|
|
5695 {
|
|
|
5696 pVelocity->x = fixpoint_mul(a2a, pVelocity->x);
|
|
|
5697 pVelocity->y = fixpoint_mul(a2a, pVelocity->y);
|
|
|
5698 pVelocity->z = fixpoint_mul(a2a, pVelocity->z);
|
|
|
5699 pActors[uActorID].vVelocity.x = 50 * LOWORD(pVelocity->x);
|
|
|
5700 pActors[uActorID].vVelocity.y = 50 * LOWORD(pVelocity->y);
|
|
|
5701 pActors[uActorID].vVelocity.z = 50 * LOWORD(pVelocity->z);
|
|
|
5702 }
|
|
|
5703 Actor::AddBloodsplatOnDamageOverlay(uActorID, 1, damage);
|
|
|
5704 }
|
|
|
5705 else
|
|
|
5706 Actor::AI_Stun(uActorID, uObjID, 0);
|
|
|
5707 }
|
|
|
5708 }
|
|
|
5709 }
|
|
|
5710 }
|
