← Back to branch summary

~ubuntu-branches/debian/sid/astromenace/sid

« back to all changes in this revision

Viewing changes to AstroMenaceSource/Object3D/GroundObject/Wheeled/Wheeled.cpp

  • Committer: Package Import Robot
  • Author(s): Boris Pek
  • Date: 2013-04-09 02:04:25 UTC
  • Revision ID: package-import@ubuntu.com-20130409020425-a7fl9xk4diamw6di
Tags: upstream-1.3.1+repack
Import upstream version 1.3.1+repack

Show diffs side-by-side

added added

removed removed

Lines of Context:
AstroMenaceSource/Object3D/GroundObject/Wheeled/Wheeled.cpp
 
1
/************************************************************************************
 
2
 
 
3
        AstroMenace (Hardcore 3D space shooter with spaceship upgrade possibilities)
 
4
        Copyright © 2006-2012 Michael Kurinnoy, Viewizard
 
5
 
 
6
 
 
7
        AstroMenace is free software: you can redistribute it and/or modify
 
8
        it under the terms of the GNU General Public License as published by
 
9
        the Free Software Foundation, either version 3 of the License, or
 
10
        (at your option) any later version.
 
11
 
 
12
        AstroMenace is distributed in the hope that it will be useful,
 
13
        but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 
15
        GNU General Public License for more details.
 
16
 
 
17
        You should have received a copy of the GNU General Public License
 
18
        along with AstroMenace. If not, see <http://www.gnu.org/licenses/>.
 
19
 
 
20
 
 
21
        Web Site: http://www.viewizard.com/
 
22
        Project: http://sourceforge.net/projects/openastromenace/
 
23
        E-mail: viewizard@viewizard.com
 
24
 
 
25
*************************************************************************************/
 
26
 
 
27
 
 
28
/// подключаем нужные файлы
 
29
#include "Wheeled.h"
 
30
 
 
31
 
 
32
 
 
33
struct WheeledData
 
34
{
 
35
        float   Strength;
 
36
        int             WeaponQuantity;
 
37
        float   SpeedToRotate;
 
38
        const   char *Name;
 
39
        const   char *TextureName;
 
40
};
 
41
 
 
42
const int       PresetWheeledDataCount = 8;
 
43
WheeledData PresetWheeledData[PresetWheeledDataCount] =
 
44
{
 
45
        {120, 4,        50.0f,  "DATA/MODELS/WHEELED/jeep-01.VW3D",     "DATA/MODELS/gr-02.VW2D"},
 
46
        {70, 2,         50.0f,  "DATA/MODELS/WHEELED/jeep-02.VW3D",     "DATA/MODELS/gr-02.VW2D"},
 
47
        {100, 2,        50.0f,  "DATA/MODELS/WHEELED/jeep-03.VW3D",     "DATA/MODELS/gr-02.VW2D"},
 
48
        {100, 1,        50.0f,  "DATA/MODELS/WHEELED/jeep-04.VW3D",     "DATA/MODELS/gr-07.VW2D"},
 
49
        {150, 1,        50.0f,  "DATA/MODELS/WHEELED/jeep-05.VW3D",     "DATA/MODELS/gr-03.VW2D"},
 
50
        {250,1,         30.0f,  "DATA/MODELS/WHEELED/apc-02.VW3D",      "DATA/MODELS/gr-03.VW2D"},
 
51
        {200, 2,        30.0f,  "DATA/MODELS/WHEELED/apc-04.VW3D",      "DATA/MODELS/gr-01.VW2D"},
 
52
        {400,2,         34.0f,  "DATA/MODELS/WHEELED/r-launcher-01.VW3D",       "DATA/MODELS/gr-02.VW2D"}
 
53
};
 
54
 
 
55
 
 
56
 
 
57
//-----------------------------------------------------------------------------
 
58
// Конструктор, инициализация всех переменных
 
59
//-----------------------------------------------------------------------------
 
60
void CWheeled::Create(int WheeledNum)
 
