annotate Engine/Objects/SpriteObject.cpp @ 2575:a76d408c5132 tip

DrawTranslucent -> DrawTextureGrayShade Removed old texture drawing stuff
author a.parshin
date Wed, 09 Mar 2016 01:39:52 +0200
parents d569340b05ff
children
rev   line source
2498
Ritor1
parents:
diff changeset
1 #define _CRTDBG_MAP_ALLOC
Ritor1
parents:
diff changeset
2 #include <stdlib.h>
Ritor1
parents:
diff changeset
3 #include <crtdbg.h>
Ritor1
parents:
diff changeset
4
Ritor1
parents:
diff changeset
5 #define _CRT_SECURE_NO_WARNINGS
2541
a902abdfc7f2 1. Renamed class Game to class Engine.
a.parshin
parents: 2534
diff changeset
6
a902abdfc7f2 1. Renamed class Game to class Engine.
a.parshin
parents: 2534
diff changeset
7 #include "Engine/Engine.h"
a902abdfc7f2 1. Renamed class Game to class Engine.
a.parshin
parents: 2534
diff changeset
8
2498
Ritor1
parents:
diff changeset
9 #include "Engine/Graphics/Sprites.h"
Ritor1
parents:
diff changeset
10 #include "Engine/Graphics/BSPModel.h"
Ritor1
parents:
diff changeset
11 #include "SpriteObject.h"
2499
68cdef6879a0 engine folder
Ritor1
parents: 2498
diff changeset
12 #include "../Party.h"
68cdef6879a0 engine folder
Ritor1
parents: 2498
diff changeset
13 #include "../TurnEngine/TurnEngine.h"
68cdef6879a0 engine folder
Ritor1
parents: 2498
diff changeset
14 #include "../OurMath.h"
2498
Ritor1
parents:
diff changeset
15 #include "ObjectList.h"
Ritor1
parents:
diff changeset
16 #include "Engine/Graphics/Outdoor.h"
Ritor1
parents:
diff changeset
17 #include "Engine/Graphics/ParticleEngine.h"
2499
68cdef6879a0 engine folder
Ritor1
parents: 2498
diff changeset
18 #include "../Timer.h"
68cdef6879a0 engine folder
Ritor1
parents: 2498
diff changeset
19 #include "../LOD.h"
2498
Ritor1
parents:
diff changeset
20 #include "Actor.h"
2499
68cdef6879a0 engine folder
Ritor1
parents: 2498
diff changeset
21 #include "../Events.h"
2502
a77c34acdbc9 Media folder
Ritor1
parents: 2499
diff changeset
22 #include "Media/Audio/AudioPlayer.h"
2498
Ritor1
parents:
diff changeset
23 #include "Engine/Graphics/Level/Decoration.h"
2499
68cdef6879a0 engine folder
Ritor1
parents: 2498
diff changeset
24 #include "../stru298.h"
68cdef6879a0 engine folder
Ritor1
parents: 2498
diff changeset
25 #include "../Random.h"
2498
Ritor1
parents:
diff changeset
26
Ritor1
parents:
diff changeset
27
Ritor1
parents:
diff changeset
28
Ritor1
parents:
diff changeset
29
Ritor1
parents:
diff changeset
30 size_t uNumSpriteObjects;
Ritor1
parents:
diff changeset
31 std::array<SpriteObject, MAX_SPRITE_OBJECTS> pSpriteObjects;
Ritor1
parents:
diff changeset
32
Ritor1
parents:
diff changeset
33 //----- (00404828) --------------------------------------------------------
Ritor1
parents:
diff changeset
34 SpriteObject::SpriteObject()
Ritor1
parents:
diff changeset
35 {
Ritor1
parents:
diff changeset
36 field_22_glow_radius_multiplier = 1;
Ritor1
parents:
diff changeset
37 uSoundID = 0;
Ritor1
parents:
diff changeset
38 uFacing = 0;
Ritor1
parents:
diff changeset
39 vVelocity.z = 0;
Ritor1
parents:
diff changeset
40 vVelocity.y = 0;
Ritor1
parents:
diff changeset
41 vVelocity.x = 0;
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
42 uType = SPRITE_NULL;
2498
Ritor1
parents:
diff changeset
43 uObjectDescID = 0;
Ritor1
parents:
diff changeset
44 field_61 = 0;
Ritor1
parents:
diff changeset
45 field_60_distance_related_prolly_lod = 0;
Ritor1
parents:
diff changeset
46 field_20 = 0;
Ritor1
parents:
diff changeset
47 uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
48 spell_skill = 0;
Ritor1
parents:
diff changeset
49 spell_level = 0;
Ritor1
parents:
diff changeset
50 spell_id = 0;
Ritor1
parents:
diff changeset
51 field_54 = 0;
Ritor1
parents:
diff changeset
52 }
Ritor1
parents:
diff changeset
53
Ritor1
parents:
diff changeset
54 //----- (0042F5ED) --------------------------------------------------------
Ritor1
parents:
diff changeset
55 int SpriteObject::Create(int yaw, int pitch, int a4, int a5)
Ritor1
parents:
diff changeset
56 {
Ritor1
parents:
diff changeset
57 signed int v6; // ebx@2
Ritor1
parents:
diff changeset
58 int v13; // ST2C_4@20
Ritor1
parents:
diff changeset
59 Vec3_int_ v17; // [sp-20h] [bp-30h]@11
Ritor1
parents:
diff changeset
60 int angle; // [sp+Ch] [bp-4h]@1
Ritor1
parents:
diff changeset
61 int a5a; // [sp+20h] [bp+10h]@20
Ritor1
parents:
diff changeset
62
Ritor1
parents:
diff changeset
63 angle = yaw;
Ritor1
parents:
diff changeset
64 if (!uObjectDescID)
Ritor1
parents:
diff changeset
65 return -1;
Ritor1
parents:
diff changeset
66
Ritor1
parents:
diff changeset
67 v6 = 1000;
Ritor1
parents:
diff changeset
68 for (uint i = 0; i < MAX_SPRITE_OBJECTS; ++i)
Ritor1
parents:
diff changeset
69 if (!pSpriteObjects[i].uObjectDescID)
Ritor1
parents:
diff changeset
70 {
Ritor1
parents:
diff changeset
71 v6 = i;
Ritor1
parents:
diff changeset
72 break;
Ritor1
parents:
diff changeset
73 }
Ritor1
parents:
diff changeset
74
Ritor1
parents:
diff changeset
75 if ( v6 >= 1000 )
Ritor1
parents:
diff changeset
76 return -1;
Ritor1
parents:
diff changeset
77 field_64.x = vPosition.x;
Ritor1
parents:
diff changeset
78 field_64.y = vPosition.y;
Ritor1
parents:
diff changeset
79 field_64.z = vPosition.z;
Ritor1
parents:
diff changeset
80
Ritor1
parents:
diff changeset
81 assert(sizeof(SpriteObject) == 0x70);
Ritor1
parents:
diff changeset
82
Ritor1
parents:
diff changeset
83 switch (a5)
Ritor1
parents:
diff changeset
84 {
Ritor1
parents:
diff changeset
85 case 0:
Ritor1
parents:
diff changeset
86 break; //do nothing
Ritor1
parents:
diff changeset
87 case 1:
Ritor1
parents:
diff changeset
88 Vec3_int_::Rotate(24, stru_5C6E00->uIntegerHalfPi + uFacing, 0, vPosition, &vPosition.x,
Ritor1
parents:
diff changeset
89 &vPosition.y, &vPosition.z);
Ritor1
parents:
diff changeset
90 break;
Ritor1
parents:
diff changeset
91 case 2:
Ritor1
parents:
diff changeset
92 Vec3_int_::Rotate(8, stru_5C6E00->uIntegerHalfPi + uFacing, 0, vPosition, &vPosition.x,
Ritor1
parents:
diff changeset
93 &vPosition.y, &vPosition.z);
Ritor1
parents:
diff changeset
94 break;
Ritor1
parents:
diff changeset
95 case 3:
Ritor1
parents:
diff changeset
96 Vec3_int_::Rotate(8, uFacing - stru_5C6E00->uIntegerHalfPi, 0, vPosition, &vPosition.x,
Ritor1
parents:
diff changeset
97 &vPosition.y, &vPosition.z);
Ritor1
parents:
diff changeset
98 break;
Ritor1
parents:
diff changeset
99 case 4:
Ritor1
parents:
diff changeset
100 Vec3_int_::Rotate(24, uFacing - stru_5C6E00->uIntegerHalfPi, 0, vPosition, &vPosition.x,
Ritor1
parents:
diff changeset
101 &vPosition.y, &vPosition.z);
Ritor1
parents:
diff changeset
102 break;
Ritor1
parents:
diff changeset
103 default:
Ritor1
parents:
diff changeset
104 assert(false);
Ritor1
parents:
diff changeset
105 return 0;
Ritor1
parents:
diff changeset
106 break;
Ritor1
parents:
diff changeset
107 }
Ritor1
parents:
diff changeset
108
Ritor1
parents:
diff changeset
109 if ( a4 )
Ritor1
parents:
diff changeset
110 {
Ritor1
parents:
diff changeset
111 v13 = fixpoint_mul(stru_5C6E00->Cos(angle), stru_5C6E00->Cos(pitch));
Ritor1
parents:
diff changeset
112 a5a = fixpoint_mul(stru_5C6E00->Sin(angle), stru_5C6E00->Cos(pitch));
Ritor1
parents:
diff changeset
113 vVelocity.x = fixpoint_mul(v13, a4);
Ritor1
parents:
diff changeset
114 vVelocity.y = fixpoint_mul(a5a, a4);
Ritor1
parents:
diff changeset
115 vVelocity.z = fixpoint_mul(stru_5C6E00->Sin(pitch), a4);
Ritor1
parents:
diff changeset
116 }
Ritor1
parents:
diff changeset
117 else
Ritor1
parents:
diff changeset
118 {
Ritor1
parents:
diff changeset
119 vVelocity.y = 0;
Ritor1
parents:
diff changeset
120 vVelocity.x = 0;
Ritor1
parents:
diff changeset
121 vVelocity.z = 0;
Ritor1
parents:
diff changeset
122 }
Ritor1
parents:
diff changeset
123
Ritor1
parents:
diff changeset
124 memcpy(&pSpriteObjects[v6], this, sizeof(*this));
Ritor1
parents:
diff changeset
125 if ( v6 >= (signed int)uNumSpriteObjects )
Ritor1
parents:
diff changeset
126 uNumSpriteObjects = v6 + 1;
Ritor1
parents:
diff changeset
127 return v6;
Ritor1
parents:
diff changeset
128 }
Ritor1
parents:
diff changeset
129
Ritor1
parents:
diff changeset
130 //----- (00471C03) --------------------------------------------------------
Ritor1
parents:
diff changeset
131 void SpriteObject::UpdateObject_fn0_ODM(unsigned int uLayingItemID)
Ritor1
parents:
diff changeset
132 {
Ritor1
parents:
diff changeset
133 ObjectDesc *object; // ebx@1
Ritor1
parents:
diff changeset
134 int v6; // eax@1
Ritor1
parents:
diff changeset
135 int v7; // ecx@1
Ritor1
parents:
diff changeset
136 int v8; // edi@1
Ritor1
parents:
diff changeset
137 int v9; // eax@4
Ritor1
parents:
diff changeset
138 // int v17; // ST10_4@25
Ritor1
parents:
diff changeset
139 //signed int v19; // eax@28
Ritor1
parents:
diff changeset
140 //Actor *v20; // edi@31
Ritor1
parents:
diff changeset
141 int v21; // eax@41
Ritor1
parents:
diff changeset
142 // int v22; // ecx@43
Ritor1
parents:
diff changeset
143 // __int16 v23; // bx@45
Ritor1
parents:
diff changeset
144 // char v24; // al@46
Ritor1
parents:
diff changeset
145 signed int i; // edi@50
Ritor1
parents:
diff changeset
146 int v26; // edi@52
Ritor1
parents:
diff changeset
147 int v27; // eax@52
Ritor1
parents:
diff changeset
148 __int16 v28; // cx@55
Ritor1
parents:
diff changeset
149 int v29; // eax@55
Ritor1
parents:
diff changeset
150 //signed int v30; // edi@59
Ritor1
parents:
diff changeset
151 BSPModel *bmodel; // ecx@61
Ritor1
parents:
diff changeset
152 ODMFace *face; // edi@61
Ritor1
parents:
diff changeset
153 // int v33; // eax@62
Ritor1
parents:
diff changeset
154 // int v34; // ecx@62
Ritor1
parents:
diff changeset
155 int v35; // eax@63
Ritor1
parents:
diff changeset
156 int v36; // ecx@67
Ritor1
parents:
diff changeset
157 __int16 v37; // ax@67
Ritor1
parents:
diff changeset
158 int v38; // eax@72
Ritor1
parents:
diff changeset
159 //int v39; // eax@72
Ritor1
parents:
diff changeset
160 // unsigned __int64 v40; // qax@72
Ritor1
parents:
diff changeset
161 // int v41; // eax@72
Ritor1
parents:
diff changeset
162 // unsigned __int8 v42; // sf@74
Ritor1
parents:
diff changeset
163 // unsigned __int8 v43; // of@74
Ritor1
parents:
diff changeset
164 int v44; // eax@77
Ritor1
parents:
diff changeset
165 // __int16 v45; // bx@81
Ritor1
parents:
diff changeset
166 // int v46; // eax@85
Ritor1
parents:
diff changeset
167 // const char *v47; // [sp-8h] [bp-B0h]@83
Ritor1
parents:
diff changeset
168 // enum TEXTURE_TYPE v48; // [sp-4h] [bp-ACh]@46
Ritor1
parents:
diff changeset
169 int v49; // [sp+Ch] [bp-9Ch]@52
Ritor1
parents:
diff changeset
170 int v50; // [sp+10h] [bp-98h]@52
Ritor1
parents:
diff changeset
171 Vec3_int_ v51; // [sp+14h] [bp-94h]@11
Ritor1
parents:
diff changeset
172 Particle_sw Dst; // [sp+20h] [bp-88h]@45
Ritor1
parents:
diff changeset
173 int v54; // [sp+8Ch] [bp-1Ch]@1
Ritor1
parents:
diff changeset
174 int v55; // [sp+90h] [bp-18h]@1
Ritor1
parents:
diff changeset
175 int v56; // [sp+94h] [bp-14h]@11
Ritor1
parents:
diff changeset
176 int v57; // [sp+98h] [bp-10h]@1
Ritor1
parents:
diff changeset
177 int v58; // [sp+9Ch] [bp-Ch]@1
Ritor1
parents:
diff changeset
178 int on_water; // [sp+A0h] [bp-8h]@1
Ritor1
parents:
diff changeset
179 int v60; // [sp+A4h] [bp-4h]@11
Ritor1
parents:
diff changeset
180
Ritor1
parents:
diff changeset
181 v58 = 0;
Ritor1
parents:
diff changeset
182 object = &pObjectList->pObjects[pSpriteObjects[uLayingItemID].uObjectDescID];
Ritor1
parents:
diff changeset
183 v57 = IsTerrainSlopeTooHigh(pSpriteObjects[uLayingItemID].vPosition.x, pSpriteObjects[uLayingItemID].vPosition.y);
Ritor1
parents:
diff changeset
184 v55 = 0;
Ritor1
parents:
diff changeset
185 v6 = ODM_GetFloorLevel(pSpriteObjects[uLayingItemID].vPosition.x, pSpriteObjects[uLayingItemID].vPosition.y, pSpriteObjects[uLayingItemID].vPosition.z, object->uHeight, &on_water, &v55, 0);
Ritor1
parents:
diff changeset
186 v7 = v6;
Ritor1
parents:
diff changeset
187 v54 = v6;
Ritor1
parents:
diff changeset
188 v8 = v6 + 1;
Ritor1
parents:
diff changeset
189 if ( pSpriteObjects[uLayingItemID].vPosition.z <= v6 + 1 )
Ritor1
parents:
diff changeset
190 {
Ritor1
parents:
diff changeset
191 if ( on_water )
Ritor1
parents:
diff changeset
192 {
Ritor1
parents:
diff changeset
193 v9 = v6 + 60;
Ritor1
parents:
diff changeset
194 if ( v55 )
Ritor1
parents:
diff changeset
195 v9 = v6 + 30;
Ritor1
parents:
diff changeset
196 sub_42F960_create_object(pSpriteObjects[uLayingItemID].vPosition.x, pSpriteObjects[uLayingItemID].vPosition.y, v9);
Ritor1
parents:
diff changeset
197 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
198 }
Ritor1
parents:
diff changeset
199 }
Ritor1
parents:
diff changeset
200 else
Ritor1
parents:
diff changeset
201 v58 = 1;
Ritor1
parents:
diff changeset
202 if ( !(object->uFlags & OBJECT_DESC_NO_GRAVITY) )
Ritor1
parents:
diff changeset
203 {
Ritor1
parents:
diff changeset
204 if ( v58 )
Ritor1
parents:
diff changeset
205 {
Ritor1
parents:
diff changeset
206 pSpriteObjects[uLayingItemID].vVelocity.z -= LOWORD(pEventTimer->uTimeElapsed) * GetGravityStrength();
Ritor1
parents:
diff changeset
207 goto LABEL_13;
Ritor1
parents:
diff changeset
208 }
Ritor1
parents:
diff changeset
209 if ( v57 )
Ritor1
parents:
diff changeset
210 {
Ritor1
parents:
diff changeset
211 pSpriteObjects[uLayingItemID].vPosition.z = v8;
Ritor1
parents:
diff changeset
212 ODM_GetTerrainNormalAt(pSpriteObjects[uLayingItemID].vPosition.x, pSpriteObjects[uLayingItemID].vPosition.y, &v51);
Ritor1
parents:
diff changeset
213 pSpriteObjects[uLayingItemID].vVelocity.z -= LOWORD(pEventTimer->uTimeElapsed) * GetGravityStrength();
Ritor1
parents:
diff changeset
214 v56 = abs(v51.y * pSpriteObjects[uLayingItemID].vVelocity.y + v51.z * pSpriteObjects[uLayingItemID].vVelocity.z + v51.x * pSpriteObjects[uLayingItemID].vVelocity.x) >> 16;
Ritor1
parents:
diff changeset
215 //v60 = ((unsigned __int64)(v56 * (signed __int64)v51.x) >> 16);
Ritor1
parents:
diff changeset
216 pSpriteObjects[uLayingItemID].vVelocity.x += fixpoint_mul(v56, v51.x);
Ritor1
parents:
diff changeset
217 //v60 = ((unsigned __int64)(v56 * (signed __int64)v51.y) >> 16);
Ritor1
parents:
diff changeset
218 pSpriteObjects[uLayingItemID].vVelocity.y += fixpoint_mul(v56, v51.y);
Ritor1
parents:
diff changeset
219 //v60 = ((unsigned __int64)(v56 * (signed __int64)v51.z) >> 16);
Ritor1
parents:
diff changeset
220 pSpriteObjects[uLayingItemID].vVelocity.z += fixpoint_mul(v56, v51.z);
Ritor1
parents:
diff changeset
221 v7 = v54;
Ritor1
parents:
diff changeset
222 goto LABEL_13;
Ritor1
parents:
diff changeset
223 }
Ritor1
parents:
diff changeset
224 if ( object->uFlags & OBJECT_DESC_INTERACTABLE )
Ritor1
parents:
diff changeset
225 {
Ritor1
parents:
diff changeset
226 if ( pSpriteObjects[uLayingItemID].vPosition.z < v7 )
Ritor1
parents:
diff changeset
227 pSpriteObjects[uLayingItemID].vPosition.z = v8;
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
228 if ( !_46BFFA_update_spell_fx(uLayingItemID, 0) )
2498
Ritor1
parents:
diff changeset
229 return;
Ritor1
parents:
diff changeset
230 }
Ritor1
parents:
diff changeset
231 pSpriteObjects[uLayingItemID].vPosition.z = v8;
Ritor1
parents:
diff changeset
232 if ( !(object->uFlags & OBJECT_DESC_BOUNCE) || (v21 = -pSpriteObjects[uLayingItemID].vVelocity.z >> 1, pSpriteObjects[uLayingItemID].vVelocity.z = v21, (signed __int16)v21 < 10) )
Ritor1
parents:
diff changeset
233 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
234
Ritor1
parents:
diff changeset
235 pSpriteObjects[uLayingItemID].vVelocity.x = fixpoint_mul(58500, pSpriteObjects[uLayingItemID].vVelocity.x);
Ritor1
parents:
diff changeset
236 pSpriteObjects[uLayingItemID].vVelocity.y = fixpoint_mul(58500, pSpriteObjects[uLayingItemID].vVelocity.y);
Ritor1
parents:
diff changeset
237 pSpriteObjects[uLayingItemID].vVelocity.z = fixpoint_mul(58500, pSpriteObjects[uLayingItemID].vVelocity.z);
Ritor1
parents:
diff changeset
238 if ( (pSpriteObjects[uLayingItemID].vVelocity.y * pSpriteObjects[uLayingItemID].vVelocity.y
Ritor1
parents:
diff changeset
239 + pSpriteObjects[uLayingItemID].vVelocity.x * pSpriteObjects[uLayingItemID].vVelocity.x) < 400 )
Ritor1
parents:
diff changeset
240 {
Ritor1
parents:
diff changeset
241 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
242 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
243 memset(&Dst, 0, 0x68u);
Ritor1
parents:
diff changeset
244 Dst.x = (double)pSpriteObjects[uLayingItemID].vPosition.x;
Ritor1
parents:
diff changeset
245 Dst.y = (double)pSpriteObjects[uLayingItemID].vPosition.y;
Ritor1
parents:
diff changeset
246 Dst.z = (double)pSpriteObjects[uLayingItemID].vPosition.z;
Ritor1
parents:
diff changeset
247 Dst.r = 0.0;
Ritor1
parents:
diff changeset
248 Dst.g = 0.0;
Ritor1
parents:
diff changeset
249 Dst.b = 0.0;
Ritor1
parents:
diff changeset
250 if (object->uFlags & OBJECT_DESC_TRIAL_FIRE )
Ritor1
parents:
diff changeset
251 {
Ritor1
parents:
diff changeset
252 Dst.type = ParticleType_Bitmap | ParticleType_Rotating | ParticleType_8;
Ritor1
parents:
diff changeset
253 Dst.uDiffuse = 0xFF3C1E;
Ritor1
parents:
diff changeset
254 Dst.timeToLive = (unsigned __int8)(rand() & 0x80) + 128;
Ritor1
parents:
diff changeset
255 Dst.uTextureID = pBitmaps_LOD->LoadTexture("effpar01", TEXTURE_DEFAULT);
Ritor1
parents:
diff changeset
256 Dst.flt_28 = 1.0;
2541
a902abdfc7f2 1. Renamed class Game to class Engine.
a.parshin
parents: 2534
diff changeset
257 pEngine->pParticleEngine->AddParticle(&Dst);
2498
Ritor1
parents:
diff changeset
258 }
Ritor1
parents:
diff changeset
259 else if ( object->uFlags & OBJECT_DESC_TRIAL_LINE)
Ritor1
parents:
diff changeset
260 {
Ritor1
parents:
diff changeset
261 Dst.type = ParticleType_Line;
Ritor1
parents:
diff changeset
262 Dst.uDiffuse = rand();
Ritor1
parents:
diff changeset
263 Dst.timeToLive = 64;
Ritor1
parents:
diff changeset
264 Dst.uTextureID = 0;
Ritor1
parents:
diff changeset
265 Dst.flt_28 = 1.0;
2541
a902abdfc7f2 1. Renamed class Game to class Engine.
a.parshin
parents: 2534
diff changeset
266 pEngine->pParticleEngine->AddParticle(&Dst);
2498
Ritor1
parents:
diff changeset
267 }
Ritor1
parents:
diff changeset
268 else if ( object->uFlags & OBJECT_DESC_TRIAL_PARTICLE )
Ritor1
parents:
diff changeset
269 {
Ritor1
parents:
diff changeset
270 Dst.type = ParticleType_Bitmap | ParticleType_8;
Ritor1
parents:
diff changeset
271 Dst.uDiffuse = rand();
Ritor1
parents:
diff changeset
272 Dst.timeToLive = (unsigned __int8)(rand() & 0x80) + 128;
Ritor1
parents:
diff changeset
273 Dst.uTextureID = pBitmaps_LOD->LoadTexture("effpar03", TEXTURE_DEFAULT);
Ritor1
parents:
diff changeset
274 Dst.flt_28 = 1.0;
2541
a902abdfc7f2 1. Renamed class Game to class Engine.
a.parshin
parents: 2534
diff changeset
275 pEngine->pParticleEngine->AddParticle(&Dst);
2498
Ritor1
parents:
diff changeset
276 }
Ritor1
parents:
diff changeset
277 return;
Ritor1
parents:
diff changeset
278 }
Ritor1
parents:
diff changeset
279 }
Ritor1
parents:
diff changeset
280 LABEL_13:
Ritor1
parents:
diff changeset
281 if ( pSpriteObjects[uLayingItemID].vPosition.x >= -0x8000 && pSpriteObjects[uLayingItemID].vPosition.x <= 0x8000
Ritor1
parents:
diff changeset
282 && pSpriteObjects[uLayingItemID].vPosition.y >= -0x8000 && pSpriteObjects[uLayingItemID].vPosition.y <= 0x8000
Ritor1
parents:
diff changeset
283 && pSpriteObjects[uLayingItemID].vPosition.z > v7 && pSpriteObjects[uLayingItemID].vPosition.z <= 13000
Ritor1
parents:
diff changeset
284 || !(object->uFlags & OBJECT_DESC_INTERACTABLE) )
Ritor1
parents:
diff changeset
285 goto LABEL_92;
Ritor1
parents:
diff changeset
286 if ( pSpriteObjects[uLayingItemID].vPosition.z < v7 )
Ritor1
parents:
diff changeset
287 pSpriteObjects[uLayingItemID].vPosition.z = v8;
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
288 if ( _46BFFA_update_spell_fx(uLayingItemID, 0) )
2498
Ritor1
parents:
diff changeset
289 {
Ritor1
parents:
diff changeset
290 LABEL_92:
Ritor1
parents:
diff changeset
291 stru_721530.field_0 = 0;
Ritor1
parents:
diff changeset
292 stru_721530.prolly_normal_d = object->uRadius;
Ritor1
parents:
diff changeset
293 stru_721530.height = object->uHeight;
Ritor1
parents:
diff changeset
294 stru_721530.field_8_radius = 0;
Ritor1
parents:
diff changeset
295 stru_721530.field_70 = 0;
Ritor1
parents:
diff changeset
296 for ( v55 = 0; v55 < 100; ++v55 )
Ritor1
parents:
diff changeset
297 {
Ritor1
parents:
diff changeset
298 stru_721530.position.x = pSpriteObjects[uLayingItemID].vPosition.x;
Ritor1
parents:
diff changeset
299 stru_721530.normal.x = stru_721530.position.x;
Ritor1
parents:
diff changeset
300 stru_721530.uSectorID = 0;
Ritor1
parents:
diff changeset
301 stru_721530.position.y = pSpriteObjects[uLayingItemID].vPosition.y;
Ritor1
parents:
diff changeset
302 stru_721530.normal.y = pSpriteObjects[uLayingItemID].vPosition.y;
Ritor1
parents:
diff changeset
303 stru_721530.position.z = pSpriteObjects[uLayingItemID].vPosition.z + stru_721530.prolly_normal_d + 1;
Ritor1
parents:
diff changeset
304 stru_721530.normal.z = stru_721530.position.z;
Ritor1
parents:
diff changeset
305 stru_721530.velocity.x = pSpriteObjects[uLayingItemID].vVelocity.x;
Ritor1
parents:
diff changeset
306 stru_721530.velocity.y = pSpriteObjects[uLayingItemID].vVelocity.y;
Ritor1
parents:
diff changeset
307 stru_721530.velocity.z = pSpriteObjects[uLayingItemID].vVelocity.z;
Ritor1
parents:
diff changeset
308 if ( stru_721530._47050A(0) )
Ritor1
parents:
diff changeset
309 return;
Ritor1
parents:
diff changeset
310 _46E889_collide_against_bmodels(0);
Ritor1
parents:
diff changeset
311 _46E26D_collide_against_sprites(WorldPosToGridCellX(pSpriteObjects[uLayingItemID].vPosition.x), WorldPosToGridCellZ(pSpriteObjects[uLayingItemID].vPosition.y));
Ritor1
parents:
diff changeset
312 if (PID_TYPE(pSpriteObjects[uLayingItemID].spell_caster_pid) != OBJECT_Player)
Ritor1
parents:
diff changeset
313 _46EF01_collision_chech_player(0);
Ritor1
parents:
diff changeset
314 if (PID_TYPE(pSpriteObjects[uLayingItemID].spell_caster_pid) == OBJECT_Actor)
Ritor1
parents:
diff changeset
315 {
Ritor1
parents:
diff changeset
316 if (( PID_ID(pSpriteObjects[uLayingItemID].spell_caster_pid) >= 0 )
Ritor1
parents:
diff changeset
317 &&( PID_ID(pSpriteObjects[uLayingItemID].spell_caster_pid) < (signed int)(uNumActors - 1) ))
Ritor1
parents:
diff changeset
318 {
Ritor1
parents:
diff changeset
319 for (v56 =0; v56 < uNumActors; ++v56)
Ritor1
parents:
diff changeset
320 {
Ritor1
parents:
diff changeset
321 if ( pActors[PID_ID(pSpriteObjects[uLayingItemID].spell_caster_pid)].GetActorsRelation(&pActors[v56]) )
Ritor1
parents:
diff changeset
322 Actor::_46DF1A_collide_against_actor(v56, 0);
Ritor1
parents:
diff changeset
323 }
Ritor1
parents:
diff changeset
324 }
Ritor1
parents:
diff changeset
325 }
Ritor1
parents:
diff changeset
326 else
Ritor1
parents:
diff changeset
327 {
Ritor1
parents:
diff changeset
328 for ( i = 0; i < (signed int)uNumActors; ++i )
Ritor1
parents:
diff changeset
329 Actor::_46DF1A_collide_against_actor(i, 0);
Ritor1
parents:
diff changeset
330 }
Ritor1
parents:
diff changeset
331 v26 = stru_721530.normal2.z - stru_721530.prolly_normal_d - 1;
Ritor1
parents:
diff changeset
332 v27 = ODM_GetFloorLevel( stru_721530.normal2.x, stru_721530.normal2.y, stru_721530.normal2.z - stru_721530.prolly_normal_d - 1,
Ritor1
parents:
diff changeset
333 object->uHeight, &v49, &v50, 0);
Ritor1
parents:
diff changeset
334 if ( on_water && v26 < v27 + 60 )
Ritor1
parents:
diff changeset
335 {
Ritor1
parents:
diff changeset
336 if ( v50 )
Ritor1
parents:
diff changeset
337 v44 = v27 + 30;
Ritor1
parents:
diff changeset
338 else
Ritor1
parents:
diff changeset
339 v44 = v54 + 60;
Ritor1
parents:
diff changeset
340 sub_42F960_create_object(pSpriteObjects[uLayingItemID].vPosition.x, pSpriteObjects[uLayingItemID].vPosition.y, v44);
Ritor1
parents:
diff changeset
341 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
342 return;
Ritor1
parents:
diff changeset
343 }
Ritor1
parents:
diff changeset
344 if ( stru_721530.field_7C >= stru_721530.field_6C )
Ritor1
parents:
diff changeset
345 {
Ritor1
parents:
diff changeset
346 pSpriteObjects[uLayingItemID].vPosition.x = stru_721530.normal2.x;
Ritor1
parents:
diff changeset
347 pSpriteObjects[uLayingItemID].vPosition.y = stru_721530.normal2.y;
Ritor1
parents:
diff changeset
348 pSpriteObjects[uLayingItemID].vPosition.z = stru_721530.normal2.z - stru_721530.prolly_normal_d - 1;
Ritor1
parents:
diff changeset
349 pSpriteObjects[uLayingItemID].uSectorID = LOWORD(stru_721530.uSectorID);
Ritor1
parents:
diff changeset
350 memset(&Dst, 0, 0x68u);
Ritor1
parents:
diff changeset
351 Dst.x = (double)pSpriteObjects[uLayingItemID].vPosition.x;
Ritor1
parents:
diff changeset
352 Dst.y = (double)pSpriteObjects[uLayingItemID].vPosition.y;
Ritor1
parents:
diff changeset
353 Dst.z = (double)pSpriteObjects[uLayingItemID].vPosition.z;
Ritor1
parents:
diff changeset
354 Dst.r = 0.0;
Ritor1
parents:
diff changeset
355 Dst.g = 0.0;
Ritor1
parents:
diff changeset
356 Dst.b = 0.0;
Ritor1
parents:
diff changeset
357 if ( object->uFlags & OBJECT_DESC_TRIAL_FIRE )
Ritor1
parents:
diff changeset
358 {
Ritor1
parents:
diff changeset
359 Dst.type = ParticleType_Bitmap | ParticleType_Rotating | ParticleType_8;
Ritor1
parents:
diff changeset
360 Dst.uDiffuse = 0xFF3C1E;
Ritor1
parents:
diff changeset
361 Dst.timeToLive = (unsigned __int8)( rand() & 0x80) + 128;
Ritor1
parents:
diff changeset
362 Dst.uTextureID = pBitmaps_LOD->LoadTexture("effpar01", TEXTURE_DEFAULT);
Ritor1
parents:
diff changeset
363 Dst.flt_28 = 1.0;
2541
a902abdfc7f2 1. Renamed class Game to class Engine.
a.parshin
parents: 2534
diff changeset
364 pEngine->pParticleEngine->AddParticle(&Dst);
2498
Ritor1
parents:
diff changeset
365 return;
Ritor1
parents:
diff changeset
366 }
Ritor1
parents:
diff changeset
367 else if ( object->uFlags & OBJECT_DESC_TRIAL_LINE )
Ritor1
parents:
diff changeset
368 {
Ritor1
parents:
diff changeset
369 Dst.type = ParticleType_Line;
Ritor1
parents:
diff changeset
370 Dst.uTextureID = 0;
Ritor1
parents:
diff changeset
371 Dst.uDiffuse = rand();
Ritor1
parents:
diff changeset
372 Dst.timeToLive = 64;
Ritor1
parents:
diff changeset
373 Dst.flt_28 = 1.0;
2541
a902abdfc7f2 1. Renamed class Game to class Engine.
a.parshin
parents: 2534
diff changeset
374 pEngine->pParticleEngine->AddParticle(&Dst);
2498
Ritor1
parents:
diff changeset
375 return;
Ritor1
parents:
diff changeset
376 }
Ritor1
parents:
diff changeset
377 else if ( object->uFlags & OBJECT_DESC_TRIAL_PARTICLE)
Ritor1
parents:
diff changeset
378 {
Ritor1
parents:
diff changeset
379 Dst.type = ParticleType_Bitmap | ParticleType_8;
Ritor1
parents:
diff changeset
380 Dst.uDiffuse = rand();
Ritor1
parents:
diff changeset
381 Dst.timeToLive = (unsigned __int8)(rand() & 0x80) + 128;
Ritor1
parents:
diff changeset
382 Dst.uTextureID = pBitmaps_LOD->LoadTexture("effpar03", TEXTURE_DEFAULT);
Ritor1
parents:
diff changeset
383 Dst.flt_28 = 1.0;
2541
a902abdfc7f2 1. Renamed class Game to class Engine.
a.parshin
parents: 2534
diff changeset
384 pEngine->pParticleEngine->AddParticle(&Dst);
2498
Ritor1
parents:
diff changeset
385 }
Ritor1
parents:
diff changeset
386 return;
Ritor1
parents:
diff changeset
387 }
Ritor1
parents:
diff changeset
388 //v60 = ((unsigned __int64)(stru_721530.field_7C * (signed __int64)stru_721530.direction.x) >> 16);
Ritor1
parents:
diff changeset
389 pSpriteObjects[uLayingItemID].vPosition.x += fixpoint_mul(stru_721530.field_7C, stru_721530.direction.x);
Ritor1
parents:
diff changeset
390 //v60 = ((unsigned __int64)(stru_721530.field_7C * (signed __int64)stru_721530.direction.y) >> 16);
Ritor1
parents:
diff changeset
391 pSpriteObjects[uLayingItemID].vPosition.y += fixpoint_mul(stru_721530.field_7C, stru_721530.direction.y);
Ritor1
parents:
diff changeset
392 //v60 = ((unsigned __int64)(stru_721530.field_7C * (signed __int64)stru_721530.direction.z) >> 16);
Ritor1
parents:
diff changeset
393 v28 = LOWORD(stru_721530.uSectorID);
Ritor1
parents:
diff changeset
394 pSpriteObjects[uLayingItemID].vPosition.z += fixpoint_mul(stru_721530.field_7C, stru_721530.direction.z);
Ritor1
parents:
diff changeset
395 v29 = pSpriteObjects[uLayingItemID].vPosition.z;
Ritor1
parents:
diff changeset
396 pSpriteObjects[uLayingItemID].uSectorID = v28;
Ritor1
parents:
diff changeset
397 stru_721530.field_70 += stru_721530.field_7C;
Ritor1
parents:
diff changeset
398 if ( object->uFlags & OBJECT_DESC_INTERACTABLE )
Ritor1
parents:
diff changeset
399 {
Ritor1
parents:
diff changeset
400 if ( v29 < v54 )
Ritor1
parents:
diff changeset
401 pSpriteObjects[uLayingItemID].vPosition.z = v54 + 1;
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
402 if ( !_46BFFA_update_spell_fx(uLayingItemID, stru_721530.uFaceID) )
2498
Ritor1
parents:
diff changeset
403 return;
Ritor1
parents:
diff changeset
404 }
Ritor1
parents:
diff changeset
405 if (PID_TYPE(stru_721530.uFaceID) == OBJECT_Decoration)
Ritor1
parents:
diff changeset
406 break;
Ritor1
parents:
diff changeset
407 if (PID_TYPE(stru_721530.uFaceID) == OBJECT_BModel)
Ritor1
parents:
diff changeset
408 {
Ritor1
parents:
diff changeset
409 bmodel = &pOutdoor->pBModels[(signed int)stru_721530.uFaceID >> 9];
Ritor1
parents:
diff changeset
410 face = &bmodel->pFaces[PID_ID(stru_721530.uFaceID) & 0x3F];
Ritor1
parents:
diff changeset
411 if ( face->uPolygonType == POLYGON_Floor )
Ritor1
parents:
diff changeset
412 {
Ritor1
parents:
diff changeset
413 pSpriteObjects[uLayingItemID].vPosition.z = bmodel->pVertices.pVertices[face->pVertexIDs[0]].z + 1;
Ritor1
parents:
diff changeset
414 if ( pSpriteObjects[uLayingItemID].vVelocity.x * pSpriteObjects[uLayingItemID].vVelocity.x
Ritor1
parents:
diff changeset
415 + pSpriteObjects[uLayingItemID].vVelocity.y * pSpriteObjects[uLayingItemID].vVelocity.y >= 400 )
Ritor1
parents:
diff changeset
416 {
Ritor1
parents:
diff changeset
417 if ( face->uAttributes & FACE_UNKNOW2 )
Ritor1
parents:
diff changeset
418 EventProcessor(face->sCogTriggeredID, 0, 1);
Ritor1
parents:
diff changeset
419 }
Ritor1
parents:
diff changeset
420 else
Ritor1
parents:
diff changeset
421 {
Ritor1
parents:
diff changeset
422 LOWORD(v35) = 0;
Ritor1
parents:
diff changeset
423 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
424 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
425 pSpriteObjects[uLayingItemID].vVelocity.y = v35;
Ritor1
parents:
diff changeset
426 }
Ritor1
parents:
diff changeset
427 }
Ritor1
parents:
diff changeset
428 else
Ritor1
parents:
diff changeset
429 {
Ritor1
parents:
diff changeset
430 v56 = abs(face->pFacePlane.vNormal.x * pSpriteObjects[uLayingItemID].vVelocity.x
Ritor1
parents:
diff changeset
431 + face->pFacePlane.vNormal.y * pSpriteObjects[uLayingItemID].vVelocity.y
Ritor1
parents:
diff changeset
432 + face->pFacePlane.vNormal.z * pSpriteObjects[uLayingItemID].vVelocity.z) >> 16;
Ritor1
parents:
diff changeset
433 if ( (stru_721530.speed >> 3) > v56 )
Ritor1
parents:
diff changeset
434 v56 = stru_721530.speed >> 3;
Ritor1
parents:
diff changeset
435 //v57 = fixpoint_mul(v56, face->pFacePlane.vNormal.x);
Ritor1
parents:
diff changeset
436 //v58 = fixpoint_mul(v56, face->pFacePlane.vNormal.y);
Ritor1
parents:
diff changeset
437 v60 = fixpoint_mul(v56, face->pFacePlane.vNormal.z);
Ritor1
parents:
diff changeset
438 pSpriteObjects[uLayingItemID].vVelocity.x += 2 * fixpoint_mul(v56, face->pFacePlane.vNormal.x);
Ritor1
parents:
diff changeset
439 pSpriteObjects[uLayingItemID].vVelocity.y += 2 * fixpoint_mul(v56, face->pFacePlane.vNormal.y);
Ritor1
parents:
diff changeset
440 if ( face->pFacePlane.vNormal.z <= 32000 )
Ritor1
parents:
diff changeset
441 v37 = 2 * (short)v60;
Ritor1
parents:
diff changeset
442 else
Ritor1
parents:
diff changeset
443 {
Ritor1
parents:
diff changeset
444 v36 = v60;
Ritor1
parents:
diff changeset
445 pSpriteObjects[uLayingItemID].vVelocity.z += (signed __int16)v60;
Ritor1
parents:
diff changeset
446 v58 = fixpoint_mul(0x7D00, v36);
Ritor1
parents:
diff changeset
447 v37 = fixpoint_mul(32000, v36);
Ritor1
parents:
diff changeset
448 }
Ritor1
parents:
diff changeset
449 pSpriteObjects[uLayingItemID].vVelocity.z += v37;
Ritor1
parents:
diff changeset
450 if ( face->uAttributes & FACE_UNKNOW2 )
Ritor1
parents:
diff changeset
451 EventProcessor(face->sCogTriggeredID, 0, 1);
Ritor1
parents:
diff changeset
452 }
Ritor1
parents:
diff changeset
453 }
Ritor1
parents:
diff changeset
454 LABEL_74:
Ritor1
parents:
diff changeset
455 pSpriteObjects[uLayingItemID].vVelocity.x = fixpoint_mul(58500, pSpriteObjects[uLayingItemID].vVelocity.x);
Ritor1
parents:
diff changeset
456 pSpriteObjects[uLayingItemID].vVelocity.y = fixpoint_mul(58500, pSpriteObjects[uLayingItemID].vVelocity.y);
Ritor1
parents:
diff changeset
457 pSpriteObjects[uLayingItemID].vVelocity.z = fixpoint_mul(58500, pSpriteObjects[uLayingItemID].vVelocity.z);
Ritor1
parents:
diff changeset
458 }
Ritor1
parents:
diff changeset
459 v57 = integer_sqrt(pSpriteObjects[uLayingItemID].vVelocity.x * pSpriteObjects[uLayingItemID].vVelocity.x
Ritor1
parents:
diff changeset
460 + pSpriteObjects[uLayingItemID].vVelocity.y * pSpriteObjects[uLayingItemID].vVelocity.y);
Ritor1
parents:
diff changeset
461 v38 = stru_5C6E00->Atan2(pSpriteObjects[uLayingItemID].vPosition.x - pLevelDecorations[PID_ID(stru_721530.uFaceID)].vPosition.x,
Ritor1
parents:
diff changeset
462 pSpriteObjects[uLayingItemID].vPosition.y - pLevelDecorations[PID_ID(stru_721530.uFaceID)].vPosition.y);
Ritor1
parents:
diff changeset
463 pSpriteObjects[uLayingItemID].vVelocity.x = fixpoint_mul(stru_5C6E00->Cos(v38), v57);
Ritor1
parents:
diff changeset
464 pSpriteObjects[uLayingItemID].vVelocity.y = fixpoint_mul(stru_5C6E00->Sin(v38 - stru_5C6E00->uIntegerHalfPi), v57);
Ritor1
parents:
diff changeset
465 goto LABEL_74;
Ritor1
parents:
diff changeset
466 }
Ritor1
parents:
diff changeset
467 }
Ritor1
parents:
diff changeset
468
Ritor1
parents:
diff changeset
469 //----- (0047136C) --------------------------------------------------------
Ritor1
parents:
diff changeset
470 void SpriteObject::UpdateObject_fn0_BLV(unsigned int uLayingItemID)
Ritor1
parents:
diff changeset
471 {
Ritor1
parents:
diff changeset
472 SpriteObject *pSpriteObject; // esi@1
Ritor1
parents:
diff changeset
473 ObjectDesc *pObject; // edi@1
Ritor1
parents:
diff changeset
474 // int v9; // ecx@16
Ritor1
parents:
diff changeset
475 // __int16 v10; // di@18
Ritor1
parents:
diff changeset
476 // int v14; // ebx@34
Ritor1
parents:
diff changeset
477 signed int v15; // ebx@46
Ritor1
parents:
diff changeset
478 int v17; // eax@50
Ritor1
parents:
diff changeset
479 // int v18; // eax@52
Ritor1
parents:
diff changeset
480 // int v19; // ecx@52
Ritor1
parents:
diff changeset
481 // Vec3_short_ *v20; // ecx@53
Ritor1
parents:
diff changeset
482 __int16 v22; // ax@57
Ritor1
parents:
diff changeset
483 int v23; // edi@62
Ritor1
parents:
diff changeset
484 // unsigned __int8 v27; // sf@64
Ritor1
parents:
diff changeset
485 // unsigned __int8 v28; // of@64
Ritor1
parents:
diff changeset
486 // __int16 v29; // di@67
Ritor1
parents:
diff changeset
487 // char v30; // al@68
Ritor1
parents:
diff changeset
488 Particle_sw Dst; // [sp+Ch] [bp-84h]@18
Ritor1
parents:
diff changeset
489 unsigned int uFaceID; // [sp+7Ch] [bp-14h]@4
Ritor1
parents:
diff changeset
490 int v39; // [sp+80h] [bp-10h]@33
Ritor1
parents:
diff changeset
491 int v40; // [sp+84h] [bp-Ch]@28
Ritor1
parents:
diff changeset
492 int v42; // [sp+8Ch] [bp-4h]@4
Ritor1
parents:
diff changeset
493
Ritor1
parents:
diff changeset
494 pSpriteObject = &pSpriteObjects[uLayingItemID];
Ritor1
parents:
diff changeset
495 pObject = &pObjectList->pObjects[pSpriteObject->uObjectDescID];
Ritor1
parents:
diff changeset
496 pSpriteObject->uSectorID = pIndoor->GetSector(pSpriteObject->vPosition.x, pSpriteObject->vPosition.y, pSpriteObject->vPosition.z);
Ritor1
parents:
diff changeset
497 v42 = BLV_GetFloorLevel(pSpriteObject->vPosition.x, pSpriteObject->vPosition.y, pSpriteObject->vPosition.z, pSpriteObject->uSectorID, &uFaceID);
Ritor1
parents:
diff changeset
498 if ( abs(pSpriteObject->vPosition.x) > 32767
Ritor1
parents:
diff changeset
499 || abs(pSpriteObject->vPosition.y) > 32767
Ritor1
parents:
diff changeset
500 || abs(pSpriteObject->vPosition.z) > 20000
Ritor1
parents:
diff changeset
501 || v42 <= -30000
Ritor1
parents:
diff changeset
502 && (pSpriteObject->uSectorID == 0))
Ritor1
parents:
diff changeset
503 // || (v42 = _46CEC3_get_floor_level(pSpriteObject->vPosition.x, pSpriteObject->vPosition.y, pSpriteObject->vPosition.z, v4, &uFaceID), v42 == -30000)) )
Ritor1
parents:
diff changeset
504 {
Ritor1
parents:
diff changeset
505 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
506 return;
Ritor1
parents:
diff changeset
507 }
Ritor1
parents:
diff changeset
508 if ( pObject->uFlags & OBJECT_DESC_NO_GRAVITY )//íå ïàäàþùèå îáúåêòû
Ritor1
parents:
diff changeset
509 {
Ritor1
parents:
diff changeset
510 LABEL_25:
Ritor1
parents:
diff changeset
511 stru_721530.field_0 = 0;
Ritor1
parents:
diff changeset
512 stru_721530.prolly_normal_d = pObject->uRadius;
Ritor1
parents:
diff changeset
513 stru_721530.field_84 = -1;
Ritor1
parents:
diff changeset
514 stru_721530.height = pObject->uHeight;
Ritor1
parents:
diff changeset
515 stru_721530.field_8_radius = 0;
Ritor1
parents:
diff changeset
516 stru_721530.field_70 = 0;
Ritor1
parents:
diff changeset
517 for ( uFaceID = 0; uFaceID < 100; uFaceID++ )
Ritor1
parents:
diff changeset
518 {
Ritor1
parents:
diff changeset
519 stru_721530.position.x = pSpriteObject->vPosition.x;
Ritor1
parents:
diff changeset
520 stru_721530.position.y = pSpriteObject->vPosition.y;
Ritor1
parents:
diff changeset
521 stru_721530.position.z = stru_721530.prolly_normal_d + pSpriteObject->vPosition.z + 1;
Ritor1
parents:
diff changeset
522
Ritor1
parents:
diff changeset
523 stru_721530.normal.x = stru_721530.position.x;
Ritor1
parents:
diff changeset
524 stru_721530.normal.y = stru_721530.position.y;
Ritor1
parents:
diff changeset
525 stru_721530.normal.z = stru_721530.position.z;
Ritor1
parents:
diff changeset
526
Ritor1
parents:
diff changeset
527 stru_721530.velocity.x = pSpriteObject->vVelocity.x;
Ritor1
parents:
diff changeset
528 stru_721530.velocity.y = pSpriteObject->vVelocity.y;
Ritor1
parents:
diff changeset
529 stru_721530.velocity.z = pSpriteObject->vVelocity.z;
Ritor1
parents:
diff changeset
530
Ritor1
parents:
diff changeset
531 stru_721530.uSectorID = pSpriteObject->uSectorID;
Ritor1
parents:
diff changeset
532 if ( stru_721530._47050A(0) )
Ritor1
parents:
diff changeset
533 return;
Ritor1
parents:
diff changeset
534
Ritor1
parents:
diff changeset
535 for ( v40 = 0; v40 < 100; ++v40 )
Ritor1
parents:
diff changeset
536 {
Ritor1
parents:
diff changeset
537 _46E44E_collide_against_faces_and_portals(0);
Ritor1
parents:
diff changeset
538 _46E0B2_collide_against_decorations();
Ritor1
parents:
diff changeset
539 if (PID_TYPE(pSpriteObject->spell_caster_pid) != OBJECT_Player)
Ritor1
parents:
diff changeset
540 _46EF01_collision_chech_player(1);
Ritor1
parents:
diff changeset
541 if (PID_TYPE(pSpriteObject->spell_caster_pid) == OBJECT_Actor)
Ritor1
parents:
diff changeset
542 {
Ritor1
parents:
diff changeset
543 for ( v42 = 0; v42 < (signed int)uNumActors; ++v42 )
Ritor1
parents:
diff changeset
544 {
Ritor1
parents:
diff changeset
545 if( pActors[pSpriteObject->spell_caster_pid >> 3].pMonsterInfo.uID != pActors[v42].pMonsterInfo.uID )
Ritor1
parents:
diff changeset
546 //not sure: pMonsterList->pMonsters[v39b->word_000086_some_monster_id-1].uToHitRadius
Ritor1
parents:
diff changeset
547 Actor::_46DF1A_collide_against_actor(v42, pMonsterList->pMonsters[pActors[v42].word_000086_some_monster_id-1].uToHitRadius);
Ritor1
parents:
diff changeset
548 }
Ritor1
parents:
diff changeset
549 }
Ritor1
parents:
diff changeset
550 else
Ritor1
parents:
diff changeset
551 {
Ritor1
parents:
diff changeset
552 for ( v42 = 0; v42 < (signed int)uNumActors; v42++ )
Ritor1
parents:
diff changeset
553 Actor::_46DF1A_collide_against_actor(v42, pMonsterList->pMonsters[pActors[v42].word_000086_some_monster_id-1].uToHitRadius);
Ritor1
parents:
diff changeset
554 }
Ritor1
parents:
diff changeset
555 if ( _46F04E_collide_against_portals() )
Ritor1
parents:
diff changeset
556 break;
Ritor1
parents:
diff changeset
557 }
Ritor1
parents:
diff changeset
558 if ( stru_721530.field_7C >= stru_721530.field_6C )
Ritor1
parents:
diff changeset
559 {
Ritor1
parents:
diff changeset
560 pSpriteObject->vPosition.x = stru_721530.normal2.x;
Ritor1
parents:
diff changeset
561 pSpriteObject->vPosition.y = stru_721530.normal2.y;
Ritor1
parents:
diff changeset
562 pSpriteObject->vPosition.z = stru_721530.normal2.z - stru_721530.prolly_normal_d - 1;
Ritor1
parents:
diff changeset
563 pSpriteObject->uSectorID = LOWORD(stru_721530.uSectorID);
Ritor1
parents:
diff changeset
564 if ( !(HIBYTE(pObject->uFlags) & 1) )
Ritor1
parents:
diff changeset
565 return;
Ritor1
parents:
diff changeset
566 memset(&Dst, 0, 0x68u);
Ritor1
parents:
diff changeset
567 Dst.x = (double)pSpriteObject->vPosition.x;
Ritor1
parents:
diff changeset
568 Dst.y = (double)pSpriteObject->vPosition.y;
Ritor1
parents:
diff changeset
569 Dst.z = (double)pSpriteObject->vPosition.z;
Ritor1
parents:
diff changeset
570 Dst.r = 0.0;
Ritor1
parents:
diff changeset
571 Dst.g = 0.0;
Ritor1
parents:
diff changeset
572 Dst.b = 0.0;
Ritor1
parents:
diff changeset
573 if ( pObject->uFlags & OBJECT_DESC_TRIAL_FIRE )
Ritor1
parents:
diff changeset
574 {
Ritor1
parents:
diff changeset
575 Dst.type = ParticleType_Bitmap | ParticleType_Rotating | ParticleType_8;
Ritor1
parents:
diff changeset
576 Dst.uDiffuse = 0xFF3C1E;
Ritor1
parents:
diff changeset
577 Dst.timeToLive = (unsigned __int8)(rand() & 0x80) + 128;
Ritor1
parents:
diff changeset
578 Dst.uTextureID = pBitmaps_LOD->LoadTexture("effpar01", TEXTURE_DEFAULT);
Ritor1
parents:
diff changeset
579 Dst.flt_28 = 1.0;
2541
a902abdfc7f2 1. Renamed class Game to class Engine.
a.parshin
parents: 2534
diff changeset
580 pEngine->pParticleEngine->AddParticle(&Dst);
2498
Ritor1
parents:
diff changeset
581 return;
Ritor1
parents:
diff changeset
582 }
Ritor1
parents:
diff changeset
583 else if ( pObject->uFlags & OBJECT_DESC_TRIAL_LINE )
Ritor1
parents:
diff changeset
584 {
Ritor1
parents:
diff changeset
585 Dst.type = ParticleType_Line;
Ritor1
parents:
diff changeset
586 Dst.uDiffuse = rand();
Ritor1
parents:
diff changeset
587 Dst.timeToLive = 64;
Ritor1
parents:
diff changeset
588 Dst.uTextureID = 0;
Ritor1
parents:
diff changeset
589 Dst.flt_28 = 1.0;
2541
a902abdfc7f2 1. Renamed class Game to class Engine.
a.parshin
parents: 2534
diff changeset
590 pEngine->pParticleEngine->AddParticle(&Dst);
2498
Ritor1
parents:
diff changeset
591 return;
Ritor1
parents:
diff changeset
592 }
Ritor1
parents:
diff changeset
593 else if ( pObject->uFlags & OBJECT_DESC_TRIAL_PARTICLE)
Ritor1
parents:
diff changeset
594 {
Ritor1
parents:
diff changeset
595 Dst.type = ParticleType_Bitmap | ParticleType_8;
Ritor1
parents:
diff changeset
596 Dst.uDiffuse = rand();
Ritor1
parents:
diff changeset
597 Dst.timeToLive = (unsigned __int8)(rand() & 0x80) + 128;
Ritor1
parents:
diff changeset
598 Dst.uTextureID = pBitmaps_LOD->LoadTexture("effpar03", TEXTURE_DEFAULT);
Ritor1
parents:
diff changeset
599 Dst.flt_28 = 1.0;
2541
a902abdfc7f2 1. Renamed class Game to class Engine.
a.parshin
parents: 2534
diff changeset
600 pEngine->pParticleEngine->AddParticle(&Dst);
2498
Ritor1
parents:
diff changeset
601 }
Ritor1
parents:
diff changeset
602 return;
Ritor1
parents:
diff changeset
603 }
Ritor1
parents:
diff changeset
604 //v40 = (unsigned __int64)(stru_721530.field_7C * (signed __int64)stru_721530.direction.x) >> 16;
Ritor1
parents:
diff changeset
605 pSpriteObject->vPosition.x += fixpoint_mul(stru_721530.field_7C, stru_721530.direction.x);
Ritor1
parents:
diff changeset
606 //v40 = (unsigned __int64)(stru_721530.field_7C * (signed __int64)stru_721530.direction.y) >> 16;
Ritor1
parents:
diff changeset
607 pSpriteObject->vPosition.y += fixpoint_mul(stru_721530.field_7C, stru_721530.direction.y);
Ritor1
parents:
diff changeset
608 //v40 = (unsigned __int64)(stru_721530.field_7C * (signed __int64)stru_721530.direction.z) >> 16;
Ritor1
parents:
diff changeset
609 pSpriteObject->vPosition.z += fixpoint_mul(stru_721530.field_7C, stru_721530.direction.z);
Ritor1
parents:
diff changeset
610 pSpriteObject->uSectorID = stru_721530.uSectorID;
Ritor1
parents:
diff changeset
611 stru_721530.field_70 += stru_721530.field_7C;
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
612 if ( pObject->uFlags & OBJECT_DESC_INTERACTABLE && !_46BFFA_update_spell_fx(uLayingItemID, stru_721530.uFaceID) )
2498
Ritor1
parents:
diff changeset
613 return;
Ritor1
parents:
diff changeset
614 v15 = (signed int)stru_721530.uFaceID >> 3;
Ritor1
parents:
diff changeset
615 if (PID_TYPE(stru_721530.uFaceID) == OBJECT_Decoration)
Ritor1
parents:
diff changeset
616 {
Ritor1
parents:
diff changeset
617 v40 = integer_sqrt(pSpriteObject->vVelocity.x * pSpriteObject->vVelocity.x + pSpriteObject->vVelocity.y * pSpriteObject->vVelocity.y);
Ritor1
parents:
diff changeset
618 v23 = stru_5C6E00->Atan2(pSpriteObject->vPosition.x - pLevelDecorations[v15].vPosition.x,
Ritor1
parents:
diff changeset
619 pSpriteObject->vPosition.y - pLevelDecorations[v15].vPosition.y);
Ritor1
parents:
diff changeset
620 pSpriteObject->vVelocity.x = fixpoint_mul(stru_5C6E00->Cos(v23), v40);
Ritor1
parents:
diff changeset
621 pSpriteObject->vVelocity.y = fixpoint_mul(stru_5C6E00->Sin(v23), v40);
Ritor1
parents:
diff changeset
622 }
Ritor1
parents:
diff changeset
623 if (PID_TYPE(stru_721530.uFaceID) == OBJECT_BModel)
Ritor1
parents:
diff changeset
624 {
Ritor1
parents:
diff changeset
625 stru_721530.field_84 = (signed int)PID_ID(stru_721530.uFaceID);
Ritor1
parents:
diff changeset
626 if ( pIndoor->pFaces[v15].uPolygonType != POLYGON_Floor )
Ritor1
parents:
diff changeset
627 {
Ritor1
parents:
diff changeset
628 v42 = abs(pIndoor->pFaces[v15].pFacePlane_old.vNormal.x * pSpriteObject->vVelocity.x
Ritor1
parents:
diff changeset
629 + pIndoor->pFaces[v15].pFacePlane_old.vNormal.y * pSpriteObject->vVelocity.y
Ritor1
parents:
diff changeset
630 + pIndoor->pFaces[v15].pFacePlane_old.vNormal.z * pSpriteObject->vVelocity.z) >> 16;
Ritor1
parents:
diff changeset
631 if ( (stru_721530.speed >> 3) > v42 )
Ritor1
parents:
diff changeset
632 v42 = stru_721530.speed >> 3;
Ritor1
parents:
diff changeset
633 pSpriteObject->vVelocity.x += 2 * fixpoint_mul(v42, pIndoor->pFaces[v15].pFacePlane_old.vNormal.x);
Ritor1
parents:
diff changeset
634 pSpriteObject->vVelocity.y += 2 * fixpoint_mul(v42, pIndoor->pFaces[v15].pFacePlane_old.vNormal.y);
Ritor1
parents:
diff changeset
635 v39 = fixpoint_mul(v42, pIndoor->pFaces[v15].pFacePlane_old.vNormal.z);
Ritor1
parents:
diff changeset
636 if ( pIndoor->pFaces[v15].pFacePlane_old.vNormal.z <= 32000 )
Ritor1
parents:
diff changeset
637 v22 = 2 * v39;
Ritor1
parents:
diff changeset
638 else
Ritor1
parents:
diff changeset
639 {
Ritor1
parents:
diff changeset
640 pSpriteObject->vVelocity.z += v39;
Ritor1
parents:
diff changeset
641 v22 = fixpoint_mul(32000, v39);
Ritor1
parents:
diff changeset
642 }
Ritor1
parents:
diff changeset
643 pSpriteObject->vVelocity.z += v22;
Ritor1
parents:
diff changeset
644 if ( pIndoor->pFaces[v15].uAttributes & FACE_UNKNOW2 )
Ritor1
parents:
diff changeset
645 EventProcessor(pIndoor->pFaceExtras[pIndoor->pFaces[v15].uFaceExtraID].uEventID, 0, 1);
Ritor1
parents:
diff changeset
646 pSpriteObject->vVelocity.x = fixpoint_mul(58500, pSpriteObject->vVelocity.x);
Ritor1
parents:
diff changeset
647 pSpriteObject->vVelocity.y = fixpoint_mul(58500, pSpriteObject->vVelocity.y);
Ritor1
parents:
diff changeset
648 pSpriteObject->vVelocity.z = fixpoint_mul(58500, pSpriteObject->vVelocity.z);
Ritor1
parents:
diff changeset
649 continue;
Ritor1
parents:
diff changeset
650 }
Ritor1
parents:
diff changeset
651 if ( pObject->uFlags & OBJECT_DESC_BOUNCE )
Ritor1
parents:
diff changeset
652 {
Ritor1
parents:
diff changeset
653 v17 = -pSpriteObject->vVelocity.z / 2;
Ritor1
parents:
diff changeset
654 pSpriteObject->vVelocity.z = v17;
Ritor1
parents:
diff changeset
655 if ( (signed __int16)v17 < 10 )
Ritor1
parents:
diff changeset
656 pSpriteObject->vVelocity.z = 0;
Ritor1
parents:
diff changeset
657 if ( pIndoor->pFaces[v15].uAttributes & FACE_UNKNOW2 )
Ritor1
parents:
diff changeset
658 EventProcessor(pIndoor->pFaceExtras[pIndoor->pFaces[v15].uFaceExtraID].uEventID, 0, 1);
Ritor1
parents:
diff changeset
659 pSpriteObject->vVelocity.x = fixpoint_mul(58500, pSpriteObject->vVelocity.x);
Ritor1
parents:
diff changeset
660 pSpriteObject->vVelocity.y = fixpoint_mul(58500, pSpriteObject->vVelocity.y);
Ritor1
parents:
diff changeset
661 pSpriteObject->vVelocity.z = fixpoint_mul(58500, pSpriteObject->vVelocity.z);
Ritor1
parents:
diff changeset
662 continue;
Ritor1
parents:
diff changeset
663 }
Ritor1
parents:
diff changeset
664 pSpriteObject->vVelocity.z = 0;
Ritor1
parents:
diff changeset
665 if ( pSpriteObject->vVelocity.x * pSpriteObject->vVelocity.x + pSpriteObject->vVelocity.y * pSpriteObject->vVelocity.y >= 400 )
Ritor1
parents:
diff changeset
666 {
Ritor1
parents:
diff changeset
667 if ( pIndoor->pFaces[v15].uAttributes & FACE_UNKNOW2 )
Ritor1
parents:
diff changeset
668 EventProcessor(pIndoor->pFaceExtras[pIndoor->pFaces[v15].uFaceExtraID].uEventID, 0, 1);
Ritor1
parents:
diff changeset
669 pSpriteObject->vVelocity.x = fixpoint_mul(58500, pSpriteObject->vVelocity.x);
Ritor1
parents:
diff changeset
670 pSpriteObject->vVelocity.y = fixpoint_mul(58500, pSpriteObject->vVelocity.y);
Ritor1
parents:
diff changeset
671 pSpriteObject->vVelocity.z = fixpoint_mul(58500, pSpriteObject->vVelocity.z);
Ritor1
parents:
diff changeset
672 continue;
Ritor1
parents:
diff changeset
673 }
Ritor1
parents:
diff changeset
674 pSpriteObject->vVelocity.z = 0;
Ritor1
parents:
diff changeset
675 pSpriteObject->vVelocity.y = 0;
Ritor1
parents:
diff changeset
676 pSpriteObject->vVelocity.x = 0;
Ritor1
parents:
diff changeset
677 pSpriteObject->vPosition.z = pIndoor->pVertices[*pIndoor->pFaces[v15].pVertexIDs].z + 1;
Ritor1
parents:
diff changeset
678 }
Ritor1
parents:
diff changeset
679 pSpriteObject->vVelocity.x = fixpoint_mul(58500, pSpriteObject->vVelocity.x);
Ritor1
parents:
diff changeset
680 pSpriteObject->vVelocity.y = fixpoint_mul(58500, pSpriteObject->vVelocity.y);
Ritor1
parents:
diff changeset
681 pSpriteObject->vVelocity.z = fixpoint_mul(58500, pSpriteObject->vVelocity.z);
Ritor1
parents:
diff changeset
682 }
Ritor1
parents:
diff changeset
683 }
Ritor1
parents:
diff changeset
684 //äëÿ ïàäàþùèõ îáúåêòîâ(äëÿ ïðèìåðà âûáðîñ âåùè èç èíâåíòàðÿ)
Ritor1
parents:
diff changeset
685 if ( v42 <= pSpriteObject->vPosition.z - 3 )
Ritor1
parents:
diff changeset
686 {
Ritor1
parents:
diff changeset
687 pSpriteObject->vVelocity.z -= LOWORD(pEventTimer->uTimeElapsed) * GetGravityStrength();
Ritor1
parents:
diff changeset
688 goto LABEL_25;
Ritor1
parents:
diff changeset
689 }
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
690 if ( !(pObject->uFlags & OBJECT_DESC_INTERACTABLE) || _46BFFA_update_spell_fx(uLayingItemID, 0) )
2498
Ritor1
parents:
diff changeset
691 {
Ritor1
parents:
diff changeset
692 pSpriteObject->vPosition.z = v42 + 1;
Ritor1
parents:
diff changeset
693 if ( pIndoor->pFaces[uFaceID].uPolygonType == POLYGON_Floor )
Ritor1
parents:
diff changeset
694 pSpriteObject->vVelocity.z = 0;
Ritor1
parents:
diff changeset
695 else
Ritor1
parents:
diff changeset
696 {
Ritor1
parents:
diff changeset
697 if ( pIndoor->pFaces[uFaceID].pFacePlane_old.vNormal.z < 45000 )
Ritor1
parents:
diff changeset
698 pSpriteObject->vVelocity.z -= LOWORD(pEventTimer->uTimeElapsed) * GetGravityStrength();
Ritor1
parents:
diff changeset
699 }
Ritor1
parents:
diff changeset
700 pSpriteObject->vVelocity.x = fixpoint_mul(58500, pSpriteObject->vVelocity.x);
Ritor1
parents:
diff changeset
701 pSpriteObject->vVelocity.y = fixpoint_mul(58500, pSpriteObject->vVelocity.y);
Ritor1
parents:
diff changeset
702 pSpriteObject->vVelocity.z = fixpoint_mul(58500, pSpriteObject->vVelocity.z);
Ritor1
parents:
diff changeset
703 if ( pSpriteObject->vVelocity.x * pSpriteObject->vVelocity.x + pSpriteObject->vVelocity.y * pSpriteObject->vVelocity.y < 400 )
Ritor1
parents:
diff changeset
704 {
Ritor1
parents:
diff changeset
705 pSpriteObject->vVelocity.x = 0;
Ritor1
parents:
diff changeset
706 pSpriteObject->vVelocity.y = 0;
Ritor1
parents:
diff changeset
707 pSpriteObject->vVelocity.z = 0;
Ritor1
parents:
diff changeset
708 if ( !(pObject->uFlags & OBJECT_DESC_NO_SPRITE) )
Ritor1
parents:
diff changeset
709 return;
Ritor1
parents:
diff changeset
710 memset(&Dst, 0, 0x68u);
Ritor1
parents:
diff changeset
711 Dst.x = (double)pSpriteObject->vPosition.x;
Ritor1
parents:
diff changeset
712 Dst.y = (double)pSpriteObject->vPosition.y;
Ritor1
parents:
diff changeset
713 Dst.z = (double)pSpriteObject->vPosition.z;
Ritor1
parents:
diff changeset
714 Dst.r = 0.0;
Ritor1
parents:
diff changeset
715 Dst.g = 0.0;
Ritor1
parents:
diff changeset
716 Dst.b = 0.0;
Ritor1
parents:
diff changeset
717 if ( pObject->uFlags & OBJECT_DESC_TRIAL_FIRE )
Ritor1
parents:
diff changeset
718 {
Ritor1
parents:
diff changeset
719 Dst.type = ParticleType_Bitmap | ParticleType_Rotating | ParticleType_8;
Ritor1
parents:
diff changeset
720 Dst.uDiffuse = 0xFF3C1E;
Ritor1
parents:
diff changeset
721 Dst.flt_28 = 1.0;
Ritor1
parents:
diff changeset
722 Dst.timeToLive = (unsigned __int8)(rand() & 0x80) + 128;
Ritor1
parents:
diff changeset
723 Dst.uTextureID = pBitmaps_LOD->LoadTexture("effpar01", TEXTURE_DEFAULT);
2541
a902abdfc7f2 1. Renamed class Game to class Engine.
a.parshin
parents: 2534
diff changeset
724 pEngine->pParticleEngine->AddParticle(&Dst);
2498
Ritor1
parents:
diff changeset
725 return;
Ritor1
parents:
diff changeset
726 }
Ritor1
parents:
diff changeset
727 else if ( pObject->uFlags & OBJECT_DESC_TRIAL_LINE )
Ritor1
parents:
diff changeset
728 {
Ritor1
parents:
diff changeset
729 Dst.type = ParticleType_Line;
Ritor1
parents:
diff changeset
730 Dst.uDiffuse = rand();
Ritor1
parents:
diff changeset
731 Dst.timeToLive = 64;
Ritor1
parents:
diff changeset
732 Dst.uTextureID = 0;
Ritor1
parents:
diff changeset
733 Dst.flt_28 = 1.0;
2541
a902abdfc7f2 1. Renamed class Game to class Engine.
a.parshin
parents: 2534
diff changeset
734 pEngine->pParticleEngine->AddParticle(&Dst);
2498
Ritor1
parents:
diff changeset
735 return;
Ritor1
parents:
diff changeset
736 }
Ritor1
parents:
diff changeset
737 else if ( pObject->uFlags & OBJECT_DESC_TRIAL_PARTICLE)
Ritor1
parents:
diff changeset
738 {
Ritor1
parents:
diff changeset
739 Dst.type = ParticleType_Bitmap | ParticleType_8;
Ritor1
parents:
diff changeset
740 Dst.uDiffuse = rand();
Ritor1
parents:
diff changeset
741 Dst.flt_28 = 1.0;
Ritor1
parents:
diff changeset
742 Dst.timeToLive = (unsigned __int8)(rand() & 0x80) + 128;
Ritor1
parents:
diff changeset
743 Dst.uTextureID = pBitmaps_LOD->LoadTexture("effpar03", TEXTURE_DEFAULT);
2541
a902abdfc7f2 1. Renamed class Game to class Engine.
a.parshin
parents: 2534
diff changeset
744 pEngine->pParticleEngine->AddParticle(&Dst);
2498
Ritor1
parents:
diff changeset
745 }
Ritor1
parents:
diff changeset
746 return;
Ritor1
parents:
diff changeset
747 }
Ritor1
parents:
diff changeset
748 goto LABEL_25;
Ritor1
parents:
diff changeset
749 }
Ritor1
parents:
diff changeset
750 }
Ritor1
parents:
diff changeset
751 // 46DF1A: using guessed type int __fastcall 46DF1A_collide_against_actor(int, int);
Ritor1
parents:
diff changeset
752
Ritor1
parents:
diff changeset
753 //----- (00438E35) --------------------------------------------------------
Ritor1
parents:
diff changeset
754 void SpriteObject::ExplosionTraps()
Ritor1
parents:
diff changeset
755 {
Ritor1
parents:
diff changeset
756 MapInfo *pMapInfo; // esi@1
Ritor1
parents:
diff changeset
757 int dir_x; // ebx@1
Ritor1
parents:
diff changeset
758 int v7; // edx@2
Ritor1
parents:
diff changeset
759 unsigned int v10; // eax@7
Ritor1
parents:
diff changeset
760 signed int v11; // ebx@8
Ritor1
parents:
diff changeset
761 signed int v13; // edi@20
Ritor1
parents:
diff changeset
762 int dir_y; // [sp+Ch] [bp-Ch]@1
Ritor1
parents:
diff changeset
763 int dir_z; // [sp+10h] [bp-8h]@1
Ritor1
parents:
diff changeset
764 DAMAGE_TYPE pDamageType; // [sp+14h] [bp-4h]@14
Ritor1
parents:
diff changeset
765
Ritor1
parents:
diff changeset
766 pMapInfo = &pMapStats->pInfos[pMapStats->GetMapInfo(pCurrentMapName)];
Ritor1
parents:
diff changeset
767 dir_x = abs(pParty->vPosition.x - this->vPosition.x);
Ritor1
parents:
diff changeset
768 dir_y = abs(pParty->vPosition.y - this->vPosition.y);
Ritor1
parents:
diff changeset
769 dir_z = abs(pParty->vPosition.z + pParty->sEyelevel - this->vPosition.z);
Ritor1
parents:
diff changeset
770 if ( dir_x < dir_y )
Ritor1
parents:
diff changeset
771 {
Ritor1
parents:
diff changeset
772 v7 = dir_x;
Ritor1
parents:
diff changeset
773 dir_x = dir_y;
Ritor1
parents:
diff changeset
774 dir_y = v7;
Ritor1
parents:
diff changeset
775 }
Ritor1
parents:
diff changeset
776 if ( dir_x < dir_z )
Ritor1
parents:
diff changeset
777 {
Ritor1
parents:
diff changeset
778 v7 = dir_x;
Ritor1
parents:
diff changeset
779 dir_x = dir_z;
Ritor1
parents:
diff changeset
780 dir_z = v7;
Ritor1
parents:
diff changeset
781 }
Ritor1
parents:
diff changeset
782 if ( dir_y < dir_z )
Ritor1
parents:
diff changeset
783 {
Ritor1
parents:
diff changeset
784 v7 = dir_z;
Ritor1
parents:
diff changeset
785 dir_z = dir_y;
Ritor1
parents:
diff changeset
786 dir_y = v7;
Ritor1
parents:
diff changeset
787 }
Ritor1
parents:
diff changeset
788 v10 = ((unsigned int)(11 * dir_y) >> 5) + (dir_z / 4) + dir_x;
Ritor1
parents:
diff changeset
789 if ( (signed int)v10 <= 768 )
Ritor1
parents:
diff changeset
790 {
Ritor1
parents:
diff changeset
791 v11 = 5;
Ritor1
parents:
diff changeset
792 if ( pMapInfo->Trap_D20 )
Ritor1
parents:
diff changeset
793 {
Ritor1
parents:
diff changeset
794 for ( uint i = 0; i < pMapInfo->Trap_D20; ++i )
Ritor1
parents:
diff changeset
795 v11 += rand() % 20 + 1;
Ritor1
parents:
diff changeset
796 }
Ritor1
parents:
diff changeset
797 switch ( this->uType )
Ritor1
parents:
diff changeset
798 {
Ritor1
parents:
diff changeset
799 case 811:
Ritor1
parents:
diff changeset
800 pDamageType = DMGT_FIRE;
Ritor1
parents:
diff changeset
801 break;
Ritor1
parents:
diff changeset
802 case 812:
Ritor1
parents:
diff changeset
803 pDamageType = DMGT_ELECTR;
Ritor1
parents:
diff changeset
804 break;
Ritor1
parents:
diff changeset
805 case 813:
Ritor1
parents:
diff changeset
806 pDamageType = DMGT_COLD;
Ritor1
parents:
diff changeset
807 break;
Ritor1
parents:
diff changeset
808 case 814:
Ritor1
parents:
diff changeset
809 pDamageType = DMGT_BODY;
Ritor1
parents:
diff changeset
810 break;
Ritor1
parents:
diff changeset
811 default:
Ritor1
parents:
diff changeset
812 return;
Ritor1
parents:
diff changeset
813 }
Ritor1
parents:
diff changeset
814 for ( uint i = 1; i <= 4; ++i )
Ritor1
parents:
diff changeset
815 {
Ritor1
parents:
diff changeset
816 if ( pPlayers[i]->CanAct() && (v13 = pPlayers[i]->GetPerception() + 20, rand() % v13 > 20) )
Ritor1
parents:
diff changeset
817 pPlayers[i]->PlaySound(SPEECH_6, 0);
Ritor1
parents:
diff changeset
818 else
Ritor1
parents:
diff changeset
819 pPlayers[i]->ReceiveDamage(v11, pDamageType);
Ritor1
parents:
diff changeset
820 }
Ritor1
parents:
diff changeset
821 }
Ritor1
parents:
diff changeset
822 }
Ritor1
parents:
diff changeset
823
Ritor1
parents:
diff changeset
824 //----- (0042F933) --------------------------------------------------------
Ritor1
parents:
diff changeset
825 void SpriteObject::OnInteraction(unsigned int uLayingItemID)
Ritor1
parents:
diff changeset
826 {
Ritor1
parents:
diff changeset
827 pSpriteObjects[uLayingItemID].uObjectDescID = 0;
Ritor1
parents:
diff changeset
828 if ( pParty->bTurnBasedModeOn == 1 )
Ritor1
parents:
diff changeset
829 {
Ritor1
parents:
diff changeset
830 if (pSpriteObjects[uLayingItemID].uAttributes & 4 )
Ritor1
parents:
diff changeset
831 {
Ritor1
parents:
diff changeset
832 pSpriteObjects[uLayingItemID].uAttributes &= 0xFFFB;//~0x00000004
Ritor1
parents:
diff changeset
833 --pTurnEngine->pending_actions;
Ritor1
parents:
diff changeset
834 }
Ritor1
parents:
diff changeset
835 }
Ritor1
parents:
diff changeset
836 }
Ritor1
parents:
diff changeset
837
Ritor1
parents:
diff changeset
838
Ritor1
parents:
diff changeset
839 //----- (0042FA22) --------------------------------------------------------
Ritor1
parents:
diff changeset
840 void CompactLayingItemsList()
Ritor1
parents:
diff changeset
841 {
Ritor1
parents:
diff changeset
842 int new_obj_pos = 0;
Ritor1
parents:
diff changeset
843
Ritor1
parents:
diff changeset
844 for ( int i = 0; i < MAX_SPRITE_OBJECTS; ++i )
Ritor1
parents:
diff changeset
845 {
Ritor1
parents:
diff changeset
846 if ( pSpriteObjects[i].uObjectDescID )
Ritor1
parents:
diff changeset
847 {
Ritor1
parents:
diff changeset
848 if ( i != new_obj_pos )//
Ritor1
parents:
diff changeset
849 {
Ritor1
parents:
diff changeset
850 memcpy(&pSpriteObjects[new_obj_pos], &pSpriteObjects[i],sizeof(SpriteObject));
Ritor1
parents:
diff changeset
851 pSpriteObjects[i].uObjectDescID = 0;
Ritor1
parents:
diff changeset
852 }
Ritor1
parents:
diff changeset
853 new_obj_pos++;
Ritor1
parents:
diff changeset
854 }
Ritor1
parents:
diff changeset
855 }
Ritor1
parents:
diff changeset
856 uNumSpriteObjects = new_obj_pos;
Ritor1
parents:
diff changeset
857 }
Ritor1
parents:
diff changeset
858 //----- (00408896) --------------------------------------------------------
Ritor1
parents:
diff changeset
859 void SpriteObject::InitializeSpriteObjects()
Ritor1
parents:
diff changeset
860 {
Ritor1
parents:
diff changeset
861 for (uint i = 0; i < uNumSpriteObjects; ++i)
Ritor1
parents:
diff changeset
862 {
Ritor1
parents:
diff changeset
863 SpriteObject* item = &pSpriteObjects[i];
Ritor1
parents:
diff changeset
864
Ritor1
parents:
diff changeset
865 if (item->uType && (item->uSoundID & 8 || pObjectList->pObjects[item->uType].uFlags & OBJECT_DESC_UNPICKABLE))
Ritor1
parents:
diff changeset
866 SpriteObject::OnInteraction(i);
Ritor1
parents:
diff changeset
867 }
Ritor1
parents:
diff changeset
868 }
Ritor1
parents:
diff changeset
869 //----- (0046BEF1) --------------------------------------------------------
Ritor1
parents:
diff changeset
870 void SpriteObject::_46BEF1_apply_spells_aoe()
Ritor1
parents:
diff changeset
871 {
Ritor1
parents:
diff changeset
872 //SpriteObject *v1; // edi@1
Ritor1
parents:
diff changeset
873 //Actor *v2; // esi@2
Ritor1
parents:
diff changeset
874 //__int16 v3; // fps@4
Ritor1
parents:
diff changeset
875 //unsigned __int8 v4; // c0@4
Ritor1
parents:
diff changeset
876 //unsigned __int8 v5; // c3@4
Ritor1
parents:
diff changeset
877 //signed int v6; // [sp+8h] [bp-4h]@1
Ritor1
parents:
diff changeset
878
Ritor1
parents:
diff changeset
879 int v7,v9,v10,v11;
Ritor1
parents:
diff changeset
880 __debugbreak();//Ritor1
Ritor1
parents:
diff changeset
881 if ( (signed int)uNumActors > 0 )
Ritor1
parents:
diff changeset
882 {
Ritor1
parents:
diff changeset
883 for ( uint i = 0; i < uNumActors; ++i )
Ritor1
parents:
diff changeset
884 {
Ritor1
parents:
diff changeset
885 if ( pActors[i].CanAct() )
Ritor1
parents:
diff changeset
886 {
Ritor1
parents:
diff changeset
887 //UNDEF(v3);
Ritor1
parents:
diff changeset
888 //.text:0046BF26 movsx eax, word ptr [esi-2]
Ritor1
parents:
diff changeset
889 //.text:0046BF2A sub eax, [edi+4]
Ritor1
parents:
diff changeset
890 //.text:0046BF31 mov [ebp+var_8], eax
Ritor1
parents:
diff changeset
891 //.text:0046BF37 fild [ebp+var_8]
Ritor1
parents:
diff changeset
892 // v7 pushed to stack
Ritor1
parents:
diff changeset
893 v7 = pActors[i].vPosition.x - this->vPosition.x;
Ritor1
parents:
diff changeset
894
Ritor1
parents:
diff changeset
895 //.text:0046BF2D movsx ecx, word ptr [esi+2]
Ritor1
parents:
diff changeset
896 //v8 = pActors[i].vPosition.z;
Ritor1
parents:
diff changeset
897
Ritor1
parents:
diff changeset
898 //.text:0046BF34 movsx eax, word ptr [esi]
Ritor1
parents:
diff changeset
899 //.text:0046BF3A sub eax, [edi+8]
Ritor1
parents:
diff changeset
900 //.text:0046BF3D mov [ebp+var_8], eax
Ritor1
parents:
diff changeset
901 //.text:0046BF44 fild [ebp+var_8]
Ritor1
parents:
diff changeset
902 // v9 pushed to stack
Ritor1
parents:
diff changeset
903 v9 = pActors[i].vPosition.y - this->vPosition.y;
Ritor1
parents:
diff changeset
904
Ritor1
parents:
diff changeset
905 //.text:0046BF40 movsx eax, word ptr [esi-6]
Ritor1
parents:
diff changeset
906 //.text:0046BF47 sar eax, 1
Ritor1
parents:
diff changeset
907 //.text:0046BF49 add eax, ecx
Ritor1
parents:
diff changeset
908 //.text:0046BF4B sub eax, [edi+0Ch]
Ritor1
parents:
diff changeset
909 //.text:0046BF4E mov [ebp+var_8], eax
Ritor1
parents:
diff changeset
910 //.text:0046BF51 fild [ebp+var_8]
Ritor1
parents:
diff changeset
911 //.text:0046BF58 fld st
Ritor1
parents:
diff changeset
912 // v10 pushed to stack, two times
Ritor1
parents:
diff changeset
913 v10 = pActors[i].uActorHeight / 2 + pActors[i].vPosition.z - this->vVelocity.y;
Ritor1
parents:
diff changeset
914
Ritor1
parents:
diff changeset
915 //.text:0046BF54 movsx eax, word ptr [esi-8]
Ritor1
parents:
diff changeset
916 //.text:0046BF5A add eax, 100h
Ritor1
parents:
diff changeset
917 //.text:0046BF63 mov ecx, eax
Ritor1
parents:
diff changeset
918 //v11 = this->vVelocity.x;
Ritor1
parents:
diff changeset
919
Ritor1
parents:
diff changeset
920 //.text:0046BF5F fmul st, st(1)
Ritor1
parents:
diff changeset
921 // stack: v10*v10, v10, v9, v7
Ritor1
parents:
diff changeset
922 //.text:0046BF61 fld st(2)
Ritor1
parents:
diff changeset
923 // stack: v7, v10*v10, v10, v9, v7
Ritor1
parents:
diff changeset
924
Ritor1
parents:
diff changeset
925
Ritor1
parents:
diff changeset
926 //.text:0046BF65 fmul st, st(3)
Ritor1
parents:
diff changeset
927 // stack: v7*v9, v10*v10, v10, v9, v7
Ritor1
parents:
diff changeset
928
Ritor1
parents:
diff changeset
929 //.text:0046BF67 imul ecx, eax
Ritor1
parents:
diff changeset
930 v11 = this->vVelocity.x * this->vVelocity.x;
Ritor1
parents:
diff changeset
931
Ritor1
parents:
diff changeset
932 //.text:0046BF6A faddp st(1), st
Ritor1
parents:
diff changeset
933 // stack: v10*v10+v7*v9, v10, v9, v7
Ritor1
parents:
diff changeset
934 //.text:0046BF6C fld st(3)
Ritor1
parents:
diff changeset
935 // stack: v7, v10*v10+v7*v9, v10, v9, v7
Ritor1
parents:
diff changeset
936 //.text:0046BF6E fmul st, st(4)
Ritor1
parents:
diff changeset
937 // stack: v7*v7, v10*v10+v7*v9, v10, v9, v7
Ritor1
parents:
diff changeset
938 //.text:0046BF70 faddp st(1), st
Ritor1
parents:
diff changeset
939 // stack: v10*v10+v7*v9+v7*v7, v10, v9, v7
Ritor1
parents:
diff changeset
940
Ritor1
parents:
diff changeset
941 //.text:0046BF72 mov [ebp+var_8], ecx
Ritor1
parents:
diff changeset
942 //.text:0046BF75 fild [ebp+var_8]
Ritor1
parents:
diff changeset
943 // v11 pushed to stack
Ritor1
parents:
diff changeset
944
Ritor1
parents:
diff changeset
945 //.text:0046BF78 fcompp
Ritor1
parents:
diff changeset
946 // if ( v11 > v10*v10+v7*v9+v7*v7 )
Ritor1
parents:
diff changeset
947 // stack: v10, v9, v7
Ritor1
parents:
diff changeset
948
Ritor1
parents:
diff changeset
949 //.text:0046BF7A fstp st
Ritor1
parents:
diff changeset
950 // stack: v9, v7
Ritor1
parents:
diff changeset
951
Ritor1
parents:
diff changeset
952 //.text:0046BF7C fnstsw ax
Ritor1
parents:
diff changeset
953 //.text:0046BF7E fstp st
Ritor1
parents:
diff changeset
954 // stack: v7
Ritor1
parents:
diff changeset
955
Ritor1
parents:
diff changeset
956 //.text:0046BF80 test ah, 41h
Ritor1
parents:
diff changeset
957 //.text:0046BF83 fstp st
Ritor1
parents:
diff changeset
958 //.text:0046BF85 jnz short loc_46BFDD
Ritor1
parents:
diff changeset
959
Ritor1
parents:
diff changeset
960 if ( v11 >= v7 * v7 + v9 * v9 + v10 * v10 )
Ritor1
parents:
diff changeset
961 {
Ritor1
parents:
diff changeset
962 if ( pActors[i].DoesDmgTypeDoDamage((DAMAGE_TYPE)0xAu) )
Ritor1
parents:
diff changeset
963 {
Ritor1
parents:
diff changeset
964 pActors[i].pActorBuffs[this->spell_id].Apply(pParty->uTimePlayed + (signed int)(signed __int64)((double)(this->spell_level << 7) * 0.033333335),
Ritor1
parents:
diff changeset
965 this->spell_skill, 4, 0, 0);
Ritor1
parents:
diff changeset
966 HIWORD(pActors[i].uAttributes) |= 8;
Ritor1
parents:
diff changeset
967 }
Ritor1
parents:
diff changeset
968 }
Ritor1
parents:
diff changeset
969 }
Ritor1
parents:
diff changeset
970 }
Ritor1
parents:
diff changeset
971 }
Ritor1
parents:
diff changeset
972 }
Ritor1
parents:
diff changeset
973
Ritor1
parents:
diff changeset
974
Ritor1
parents:
diff changeset
975 //----- (0042F7EB) --------------------------------------------------------
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
976 bool SpriteObject::sub_42F7EB_DropItemAt(SPRITE_OBJECT_TYPE sprite, int x, int y, int z, int a4, int count, int a7, unsigned __int16 attributes, ItemGen *a9)
2498
Ritor1
parents:
diff changeset
977 {
Ritor1
parents:
diff changeset
978 unsigned __int16 pObjectDescID; // ax@7
Ritor1
parents:
diff changeset
979 SpriteObject pSpellObject; // [sp+Ch] [bp-78h]@1
Ritor1
parents:
diff changeset
980
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
981 pSpellObject.containing_item.Reset();
2498
Ritor1
parents:
diff changeset
982 if ( a9 )
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
983 memcpy(&pSpellObject.containing_item, a9, sizeof(pSpellObject.containing_item));
2498
Ritor1
parents:
diff changeset
984 pSpellObject.spell_skill = 0;
Ritor1
parents:
diff changeset
985 pSpellObject.spell_level = 0;
Ritor1
parents:
diff changeset
986 pSpellObject.spell_id = 0;
Ritor1
parents:
diff changeset
987 pSpellObject.field_54 = 0;
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
988 pSpellObject.uType = sprite;
2498
Ritor1
parents:
diff changeset
989 pObjectDescID = 0;
Ritor1
parents:
diff changeset
990 for ( uint i = 0; i < (signed int)pObjectList->uNumObjects; ++i )
Ritor1
parents:
diff changeset
991 {
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
992 if (sprite == pObjectList->pObjects[i].uObjectID)
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
993 pObjectDescID = i;
2498
Ritor1
parents:
diff changeset
994 }
Ritor1
parents:
diff changeset
995 pSpellObject.uObjectDescID = pObjectDescID;
Ritor1
parents:
diff changeset
996 pSpellObject.vPosition.x = x;
Ritor1
parents:
diff changeset
997 pSpellObject.vPosition.y = y;
Ritor1
parents:
diff changeset
998 pSpellObject.vPosition.z = z;
Ritor1
parents:
diff changeset
999 pSpellObject.uSoundID = 0;
Ritor1
parents:
diff changeset
1000 pSpellObject.uAttributes = attributes;
Ritor1
parents:
diff changeset
1001 pSpellObject.uSectorID = pIndoor->GetSector(x, y, z);
Ritor1
parents:
diff changeset
1002 pSpellObject.uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1003 pSpellObject.spell_caster_pid = 0;
Ritor1
parents:
diff changeset
1004 pSpellObject.spell_target_pid = 0;
Ritor1
parents:
diff changeset
1005 if ( !(pSpellObject.uAttributes & 0x10) )
Ritor1
parents:
diff changeset
1006 {
Ritor1
parents:
diff changeset
1007 if ( pItemsTable->uAllItemsCount )
Ritor1
parents:
diff changeset
1008 {
Ritor1
parents:
diff changeset
1009 for ( uint i = 1; i < pItemsTable->uAllItemsCount; ++i )
Ritor1
parents:
diff changeset
1010 {
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1011 if (pItemsTable->pItems[i].uSpriteID == sprite)
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1012 pSpellObject.containing_item.uItemID = i;
2498
Ritor1
parents:
diff changeset
1013 }
Ritor1
parents:
diff changeset
1014 }
Ritor1
parents:
diff changeset
1015 }
Ritor1
parents:
diff changeset
1016 if ( a7 )
Ritor1
parents:
diff changeset
1017 {
Ritor1
parents:
diff changeset
1018 if ( count > 0 )
Ritor1
parents:
diff changeset
1019 {
Ritor1
parents:
diff changeset
1020 for ( uint i = count; i; --i )
Ritor1
parents:
diff changeset
1021 {
Ritor1
parents:
diff changeset
1022 pSpellObject.uFacing = rand() % (signed int)stru_5C6E00->uIntegerDoublePi;
Ritor1
parents:
diff changeset
1023 pSpellObject.Create((signed __int16)pSpellObject.uFacing,
Ritor1
parents:
diff changeset
1024 ((signed int)stru_5C6E00->uIntegerHalfPi / 2) + (rand() % ((signed int)stru_5C6E00->uIntegerHalfPi / 2)), a4, 0);
Ritor1
parents:
diff changeset
1025
Ritor1
parents:
diff changeset
1026 }
Ritor1
parents:
diff changeset
1027 }
Ritor1
parents:
diff changeset
1028 }
Ritor1
parents:
diff changeset
1029 else
Ritor1
parents:
diff changeset
1030 {
Ritor1
parents:
diff changeset
1031 pSpellObject.uFacing = 0;
Ritor1
parents:
diff changeset
1032 if ( count > 0 )
Ritor1
parents:
diff changeset
1033 {
Ritor1
parents:
diff changeset
1034 for ( uint i = count; i; --i )
Ritor1
parents:
diff changeset
1035 {
Ritor1
parents:
diff changeset
1036 pSpellObject.Create((signed __int16)pSpellObject.uFacing, stru_5C6E00->uIntegerHalfPi, a4, 0);
Ritor1
parents:
diff changeset
1037 }
Ritor1
parents:
diff changeset
1038 }
Ritor1
parents:
diff changeset
1039 }
Ritor1
parents:
diff changeset
1040 return true;
Ritor1
parents:
diff changeset
1041 }
Ritor1
parents:
diff changeset
1042
Ritor1
parents:
diff changeset
1043 //----- (0042F960) --------------------------------------------------------
Ritor1
parents:
diff changeset
1044 void SpriteObject::sub_42F960_create_object(int x, int y, int z)
Ritor1
parents:
diff changeset
1045 {
Ritor1
parents:
diff changeset
1046 unsigned __int16 v7; // ax@5
Ritor1
parents:
diff changeset
1047 signed int v8; // eax@6
Ritor1
parents:
diff changeset
1048 signed int v9; // eax@7
Ritor1
parents:
diff changeset
1049
Ritor1
parents:
diff changeset
1050 SpriteObject a1; // [sp+Ch] [bp-70h]@1
Ritor1
parents:
diff changeset
1051 //SpriteObject::SpriteObject(&a1);
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1052 a1.containing_item.Reset();
2498
Ritor1
parents:
diff changeset
1053
Ritor1
parents:
diff changeset
1054 a1.spell_skill = 0;
Ritor1
parents:
diff changeset
1055 a1.spell_level = 0;
Ritor1
parents:
diff changeset
1056 a1.spell_id = 0;
Ritor1
parents:
diff changeset
1057 a1.field_54 = 0;
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1058 a1.uType = SPRITE_800;
2498
Ritor1
parents:
diff changeset
1059 v7 = 0;
Ritor1
parents:
diff changeset
1060 for ( uint i = 0; i < (signed int)pObjectList->uNumObjects; ++i )
Ritor1
parents:
diff changeset
1061 {
Ritor1
parents:
diff changeset
1062 if ( a1.uType == pObjectList->pObjects[i].uObjectID )
Ritor1
parents:
diff changeset
1063 v7 = i;
Ritor1
parents:
diff changeset
1064 }
Ritor1
parents:
diff changeset
1065 a1.uObjectDescID = v7;
Ritor1
parents:
diff changeset
1066 a1.vPosition.x = x;
Ritor1
parents:
diff changeset
1067 a1.vPosition.y = y;
Ritor1
parents:
diff changeset
1068 a1.vPosition.z = z;
Ritor1
parents:
diff changeset
1069 a1.uSoundID = 0;
Ritor1
parents:
diff changeset
1070 a1.uAttributes = 0;
Ritor1
parents:
diff changeset
1071 a1.uSectorID = pIndoor->GetSector(x, y, z);
Ritor1
parents:
diff changeset
1072 a1.uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1073 a1.spell_caster_pid = 0;
Ritor1
parents:
diff changeset
1074 a1.spell_target_pid = 0;
Ritor1
parents:
diff changeset
1075 v8 = a1.Create(0, 0, 0, 0);
Ritor1
parents:
diff changeset
1076 if ( v8 != -1 )
Ritor1
parents:
diff changeset
1077 {
Ritor1
parents:
diff changeset
1078 v9 = 8 * v8;
Ritor1
parents:
diff changeset
1079 LOBYTE(v9) = v9 | 2;
2534
1bcadc6dd203 enum SOUND_
Ritor1
parents: 2506
diff changeset
1080 pAudioPlayer->PlaySound((SoundID)SOUND_splash, v9, 0, -1, 0, 0, 0, 0);
2498
Ritor1
parents:
diff changeset
1081 }
Ritor1
parents:
diff changeset
1082 }
Ritor1
parents:
diff changeset
1083
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1084
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1085
2498
Ritor1
parents:
diff changeset
1086 //----- (0046BFFA) --------------------------------------------------------
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1087 bool __fastcall _46BFFA_update_spell_fx(unsigned int uLayingItemID, signed int a2)
2498
Ritor1
parents:
diff changeset
1088 {
Ritor1
parents:
diff changeset
1089 ObjectDesc *object; // ebx@1
Ritor1
parents:
diff changeset
1090 unsigned int v8; // eax@19
Ritor1
parents:
diff changeset
1091 signed int v10; // ebx@19
Ritor1
parents:
diff changeset
1092 char *v11; // edx@20
Ritor1
parents:
diff changeset
1093 unsigned __int16 v12; // ax@23
Ritor1
parents:
diff changeset
1094 int v13; // eax@27
Ritor1
parents:
diff changeset
1095 int v16; // eax@36
Ritor1
parents:
diff changeset
1096 __int16 v18; // di@37
Ritor1
parents:
diff changeset
1097 signed int v19; // edx@37
Ritor1
parents:
diff changeset
1098 unsigned __int16 v22; // ax@41
Ritor1
parents:
diff changeset
1099 signed int v24; // ebx@46
Ritor1
parents:
diff changeset
1100 char *v25; // edx@47
Ritor1
parents:
diff changeset
1101 signed int v34; // edx@65
Ritor1
parents:
diff changeset
1102 unsigned __int16 v36; // ax@69
Ritor1
parents:
diff changeset
1103 int v37; // ST14_4@72
Ritor1
parents:
diff changeset
1104 int v38; // eax@72
Ritor1
parents:
diff changeset
1105 int v39; // ST10_4@72
Ritor1
parents:
diff changeset
1106 int v40; // ST0C_4@72
Ritor1
parents:
diff changeset
1107 unsigned __int8 v44; // zf@79
Ritor1
parents:
diff changeset
1108 int v47; // eax@81
Ritor1
parents:
diff changeset
1109 signed int v52; // ebx@93
Ritor1
parents:
diff changeset
1110 signed int v56; // ebx@98
Ritor1
parents:
diff changeset
1111 unsigned __int16 v58; // ax@102
Ritor1
parents:
diff changeset
1112 unsigned __int16 v59; // ax@107
Ritor1
parents:
diff changeset
1113 signed int v61; // ebx@107
Ritor1
parents:
diff changeset
1114 unsigned __int16 v63; // ax@111
Ritor1
parents:
diff changeset
1115 int v64; // ebx@114
Ritor1
parents:
diff changeset
1116 signed int v65; // eax@114
Ritor1
parents:
diff changeset
1117 signed int v69; // ebx@124
Ritor1
parents:
diff changeset
1118 unsigned __int16 v71; // ax@128
Ritor1
parents:
diff changeset
1119 unsigned int v72; // ebx@131
Ritor1
parents:
diff changeset
1120 int v78; // eax@133
Ritor1
parents:
diff changeset
1121 signed int v81; // edx@140
Ritor1
parents:
diff changeset
1122 unsigned __int16 v83; // ax@144
Ritor1
parents:
diff changeset
1123 signed int v86; // ebx@151
Ritor1
parents:
diff changeset
1124 unsigned __int16 v88; // ax@155
Ritor1
parents:
diff changeset
1125 unsigned int v89; // eax@158
Ritor1
parents:
diff changeset
1126 int v90; // ST34_4@159
Ritor1
parents:
diff changeset
1127 int v91; // eax@159
Ritor1
parents:
diff changeset
1128 unsigned int v92; // eax@163
Ritor1
parents:
diff changeset
1129 unsigned __int16 v95; // ax@181
Ritor1
parents:
diff changeset
1130 unsigned __int16 v96; // ax@184
Ritor1
parents:
diff changeset
1131 int v97; // eax@185
Ritor1
parents:
diff changeset
1132 char v100; // ST18_1@198
Ritor1
parents:
diff changeset
1133 int v102; // eax@198
Ritor1
parents:
diff changeset
1134 signed int v106; // eax@208
Ritor1
parents:
diff changeset
1135 unsigned int v107; // edx@220
Ritor1
parents:
diff changeset
1136 signed int v108; // ebx@225
Ritor1
parents:
diff changeset
1137 signed int v110; // ebx@234
Ritor1
parents:
diff changeset
1138 unsigned __int16 v112; // ax@238
Ritor1
parents:
diff changeset
1139 unsigned __int16 v113; // si@241
Ritor1
parents:
diff changeset
1140 int v114; // eax@242
Ritor1
parents:
diff changeset
1141 int v115; // eax@245
Ritor1
parents:
diff changeset
1142 signed int v119; // ebx@251
Ritor1
parents:
diff changeset
1143 unsigned __int16 v121; // ax@255
Ritor1
parents:
diff changeset
1144 int v124; // eax@267
Ritor1
parents:
diff changeset
1145 int v125; // [sp-20h] [bp-4Ch]@28
Ritor1
parents:
diff changeset
1146 char v132; // [sp-8h] [bp-34h]@131
Ritor1
parents:
diff changeset
1147 char v134; // [sp-4h] [bp-30h]@131
Ritor1
parents:
diff changeset
1148 signed int v135; // [sp-4h] [bp-30h]@217
Ritor1
parents:
diff changeset
1149 int v136; // [sp+Ch] [bp-20h]@208
Ritor1
parents:
diff changeset
1150 int v137; // [sp+10h] [bp-1Ch]@208
Ritor1
parents:
diff changeset
1151 signed int v138; // [sp+14h] [bp-18h]@207
Ritor1
parents:
diff changeset
1152 signed int v139; // [sp+18h] [bp-14h]@208
Ritor1
parents:
diff changeset
1153 signed int v141; // [sp+1Ch] [bp-10h]@117
Ritor1
parents:
diff changeset
1154 unsigned int v142; // [sp+1Ch] [bp-10h]@158
Ritor1
parents:
diff changeset
1155 signed int v143; // [sp+1Ch] [bp-10h]@172
Ritor1
parents:
diff changeset
1156 signed int v146; // [sp+20h] [bp-Ch]@60
Ritor1
parents:
diff changeset
1157 int v147; // [sp+20h] [bp-Ch]@72
Ritor1
parents:
diff changeset
1158 signed int v148; // [sp+20h] [bp-Ch]@158
Ritor1
parents:
diff changeset
1159 unsigned __int16 v150; // [sp+20h] [bp-Ch]@208
Ritor1
parents:
diff changeset
1160 signed int v152; // [sp+24h] [bp-8h]@208
Ritor1
parents:
diff changeset
1161
Ritor1
parents:
diff changeset
1162 object = &pObjectList->pObjects[pSpriteObjects[uLayingItemID].uObjectDescID];
Ritor1
parents:
diff changeset
1163 //v151 = PID_TYPE(a2);
Ritor1
parents:
diff changeset
1164 if (PID_TYPE(a2) == OBJECT_Actor)
Ritor1
parents:
diff changeset
1165 {
Ritor1
parents:
diff changeset
1166 if (PID_TYPE(pSpriteObjects[uLayingItemID].spell_caster_pid) == OBJECT_Actor
Ritor1
parents:
diff changeset
1167 && !pActors[PID_ID(pSpriteObjects[uLayingItemID].spell_caster_pid)].GetActorsRelation(&pActors[PID_ID(a2)]))
Ritor1
parents:
diff changeset
1168 return 1;
Ritor1
parents:
diff changeset
1169 }
Ritor1
parents:
diff changeset
1170 else
Ritor1
parents:
diff changeset
1171 {
Ritor1
parents:
diff changeset
1172 if (PID_TYPE(a2) == OBJECT_Player && PID_TYPE(pSpriteObjects[uLayingItemID].spell_caster_pid) == OBJECT_Player)
Ritor1
parents:
diff changeset
1173 return 1;
Ritor1
parents:
diff changeset
1174 }
Ritor1
parents:
diff changeset
1175 if (pParty->bTurnBasedModeOn == 1)
Ritor1
parents:
diff changeset
1176 {
Ritor1
parents:
diff changeset
1177 if (pSpriteObjects[uLayingItemID].uAttributes & 4)
Ritor1
parents:
diff changeset
1178 {
Ritor1
parents:
diff changeset
1179 --pTurnEngine->pending_actions;
Ritor1
parents:
diff changeset
1180 pSpriteObjects[uLayingItemID].uAttributes &= 0xFFFB;//~0x00000004
Ritor1
parents:
diff changeset
1181 }
Ritor1
parents:
diff changeset
1182 }
Ritor1
parents:
diff changeset
1183 if (PID_TYPE(a2) == OBJECT_BModel && PID_TYPE(pSpriteObjects[uLayingItemID].spell_caster_pid) != OBJECT_Player)
Ritor1
parents:
diff changeset
1184 {
Ritor1
parents:
diff changeset
1185 if (PID_ID(pSpriteObjects[uLayingItemID].spell_caster_pid) < 500) //bugfix PID_ID(v2->spell_caster_pid)==1000
Ritor1
parents:
diff changeset
1186 pActors[PID_ID(pSpriteObjects[uLayingItemID].spell_caster_pid)].uAttributes |= ACTOR_UNKNOW5;
Ritor1
parents:
diff changeset
1187 }
Ritor1
parents:
diff changeset
1188
Ritor1
parents:
diff changeset
1189 //v6 = v2->uType;
Ritor1
parents:
diff changeset
1190 //v7 = v2->uType;
Ritor1
parents:
diff changeset
1191
Ritor1
parents:
diff changeset
1192 switch (pSpriteObjects[uLayingItemID].uType)
Ritor1
parents:
diff changeset
1193 {
Ritor1
parents:
diff changeset
1194
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1195 case SPRITE_SPELL_FIRE_FIRE_SPIKE:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1196 case SPRITE_SPELL_AIR_SPARKS:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1197 case SPRITE_SPELL_DARK_TOXIC_CLOUD:
2498
Ritor1
parents:
diff changeset
1198 {
Ritor1
parents:
diff changeset
1199 //v9 = 0;
Ritor1
parents:
diff changeset
1200 if (PID_TYPE(a2) == 6 || PID_TYPE(a2) == 5 || !PID_TYPE(a2))
Ritor1
parents:
diff changeset
1201 return 1;
Ritor1
parents:
diff changeset
1202 if (PID_TYPE(a2) != 2)
Ritor1
parents:
diff changeset
1203 {
Ritor1
parents:
diff changeset
1204 sub_43A97E(uLayingItemID, a2);
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1205 pSpriteObjects[uLayingItemID].uType = (SPRITE_OBJECT_TYPE)(pSpriteObjects[uLayingItemID].uType + 1);
2498
Ritor1
parents:
diff changeset
1206 v95 = 0;
Ritor1
parents:
diff changeset
1207 for (v52 = 0; v52 < (signed int)pObjectList->uNumObjects; ++v52)
Ritor1
parents:
diff changeset
1208 {
Ritor1
parents:
diff changeset
1209 if (pSpriteObjects[uLayingItemID].uType == pObjectList->pObjects[v52].uObjectID)
Ritor1
parents:
diff changeset
1210 v95 = v52;
Ritor1
parents:
diff changeset
1211 }
Ritor1
parents:
diff changeset
1212 pSpriteObjects[uLayingItemID].uObjectDescID = v95;
Ritor1
parents:
diff changeset
1213 if (!v95)
Ritor1
parents:
diff changeset
1214 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1215 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1216 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1217 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1218 pSpriteObjects[uLayingItemID].uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1219 if (!pSpriteObjects[uLayingItemID].uSoundID)
Ritor1
parents:
diff changeset
1220 v97 = 0;
Ritor1
parents:
diff changeset
1221 else
Ritor1
parents:
diff changeset
1222 v97 = (signed __int16)pSpriteObjects[uLayingItemID].uSoundID + 4;
Ritor1
parents:
diff changeset
1223 v124 = 8 * uLayingItemID;
Ritor1
parents:
diff changeset
1224 LOBYTE(v124) = v124 | 2;
Ritor1
parents:
diff changeset
1225 v125 = word_4EE088_sound_ids[pSpriteObjects[uLayingItemID].spell_id - 1] + 1;
Ritor1
parents:
diff changeset
1226 pAudioPlayer->PlaySound((SoundID)v125, v124, 0, -1, 0, v97, 0, 0);
Ritor1
parents:
diff changeset
1227 return 0;
Ritor1
parents:
diff changeset
1228 }
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1229 pSpriteObjects[uLayingItemID].uType = (SPRITE_OBJECT_TYPE)(pSpriteObjects[uLayingItemID].uType + 1);
2498
Ritor1
parents:
diff changeset
1230 v121 = 0;
Ritor1
parents:
diff changeset
1231 for (v119 = 0; v119 < (signed int)pObjectList->uNumObjects; ++v119)
Ritor1
parents:
diff changeset
1232 {
Ritor1
parents:
diff changeset
1233 if (pSpriteObjects[uLayingItemID].uType == pObjectList->pObjects[v119].uObjectID)
Ritor1
parents:
diff changeset
1234 v121 = v119;
Ritor1
parents:
diff changeset
1235 }
Ritor1
parents:
diff changeset
1236 pSpriteObjects[uLayingItemID].uObjectDescID = v121;
Ritor1
parents:
diff changeset
1237 if (!v121)
Ritor1
parents:
diff changeset
1238 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1239 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1240 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1241 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1242 pSpriteObjects[uLayingItemID].uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1243 v13 = 8 * uLayingItemID;
Ritor1
parents:
diff changeset
1244 LOBYTE(v13) = PID(OBJECT_Item, uLayingItemID);
2534
1bcadc6dd203 enum SOUND_
Ritor1
parents: 2506
diff changeset
1245 pAudioPlayer->PlaySound(SOUND_fireBall, v13, 0, -1, 0, 0, 0, 0);
2498
Ritor1
parents:
diff changeset
1246 return 0;
Ritor1
parents:
diff changeset
1247 }
Ritor1
parents:
diff changeset
1248
Ritor1
parents:
diff changeset
1249
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1250 case SPRITE_PROJECTILE_500:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1251 case SPRITE_PROJECTILE_505:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1252 case SPRITE_PROJECTILE_510:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1253 case SPRITE_PROJECTILE_515:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1254 case SPRITE_PROJECTILE_520:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1255 case SPRITE_PROJECTILE_525:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1256 case SPRITE_PROJECTILE_530:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1257 case SPRITE_PROJECTILE_535:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1258 case SPRITE_PROJECTILE_540:
2498
Ritor1
parents:
diff changeset
1259 {
Ritor1
parents:
diff changeset
1260 sub_43A97E(uLayingItemID, a2);
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1261 pSpriteObjects[uLayingItemID].uType = (SPRITE_OBJECT_TYPE)(pSpriteObjects[uLayingItemID].uType + 1);
2498
Ritor1
parents:
diff changeset
1262 v12 = 0;
Ritor1
parents:
diff changeset
1263 for (v10 = 0; v10 < (signed int)pObjectList->uNumObjects; ++v10)
Ritor1
parents:
diff changeset
1264 {
Ritor1
parents:
diff changeset
1265 if (pSpriteObjects[uLayingItemID].uType == pObjectList->pObjects[v10].uObjectID)
Ritor1
parents:
diff changeset
1266 v12 = v10;
Ritor1
parents:
diff changeset
1267 }
Ritor1
parents:
diff changeset
1268 pSpriteObjects[uLayingItemID].uObjectDescID = v12;
Ritor1
parents:
diff changeset
1269 if (!v12)
Ritor1
parents:
diff changeset
1270 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1271 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1272 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1273 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1274 pSpriteObjects[uLayingItemID].uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1275 if (pSpriteObjects[uLayingItemID].uType == 555)
Ritor1
parents:
diff changeset
1276 {
Ritor1
parents:
diff changeset
1277 v13 = 8 * uLayingItemID;
Ritor1
parents:
diff changeset
1278 LOBYTE(v13) = PID(OBJECT_Item, uLayingItemID);
2534
1bcadc6dd203 enum SOUND_
Ritor1
parents: 2506
diff changeset
1279 pAudioPlayer->PlaySound(SOUND_fireBall, v13, 0, -1, 0, 0, 0, 0);
2498
Ritor1
parents:
diff changeset
1280 }
Ritor1
parents:
diff changeset
1281 return 0;
Ritor1
parents:
diff changeset
1282 }
Ritor1
parents:
diff changeset
1283
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1284 case SPRITE_PROJECTILE_545:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1285 case SPRITE_PROJECTILE_550:
2498
Ritor1
parents:
diff changeset
1286 {
2567
d569340b05ff Few constants changed into enum values
a.parshin
parents: 2566
diff changeset
1287 if (pSpriteObjects[uLayingItemID].containing_item.uItemID != 405 && pSpriteObjects[uLayingItemID].containing_item.special_enchantment != 3)
2498
Ritor1
parents:
diff changeset
1288 {
Ritor1
parents:
diff changeset
1289 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1290 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1291 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1292 pSpriteObjects[uLayingItemID].uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1293 sub_43A97E(uLayingItemID, a2);
Ritor1
parents:
diff changeset
1294 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1295 if (pSpriteObjects[uLayingItemID].uSoundID == 0)
Ritor1
parents:
diff changeset
1296 v16 = 0;
Ritor1
parents:
diff changeset
1297 else
Ritor1
parents:
diff changeset
1298 v16 = (signed __int16)pSpriteObjects[uLayingItemID].uSoundID + 4;
Ritor1
parents:
diff changeset
1299 v124 = 8 * uLayingItemID;
Ritor1
parents:
diff changeset
1300 LOBYTE(v124) = v124 | 2;
Ritor1
parents:
diff changeset
1301 v125 = word_4EE088_sound_ids[pSpriteObjects[uLayingItemID].spell_id] + 1;
Ritor1
parents:
diff changeset
1302 pAudioPlayer->PlaySound((SoundID)v125, v124, 0, -1, 0, v16, 0, 0);
Ritor1
parents:
diff changeset
1303 return 0;
Ritor1
parents:
diff changeset
1304 }
Ritor1
parents:
diff changeset
1305 v18 = 0;
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1306 pSpriteObjects[uLayingItemID].uType = SPRITE_600;
2498
Ritor1
parents:
diff changeset
1307 v22 = 0;
Ritor1
parents:
diff changeset
1308 for (v19 = 0; v19 < (signed int)pObjectList->uNumObjects; ++v19)
Ritor1
parents:
diff changeset
1309 {
Ritor1
parents:
diff changeset
1310 if (pSpriteObjects[uLayingItemID].uType == pObjectList->pObjects[v19].uObjectID)
Ritor1
parents:
diff changeset
1311 v22 = v19;
Ritor1
parents:
diff changeset
1312 }
Ritor1
parents:
diff changeset
1313 pSpriteObjects[uLayingItemID].uObjectDescID = v22;
Ritor1
parents:
diff changeset
1314 if (!v22)
Ritor1
parents:
diff changeset
1315 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1316 pSpriteObjects[uLayingItemID].vVelocity.z = v18;
Ritor1
parents:
diff changeset
1317 pSpriteObjects[uLayingItemID].vVelocity.y = v18;
Ritor1
parents:
diff changeset
1318 pSpriteObjects[uLayingItemID].vVelocity.x = v18;
Ritor1
parents:
diff changeset
1319 pSpriteObjects[uLayingItemID].uSpriteFrameID = v18;
Ritor1
parents:
diff changeset
1320 v12 = 0;
Ritor1
parents:
diff changeset
1321 for (v10; v10 < (signed int)v8; ++v10)
Ritor1
parents:
diff changeset
1322 {
Ritor1
parents:
diff changeset
1323 v11 += 56;
Ritor1
parents:
diff changeset
1324 if (pSpriteObjects[uLayingItemID].uType != *(short *)v11)
Ritor1
parents:
diff changeset
1325 v12 = v10;
Ritor1
parents:
diff changeset
1326 }
Ritor1
parents:
diff changeset
1327 pSpriteObjects[uLayingItemID].uObjectDescID = v12;
Ritor1
parents:
diff changeset
1328 if (!v12)
Ritor1
parents:
diff changeset
1329 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1330 v44 = pSpriteObjects[uLayingItemID].uType == 555;
Ritor1
parents:
diff changeset
1331 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1332 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1333 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1334 pSpriteObjects[uLayingItemID].uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1335 if (!v44)
Ritor1
parents:
diff changeset
1336 {
Ritor1
parents:
diff changeset
1337 v13 = 8 * uLayingItemID;
Ritor1
parents:
diff changeset
1338 LOBYTE(v13) = PID(OBJECT_Item, uLayingItemID);
2534
1bcadc6dd203 enum SOUND_
Ritor1
parents: 2506
diff changeset
1339 pAudioPlayer->PlaySound(SOUND_fireBall, v13, 0, -1, 0, 0, 0, 0);
2498
Ritor1
parents:
diff changeset
1340 return 0;
Ritor1
parents:
diff changeset
1341 }
Ritor1
parents:
diff changeset
1342 return 0;
Ritor1
parents:
diff changeset
1343 }
Ritor1
parents:
diff changeset
1344
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1345 case SPRITE_600:
2498
Ritor1
parents:
diff changeset
1346 {
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1347 pSpriteObjects[uLayingItemID].uType = SPRITE_601;
2498
Ritor1
parents:
diff changeset
1348 v36 = 0;
Ritor1
parents:
diff changeset
1349 for (v34 = 0; v34 < (signed int)pObjectList->uNumObjects; ++v34)
Ritor1
parents:
diff changeset
1350 {
Ritor1
parents:
diff changeset
1351 if (pSpriteObjects[uLayingItemID].uType == pObjectList->pObjects[v34].uObjectID)
Ritor1
parents:
diff changeset
1352 v36 = v34;
Ritor1
parents:
diff changeset
1353 }
Ritor1
parents:
diff changeset
1354 pSpriteObjects[uLayingItemID].uObjectDescID = v36;
Ritor1
parents:
diff changeset
1355 if (!v36)
Ritor1
parents:
diff changeset
1356 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1357 v37 = pSpriteObjects[uLayingItemID].vPosition.z;
Ritor1
parents:
diff changeset
1358 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1359 v38 = 8 * uLayingItemID;
Ritor1
parents:
diff changeset
1360 v39 = pSpriteObjects[uLayingItemID].vPosition.y;
Ritor1
parents:
diff changeset
1361 LOBYTE(v38) = PID(OBJECT_Item, uLayingItemID);
Ritor1
parents:
diff changeset
1362 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1363 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1364 v40 = pSpriteObjects[uLayingItemID].vPosition.x;
Ritor1
parents:
diff changeset
1365 pSpriteObjects[uLayingItemID].uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1366 v147 = v38;
Ritor1
parents:
diff changeset
1367 AttackerInfo.Add(v38, 512, v40, v39, v37, 0, 0);
Ritor1
parents:
diff changeset
1368 if (object->uFlags & OBJECT_DESC_TRIAL_PARTICLE)
Ritor1
parents:
diff changeset
1369 trail_particle_generator.GenerateTrailParticles(pSpriteObjects[uLayingItemID].vPosition.x, pSpriteObjects[uLayingItemID].vPosition.y, pSpriteObjects[uLayingItemID].vPosition.z, object->uParticleTrailColor);
2534
1bcadc6dd203 enum SOUND_
Ritor1
parents: 2506
diff changeset
1370 pAudioPlayer->PlaySound(SOUND_fireBall, v147, 0, -1, 0, 0, 0, 0);
2498
Ritor1
parents:
diff changeset
1371 return 0;
Ritor1
parents:
diff changeset
1372 }
Ritor1
parents:
diff changeset
1373
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1374 case SPRITE_SPELL_FIRE_FIRE_BOLT:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1375 case SPRITE_SPELL_FIRE_INCINERATE:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1376 case SPRITE_SPELL_AIR_LIGHNING_BOLT:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1377 case SPRITE_SPELL_WATER_POISON_SPRAY:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1378 case SPRITE_SPELL_WATER_ICE_BOLT:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1379 case SPRITE_SPELL_WATER_ACID_BURST:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1380 case SPRITE_SPELL_EARTH_STUN:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1381 case SPRITE_SPELL_EARTH_DEADLY_SWARM:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1382 case SPRITE_SPELL_EARTH_BLADES:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1383 case SPRITE_SPELL_EARTH_MASS_DISTORTION:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1384 case SPRITE_SPELL_MIND_MIND_BLAST:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1385 case SPRITE_SPELL_MIND_PSYCHIC_SHOCK:
2498
Ritor1
parents:
diff changeset
1386 {
Ritor1
parents:
diff changeset
1387 sub_43A97E(uLayingItemID, a2);
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1388 pSpriteObjects[uLayingItemID].uType = (SPRITE_OBJECT_TYPE)(pSpriteObjects[uLayingItemID].uType + 1);
2498
Ritor1
parents:
diff changeset
1389 v95 = 0;
Ritor1
parents:
diff changeset
1390 for (v52 = 0; v52 < (signed int)pObjectList->uNumObjects; ++v52)
Ritor1
parents:
diff changeset
1391 {
Ritor1
parents:
diff changeset
1392 if (pSpriteObjects[uLayingItemID].uType == pObjectList->pObjects[v52].uObjectID)
Ritor1
parents:
diff changeset
1393 v95 = v52;
Ritor1
parents:
diff changeset
1394 }
Ritor1
parents:
diff changeset
1395 pSpriteObjects[uLayingItemID].uObjectDescID = v95;
Ritor1
parents:
diff changeset
1396 if (!v95)
Ritor1
parents:
diff changeset
1397 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1398 v96 = pSpriteObjects[uLayingItemID].uSoundID;
Ritor1
parents:
diff changeset
1399 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1400 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1401 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1402 pSpriteObjects[uLayingItemID].uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1403 if (!v96)
Ritor1
parents:
diff changeset
1404 v97 = 0;
Ritor1
parents:
diff changeset
1405 else
Ritor1
parents:
diff changeset
1406 v97 = (signed __int16)v96 + 4;
Ritor1
parents:
diff changeset
1407 v124 = 8 * uLayingItemID;
Ritor1
parents:
diff changeset
1408 LOBYTE(v124) = v124 | 2;
Ritor1
parents:
diff changeset
1409 v125 = word_4EE088_sound_ids[pSpriteObjects[uLayingItemID].spell_id - 1] + 1;
Ritor1
parents:
diff changeset
1410 pAudioPlayer->PlaySound((SoundID)v125, v124, 0, -1, 0, v97, 0, 0);
Ritor1
parents:
diff changeset
1411 return 0;
Ritor1
parents:
diff changeset
1412 }
Ritor1
parents:
diff changeset
1413
Ritor1
parents:
diff changeset
1414
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1415 case SPRITE_PROJECTILE_555:
2498
Ritor1
parents:
diff changeset
1416 {
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1417 sub_43A97E(uLayingItemID, a2);
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1418 pSpriteObjects[uLayingItemID].uType = SPRITE_556;
2498
Ritor1
parents:
diff changeset
1419 v18 = 0;
Ritor1
parents:
diff changeset
1420 v22 = 0;
Ritor1
parents:
diff changeset
1421 v25 = (char *)&pObjectList->pObjects->uObjectID;
Ritor1
parents:
diff changeset
1422 for (v24 = 0; v24 < (signed int)pObjectList->uNumObjects; ++v24)
Ritor1
parents:
diff changeset
1423 {
Ritor1
parents:
diff changeset
1424 if (pSpriteObjects[uLayingItemID].uType == pObjectList->pObjects[v24].uObjectID)
Ritor1
parents:
diff changeset
1425 v22 = v24;
Ritor1
parents:
diff changeset
1426 }
Ritor1
parents:
diff changeset
1427 pSpriteObjects[uLayingItemID].uObjectDescID = v22;
Ritor1
parents:
diff changeset
1428 if (v22 == v18)
Ritor1
parents:
diff changeset
1429 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1430 pSpriteObjects[uLayingItemID].vVelocity.z = v18;
Ritor1
parents:
diff changeset
1431 pSpriteObjects[uLayingItemID].vVelocity.y = v18;
Ritor1
parents:
diff changeset
1432 pSpriteObjects[uLayingItemID].vVelocity.x = v18;
Ritor1
parents:
diff changeset
1433 pSpriteObjects[uLayingItemID].uSpriteFrameID = v18;
Ritor1
parents:
diff changeset
1434 return 0;
Ritor1
parents:
diff changeset
1435 }
Ritor1
parents:
diff changeset
1436
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1437 case SPRITE_SPELL_WATER_ICE_BLAST:
2498
Ritor1
parents:
diff changeset
1438 {
Ritor1
parents:
diff changeset
1439 //v9 = 0;
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1440 pSpriteObjects[uLayingItemID].uType = SPRITE_SPELL_WATER_ICE_BLAST_FALLOUT;
2498
Ritor1
parents:
diff changeset
1441 v63 = 0;
Ritor1
parents:
diff changeset
1442 for (v61 = 0; v61 < (signed int)pObjectList->uNumObjects; ++v61)
Ritor1
parents:
diff changeset
1443 {
Ritor1
parents:
diff changeset
1444 if (v59 == pObjectList->pObjects[v61].uObjectID)
Ritor1
parents:
diff changeset
1445 v63 = v61;
Ritor1
parents:
diff changeset
1446 }
Ritor1
parents:
diff changeset
1447 pSpriteObjects[uLayingItemID].uObjectDescID = v63;
Ritor1
parents:
diff changeset
1448 if (!v63)
Ritor1
parents:
diff changeset
1449 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1450 v64 = pSpriteObjects[uLayingItemID].uFacing - stru_5C6E00->uIntegerDoublePi;
Ritor1
parents:
diff changeset
1451 v44 = pSpriteObjects[uLayingItemID].spell_skill == 4;
Ritor1
parents:
diff changeset
1452 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1453 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1454 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1455 v65 = 7;
Ritor1
parents:
diff changeset
1456 if (v44)
Ritor1
parents:
diff changeset
1457 v65 = 9;
Ritor1
parents:
diff changeset
1458 if (v65 > 0)
Ritor1
parents:
diff changeset
1459 {
Ritor1
parents:
diff changeset
1460 v141 = v65;
Ritor1
parents:
diff changeset
1461 do
Ritor1
parents:
diff changeset
1462 {
Ritor1
parents:
diff changeset
1463 v64 += (signed int)stru_5C6E00->uIntegerHalfPi / 2;
Ritor1
parents:
diff changeset
1464 pSpriteObjects[uLayingItemID].Create(v64, 0, 1000, 0);
Ritor1
parents:
diff changeset
1465 --v141;
Ritor1
parents:
diff changeset
1466 } while (v141);
Ritor1
parents:
diff changeset
1467 }
Ritor1
parents:
diff changeset
1468 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1469 if (!pSpriteObjects[uLayingItemID].uSoundID)
Ritor1
parents:
diff changeset
1470 v16 = 0;
Ritor1
parents:
diff changeset
1471 else
Ritor1
parents:
diff changeset
1472 v16 = (signed __int16)pSpriteObjects[uLayingItemID].uSoundID + 4;
Ritor1
parents:
diff changeset
1473 v124 = 8 * uLayingItemID;
Ritor1
parents:
diff changeset
1474 LOBYTE(v124) = v124 | 2;
Ritor1
parents:
diff changeset
1475 v125 = word_4EE088_sound_ids[pSpriteObjects[uLayingItemID].spell_id - 1] + 1;
Ritor1
parents:
diff changeset
1476 pAudioPlayer->PlaySound((SoundID)v125, v124, 0, -1, 0, v16, 0, 0);
Ritor1
parents:
diff changeset
1477 return 0;
Ritor1
parents:
diff changeset
1478 }
Ritor1
parents:
diff changeset
1479
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1480 case SPRITE_SPELL_WATER_ICE_BLAST_FALLOUT:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1481 {
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1482 pSpriteObjects[uLayingItemID].uType = SPRITE_SPELL_WATER_ICE_BLAST_IMPACT;
2498
Ritor1
parents:
diff changeset
1483 v58 = 0;
Ritor1
parents:
diff changeset
1484 for (v56 = 0; v56 < (signed int)pObjectList->uNumObjects; ++v56)
Ritor1
parents:
diff changeset
1485 {
Ritor1
parents:
diff changeset
1486 if (pSpriteObjects[uLayingItemID].uType == pObjectList->pObjects[v56].uObjectID)
Ritor1
parents:
diff changeset
1487 v58 = v56;
Ritor1
parents:
diff changeset
1488 }
Ritor1
parents:
diff changeset
1489 pSpriteObjects[uLayingItemID].uObjectDescID = v58;
Ritor1
parents:
diff changeset
1490 if (!v58)
Ritor1
parents:
diff changeset
1491 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1492 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1493 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1494 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1495 pSpriteObjects[uLayingItemID].uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1496 sub_43A97E(uLayingItemID, a2);
Ritor1
parents:
diff changeset
1497 if (!pSpriteObjects[uLayingItemID].uSoundID)
Ritor1
parents:
diff changeset
1498 v16 = 0;
Ritor1
parents:
diff changeset
1499 else
Ritor1
parents:
diff changeset
1500 v16 = (signed __int16)pSpriteObjects[uLayingItemID].uSoundID + 4;
Ritor1
parents:
diff changeset
1501 v124 = 8 * uLayingItemID;
Ritor1
parents:
diff changeset
1502 LOBYTE(v124) = v124 | 2;
Ritor1
parents:
diff changeset
1503 v125 = word_4EE088_sound_ids[pSpriteObjects[uLayingItemID].spell_id - 1] + 1;
Ritor1
parents:
diff changeset
1504 pAudioPlayer->PlaySound((SoundID)v125, v124, 0, -1, 0, v16, 0, 0);
Ritor1
parents:
diff changeset
1505 return 0;
Ritor1
parents:
diff changeset
1506 }
Ritor1
parents:
diff changeset
1507
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1508 case SPRITE_SPELL_EARTH_ROCK_BLAST:
2498
Ritor1
parents:
diff changeset
1509 {
Ritor1
parents:
diff changeset
1510 if (PID_TYPE(a2) == 6 || PID_TYPE(a2) == 5 || !PID_TYPE(a2))
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1511 return 1;
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1512 pSpriteObjects[uLayingItemID].uType = SPRITE_SPELL_EARTH_ROCK_BLAST_IMPACT;
2498
Ritor1
parents:
diff changeset
1513 v71 = 0;
Ritor1
parents:
diff changeset
1514 for (v69 = 0; v69 < (signed int)pObjectList->uNumObjects; ++v69)
Ritor1
parents:
diff changeset
1515 {
Ritor1
parents:
diff changeset
1516 if (pSpriteObjects[uLayingItemID].uType == pObjectList->pObjects[v69].uObjectID)
Ritor1
parents:
diff changeset
1517 v71 = v69;
Ritor1
parents:
diff changeset
1518 }
Ritor1
parents:
diff changeset
1519 pSpriteObjects[uLayingItemID].uObjectDescID = v71;
Ritor1
parents:
diff changeset
1520 if (!v71)
Ritor1
parents:
diff changeset
1521 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1522 v134 = 0;
Ritor1
parents:
diff changeset
1523 v72 = uLayingItemID;
Ritor1
parents:
diff changeset
1524 v132 = 0;
Ritor1
parents:
diff changeset
1525 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1526 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1527 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1528 pSpriteObjects[uLayingItemID].uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1529 AttackerInfo.Add(PID(OBJECT_Item, v72), 512, pSpriteObjects[uLayingItemID].vPosition.x, pSpriteObjects[uLayingItemID].vPosition.y, pSpriteObjects[uLayingItemID].vPosition.z, v132, v134);
Ritor1
parents:
diff changeset
1530 if (!pSpriteObjects[uLayingItemID].uSoundID)
Ritor1
parents:
diff changeset
1531 v78 = 0;
Ritor1
parents:
diff changeset
1532 else
Ritor1
parents:
diff changeset
1533 v78 = (signed __int16)pSpriteObjects[uLayingItemID].uSoundID + 4;
Ritor1
parents:
diff changeset
1534 v125 = word_4EE088_sound_ids[pSpriteObjects[uLayingItemID].spell_id - 1] + 1;
Ritor1
parents:
diff changeset
1535 pAudioPlayer->PlaySound((SoundID)v125, pSpriteObjects[uLayingItemID].vPosition.x, 0, -1, 0, v78, 0, 0);
Ritor1
parents:
diff changeset
1536 return 0;
Ritor1
parents:
diff changeset
1537 }
Ritor1
parents:
diff changeset
1538
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1539 case SPRITE_SPELL_EARTH_DEATH_BLOSSOM:
2498
Ritor1
parents:
diff changeset
1540 {
Ritor1
parents:
diff changeset
1541 //v9 = 0;
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1542 pSpriteObjects[uLayingItemID].uType = SPRITE_SPELL_EARTH_DEATH_BLOSSOM_FALLOUT;
2498
Ritor1
parents:
diff changeset
1543 v88 = 0;
Ritor1
parents:
diff changeset
1544 for (v86 = 0; v86 < (signed int)pObjectList->uNumObjects; ++v86)
Ritor1
parents:
diff changeset
1545 {
Ritor1
parents:
diff changeset
1546 if (pSpriteObjects[uLayingItemID].uType == pObjectList->pObjects[v86].uObjectID)
Ritor1
parents:
diff changeset
1547 v88 = v86;
Ritor1
parents:
diff changeset
1548 }
Ritor1
parents:
diff changeset
1549 pSpriteObjects[uLayingItemID].uObjectDescID = v88;
Ritor1
parents:
diff changeset
1550 if (!v88)
Ritor1
parents:
diff changeset
1551 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1552 v89 = pSpriteObjects[uLayingItemID].uFacing - stru_5C6E00->uIntegerDoublePi;
Ritor1
parents:
diff changeset
1553 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1554 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1555 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1556 v142 = v89;
Ritor1
parents:
diff changeset
1557 v148 = 7;
Ritor1
parents:
diff changeset
1558 do
Ritor1
parents:
diff changeset
1559 {
Ritor1
parents:
diff changeset
1560 pRnd->SetRange(-128, 128);
Ritor1
parents:
diff changeset
1561 v90 = pRnd->GetInRange();
Ritor1
parents:
diff changeset
1562 pRnd->SetRange(5, 500);
Ritor1
parents:
diff changeset
1563 v91 = pRnd->GetInRange();
Ritor1
parents:
diff changeset
1564 v142 += (signed int)stru_5C6E00->uIntegerHalfPi >> 1;
Ritor1
parents:
diff changeset
1565 pSpriteObjects[uLayingItemID].Create(v90 + v142, 0, v91, 0);
Ritor1
parents:
diff changeset
1566 --v148;
Ritor1
parents:
diff changeset
1567 } while (v148);
Ritor1
parents:
diff changeset
1568 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1569 if (!pSpriteObjects[uLayingItemID].uSoundID)
Ritor1
parents:
diff changeset
1570 v16 = 0;
Ritor1
parents:
diff changeset
1571 else
Ritor1
parents:
diff changeset
1572 v16 = (signed __int16)pSpriteObjects[uLayingItemID].uSoundID + 4;
Ritor1
parents:
diff changeset
1573 v124 = 8 * uLayingItemID;
Ritor1
parents:
diff changeset
1574 LOBYTE(v124) = v124 | 2;
Ritor1
parents:
diff changeset
1575 v125 = word_4EE088_sound_ids[pSpriteObjects[uLayingItemID].spell_id - 1] + 1;
Ritor1
parents:
diff changeset
1576 pAudioPlayer->PlaySound((SoundID)v125, v124, 0, -1, 0, v16, 0, 0);
Ritor1
parents:
diff changeset
1577 return 0;
Ritor1
parents:
diff changeset
1578 }
Ritor1
parents:
diff changeset
1579
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1580 case SPRITE_SPELL_EARTH_DEATH_BLOSSOM_FALLOUT:
2498
Ritor1
parents:
diff changeset
1581 {
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1582 pSpriteObjects[uLayingItemID].uType = SPRITE_SPELL_EARTH_DEATH_BLOSSOM_IMPACT;
2498
Ritor1
parents:
diff changeset
1583 v83 = 0;
Ritor1
parents:
diff changeset
1584 for (v81 = 0; v81 < (signed int)pObjectList->uNumObjects; ++v81)
Ritor1
parents:
diff changeset
1585 {
Ritor1
parents:
diff changeset
1586 if (pSpriteObjects[uLayingItemID].uType == pObjectList->pObjects[v81].uObjectID)
Ritor1
parents:
diff changeset
1587 v83 = v81;
Ritor1
parents:
diff changeset
1588 }
Ritor1
parents:
diff changeset
1589 pSpriteObjects[uLayingItemID].uObjectDescID = v83;
Ritor1
parents:
diff changeset
1590 if (!v83)
Ritor1
parents:
diff changeset
1591 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1592 v134 = 0;
Ritor1
parents:
diff changeset
1593 //v72 = uLayingItemID;
Ritor1
parents:
diff changeset
1594 v132 = pSpriteObjects[uLayingItemID].field_61;
Ritor1
parents:
diff changeset
1595 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1596 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1597 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1598 pSpriteObjects[uLayingItemID].uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1599 AttackerInfo.Add(PID(OBJECT_Item, uLayingItemID), 512, pSpriteObjects[uLayingItemID].vPosition.x, pSpriteObjects[uLayingItemID].vPosition.y, pSpriteObjects[uLayingItemID].vPosition.z, v132, v134);
Ritor1
parents:
diff changeset
1600 if (!pSpriteObjects[uLayingItemID].uSoundID)
Ritor1
parents:
diff changeset
1601 v78 = 0;
Ritor1
parents:
diff changeset
1602 else
Ritor1
parents:
diff changeset
1603 v78 = (signed __int16)pSpriteObjects[uLayingItemID].uSoundID + 4;
Ritor1
parents:
diff changeset
1604 v125 = word_4EE088_sound_ids[pSpriteObjects[uLayingItemID].spell_id - 1] + 1;
Ritor1
parents:
diff changeset
1605 pAudioPlayer->PlaySound((SoundID)v125, pSpriteObjects[uLayingItemID].vPosition.x, 0, -1, 0, v78, 0, 0);
Ritor1
parents:
diff changeset
1606 return 0;
Ritor1
parents:
diff changeset
1607 }
Ritor1
parents:
diff changeset
1608
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1609 case SPRITE_SPELL_LIGHT_DESTROY_UNDEAD:
2498
Ritor1
parents:
diff changeset
1610 {
Ritor1
parents:
diff changeset
1611 if (PID_TYPE(a2) == 3
Ritor1
parents:
diff changeset
1612 && MonsterStats::BelongsToSupertype(pActors[PID_ID(a2)].pMonsterInfo.uID, MONSTER_SUPERTYPE_UNDEAD))
Ritor1
parents:
diff changeset
1613 sub_43A97E(uLayingItemID, a2);
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1614 pSpriteObjects[uLayingItemID].uType = SPRITE_SPELL_LIGHT_DESTROY_UNDEAD_1;
2498
Ritor1
parents:
diff changeset
1615 //v9 = 0;
Ritor1
parents:
diff changeset
1616 v95 = 0;
Ritor1
parents:
diff changeset
1617 for (v52 = 0; v52 < (signed int)pObjectList->uNumObjects; ++v52)
Ritor1
parents:
diff changeset
1618 {
Ritor1
parents:
diff changeset
1619 if (pSpriteObjects[uLayingItemID].uType == pObjectList->pObjects[v52].uObjectID)
Ritor1
parents:
diff changeset
1620 v95 = v52;
Ritor1
parents:
diff changeset
1621 }
Ritor1
parents:
diff changeset
1622 pSpriteObjects[uLayingItemID].uObjectDescID = v95;
Ritor1
parents:
diff changeset
1623 if (!v95)
Ritor1
parents:
diff changeset
1624 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1625 v96 = pSpriteObjects[uLayingItemID].uSoundID;
Ritor1
parents:
diff changeset
1626 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1627 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1628 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1629 pSpriteObjects[uLayingItemID].uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1630 if (!v96)
Ritor1
parents:
diff changeset
1631 v97 = 0;
Ritor1
parents:
diff changeset
1632 else
Ritor1
parents:
diff changeset
1633 v97 = (signed __int16)v96 + 4;
Ritor1
parents:
diff changeset
1634 v92 = uLayingItemID;
Ritor1
parents:
diff changeset
1635 v124 = 8 * v92;
Ritor1
parents:
diff changeset
1636 LOBYTE(v124) = v124 | 2;
Ritor1
parents:
diff changeset
1637 v125 = word_4EE088_sound_ids[pSpriteObjects[uLayingItemID].spell_id - 1] + 1;
Ritor1
parents:
diff changeset
1638 pAudioPlayer->PlaySound((SoundID)v125, v124, 0, -1, 0, v97, 0, 0);
Ritor1
parents:
diff changeset
1639 return 0;
Ritor1
parents:
diff changeset
1640 }
Ritor1
parents:
diff changeset
1641
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1642 case SPRITE_SPELL_BODY_HARM:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1643 case SPRITE_SPELL_BODY_FLYING_FIST:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1644 case SPRITE_SPELL_LIGHT_LIGHT_BOLT:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1645 case SPRITE_SPELL_LIGHT_SUNRAY:
2498
Ritor1
parents:
diff changeset
1646 {
Ritor1
parents:
diff changeset
1647 sub_43A97E(uLayingItemID, a2);
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1648 pSpriteObjects[uLayingItemID].uType = (SPRITE_OBJECT_TYPE)(pSpriteObjects[uLayingItemID].uType + 1);
2498
Ritor1
parents:
diff changeset
1649 v95 = 0;
Ritor1
parents:
diff changeset
1650 for (v52 = 0; v52 < (signed int)pObjectList->uNumObjects; ++v52)
Ritor1
parents:
diff changeset
1651 {
Ritor1
parents:
diff changeset
1652 if (pSpriteObjects[uLayingItemID].uType == pObjectList->pObjects[v52].uObjectID)
Ritor1
parents:
diff changeset
1653 v95 = v52;
Ritor1
parents:
diff changeset
1654 }
Ritor1
parents:
diff changeset
1655 pSpriteObjects[uLayingItemID].uObjectDescID = v95;
Ritor1
parents:
diff changeset
1656 if (!v95)
Ritor1
parents:
diff changeset
1657 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1658 v96 = pSpriteObjects[uLayingItemID].uSoundID;
Ritor1
parents:
diff changeset
1659 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1660 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1661 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1662 pSpriteObjects[uLayingItemID].uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1663 if (!v96)
Ritor1
parents:
diff changeset
1664 v97 = 0;
Ritor1
parents:
diff changeset
1665 else
Ritor1
parents:
diff changeset
1666 v97 = (signed __int16)v96 + 4;
Ritor1
parents:
diff changeset
1667 v124 = 8 * uLayingItemID;
Ritor1
parents:
diff changeset
1668 LOBYTE(v124) = v124 | 2;
Ritor1
parents:
diff changeset
1669 v125 = word_4EE088_sound_ids[pSpriteObjects[uLayingItemID].spell_id - 1] + 1;
Ritor1
parents:
diff changeset
1670 pAudioPlayer->PlaySound((SoundID)v125, v124, 0, -1, 0, v97, 0, 0);
Ritor1
parents:
diff changeset
1671 return 0;
Ritor1
parents:
diff changeset
1672 }
Ritor1
parents:
diff changeset
1673
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1674 case SPRITE_SPELL_MIND_CHARM:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1675 case SPRITE_SPELL_LIGHT_PARALYZE:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1676 case SPRITE_SPELL_DARK_SHRINKING_RAY:
2498
Ritor1
parents:
diff changeset
1677 {
Ritor1
parents:
diff changeset
1678 v143 = 17030;
Ritor1
parents:
diff changeset
1679 switch (pSpriteObjects[uLayingItemID].uType)
Ritor1
parents:
diff changeset
1680 {
Ritor1
parents:
diff changeset
1681 case 0x1798u:
Ritor1
parents:
diff changeset
1682 v143 = 15040;
Ritor1
parents:
diff changeset
1683 break;
Ritor1
parents:
diff changeset
1684 case 0xFAAu:
Ritor1
parents:
diff changeset
1685 v143 = 13010;
Ritor1
parents:
diff changeset
1686 break;
Ritor1
parents:
diff changeset
1687 case 0x2346u:
Ritor1
parents:
diff changeset
1688 v143 = 18030;
Ritor1
parents:
diff changeset
1689 break;
Ritor1
parents:
diff changeset
1690 }
Ritor1
parents:
diff changeset
1691 v138 = 1;
Ritor1
parents:
diff changeset
1692 if (PID_TYPE(a2) != OBJECT_Actor)
Ritor1
parents:
diff changeset
1693 {
Ritor1
parents:
diff changeset
1694 if (pSpriteObjects[uLayingItemID].uType != 9030 || pSpriteObjects[uLayingItemID].spell_skill != 4)
Ritor1
parents:
diff changeset
1695 {
Ritor1
parents:
diff changeset
1696 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1697 return 0;
Ritor1
parents:
diff changeset
1698 }
Ritor1
parents:
diff changeset
1699 pSpriteObjects[uLayingItemID]._46BEF1_apply_spells_aoe();
Ritor1
parents:
diff changeset
1700 if (!v138)
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1701 {
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1702 pSpriteObjects[uLayingItemID].uType = (SPRITE_OBJECT_TYPE)(pSpriteObjects[uLayingItemID].uType + 1);
2498
Ritor1
parents:
diff changeset
1703 v112 = 0;
Ritor1
parents:
diff changeset
1704 for (v110 = 0; v110 < (signed int)pObjectList->uNumObjects; ++v110)
Ritor1
parents:
diff changeset
1705 {
Ritor1
parents:
diff changeset
1706 if (pSpriteObjects[uLayingItemID].uType == pObjectList->pObjects[v110].uObjectID)
Ritor1
parents:
diff changeset
1707 v112 = v110;
Ritor1
parents:
diff changeset
1708 }
Ritor1
parents:
diff changeset
1709 pSpriteObjects[uLayingItemID].uObjectDescID = v112;
Ritor1
parents:
diff changeset
1710 if (!v112)
Ritor1
parents:
diff changeset
1711 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1712 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1713 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1714 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1715 pSpriteObjects[uLayingItemID].uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1716 v113 = pSpriteObjects[uLayingItemID].uSoundID;
Ritor1
parents:
diff changeset
1717 if (v113)
Ritor1
parents:
diff changeset
1718 v114 = (signed __int16)v113 + 4;
Ritor1
parents:
diff changeset
1719 else
Ritor1
parents:
diff changeset
1720 v114 = 0;
Ritor1
parents:
diff changeset
1721 v115 = 8 * uLayingItemID;
Ritor1
parents:
diff changeset
1722 LOBYTE(v115) = PID(OBJECT_Item, uLayingItemID);
Ritor1
parents:
diff changeset
1723 v125 = v143 + 1;
Ritor1
parents:
diff changeset
1724 pAudioPlayer->PlaySound((SoundID)v125, v115, 0, -1, 0, v114, 0, 0);
Ritor1
parents:
diff changeset
1725 }
Ritor1
parents:
diff changeset
1726 else
Ritor1
parents:
diff changeset
1727 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1728 return 0;
Ritor1
parents:
diff changeset
1729 }
Ritor1
parents:
diff changeset
1730 v106 = a2;
Ritor1
parents:
diff changeset
1731 v150 = 0;
Ritor1
parents:
diff changeset
1732 v139 = PID_ID(v106);
Ritor1
parents:
diff changeset
1733 v137 = pSpriteObjects[uLayingItemID].spell_level;
Ritor1
parents:
diff changeset
1734 v152 = pSpriteObjects[uLayingItemID].spell_skill;
Ritor1
parents:
diff changeset
1735 v136 = pSpriteObjects[uLayingItemID].spell_id;
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1736 if (pSpriteObjects[uLayingItemID].uType == SPRITE_SPELL_DARK_SHRINKING_RAY)
2498
Ritor1
parents:
diff changeset
1737 {
Ritor1
parents:
diff changeset
1738 v150 = 2;
Ritor1
parents:
diff changeset
1739 if (v152 == 2)
Ritor1
parents:
diff changeset
1740 v150 = 3;
Ritor1
parents:
diff changeset
1741 else
Ritor1
parents:
diff changeset
1742 {
Ritor1
parents:
diff changeset
1743 if (v152 >= 3)
Ritor1
parents:
diff changeset
1744 v150 = 4;
Ritor1
parents:
diff changeset
1745 }
Ritor1
parents:
diff changeset
1746 pActors[v139].uAttributes |= ACTOR_AGGRESSOR;
Ritor1
parents:
diff changeset
1747 v107 = v135;
Ritor1
parents:
diff changeset
1748 }
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1749 if (pSpriteObjects[uLayingItemID].uType == SPRITE_SPELL_MIND_CHARM)
2498
Ritor1
parents:
diff changeset
1750 {
Ritor1
parents:
diff changeset
1751 v135 = 7;
Ritor1
parents:
diff changeset
1752 v107 = v135;
Ritor1
parents:
diff changeset
1753 }
Ritor1
parents:
diff changeset
1754 else
Ritor1
parents:
diff changeset
1755 {
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1756 if (pSpriteObjects[uLayingItemID].uType == SPRITE_SPELL_LIGHT_PARALYZE)
2498
Ritor1
parents:
diff changeset
1757 {
Ritor1
parents:
diff changeset
1758 v135 = 9;
Ritor1
parents:
diff changeset
1759 v107 = v135;
Ritor1
parents:
diff changeset
1760 }
Ritor1
parents:
diff changeset
1761 else
Ritor1
parents:
diff changeset
1762 {
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1763 if (pSpriteObjects[uLayingItemID].uType != SPRITE_SPELL_DARK_SHRINKING_RAY)
2498
Ritor1
parents:
diff changeset
1764 {
Ritor1
parents:
diff changeset
1765 v107 = v136;
Ritor1
parents:
diff changeset
1766 }
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1767 if (pSpriteObjects[uLayingItemID].uType == SPRITE_SPELL_DARK_SHRINKING_RAY)
2498
Ritor1
parents:
diff changeset
1768 {
Ritor1
parents:
diff changeset
1769 v135 = 10;
Ritor1
parents:
diff changeset
1770 v107 = v135;
Ritor1
parents:
diff changeset
1771 }
Ritor1
parents:
diff changeset
1772 }
Ritor1
parents:
diff changeset
1773 }
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1774 if (pSpriteObjects[uLayingItemID].uType != SPRITE_SPELL_DARK_SHRINKING_RAY || v152 != 4)
2498
Ritor1
parents:
diff changeset
1775 {
Ritor1
parents:
diff changeset
1776 v108 = v139;
Ritor1
parents:
diff changeset
1777 if (pActors[v139].DoesDmgTypeDoDamage((DAMAGE_TYPE)v107))
Ritor1
parents:
diff changeset
1778 {
Ritor1
parents:
diff changeset
1779 v138 = 0;
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1780 if (pSpriteObjects[uLayingItemID].uType == SPRITE_SPELL_LIGHT_PARALYZE)
2498
Ritor1
parents:
diff changeset
1781 {
Ritor1
parents:
diff changeset
1782 pActors[v108].uAIState = Standing;
Ritor1
parents:
diff changeset
1783 pActors[v108].UpdateAnimation();
Ritor1
parents:
diff changeset
1784 }
Ritor1
parents:
diff changeset
1785 pActors[v108].pActorBuffs[v136].Apply(pParty->uTimePlayed + (signed int)(signed __int64)((double)(v137 << 7) * 0.033333335),
Ritor1
parents:
diff changeset
1786 v152, v150, 0, 0);
Ritor1
parents:
diff changeset
1787 }
Ritor1
parents:
diff changeset
1788 }
Ritor1
parents:
diff changeset
1789 else
Ritor1
parents:
diff changeset
1790 {
Ritor1
parents:
diff changeset
1791 pSpriteObjects[uLayingItemID]._46BEF1_apply_spells_aoe();
Ritor1
parents:
diff changeset
1792 }
Ritor1
parents:
diff changeset
1793 pSpriteObjects[uLayingItemID].spell_level = 0;
Ritor1
parents:
diff changeset
1794 pSpriteObjects[uLayingItemID].spell_skill = 0;
Ritor1
parents:
diff changeset
1795 pSpriteObjects[uLayingItemID].spell_id = 0;
Ritor1
parents:
diff changeset
1796 if (!v138)
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1797 {
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1798 pSpriteObjects[uLayingItemID].uType = (SPRITE_OBJECT_TYPE)(pSpriteObjects[uLayingItemID].uType + 1);
2498
Ritor1
parents:
diff changeset
1799 v112 = 0;
Ritor1
parents:
diff changeset
1800 for (v110 = 0; v110 < (signed int)pObjectList->uNumObjects; ++v110)
Ritor1
parents:
diff changeset
1801 {
Ritor1
parents:
diff changeset
1802 if (pSpriteObjects[uLayingItemID].uType == pObjectList->pObjects[v110].uObjectID)
Ritor1
parents:
diff changeset
1803 v112 = v110;
Ritor1
parents:
diff changeset
1804 }
Ritor1
parents:
diff changeset
1805 pSpriteObjects[uLayingItemID].uObjectDescID = v112;
Ritor1
parents:
diff changeset
1806 if (!v112)
Ritor1
parents:
diff changeset
1807 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1808 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1809 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1810 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1811 pSpriteObjects[uLayingItemID].uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1812 v113 = pSpriteObjects[uLayingItemID].uSoundID;
Ritor1
parents:
diff changeset
1813 if (v113)
Ritor1
parents:
diff changeset
1814 v114 = (signed __int16)v113 + 4;
Ritor1
parents:
diff changeset
1815 else
Ritor1
parents:
diff changeset
1816 v114 = 0;
Ritor1
parents:
diff changeset
1817 v115 = 8 * uLayingItemID;
Ritor1
parents:
diff changeset
1818 LOBYTE(v115) = PID(OBJECT_Item, uLayingItemID);
Ritor1
parents:
diff changeset
1819 v125 = v143 + 1;
Ritor1
parents:
diff changeset
1820 pAudioPlayer->PlaySound((SoundID)v125, v115, 0, -1, 0, v114, 0, 0);
Ritor1
parents:
diff changeset
1821 }
Ritor1
parents:
diff changeset
1822 else
Ritor1
parents:
diff changeset
1823 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1824 return 0;
Ritor1
parents:
diff changeset
1825 }
Ritor1
parents:
diff changeset
1826
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1827 case SPRITE_SPELL_DARK_SHARPMETAL:
2498
Ritor1
parents:
diff changeset
1828 {
Ritor1
parents:
diff changeset
1829 sub_43A97E(uLayingItemID, a2);
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1830 pSpriteObjects[uLayingItemID].uType = SPRITE_SPELL_DARK_SHARPMETAL_IMPACT;
2498
Ritor1
parents:
diff changeset
1831 v95 = 0;
Ritor1
parents:
diff changeset
1832 for (v52 = 0; v52 < (signed int)pObjectList->uNumObjects; ++v52)
Ritor1
parents:
diff changeset
1833 {
Ritor1
parents:
diff changeset
1834 if (pSpriteObjects[uLayingItemID].uType == pObjectList->pObjects[v52].uObjectID)
Ritor1
parents:
diff changeset
1835 v95 = v52;
Ritor1
parents:
diff changeset
1836 }
Ritor1
parents:
diff changeset
1837 pSpriteObjects[uLayingItemID].uObjectDescID = v95;
Ritor1
parents:
diff changeset
1838 if (!v95)
Ritor1
parents:
diff changeset
1839 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1840 v96 = pSpriteObjects[uLayingItemID].uSoundID;
Ritor1
parents:
diff changeset
1841 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1842 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1843 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1844 pSpriteObjects[uLayingItemID].uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1845 if (!v96)
Ritor1
parents:
diff changeset
1846 v97 = 0;
Ritor1
parents:
diff changeset
1847 else
Ritor1
parents:
diff changeset
1848 v97 = (signed __int16)v96 + 4;
Ritor1
parents:
diff changeset
1849 v124 = 8 * uLayingItemID;
Ritor1
parents:
diff changeset
1850 LOBYTE(v124) = v124 | 2;
Ritor1
parents:
diff changeset
1851 v125 = word_4EE088_sound_ids[pSpriteObjects[uLayingItemID].spell_id - 1] + 1;
Ritor1
parents:
diff changeset
1852 pAudioPlayer->PlaySound((SoundID)v125, v124, 0, -1, 0, v97, 0, 0);
Ritor1
parents:
diff changeset
1853 return 0;
Ritor1
parents:
diff changeset
1854 }
Ritor1
parents:
diff changeset
1855
Ritor1
parents:
diff changeset
1856 /*
Ritor1
parents:
diff changeset
1857 case 1080:
Ritor1
parents:
diff changeset
1858 case 2100:
Ritor1
parents:
diff changeset
1859 {
Ritor1
parents:
diff changeset
1860 if (PID_TYPE(a2) != 3)
Ritor1
parents:
diff changeset
1861 {
Ritor1
parents:
diff changeset
1862 //v32 = 0;
Ritor1
parents:
diff changeset
1863 pSpriteObjects[uLayingItemID].uType = pSpriteObjects[uLayingItemID].uType + 1;
Ritor1
parents:
diff changeset
1864 v46 = 0;
Ritor1
parents:
diff changeset
1865 for (v146 = 0; v146 < (signed int)pObjectList->uNumObjects; ++v146)
Ritor1
parents:
diff changeset
1866 {
Ritor1
parents:
diff changeset
1867 if (pSpriteObjects[uLayingItemID].uType == pObjectList->pObjects[v146].uObjectID)
Ritor1
parents:
diff changeset
1868 v46 = v146;
Ritor1
parents:
diff changeset
1869 }
Ritor1
parents:
diff changeset
1870 pSpriteObjects[uLayingItemID].uObjectDescID = v46;
Ritor1
parents:
diff changeset
1871 if (!v46)
Ritor1
parents:
diff changeset
1872 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1873 v100 = pSpriteObjects[uLayingItemID].field_61;
Ritor1
parents:
diff changeset
1874 pSpriteObjects[uLayingItemID].uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1875 v102 = 8 * uLayingItemID;
Ritor1
parents:
diff changeset
1876 LOBYTE(v102) = PID(OBJECT_Item, uLayingItemID);
Ritor1
parents:
diff changeset
1877 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1878 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1879 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1880 AttackerInfo.Add(v102, 512, pSpriteObjects[uLayingItemID].vPosition.x, pSpriteObjects[uLayingItemID].vPosition.y, pSpriteObjects[uLayingItemID].vPosition.z, v100, 0);
Ritor1
parents:
diff changeset
1881 if (object->uFlags & OBJECT_DESC_TRIAL_PARTICLE)
Ritor1
parents:
diff changeset
1882 trail_particle_generator.GenerateTrailParticles(pSpriteObjects[uLayingItemID].vPosition.x, pSpriteObjects[uLayingItemID].vPosition.y, pSpriteObjects[uLayingItemID].vPosition.z, object->uParticleTrailColor);
Ritor1
parents:
diff changeset
1883 if (!pSpriteObjects[uLayingItemID].uSoundID)
Ritor1
parents:
diff changeset
1884 v47 = 0;
Ritor1
parents:
diff changeset
1885 else
Ritor1
parents:
diff changeset
1886 v47 = (signed __int16)pSpriteObjects[uLayingItemID].uSoundID + 4;
Ritor1
parents:
diff changeset
1887 v125 = word_4EE088_sound_ids[pSpriteObjects[uLayingItemID].spell_id - 1] + 1;
Ritor1
parents:
diff changeset
1888 pAudioPlayer->PlaySound((SoundID)v125, v102, 0, -1, 0, v47, 0, 0);
Ritor1
parents:
diff changeset
1889 return 0;
Ritor1
parents:
diff changeset
1890 }
Ritor1
parents:
diff changeset
1891 return 1;
Ritor1
parents:
diff changeset
1892 }*/
Ritor1
parents:
diff changeset
1893
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1894 case SPRITE_SPELL_FIRE_METEOR_SHOWER:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1895 case SPRITE_SPELL_AIR_STARBURST:
2498
Ritor1
parents:
diff changeset
1896 {
Ritor1
parents:
diff changeset
1897 if (PID_TYPE(a2) == 3)
Ritor1
parents:
diff changeset
1898 return 1;
Ritor1
parents:
diff changeset
1899 //else go to next case
Ritor1
parents:
diff changeset
1900 }
Ritor1
parents:
diff changeset
1901
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1902 case SPRITE_SPELL_FIRE_FIREBALL:
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1903 case SPRITE_SPELL_DARK_DRAGON_BREATH:
2498
Ritor1
parents:
diff changeset
1904 {
Ritor1
parents:
diff changeset
1905 v95 = 0;
2566
30eb6dcac768 big spell fx overhaul
a.parshin
parents: 2541
diff changeset
1906 pSpriteObjects[uLayingItemID].uType = (SPRITE_OBJECT_TYPE)(pSpriteObjects[uLayingItemID].uType + 1);
2498
Ritor1
parents:
diff changeset
1907 for (v146 = 0; v146 < (signed int)pObjectList->uNumObjects; ++v146)
Ritor1
parents:
diff changeset
1908 {
Ritor1
parents:
diff changeset
1909 if (pSpriteObjects[uLayingItemID].uType == pObjectList->pObjects[v146].uObjectID)
Ritor1
parents:
diff changeset
1910 v95 = v146;
Ritor1
parents:
diff changeset
1911 }
Ritor1
parents:
diff changeset
1912 pSpriteObjects[uLayingItemID].uObjectDescID = v95;
Ritor1
parents:
diff changeset
1913 if (!v95)
Ritor1
parents:
diff changeset
1914 SpriteObject::OnInteraction(uLayingItemID);
Ritor1
parents:
diff changeset
1915 v100 = pSpriteObjects[uLayingItemID].field_61;
Ritor1
parents:
diff changeset
1916 pSpriteObjects[uLayingItemID].uSpriteFrameID = 0;
Ritor1
parents:
diff changeset
1917 v102 = 8 * uLayingItemID;
Ritor1
parents:
diff changeset
1918 LOBYTE(v102) = PID(OBJECT_Item, uLayingItemID);
Ritor1
parents:
diff changeset
1919 pSpriteObjects[uLayingItemID].vVelocity.x = 0;
Ritor1
parents:
diff changeset
1920 pSpriteObjects[uLayingItemID].vVelocity.y = 0;
Ritor1
parents:
diff changeset
1921 pSpriteObjects[uLayingItemID].vVelocity.z = 0;
Ritor1
parents:
diff changeset
1922 AttackerInfo.Add(v102, 512, pSpriteObjects[uLayingItemID].vPosition.x, pSpriteObjects[uLayingItemID].vPosition.y, pSpriteObjects[uLayingItemID].vPosition.z, v100, 0);
Ritor1
parents:
diff changeset
1923 if (object->uFlags & OBJECT_DESC_TRIAL_PARTICLE)
Ritor1
parents:
diff changeset
1924 trail_particle_generator.GenerateTrailParticles(pSpriteObjects[uLayingItemID].vPosition.x, pSpriteObjects[uLayingItemID].vPosition.y, pSpriteObjects[uLayingItemID].vPosition.z, object->uParticleTrailColor);
Ritor1
parents:
diff changeset
1925 if (!pSpriteObjects[uLayingItemID].uSoundID)
Ritor1
parents:
diff changeset
1926 v47 = 0;
Ritor1
parents:
diff changeset
1927 else
Ritor1
parents:
diff changeset
1928 v47 = (signed __int16)pSpriteObjects[uLayingItemID].uSoundID + 4;
Ritor1
parents:
diff changeset
1929 v125 = word_4EE088_sound_ids[pSpriteObjects[uLayingItemID].spell_id - 1] + 1;
Ritor1
parents:
diff changeset
1930 pAudioPlayer->PlaySound((SoundID)v125, v102, 0, -1, 0, v47, 0, 0);
Ritor1
parents:
diff changeset
1931 return 0;
Ritor1
parents:
diff changeset
1932 }
Ritor1
parents:
diff changeset
1933
Ritor1
parents:
diff changeset
1934 default:
Ritor1
parents:
diff changeset
1935 return 0;
Ritor1
parents:
diff changeset
1936 }
Ritor1
parents:
diff changeset
1937
Ritor1
parents:
diff changeset
1938 }
Ritor1
parents:
diff changeset
1939
Ritor1
parents:
diff changeset
1940 //----- (0043A97E) --------------------------------------------------------
Ritor1
parents:
diff changeset
1941 void __fastcall sub_43A97E(unsigned int uLayingItemID, signed int a2)
Ritor1
parents:
diff changeset
1942 {
Ritor1
parents:
diff changeset
1943 if (PID_TYPE(a2) == OBJECT_Player)
Ritor1
parents:
diff changeset
1944 {
Ritor1
parents:
diff changeset
1945 layingitem_vel_50FDFC.x = pSpriteObjects[uLayingItemID].vVelocity.x;
Ritor1
parents:
diff changeset
1946 layingitem_vel_50FDFC.y = pSpriteObjects[uLayingItemID].vVelocity.y;
Ritor1
parents:
diff changeset
1947 layingitem_vel_50FDFC.z = pSpriteObjects[uLayingItemID].vVelocity.z;
Ritor1
parents:
diff changeset
1948
Ritor1
parents:
diff changeset
1949 Vec3_int_::Normalize(&layingitem_vel_50FDFC.x, &layingitem_vel_50FDFC.y, &layingitem_vel_50FDFC.z);
Ritor1
parents:
diff changeset
1950 DamagePlayerFromMonster(PID(OBJECT_Item, uLayingItemID), pSpriteObjects[uLayingItemID].field_61, &layingitem_vel_50FDFC, -1);
Ritor1
parents:
diff changeset
1951 }
Ritor1
parents:
diff changeset
1952 else if (PID_TYPE(a2) == OBJECT_Actor)
Ritor1
parents:
diff changeset
1953 {
Ritor1
parents:
diff changeset
1954 layingitem_vel_50FDFC.x = pSpriteObjects[uLayingItemID].vVelocity.x;
Ritor1
parents:
diff changeset
1955 layingitem_vel_50FDFC.y = pSpriteObjects[uLayingItemID].vVelocity.y;
Ritor1
parents:
diff changeset
1956 layingitem_vel_50FDFC.z = pSpriteObjects[uLayingItemID].vVelocity.z;
Ritor1
parents:
diff changeset
1957
Ritor1
parents:
diff changeset
1958 Vec3_int_::Normalize(&layingitem_vel_50FDFC.x, &layingitem_vel_50FDFC.y, &layingitem_vel_50FDFC.z);
Ritor1
parents:
diff changeset
1959 switch (PID_TYPE(pSpriteObjects[uLayingItemID].spell_caster_pid))
Ritor1
parents:
diff changeset
1960 {
Ritor1
parents:
diff changeset
1961 case OBJECT_Actor:
Ritor1
parents:
diff changeset
1962 Actor::ActorDamageFromMonster(PID(OBJECT_Item, uLayingItemID), PID_ID(a2), &layingitem_vel_50FDFC, pSpriteObjects[uLayingItemID].field_61);
Ritor1
parents:
diff changeset
1963 break;
Ritor1
parents:
diff changeset
1964 case OBJECT_Player:
Ritor1
parents:
diff changeset
1965 Actor::DamageMonsterFromParty(PID(OBJECT_Item, uLayingItemID), PID_ID(a2), &layingitem_vel_50FDFC);
Ritor1
parents:
diff changeset
1966 break;
Ritor1
parents:
diff changeset
1967 case OBJECT_Item:
Ritor1
parents:
diff changeset
1968 ItemDamageFromActor(PID(OBJECT_Item, uLayingItemID), PID_ID(a2), &layingitem_vel_50FDFC);
Ritor1
parents:
diff changeset
1969 break;
Ritor1
parents:
diff changeset
1970 }
Ritor1
parents:
diff changeset
1971 }
Ritor1
parents:
diff changeset
1972 }