← Back to branch summary

~ubuntu-branches/ubuntu/lucid/warzone2100/lucid

« back to all changes in this revision

Viewing changes to data/base/multiplay/script/multiplay.slo

  • Committer: Bazaar Package Importer
  • Author(s): Christoph Egger, Paul Wise, Christoph Egger
  • Date: 2009-06-29 17:12:52 UTC
  • mfrom: (1.1.11 upstream) (2.1.7 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090629171252-5ddnlfg3zfchrega
Tags: 2.2.1+dfsg1-1
http://bugs.debian.org/534962
https://launchpad.net/bugs/372872
[ Paul Wise ]
* New upstream release (Closes: #534962)
* Adjust the flex build-depends to take account of the conflict
  with all the versions of flex 2.5.34 (LP: #372872)
* Make the -music Recommends more strict, 2.1 music doesn't work
  with 2.2.
* Upstream moved the downloads to sourceforge, update the watch file
* Bump Standards-Version, no changes needed
* Drop use of dh_desktop since it no longer does anything
* Recommend the new warzone2100-video package, version 2.2 or similar
* Mention the warzone2100 crash reports in the -dbg package description

[ Christoph Egger ]
* Replace CC-2.0 graphic from cybersphinx, create a new tarball
* Add myself to uploaders

Show diffs side-by-side

added added

removed removed

Lines of Context:
data/base/multiplay/script/multiplay.slo
 
1
//
 
2
// Multi-player script for upto 8 players.
 
3
//
 
4
 
 
5
public  STRUCTURESTAT   command;                        
 
6
public  STRUCTURESTAT   factory;                        
 
7
public  STRUCTURESTAT   wall;                   
 
8
public  STRUCTURESTAT   cornerWall;             
 
9
public  STRUCTURESTAT   oilDerrick;             
 
10
public  STRUCTURESTAT   powerGen;               
 
11
public  STRUCTURESTAT   research;
 
12
public  STRUCTURESTAT   commandrelay;
 
13
public  STRUCTURESTAT   cybfac;
 
14
public  STRUCTURESTAT   vtolfac;
 
15
 
 
16
// starting technologies.
 
17
public  int                             numtecP0, numtecP1, numtecP2, numtecP3,numtecP4, numtecP5, numtecP6, numtecP7;
 
18
public  RESEARCHSTAT    tecP0[5], tecP1[5], tecP2[5], tecP3[5], tecP4[5], tecP5[5], tecP6[5], tecP7[5];
 
19
 
 
20
public  int                             numCleanTech,   numBaseTech,    numDefTech;
 
21
public  RESEARCHSTAT    cleanTech[32],  baseTech[32],   defTech[64];
 
22
 
 
23
// research topics
 
24
public  int                             numResP0, numResP1, numResP2, numResP3, numResP4, numResP5, numResP6, numResP7;
 
25
public  RESEARCHSTAT    resP0[5], resP1[5], resP2[5], resP3[5], resP4[5], resP5[5], resP6[5], resP7[5];
 
26
 
 
27
public  int                             numCleanRes,    numBaseRes,             numDefRes;
 
28
public  RESEARCHSTAT    cleanRes[10],   baseRes[10],    defRes[10];             
 
29
 
 
30
//      Other Stuff
 
31
private INT                             count;
 
32
private INT                             playnum;
 
33
private BOOL                    gamenotwon;
 
34
 
 
35
// Base Under Attack Stuff 
 
36
private STRUCTURE               hitStruc;
 
37
private BASEOBJ                 attackerObj;
 
38
private int                             t;
 
39
public  SOUND                   attackSnd1;     
 
40
 
 
41
public  INTMESSAGE              endMsg, winMsg;
 
42
 
 
43
// /////////////////////////////////////////////////////////////////
 
44
 
 
45
trigger endConditions(every, 100);      
 
46
 
 
47
// /////////////////////////////////////////////////////////////////
 
48
//this event is called once the game has initialised itself
 
49
 
 
50
event initialisedEvent(CALL_GAMEINIT)
 
51
{
 
52
        playnum=0;
 
53
        while (playnum < 8)
 
54
        {
 
55
                if(multiPlayerBaseType == CAMP_CLEAN)
 
56
                {
 
57
                        setPowerLevel(750,playnum);     
 
58
                        count = 0;                                                              
 
59
                        while (count < numCleanTech)
 
60
                        {
 
61
                                completeResearch(cleanTech[count], playnum);
 
62
                                count = count +1;
 
63
                        }
 
64
                        
 
65
                        count = 0;
 
66
                        while (count < numCleanRes)
 
67
                        {
 
68
                                enableResearch(cleanRes[count], playnum);
 
69
                                count = count +1;
 
70
                        }
 
71
                }
 
72
                else if(multiPlayerBaseType == CAMP_BASE)
 
73
                {
 
74
                        setPowerLevel(1000,playnum);    
 
75
                        count = 0;                                                              
 
76
                        while (count < numBaseTech)
 
77
                        {
 
78
                                completeResearch(baseTech[count], playnum);
 
79
                                count = count +1;
 
80
                        }
 
81
                        count = 0;                                                              
 
82
                        while (count < numBaseRes)
 
83
                        {
 
84
                                enableResearch(baseRes[count], playnum);
 
85
                                count = count +1;
 
86
                        }
 
87
                }
 
88
                else
 
89
                {       
 
90
                        setPowerLevel(2000,playnum);            
 
91
                        count = 0;                                                              
 
92
                        while (count < numDefTech)
 
93
                        {
 
94
                                completeResearch(defTech[count], playnum);
 
95
                                count = count +1;
 
96
                        }
 
97
                        count = 0;                                                              
 
98
                        while (count < numDefRes)
 
99
                        {
 
100
                                enableResearch(defRes[count], playnum);
 
101
                                count = count +1;
 
102
                        }
 
103
                }
 
104
        
 
105
                playnum = playnum + 1;          
 
106
        }
 
107
 
 
108
}
 
109
 
 
110
 
 
111
event initialisedEvent2(CALL_GAMEINIT)
 
112
{
 
113
 
 
114
        //set up the reticule buttons
 
115
        addReticuleButton(OPTIONS);
 
116
        addReticuleButton(CANCEL);
 
117
        addReticuleButton(BUILD);
 
118
        addReticuleButton(MANUFACTURE);
 
119
        addReticuleButton(RESEARCH);
 
120
        addReticuleButton(INTELMAP);
 
121
        addReticuleButton(DESIGN);
 
122
 
 
123
        playnum=0;
 
124
        while (playnum < 8)
 
125
        {
 
126
                enableStructure(command ,       playnum);               //make structures available to build
 
127
                enableStructure(factory,        playnum);
 
128
                //enableStructure(wall,         playnum);
 
129
                //enableStructure(cornerWall,   playnum);
 
130
                enableStructure(oilDerrick,     playnum);
 
131
                enableStructure(powerGen,       playnum);
 
132
                enableStructure(research,       playnum);
 
133
                
 
134
                setStructureLimits(factory,     5, playnum);    // set structure limits
 
135
                setStructureLimits(powerGen,    5, playnum);
 
136
                setStructureLimits(research,    5, playnum);
 
137
                setStructureLimits(command,     1, playnum);
 
138
                setStructureLimits(commandrelay,1, playnum);
 
139
                setStructureLimits(cybfac,      5, playnum);
 
140
                setStructureLimits(vtolfac,     5, playnum);
 
141
 
 
142
                playnum = playnum+1;
 
143
        }
 
144
        applyLimitSet();        // set limit options
 
145
 
 
146
        // player specific technology startups
 
147
        count = 0;
 
148
        while (count < numtecP0)
 
149
        {
 
150
                completeResearch(tecP0[count], 0);
 
151
                count = count +1;
 
152
        }
 
153
        count = 0;
 
154
        while (count < numtecP1)
 
155
        {
 
156
                completeResearch(tecP1[count], 1);
 
157
                count = count +1;
 
158
        }
 
159
        count = 0;
 
160
        while (count < numtecP2)
 
161
        {
 
162
                completeResearch(tecP2[count], 2);
 
163
                count = count +1;
 
164
        }
 
165
        count = 0;
 
166
        while (count < numtecP3)
 
167
        {
 
168
                completeResearch(tecP3[count], 3);
 
169
                count = count +1;
 
170
        }
 
171
        count = 0;
 
172
        while (count < numtecP4)
 
173
        {
 
174
                completeResearch(tecP4[count], 4);
 
175
                count = count +1;
 
176
        }
 
177
        count = 0;
 
178
        while (count < numtecP5)
 
179
        {
 
180
                completeResearch(tecP5[count], 5);
 
181
                count = count +1;
 
182
        }
 
183
        count = 0;
 
184
        while (count < numtecP6)
 
185
        {
 
186
                completeResearch(tecP6[count], 6);
 
187
                count = count +1;
 
188
        }
 
189
        count = 0;
 
190
        while (count < numtecP7)
 
191
        {
 
192
                completeResearch(tecP7[count], 7);
 
193
                count = count +1;
 
194
        }
 
195
 
 
196
 
 
197
        // player specific research startups
 
198
        count = 0;
 
199
        while (count < numResP0)
 
200
        {
 
201
                enableResearch(resP0[count], 0);
 
202
                count = count +1;
 
203
        }
 
204
        count = 0;
 
205
        while (count < numResP1)
 
206
        {
 
207
                enableResearch(resP1[count], 1);
 
208
                count = count +1;
 
209
        }
 
210
        count = 0;
 
211
        while (count < numResP2)
 
212
        {
 
213
                enableResearch(resP2[count], 2);
 
214
                count = count +1;
 
215
        }
 
216
        count = 0;
 
217
        while (count < numResP3)
 
218
        {
 
219
                enableResearch(resP3[count], 3);
 
220
                count = count +1;
 
221
        }
 
222
        count = 0;
 
223
        while (count < numResP4)
 
224
        {
 
225
                enableResearch(resP4[count], 4);
 
226
                count = count +1;
 
227
        }
 
228
        count = 0;
 
229
        while (count < numResP5)
 
230
        {
 
231
                enableResearch(resP5[count], 5);
 
232
                count = count +1;
 
233
        }
 
234
        count = 0;
 
235
        while (count < numResP6)
 
236
        {
 
237
                enableResearch(resP6[count], 6);
 
238
                count = count +1;
 
239
        }
 
240
        count = 0;
 
241
        while (count < numResP7)
 
242
        {
 
243
                enableResearch(resP7[count], 7);
 
244
                count = count +1;
 
245
        }
 
246
}
 
247
 
 
248
 
 
249
 
 
250
// /////////////////////////////////////////////////////////////////
 
251
event checkEndConditions (endConditions)
 
252
{
 
253
        // Losing Conditions
 
254
//      if(        ( not (multiPlayerGameType == DMATCH))
 
255
          if(  ( not anyDroidsLeft(selectedPlayer))
 
256
          and  ( not anyFactoriesLeft(selectedPlayer))  
 
257
//        and  ( not playerInAlliance(selectedPlayer)) 
 
258
          )
 
259
        {
 
260
//              addMessage(endMsg, MISS_MSG, 0, true);
 
261
//              pause(10);
 
262
//              gameOver(FALSE);
 
263
                gameOverMessage(endMsg, MISS_MSG, 0, FALSE);
 
264
                setEventTrigger(checkEndConditions, inactive);
 
265
                exit;
 
266
        }
 
267
        
 
268
        
 
269
        // Winning Conditions
 
270
        playnum=0;
 
271
        gamenotwon = FALSE;
 
272
 
 
273
        ////////////////
 
274
        // Campaign Game
 
275
        if(multiPlayerGameType == CAMPAIGN)
 
276
        {
 
277
                // check humans are still about
 
278
                while (playnum < multiPlayerMaxPlayers)
 
279
                {
 
280
                        if (playnum != selectedPlayer)
 
281
                        {
 
282
                                if(anyDroidsLeft(playnum) or anyFactoriesLeft(playnum) )
 
283
                                {
 
284
                                        gamenotwon = TRUE;
 
285
                                }
 
286
                        }
 
287
                        playnum = playnum + 1;                  
 
288
                }
 
289
                
 
290
                //check computer/babas are wiped out completely
 
291
                while(playnum<8)
 
292
                {
 
293
                        if(not isHumanPlayer(playnum))
 
294
                        {
 
295
                                if(anyDroidsLeft(playnum) or anyStructButWallsLeft(playnum))
 
296
                                {
 
297
                                        gamenotwon = TRUE;
 
298
                                }
 
299
                        }
 
300
                        playnum = playnum + 1;                  
 
301
                }                       
 
302
        }
 
303
        
 
304
        if(gamenotwon == FALSE)
 
305
        {
 
306
//              addMessage(winMsg, MISS_MSG, 0, true);
 
307
//              pause(10);
 
308
//              gameOver(TRUE);
 
309
                gameOverMessage(winMsg, MISS_MSG, 0, TRUE);
 
310
                setEventTrigger(checkEndConditions, inactive);
 
311
        }       
 
312
}
 
313
 
 
314
// /////////////////////////////////////////////////////////////////
 
315
/* Base Under Attack */
 
316
event baseHit(CALL_STRUCT_ATTACKED, selectedPlayer, ref hitStruc, ref attackerObj)
 
317
{
 
318
        if (t >= 10)
 
319
        {
 
320
                t=0;
 
321
                if (hitStruc != NULLOBJECT)
 
322
                {
 
323
                        playSoundPos(attackSnd1, selectedPlayer, hitStruc.x, hitStruc.y, hitStruc.z);   //show position if still alive
 
324
                }
 
325
                else
 
326
                {
 
327
                        playSound(attackSnd1, selectedPlayer);
 
328
                }
 
329
        }
 
330
}
 
331
 
 
332
event everySec(every, 10)
 
333
{
 
334
        t=t+1;
 
335
}
 
336
 
 
337
//go to where the structure being attacked is on CTRL B
 
338
event seeBaseHit(CALL_MISSION_END)
 
339
{
 
340
        if (hitStruc!=NULLOBJECT)
 
341
        {
 
342
                centreView(hitStruc);
 
343
                t=0;                                                    //flag known about!
 
344
        }
 
345
}
 
346