61
{
 
62
        ObjectType = 5;
 
63
        ObjectCreationType = WheeledNum;
 
64
        MaxSpeed = 20.0f;
 
65
        MaxAcceler = 5.0f;
 
66
        MaxSpeedRotate = 20.0f;
 
67
 
 
68
 
 
69
        LoadObjectData(PresetWheeledData[WheeledNum-1].Name, this, 0, 2.0f);
 
70
 
 
71
        for (int i=0; i<DrawObjectQuantity; i++)
 
72
        {
 
73
                Texture[i] = vw_FindTextureByName(PresetWheeledData[WheeledNum-1].TextureName);
 
74
        }
 
75
        ResistanceHull = 1.0f;
 
76
        ResistanceSystems = 1.0f;
 
77
        SpeedToRotate = PresetWheeledData[WheeledNum-1].SpeedToRotate;
 
78
 
 
79
 
 
80
        Strength = StrengthStart = PresetWheeledData[WheeledNum-1].Strength/GameNPCArmorPenalty;
 
81
 
 
82
 
 
83
        WeaponQuantity = PresetWheeledData[WheeledNum-1].WeaponQuantity;
 
84
        // начальные установки для оружия
 
85
        WeaponSetFire = new bool[WeaponQuantity];
 
86
        WeaponLocation = new VECTOR3D[WeaponQuantity];
 
87
        Weapon = new CWeapon*[WeaponQuantity];
 
88
        WeaponBound = new VECTOR3D[WeaponQuantity];
 
89
        for (int i=0; i<WeaponQuantity; i++)
 
90
        {
 
91
                WeaponSetFire[i] = false;
 
92
                Weapon[i] = 0;
 
93
        }
 
94
 
 
95
 
 
96
 
 
97
        // установка доп. текстуры и других настроек для каждой модели
 
98
        switch (WheeledNum)
 
99
        {
 
100
                case 1:
 
101
                        WeaponLocation[0] = VECTOR3D(0.3f, 4.5f, -1.5f);
 
102
                        Weapon[0] = new CWeapon;
 
103
                        Weapon[0]->Create(206);
 
104
                        WeaponLocation[1] = VECTOR3D(-0.3f, 4.5f, -1.5f);
 
105
                        Weapon[1] = new CWeapon;
 
106
                        Weapon[1]->Create(206);
 
107
                        WeaponLocation[2] = VECTOR3D(0.9f, 4.5f, -1.5f);
 
108
                        Weapon[2] = new CWeapon;
 
109
                        Weapon[2]->Create(206);
 
110
                        WeaponLocation[3] = VECTOR3D(-0.9f, 4.5f, -1.5f);
 
111
                        Weapon[3] = new CWeapon;
 
112
                        Weapon[3]->Create(206);
 
113
                        WeaponFireType = 3;
 
114
 
 
115
                        WheelQuantity = 4;
 
116
                        WheelObjectsNum = new int[4];
 
117
                        WheelObjectsNum[0] = 0;
 
118
                        WheelObjectsNum[1] = 2;
 
119
                        WheelObjectsNum[2] = 3;
 
120
                        WheelObjectsNum[3] = 4;
 
121
 
 
122
                        WheelRotateQuantity = 2;
 
123
                        WheelRotateObjectsNum = new int[2];
 
124
                        WheelRotateObjectsNum[0] = 3;
 
125
                        WheelRotateObjectsNum[1] = 4;
 
126
                        MaxWheelRotateAngle = 30.0f;
 
127
 
 
128
                        TargetVertObjectQuantity = 1;
 
129
                        TargetVertObject = new int[TargetVertObjectQuantity];
 
130
                        TargetVertObject[0] = 5;
 
131
                        TargetVertObjectMaxAngle = 30.0f;
 
132
                        break;
 
133
 
 
134
                case 2:
 
135
                        WeaponLocation[0] = VECTOR3D(1.3f, 3.5f, -1.5f);
 
136
                        Weapon[0] = new CWeapon;
 
137
                        Weapon[0]->Create(206);
 
138
                        WeaponLocation[1] = VECTOR3D(-1.3f, 3.5f, -1.5f);
 
139
                        Weapon[1] = new CWeapon;
 
140
                        Weapon[1]->Create(206);
 
141
                        WeaponFireType = 3;
 
142
                        DoNotCalculateRotation = true;
 
143
 
 
144
                        WheelQuantity = 4;
 
145
                        WheelObjectsNum = new int[4];
 
146
                        WheelObjectsNum[0] = 1;
 
147
                        WheelObjectsNum[1] = 2;
 
148
                        WheelObjectsNum[2] = 3;
 
149
                        WheelObjectsNum[3] = 4;
 
150
 
 
151
                        WheelRotateQuantity = 2;
 
152
                        WheelRotateObjectsNum = new int[2];
 
153
                        WheelRotateObjectsNum[0] = 1;
 
154
                        WheelRotateObjectsNum[1] = 4;
 
155
                        MaxWheelRotateAngle = 20.0f;
 
156
                        break;
 
157
 
 
158
                case 3:
 
159
                        WeaponLocation[0] = VECTOR3D(0.8f, 4.2f, -1.0f);
 
160
                        Weapon[0] = new CWeapon;
 
161
                        Weapon[0]->Create(204);
 
162
                        WeaponLocation[1] = VECTOR3D(-0.8f, 4.2f, -1.0f);
 
163
                        Weapon[1] = new CWeapon;
 
164
                        Weapon[1]->Create(204);
 
165
                        WeaponFireType = 2;
 
166
 
 
167
                        WheelQuantity = 4;
 
168
                        WheelObjectsNum = new int[4];
 
169
                        WheelObjectsNum[0] = 0;
 
170
                        WheelObjectsNum[1] = 1;
 
171
                        WheelObjectsNum[2] = 2;
 
172
                        WheelObjectsNum[3] = 5;
 
173
 
 
174
                        WheelRotateQuantity = 2;
 
175
                        WheelRotateObjectsNum = new int[2];
 
176
                        WheelRotateObjectsNum[0] = 0;
 
177
                        WheelRotateObjectsNum[1] = 1;
 
178
                        MaxWheelRotateAngle = 20.0f;
 
179
 
 
180
                        TargetHorizObjectQuantity = 2;
 
181
                        TargetHorizObject = new int[TargetHorizObjectQuantity];
 
182
                        TargetHorizObject[0] = 3;
 
183
                        TargetHorizObject[1] = 6;
 
184
 
 
185
                        TargetVertObjectQuantity = 1;
 
186
                        TargetVertObject = new int[TargetVertObjectQuantity];
 
187
                        TargetVertObject[0] = 6;
 
188
                        TargetVertObjectMaxAngle = 60.0f;
 
189
                        break;
 
190
 
 
191
                case 4:
 
192
                        WeaponLocation[0] = VECTOR3D(0.0f, 4.5f, -4.0f);
 
193
                        Weapon[0] = new CWeapon;
 
194
                        Weapon[0]->Create(207);
 
195
 
 
196
                        WheelQuantity = 4;
 
197
                        WheelObjectsNum = new int[4];
 
198
                        WheelObjectsNum[0] = 0;
 
199
                        WheelObjectsNum[1] = 1;
 
200
                        WheelObjectsNum[2] = 3;
 
201
                        WheelObjectsNum[3] = 4;
 
202
 
 
203
                        WheelRotateQuantity = 2;
 
204
                        WheelRotateObjectsNum = new int[2];
 
205
                        WheelRotateObjectsNum[0] = 0;
 
206
                        WheelRotateObjectsNum[1] = 3;
 
207
                        MaxWheelRotateAngle = 20.0f;
 
208
                        break;
 
209
 
 
210
                case 5:
 
211
                        WeaponLocation[0] = VECTOR3D(0.0f, 4.5f, -4.0f);
 
212
                        Weapon[0] = new CWeapon;
 
213
                        Weapon[0]->Create(208);
 
214
 
 
215
                        WheelQuantity = 4;
 
216
                        WheelObjectsNum = new int[4];
 
217
                        WheelObjectsNum[0] = 1;
 
218
                        WheelObjectsNum[1] = 2;
 
219
                        WheelObjectsNum[2] = 3;
 
220
                        WheelObjectsNum[3] = 4;
 
221
 
 
222
                        WheelRotateQuantity = 2;
 
223
                        WheelRotateObjectsNum = new int[2];
 
224
                        WheelRotateObjectsNum[0] = 1;
 
225
                        WheelRotateObjectsNum[1] = 2;
 
226
                        MaxWheelRotateAngle = 30.0f;
 
227
                        break;
 
228
 
 
229
                case 6:
 
230
                        WeaponLocation[0] = VECTOR3D(0.0f, 6.0f, -3.0f);
 
231
                        Weapon[0] = new CWeapon;
 
232
                        Weapon[0]->Create(204);
 
233
 
 
234
                        WheelQuantity = 4;
 
235
                        WheelObjectsNum = new int[4];
 
236
                        WheelObjectsNum[0] = 1;
 
237
                        WheelObjectsNum[1] = 2;
 
238
                        WheelObjectsNum[2] = 3;
 
239
                        WheelObjectsNum[3] = 4;
 
240
 
 
241
                        WheelRotateQuantity = 2;
 
242
                        WheelRotateObjectsNum = new int[2];
 
243
                        WheelRotateObjectsNum[0] = 1;
 
244
                        WheelRotateObjectsNum[1] = 4;
 
245
                        MaxWheelRotateAngle = 30.0f;
 
246
 
 
247
                        TargetHorizObjectQuantity = 2;
 
248
                        TargetHorizObject = new int[TargetHorizObjectQuantity];
 
249
                        TargetHorizObject[0] = 5;
 
250
                        TargetHorizObject[1] = 6;
 
251
 
 
252
                        TargetVertObjectQuantity = 1;
 
253
                        TargetVertObject = new int[TargetVertObjectQuantity];
 
254
                        TargetVertObject[0] = 6;
 
255
                        TargetVertObjectMaxAngle = 40.0f;
 
256
                        break;
 
257
 
 
258
                case 7:
 
259
                        WeaponLocation[0] = VECTOR3D(0.1f, 5.0f, -1.0f);
 
260
                        Weapon[0] = new CWeapon;
 
261
                        Weapon[0]->Create(204);
 
262
                        WeaponLocation[1] = VECTOR3D(-0.1f, 5.0f, -1.0f);
 
263
                        Weapon[1] = new CWeapon;
 
264
                        Weapon[1]->Create(204);
 
265
                        WeaponFireType = 2;
 
266
 
 
267
                        WheelQuantity = 4;
 
268
                        WheelObjectsNum = new int[4];
 
269
                        WheelObjectsNum[0] = 1;
 
270
                        WheelObjectsNum[1] = 2;
 
271
                        WheelObjectsNum[2] = 3;
 
272
                        WheelObjectsNum[3] = 4;
 
273
 
 
274
                        WheelRotateQuantity = 2;
 
275
                        WheelRotateObjectsNum = new int[2];
 
276
                        WheelRotateObjectsNum[0] = 1;
 
277
                        WheelRotateObjectsNum[1] = 4;
 
278
                        MaxWheelRotateAngle = 20.0f;
 
279
 
 
280
                        TargetHorizObjectQuantity = 2;
 
281
                        TargetHorizObject = new int[TargetHorizObjectQuantity];
 
282
                        TargetHorizObject[0] = 5;
 
283
                        TargetHorizObject[1] = 6;
 
284
 
 
285
                        TargetVertObjectQuantity = 1;
 
286
                        TargetVertObject = new int[TargetVertObjectQuantity];
 
287
                        TargetVertObject[0] = 6;
 
288
                        TargetVertObjectMaxAngle = 40.0f;
 
289
                        break;
 
290
 
 
291
                case 8:
 
292
                        WeaponLocation[0] = VECTOR3D(1.5f, 5.2f, 7.0f);
 
293
                        Weapon[0] = new CWeapon;
 
294
                        Weapon[0]->Create(210);
 
295
                        WeaponLocation[1] = VECTOR3D(-1.5f, 5.2f, 7.0f);
 
296
                        Weapon[1] = new CWeapon;
 
297
                        Weapon[1]->Create(210);
 
298
                        WeaponFireType = 3;
 
299
 
 
300
                        WheelQuantity = 8;
 
301
                        WheelObjectsNum = new int[8];
 
302
                        WheelObjectsNum[0] = 1;
 
303
                        WheelObjectsNum[1] = 3;
 
304
                        WheelObjectsNum[2] = 4;
 
305
                        WheelObjectsNum[3] = 5;
 
306
                        WheelObjectsNum[4] = 6;
 
307
                        WheelObjectsNum[5] = 7;
 
308
                        WheelObjectsNum[6] = 8;
 
309
                        WheelObjectsNum[7] = 9;
 
310
 
 
311
                        WheelRotateQuantity = 4;
 
312
                        WheelRotateObjectsNum = new int[4];
 
313
                        WheelRotateObjectsNum[0] = 1;
 
314
                        WheelRotateObjectsNum[1] = 3;
 
315
                        WheelRotateObjectsNum[2] = 6;
 
316
                        WheelRotateObjectsNum[3] = 7;
 
317
                        MaxWheelRotateAngle = 20.0f;
 
318
 
 
319
                        TargetVertObjectQuantity = 1;
 
320
                        TargetVertObject = new int[TargetVertObjectQuantity];
 
321
                        TargetVertObject[0] = 2;
 
322
                        TargetVertObjectMaxAngle = 90.0f;
 
323
                        break;
 
324
        }
 
325
 
 
326
 
 
327
        // находим все данные по геометрии
 
328
        ::CObject3D::InitByDrawObjectList();
 
329
 
 
330
 
 
331
        // установка остальных параметров девиации
 
332
        DeviationOn = false;
 
333
        DeviationObjQuantity = WheelQuantity;
 
334
        Deviation = new VECTOR3D[DeviationObjQuantity];
 
335
        NeedDeviation = new float[DeviationObjQuantity];
 
336
        CurentDeviation = new float[DeviationObjQuantity];
 
337
        CurentDeviationSum = new float[DeviationObjQuantity];
 
338
        DeviationObjNum = new int[DeviationObjQuantity];
 
339
 
 
340
        for (int i=0; i<DeviationObjQuantity; i++)
 
341
        {
 
342
                Deviation[i] = VECTOR3D(0.0f, 1.0f, 0.0f);
 
343
                NeedDeviation[i] = vw_Randf0*0.1f;
 
344
                CurentDeviation[i] = CurentDeviationSum[i] = 0.0f;
 
345
                DeviationObjNum[i] = WheelObjectsNum[i];
 
346
        }
 
347
 
 
348
        // делаем сдвиг поворота колес, чтобы смотрелось естественнее
 
349
        for (int i=0; i<WheelQuantity; i++)
 
350
                DrawObjectList[WheelObjectsNum[i]].Rotation.x = vw_fRandNum(360.0f);
 
351
 
 
352
 
 
353
 
 
354
        // вычисляем данные для нахождения точки стрельбы
 
355
        if (TargetHorizObject != 0)
 
356
        {
 
357
                BaseBound = DrawObjectList[TargetHorizObject[0]].Location;
 
358
        }
 
359
 
 
360
        if (TargetVertObject != 0)
 
361
        {
 
362
                if (TargetHorizObject != 0)
 
363
                {
 
364
                        MiddleBound = DrawObjectList[TargetVertObject[0]].Location - DrawObjectList[TargetHorizObject[0]].Location;
 
365
                }
 
366
                else
 
367
                {
 
368
                        MiddleBound = DrawObjectList[TargetVertObject[0]].Location;
 
369
                }
 
370
        }
 
371
 
 
372
        if (WeaponBound != 0)
 
373
        for (int i=0; i<WeaponQuantity; i++)
 
374
        {
 
375
                if (TargetVertObject != 0)
 
376
                {
 
377
                        WeaponBound[i] = WeaponLocation[i] - DrawObjectList[TargetVertObject[0]].Location;
 
378
                }
 
379
                else
 
380
                if (TargetHorizObject != 0)
 
381
                {
 
382
                        WeaponBound[i] = WeaponLocation[i] - DrawObjectList[TargetHorizObject[0]].Location;
 
383
                }
 
384
                else
 
385
                {
 
386
                        WeaponBound[i] = WeaponLocation[i];
 
387
                }
 
388
        }
 
389
 
 
390
}
 
391