1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
|
/*
* This file is part of the Colobot: Gold Edition source code
* Copyright (C) 2001-2023, Daniel Roux, EPSITEC SA & TerranovaTeam
* http://epsitec.ch; http://colobot.info; http://github.com/colobot
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see http://gnu.org/licenses
*/
/**
* \file object/old_object.h
* \brief COldObject - legacy CObject code
*/
#pragma once
#include "common/event.h"
#include "object/object.h"
#include "object/implementation/power_container_impl.h"
#include "object/implementation/program_storage_impl.h"
#include "object/implementation/programmable_impl.h"
#include "object/implementation/task_executor_impl.h"
#include "object/interface/controllable_object.h"
#include "object/interface/flying_object.h"
#include "object/interface/interactive_object.h"
#include "object/interface/jet_flying_object.h"
#include "object/interface/jostleable_object.h"
#include "object/interface/movable_object.h"
#include "object/interface/power_container_object.h"
#include "object/interface/programmable_object.h"
#include "object/interface/ranged_object.h"
#include "object/interface/shielded_auto_regen_object.h"
#include "object/interface/slotted_object.h"
#include "object/interface/task_executor_object.h"
#include "object/interface/trace_drawing_object.h"
#include "object/interface/transportable_object.h"
// The father of all parts must always be the part number zero!
const int OBJECTMAXPART = 40;
struct ObjectPart
{
bool bUsed = false;
int object = -1; // number of the object in CEngine
int parentPart = -1; // number of father part
int masterParti = -1; // master canal of the particle
Math::Vector position;
Math::Vector angle;
Math::Vector zoom;
bool bTranslate = false;
bool bRotate = false;
bool bZoom = false;
Math::Matrix matTranslate;
Math::Matrix matRotate;
Math::Matrix matTransform;
Math::Matrix matWorld;
};
namespace Ui
{
class CObjectInterface;
}
class COldObject : public CObject,
public CInteractiveObject,
public CTransportableObject,
public CTaskExecutorObjectImpl,
public CProgramStorageObjectImpl,
public CProgrammableObjectImpl,
public CJostleableObject,
public CSlottedObject,
public CJetFlyingObject,
public CControllableObject,
public CPowerContainerObjectImpl,
public CRangedObject,
public CTraceDrawingObject,
public CShieldedAutoRegenObject
{
friend class CObjectFactory;
friend class CObjectManager;
protected:
void DeleteObject(bool bAll=false);
void SetProgrammable();
void SetMovable(std::unique_ptr<CMotion> motion, std::unique_ptr<CPhysics> physics);
void SetAuto(std::unique_ptr<CAuto> automat);
void SetOption(int option);
void SetJostlingSphere(const Math::Sphere& jostlingSphere);
public:
COldObject(int id); // should only be called by CObjectFactory
~COldObject();
void Simplify() override;
bool DamageObject(DamageType type, float force = std::numeric_limits<float>::infinity(), CObject* killer = nullptr) override;
void DestroyObject(DestructionType type, CObject* killer = nullptr) override;
bool EventProcess(const Event& event) override;
void UpdateMapping();
void DeletePart(int part) override;
void SetObjectRank(int part, int objRank);
int GetObjectRank(int part) override;
void SetObjectParent(int part, int parent);
void SetType(ObjectType type) override;
const char* GetName();
int GetOption() override;
void Write(CLevelParserLine* line) override;
void Read(CLevelParserLine* line) override;
void SetDrawFront(bool bDraw) override;
int GetShadowLight();
void SetFloorHeight(float height);
void FloorAdjust() override;
void SetLinVibration(Math::Vector dir) override;
Math::Vector GetLinVibration();
void SetCirVibration(Math::Vector dir) override;
Math::Vector GetCirVibration();
void SetTilt(Math::Vector dir);
Math::Vector GetTilt() override;
void SetPartPosition(int part, const Math::Vector &pos);
Math::Vector GetPartPosition(int part) const;
void SetPartRotation(int part, const Math::Vector &angle);
Math::Vector GetPartRotation(int part) const;
void SetPartRotationY(int part, float angle);
void SetPartRotationX(int part, float angle);
void SetPartRotationZ(int part, float angle);
float GetPartRotationY(int part);
float GetPartRotationX(int part);
float GetPartRotationZ(int part);
void SetPartScale(int part, float zoom);
void SetPartScale(int part, Math::Vector zoom);
Math::Vector GetPartScale(int part) const;
void SetPartScaleX(int part, float zoom);
float GetPartScaleX(int part);
void SetPartScaleY(int part, float zoom);
float GetPartScaleY(int part);
void SetPartScaleZ(int part, float zoom);
float GetPartScaleZ(int part);
void SetTrainer(bool bEnable) override;
bool GetTrainer() override;
bool GetPlusTrainer();
void SetToy(bool bEnable);
bool GetToy();
void SetManual(bool bManual);
bool GetManual();
void SetMasterParticle(int part, int parti) override;
void SetTransporter(CObject* transporter) override;
CObject* GetTransporter() override;
void SetTransporterPart(int part) override;
Math::Matrix* GetRotateMatrix(int part);
Math::Matrix* GetWorldMatrix(int part) override;
void AdjustCamera(Math::Vector &eye, float &dirH, float &dirV,
Math::Vector &lookat, Math::Vector &upVec,
Gfx::CameraType type) override;
Character* GetCharacter() override;
float GetAbsTime();
float GetCapacity() override;
bool IsRechargeable() override;
void SetShield(float level) override;
float GetShield() override;
void SetRange(float delay) override;
float GetRange() override;
void SetReactorRange(float reactorRange) override;
float GetReactorRange() override;
void SetTransparency(float value) override;
Math::Sphere GetJostlingSphere() const override;
bool JostleObject(float force) override;
void SetVirusMode(bool bEnable) override;
bool GetVirusMode() override;
void SetCameraType(Gfx::CameraType type) override;
Gfx::CameraType GetCameraType() override;
void SetCameraLock(bool lock) override;
bool GetCameraLock() override;
void SetHighlight(bool highlight) override;
void SetSelect(bool select, bool bDisplayError = true) override;
bool GetSelect() override;
void SetSelectable(bool bMode);
bool GetSelectable() override;
void SetUnderground(bool underground);
void SetCheckToken(bool bMode);
bool GetCheckToken();
void SetMagnifyDamage(float factor) override;
float GetMagnifyDamage() override;
void SetDamaging(bool damaging) override;
bool IsDamaging() override;
void SetDying(DeathType deathType) override;
DeathType GetDying() override;
bool IsDying() override;
bool GetActive() override;
bool GetDetectable() override;
void SetGunGoalV(float gunGoal);
void SetGunGoalH(float gunGoal);
float GetGunGoalV();
float GetGunGoalH();
float GetShowLimitRadius() override;
void CreateSelectParticle();
CPhysics* GetPhysics() override;
CMotion* GetMotion() override;
CAuto* GetAuto() override;
bool CreateShadowCircle(float radius, float intensity, Gfx::EngineShadowType type = Gfx::ENG_SHADOW_NORM);
bool CreateShadowLight(float height, Gfx::Color color);
void FlatParent() override;
void SetPosition(const Math::Vector& pos) override;
Math::Vector GetPosition() const override;
void SetRotation(const Math::Vector& rotation) override;
Math::Vector GetRotation() const override;
using CObject::SetScale; // SetScale(float) version
void SetScale(const Math::Vector& scale) override;
Math::Vector GetScale() const override;
void UpdateInterface() override;
void StopProgram() override;
bool GetTraceDown() override;
void SetTraceDown(bool down) override;
TraceColor GetTraceColor() override;
void SetTraceColor(TraceColor color) override;
float GetTraceWidth() override;
void SetTraceWidth(float width) override;
bool IsRepairable() override;
float GetShieldFullRegenTime() override;
float GetLightningHitProbability() override;
void SetBulletWall(bool bulletWall);
bool IsBulletWall() override;
// CSlottedObject
int MapPseudoSlot(Pseudoslot pseudoslot) override;
int GetNumSlots() override;
Math::Vector GetSlotPosition(int slotNum) override;
float GetSlotAngle(int slotNum) override;
float GetSlotAcceptanceAngle(int slotNum) override;
CObject *GetSlotContainedObject(int slotNum) override;
void SetSlotContainedObject(int slotNum, CObject *object) override;
// Helper for CSlottedObject initialization
void SetPowerPosition(const Math::Vector& powerPosition);
protected:
bool EventFrame(const Event &event);
void VirusFrame(float rTime);
void PartiFrame(float rTime);
void InitPart(int part);
void UpdateTotalPart();
int SearchDescendant(int parent, int n);
void UpdateEnergyMapping();
bool UpdateTransformObject(int part, bool bForceUpdate);
bool UpdateTransformObject();
void UpdateSelectParticle();
void TransformCrashSphere(Math::Sphere &crashSphere) override;
void TransformCameraCollisionSphere(Math::Sphere& collisionSphere) override;
/**
* \brief Check if given object type should be selectable by default
* \note This is a default value for the selectable= parameter and can still be overriden in the scene file or using the \a selectinsect cheat
*/
static bool IsSelectableByDefault(ObjectType type);
/**
* \brief Check if given object type should have bulletWall enabled by default
* \note This is a default value for the bulletWall= parameter and can still be overriden in the scene file
*/
static bool IsBulletWallByDefault(ObjectType type);
protected:
Gfx::CEngine* m_engine;
Gfx::CLightManager* m_lightMan;
Gfx::CTerrain* m_terrain;
Gfx::CCamera* m_camera;
Gfx::CParticle* m_particle;
CRobotMain* m_main;
CSoundInterface* m_sound;
std::unique_ptr<CPhysics> m_physics;
std::unique_ptr<CMotion> m_motion;
std::unique_ptr<CAuto> m_auto;
std::unique_ptr<Ui::CObjectInterface> m_objectInterface;
std::string m_name; // name of the object
Character m_character; // characteristic
int m_option; // option
int m_shadowLight; // number of light from the shadows
float m_shadowHeight; // height of light from the shadows
Math::Vector m_linVibration; // linear vibration
Math::Vector m_cirVibration; // circular vibration
Math::Vector m_tilt; // tilt
CObject* m_power; // battery used by the vehicle
Math::Vector m_powerPosition;
CObject* m_cargo; // object transported
CObject* m_transporter; // object with the latter
int m_transporterLink; // part
float m_lastEnergy;
float m_shield; // shield
float m_range; // flight range
float m_aTime;
float m_shotTime; // time since last shot
bool m_bVirusMode; // virus activated/triggered
float m_virusTime; // lifetime of the virus
float m_lastVirusParticle;
bool m_bSelect; // object selected
bool m_bSelectable; // selectable object
bool m_bCheckToken; // object with audited tokens
bool m_underground; // object active but undetectable
bool m_damaging;
float m_damageTime;
DeathType m_dying;
bool m_bFlat;
bool m_bTrainer; // drive vehicle (without remote)
bool m_bToy; // toy key
bool m_bManual; // manual control (Scribbler)
float m_gunGoalV;
float m_gunGoalH;
Gfx::CameraType m_cameraType;
bool m_bCameraLock;
float m_magnifyDamage;
Math::Sphere m_jostlingSphere;
float m_shieldRadius;
int m_totalPart;
ObjectPart m_objectPart[OBJECTMAXPART];
int m_partiSel[4];
EventType m_buttonAxe;
float m_time;
float m_burnTime;
float m_reactorRange;
bool m_traceDown;
TraceColor m_traceColor;
float m_traceWidth;
bool m_bulletWall = false;
bool m_hasCargoSlot;
bool m_hasPowerSlot;
};
|