1 #include "3dc.h"
2 #include "inline.h"
3 #include "module.h"
4
5 #include "stratdef.h"
6 #include "gamedef.h"
7 #include "bh_types.h"
8
9 #include "weapons.h"
10 #include "comp_shp.h"
11 #include "inventry.h"
12 #include "triggers.h"
13
14 #include "dynblock.h"
15 #include "dynamics.h"
16
17 #define UseLocalAssert Yes
18
19 #include "ourasert.h"
20
21 #include "pmove.h"
22 #include "pvisible.h"
23 #include "bh_pred.h"
24 #include "bh_swdor.h"
25 #include "bh_ldoor.h"
26 #include "bh_plift.h"
27 #include "load_shp.h"
28 #include "lighting.h"
29 #include "bh_lnksw.h"
30 #include "bh_binsw.h"
31 #include "bh_lift.h"
32
33 #include "psnd.h"
34 #include "savegame.h"
35
36 /* for win95 net game support */
37 #include "pldghost.h"
38
39
40 extern int NormalFrameTime;
41
42
LiftDoorBehaveInit(void * bhdata,STRATEGYBLOCK * sbptr)43 void* LiftDoorBehaveInit(void* bhdata, STRATEGYBLOCK* sbptr)
44 {
45 LIFT_DOOR_BEHAV_BLOCK *doorbhv;
46 LIFT_DOOR_TOOLS_TEMPLATE *doortt;
47 MORPHCTRL* morphctrl;
48 MORPHHEADER* morphheader;
49 MORPHFRAME* morphframe;
50 MODULE * my_mod;
51
52 doorbhv = (LIFT_DOOR_BEHAV_BLOCK*)AllocateMem(sizeof(LIFT_DOOR_BEHAV_BLOCK));
53 if (!doorbhv)
54 {
55 memoryInitialisationFailure = 1;
56 return ((void *)NULL);
57 }
58
59 doorbhv->bhvr_type = I_BehaviourLiftDoor;
60
61 // from loaders
62
63 doortt = (LIFT_DOOR_TOOLS_TEMPLATE*)bhdata;
64
65 // Set up a new Morph Control
66 morphctrl = (MORPHCTRL*)AllocateMem(sizeof(MORPHCTRL));
67 if (!morphctrl)
68 {
69 memoryInitialisationFailure = 1;
70 return ((void *)NULL);
71 }
72 morphheader = (MORPHHEADER*)AllocateMem(sizeof(MORPHHEADER));
73 if (!morphheader)
74 {
75 memoryInitialisationFailure = 1;
76 return ((void *)NULL);
77 }
78 morphframe = (MORPHFRAME*)AllocateMem(sizeof(MORPHFRAME));
79 if (!morphframe)
80 {
81 memoryInitialisationFailure = 1;
82 return ((void *)NULL);
83 }
84
85 morphframe->mf_shape1 = doortt->shape_open;
86 morphframe->mf_shape2 = doortt->shape_closed;
87
88 morphheader->mph_numframes = 1;
89 morphheader->mph_maxframes = ONE_FIXED;
90 morphheader->mph_frames = morphframe;
91
92 morphctrl->ObMorphCurrFrame = 0;
93 morphctrl->ObMorphFlags = 0;
94 morphctrl->ObMorphSpeed = 0;
95 morphctrl->ObMorphHeader = morphheader;
96
97 // Copy the name over
98 COPY_NAME (sbptr->SBname, doortt->nameID);
99
100 // Setup module ref
101 {
102 MREF mref=doortt->my_module;
103 ConvertModuleNameToPointer (&mref, MainSceneArray[0]->sm_marray);
104 my_mod = mref.mref_ptr;
105 }
106 GLOBALASSERT (my_mod);
107
108 my_mod->m_sbptr = sbptr;
109 sbptr->SBmoptr = my_mod;
110 sbptr->SBmomptr = my_mod->m_mapptr;
111 sbptr->SBflags.no_displayblock = 1;
112
113 doorbhv->door_state = doortt->state;
114 doorbhv->PDmctrl = morphctrl;
115 doorbhv->door_closing_speed=doortt->door_closing_speed;
116 doorbhv->door_opening_speed=doortt->door_opening_speed;
117
118 // all lift doors have a closed starting state except the
119 // one where the lift is - fill in other data
120
121 sbptr->SBmorphctrl = doorbhv->PDmctrl;
122
123 if(doorbhv->door_state == I_door_open)
124 {
125 sbptr->SBmorphctrl->ObMorphCurrFrame = 0;
126 OpenDoor(sbptr->SBmorphctrl, DOOR_OPENFASTSPEED);
127 }
128 else
129 {
130 GLOBALASSERT(doorbhv->door_state == I_door_closed);
131 sbptr->SBmorphctrl->ObMorphCurrFrame = 1;
132 CloseDoor(sbptr->SBmorphctrl, DOOR_CLOSEFASTSPEED);
133 }
134 doorbhv->request_state = doorbhv->door_state;
135
136 // copy data into relevant structures
137
138 sbptr->SBmorphctrl = doorbhv->PDmctrl;
139
140 if(sbptr->SBmoptr)
141 {
142 sbptr->SBmoptr->m_flags |= m_flag_open;
143 }
144 if(sbptr->SBmomptr)
145 {
146 sbptr->SBmomptr->MapMorphHeader = sbptr->SBmorphctrl->ObMorphHeader;
147 }
148
149
150 doorbhv->SoundHandle=SOUND_NOACTIVEINDEX;
151
152 return((void*)doorbhv);
153 }
154
155
LiftDoorBehaveFun(STRATEGYBLOCK * sbptr)156 void LiftDoorBehaveFun(STRATEGYBLOCK* sbptr)
157 {
158 LIFT_DOOR_BEHAV_BLOCK *doorbhv;
159 MORPHCTRL *mctrl;
160 DISPLAYBLOCK* dptr;
161 MODULE *mptr;
162
163 GLOBALASSERT(sbptr);
164 doorbhv = (LIFT_DOOR_BEHAV_BLOCK*)sbptr->SBdataptr;
165 GLOBALASSERT((doorbhv->bhvr_type == I_BehaviourLiftDoor));
166 mctrl = doorbhv->PDmctrl;
167 GLOBALASSERT(mctrl);
168 mptr = sbptr->SBmoptr;
169 GLOBALASSERT(mptr);
170 dptr = sbptr->SBdptr;
171
172 /* update morphing.... */
173 UpdateMorphing(mctrl);
174
175 switch(doorbhv->door_state)
176 {
177 case I_door_opening:
178 {
179 mptr->m_flags |= m_flag_open;
180 if(mctrl->ObMorphFlags & mph_flag_finished)
181 {
182 if (doorbhv->SoundHandle!=SOUND_NOACTIVEINDEX)
183 {
184 Sound_Play(SID_DOOREND,"d",&mptr->m_world);
185 Sound_Stop(doorbhv->SoundHandle);
186 }
187 doorbhv->door_state = I_door_open;
188 }
189 break;
190 }
191 case I_door_closing:
192 {
193 if(mctrl->ObMorphFlags & mph_flag_finished)
194 {
195 if (doorbhv->SoundHandle!=SOUND_NOACTIVEINDEX)
196 {
197 Sound_Play(SID_DOOREND,"d",&mptr->m_world);
198 Sound_Stop(doorbhv->SoundHandle);
199 }
200 doorbhv->door_state = I_door_closed;
201 mptr->m_flags &= ~m_flag_open;
202 }
203 else if(AnythingInMyModule(sbptr->SBmoptr))
204 {
205 if (doorbhv->SoundHandle==SOUND_NOACTIVEINDEX)
206 {
207 Sound_Play(SID_DOORSTART,"d",&mptr->m_world);
208 Sound_Play(SID_DOORMID,"del",&mptr->m_world,&doorbhv->SoundHandle);
209 }
210 OpenDoor(mctrl, doorbhv->door_opening_speed);
211 doorbhv->door_state = I_door_opening;
212 mptr->m_flags |= m_flag_open;
213 }
214 break;
215 }
216 case I_door_open:
217 {
218 mptr->m_flags |= m_flag_open;
219 if(doorbhv->request_state == I_door_closed)
220 {
221
222 if (doorbhv->SoundHandle==SOUND_NOACTIVEINDEX)
223 {
224 Sound_Play(SID_DOORSTART,"d",&mptr->m_world);
225 Sound_Play(SID_DOORMID,"del",&mptr->m_world,&doorbhv->SoundHandle);
226 }
227
228 CloseDoor(mctrl, doorbhv->door_closing_speed);
229 doorbhv->door_state = I_door_closing;
230 }
231 break;
232 }
233 case I_door_closed:
234 {
235 mptr->m_flags &= ~m_flag_open;
236 if(doorbhv->request_state == I_door_open)
237 {
238
239 if (doorbhv->SoundHandle==SOUND_NOACTIVEINDEX)
240 {
241 Sound_Play(SID_DOORSTART,"d",&mptr->m_world);
242 Sound_Play(SID_DOORMID,"del",&mptr->m_world,&doorbhv->SoundHandle);
243 }
244
245 OpenDoor(mctrl, doorbhv->door_opening_speed);
246 doorbhv->door_state = I_door_opening;
247 mptr->m_flags |= m_flag_open;
248 }
249 break;
250 }
251 default:
252 LOCALASSERT(1==0);
253 }
254 }
255
256
257
258 /*--------------------**
259 ** Loading and Saving **
260 **--------------------*/
261 typedef struct lift_door_save_block
262 {
263 SAVE_BLOCK_STRATEGY_HEADER header;
264
265 DOOR_STATES door_state;
266 DOOR_STATES request_state;
267
268 //from the morph control
269 int ObMorphCurrFrame;
270 int ObMorphFlags;
271 int ObMorphSpeed;
272
273 }LIFT_DOOR_SAVE_BLOCK;
274
LoadStrategy_LiftDoor(SAVE_BLOCK_STRATEGY_HEADER * header)275 void LoadStrategy_LiftDoor(SAVE_BLOCK_STRATEGY_HEADER* header)
276 {
277 STRATEGYBLOCK* sbPtr;
278 LIFT_DOOR_BEHAV_BLOCK *doorbhv;
279 LIFT_DOOR_SAVE_BLOCK* block = (LIFT_DOOR_SAVE_BLOCK*) header;
280
281 if(header->size!=sizeof(*block)) return;
282
283 //find the existing strategy block
284 sbPtr = FindSBWithName(block->header.SBname);
285 if(!sbPtr) return;
286
287 //make sure the strategy found is of the right type
288 if(sbPtr->I_SBtype != I_BehaviourLiftDoor) return;
289
290 doorbhv = (LIFT_DOOR_BEHAV_BLOCK*)sbPtr->SBdataptr;
291
292 doorbhv->request_state = block->request_state;
293 doorbhv->door_state = block->door_state;
294
295
296 doorbhv->PDmctrl->ObMorphCurrFrame = block->ObMorphCurrFrame;
297 doorbhv->PDmctrl->ObMorphFlags = block->ObMorphFlags;
298 doorbhv->PDmctrl->ObMorphSpeed = block->ObMorphSpeed;
299
300 Load_SoundState(&doorbhv->SoundHandle);
301
302 }
303
SaveStrategy_LiftDoor(STRATEGYBLOCK * sbPtr)304 void SaveStrategy_LiftDoor(STRATEGYBLOCK* sbPtr)
305 {
306 LIFT_DOOR_SAVE_BLOCK *block;
307 LIFT_DOOR_BEHAV_BLOCK *doorbhv ;
308
309 doorbhv = (LIFT_DOOR_BEHAV_BLOCK*)sbPtr->SBdataptr;
310
311 GET_STRATEGY_SAVE_BLOCK(block,sbPtr);
312
313 block->request_state = doorbhv->request_state;
314 block->door_state = doorbhv->door_state;
315 block->ObMorphCurrFrame = doorbhv->PDmctrl->ObMorphCurrFrame;
316 block->ObMorphFlags = doorbhv->PDmctrl->ObMorphFlags;
317 block->ObMorphSpeed = doorbhv->PDmctrl->ObMorphSpeed;
318
319 Save_SoundState(&doorbhv->SoundHandle);
320 }
321
322 /*---------------------------**
323 ** End of loading and saving **
324 **---------------------------*/
325