← Back to branch summary

~agrip-hackers/sns/trunk

« back to all changes in this revision

Viewing changes to zq-repo/qc/frikbot/bot_fight.qc

  • Committer: Matthew Tylee Atkinson
  • Date: 2008-03-07 20:15:20 UTC
  • Revision ID: mta@agrip.org.uk-20080307201520-uj9sa2jrytx91b2t
Remove non-SNS components.

Show diffs side-by-side

added added

removed removed

Lines of Context:
zq-repo/qc/frikbot/bot_fight.qc
1
 
.entity avoid;
2
 
 
3
 
float bot_size_player (entity e)
4
 
{
5
 
        float   sz;
6
 
 
7
 
        sz = e.health + e.armorvalue * e.armortype;
8
 
        if (e.weapon == IT_LIGHTNING)
9
 
                sz = sz + 60;
10
 
        else if (e.weapon == IT_ROCKET_LAUNCHER)
11
 
                sz = sz + 60;
12
 
        else if (e.weapon == IT_GRENADE_LAUNCHER)
13
 
                sz = sz + 50;
14
 
        else if (e.weapon == IT_SUPER_NAILGUN)
15
 
                sz = sz + 50;
16
 
        else if (e.weapon == IT_NAILGUN)
17
 
                sz = sz + 40;
18
 
        else if (e.weapon == IT_SUPER_SHOTGUN)
19
 
                sz = sz + 40;
20
 
        else if (e.weapon == IT_SHOTGUN)
21
 
                sz = sz + 10;
22
 
        else if (e.weapon == IT_AXE)
23
 
                sz = sz - 50;
24
 
        if (e.items & IT_QUAD)
25
 
                sz = sz + 200;
26
 
        if (e.items & IT_INVULNERABILITY)
27
 
                sz = sz + 300;
28
 
        if (e.items & IT_INVISIBILITY)
29
 
                sz = sz + 250;
30
 
        return sz;
31
 
}
32
 
 
33
 
void bot_dodge_stuff ()
34
 
{
35
 
        entity  foe;
36
 
        float   foedist, avdist, foesz, flen, tsz;
37
 
        vector  v;
38
 
    string foe_team, self_team;
39
 
 
40
 
        if (waypoint_mode > WM_LOADED)
41
 
                return;
42
 
 
43
 
        self.avoid = world;
44
 
 
45
 
 
46
 
        if (self.enemy)
47
 
        {
48
 
                v = self.origin - realorigin(self.enemy);
49
 
                foedist = vlen(v);
50
 
                foesz = bot_size_player(self.enemy);
51
 
        }
52
 
        else 
53
 
        {
54
 
                foedist = 3000;
55
 
                foesz = 9999999;
56
 
        }
57
 
        avdist = 256;
58
 
 
59
 
        foe = find(world, classname, "grenade");
60
 
        while(foe)
61
 
        {
62
 
                flen = vlen(foe.origin - self.origin);
63
 
                if (flen < avdist)
64
 
                {
65
 
                        avdist = flen;
66
 
                        self.avoid = foe;
67
 
                }
68
 
                foe = find(foe, classname, "grenade");
69
 
        }
70
 
        if (!self.avoid)
71
 
        {
72
 
                foe = find(world, classname, "missile");
73
 
                while(foe)
74
 
                {
75
 
                        if (foe.owner != self)
76
 
                        {
77
 
                                flen = vlen(foe.origin - self.origin);
78
 
                                if (flen < avdist)
79
 
                                {
80
 
                                        avdist = flen;
81
 
                                        self.avoid = foe;
82
 
                                }
83
 
                        }
84
 
                        foe = find(foe, classname, "missile");
85
 
                }
86
 
                if (!self.avoid)
87
 
                {
88
 
                        foe = find(world, classname, "spike");
89
 
                        while(foe)
90
 
                        {
91
 
                                if (foe.owner != self)
92
 
                                {
93
 
                                        flen = vlen(foe.origin - self.origin);
94
 
                                        if (flen < avdist)
95
 
                                        {
96
 
                                                avdist = flen;
97
 
                                                self.avoid = foe;
98
 
                                        }
99
 
                                }
100
 
                                foe = find(foe, classname, "spike");
101
 
                        }
102
 
                }
103
 
        }
104
 
        if (coop)
105
 
        {
106
 
                if (!self.enemy)
107
 
                {
108
 
                        foe = findradius(self.origin, foedist);
109
 
                        while(foe)
110
 
                        {
111
 
                                if(foe.flags & FL_MONSTER)
112
 
                                {
113
 
                                        if(foe.health > 0)
114
 
                                        {
115
 
                                                flen = vlen(foe.origin - self.origin);
116
 
                                                if (flen < foedist)
117
 
                                                {
118
 
                                                        tsz = bot_size_player(foe);
119
 
                                                        if (tsz < foesz)
120
 
                                                        {
121
 
                                                                if (fisible(foe))
122
 
                                                                {
123
 
                                                                        self.enemy = foe;
124
 
                                                                        foedist = flen;
125
 
                                                                        foesz = tsz;
126
 
                                                                }
127
 
                                                        }
128
 
                                                }
129
 
                                        }
130
 
                                }
131
 
                                foe = foe.chain;
132
 
                        }
133
 
                }               
134
 
        }
135
 
        else
136
 
        {
137
 
                foe = player_head;
138
 
                while(foe)
139
 
                {
140
 
                        if(foe != self)
141
 
                        {
142
 
                                if (foe.modelindex != 0)
143
 
                                {
144
 
                                        if (foe.health > 0)
145
 
                                        {
146
 
                        self_team = infokey (self, "team");
147
 
                        foe_team = infokey (foe, "team");
148
 
                                                if (!(teamplay && self_team == foe_team))
149
 
                                                {
150
 
                                                        flen = vlen(foe.origin - self.origin);
151
 
                                                        if (flen < foedist)
152
 
                                                        {
153
 
                                                                tsz = bot_size_player(foe);
154
 
                                                                if (tsz < foesz)
155
 
                                                                {
156
 
                                                                        if (fov(foe) || foe.b_sound > time || self.b_skill == 3)
157
 
                                                                        {
158
 
                                                                                if (fisible(foe))
159
 
                                                                                {
160
 
                                                                                        self.enemy = foe;
161
 
                                                                                        foedist = vlen(foe.origin - self.origin);
162
 
                                                                                }
163
 
                                                                        }
164
 
                                                                }
165
 
                                                        }
166
 
                                                }
167
 
                                        }
168
 
                                }
169
 
                        }
170
 
                        foe = foe._next;
171
 
                }
172
 
        }
173
 
}
174
 
 
175
 
 
176
 
 
177
 
 
178
 
/*
179
 
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
180
 
 
181
 
weapon_range
182
 
 
183
 
_x "sweet spot range" - try to maintain this range if possible
184
 
_y minimum range bot can be to be effective (rl/gl) (move away)
185
 
_z maximum range bot can be to be effective (lg/axe) (move in)
186
 
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
187
 
*/
188
 
 
189
 
vector weapon_range (float wep)
190
 
{
191
 
        if (wep == IT_AXE)
192
 
                return '48 0 64';
193
 
        else if (wep == IT_SHOTGUN)
194
 
                return '128 0 99999';
195
 
        else if (wep == IT_SUPER_SHOTGUN)
196
 
                return '128 0 99999';
197
 
        else if (wep == IT_NAILGUN)
198
 
                return '180 0 3000';
199
 
        else if (wep == IT_SUPER_NAILGUN)
200
 
                return '180 0 3000';
201
 
        else if (wep == IT_GRENADE_LAUNCHER)
202
 
                return '180 48 3000';
203
 
        else if (wep == IT_ROCKET_LAUNCHER)
204
 
                return '180 48 3000';
205
 
        else if (wep == IT_LIGHTNING)
206
 
                return '350 0 512';
207
 
}
208
 
/*
209
 
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
210
 
 
211
 
bot_weapon_switch
212
 
 
213
 
Pick a weapon based on range / ammo
214
 
 
215
 
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
216
 
*/
217
 
 
218
 
void bot_weapon_switch (float brange)
219
 
{
220
 
        float   it, flag, pulse;
221
 
        vector  v;
222
 
 
223
 
        it = self.items & 127;
224
 
 
225
 
        while(it)
226
 
        {
227
 
                if ((self.ammo_rockets >= 1) && (it & IT_ROCKET_LAUNCHER))
228
 
                {
229
 
                        flag = IT_ROCKET_LAUNCHER;
230
 
                        pulse = 7;
231
 
                }
232
 
                else if (self.waterlevel <= 1 && self.ammo_cells >= 1 && (it & IT_LIGHTNING))
233
 
                {
234
 
                        flag = IT_LIGHTNING;
235
 
                        pulse = 8;
236
 
                }
237
 
                else if(self.ammo_nails >= 2 && (it & IT_SUPER_NAILGUN))
238
 
                {
239
 
                        flag = IT_SUPER_NAILGUN;
240
 
                        pulse = 5;
241
 
                }
242
 
                else if ((self.ammo_rockets >= 1) && (it & IT_GRENADE_LAUNCHER))
243
 
                {
244
 
                        flag = IT_GRENADE_LAUNCHER;
245
 
                        pulse = 6;
246
 
                }
247
 
                else if(self.ammo_shells >= 2 && (it & IT_SUPER_SHOTGUN))
248
 
                {
249
 
                        flag = IT_SUPER_SHOTGUN;
250
 
                        pulse = 3;
251
 
                }
252
 
                else if(self.ammo_nails >= 1 && (it & IT_NAILGUN))
253
 
                {
254
 
                        flag = IT_NAILGUN;
255
 
                        pulse = 4;
256
 
                }
257
 
                else if(self.ammo_shells >= 1 && (it & IT_SHOTGUN))
258
 
                {
259
 
                        flag = IT_SHOTGUN;
260
 
                        pulse = 2;
261
 
                }
262
 
                else
263
 
                {
264
 
                        if (pulse)
265
 
                                self.impulse = pulse;
266
 
                        return;
267
 
                }
268
 
 
269
 
                if (brange == -1)
270
 
                {
271
 
                        if (pulse)
272
 
                                self.impulse = pulse;
273
 
                        return;
274
 
                }
275
 
 
276
 
                v = weapon_range(flag);
277
 
                if (brange < v_y || brange > v_z)
278
 
                        it = it - flag;
279
 
                else
280
 
                {
281
 
                        if (pulse)
282
 
                                self.impulse = pulse;
283
 
                        return;
284
 
                }
285
 
        }
286
 
}
287
 
 
288
 
void bot_shoot ()
289
 
{
290
 
        // quick little function to stop making him shoot the wrong way ! Argh
291
 
        float   g;
292
 
        g = angcomp(self.v_angle_x, self.b_angle_x);
293
 
        if (fabs(g) > 30)
294
 
                return; // argh, too far away
295
 
        g = angcomp(self.v_angle_y, self.b_angle_y);
296
 
        if (fabs(g) > 30)
297
 
                return; // not again!
298
 
        self.button0 = true;
299
 
}
300
 
 
301
 
/*
302
 
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
303
 
 
304
 
Bot_fight_style
305
 
 
306
 
This is the core of the bot's thinking when
307
 
attacking an enemy. 
308
 
 
309
 
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
310
 
*/
311
 
 
312
 
void bot_fight_style ()
313
 
{
314
 
        vector  v, v1, v2, org;
315
 
        float   foedist, mysz, foesz;
316
 
    string trace_ent_team, self_team;
317
 
 
318
 
        if (self.enemy.health <= 0)
319
 
        {
320
 
                self.enemy = world;
321
 
                return;
322
 
        }
323
 
        else if (!self.enemy.takedamage)
324
 
        {
325
 
                self.enemy = world;
326
 
                return;
327
 
        }
328
 
        else if (!fisible(self.enemy))
329
 
        {
330
 
                self.enemy = world;
331
 
                return;
332
 
        }
333
 
 
334
 
        org = realorigin(self.enemy);
335
 
        makevectors(self.v_angle);
336
 
 
337
 
        // decide if I should shoot
338
 
 
339
 
        foedist = vlen(org - self.origin);
340
 
        v = weapon_range(self.weapon);
341
 
        if (foedist > v_y && foedist < v_z)
342
 
        {
343
 
                traceline(self.origin + self.view_ofs, self.origin + self.view_ofs + v_forward * v_z, false, self);
344
 
                if (vlen(trace_endpos - (self.origin + self.view_ofs)) >= v_y)
345
 
                {
346
 
                        // try to avoid shooting teammates
347
 
                        if (trace_ent.classname == "player")
348
 
            {
349
 
                trace_ent_team = infokey (trace_ent, "team");
350
 
                self_team = infokey (self, "team");
351
 
                                if ((trace_ent_team == self_team && teamplay) || (coop))
352
 
                                        return;
353
 
            }
354
 
                        bot_shoot();
355
 
                }
356
 
        }
357
 
        else
358
 
                bot_weapon_switch(foedist);
359
 
 
360
 
        if (!(self.b_aiflags & (AI_PRECISION | AI_BLIND | AI_OBSTRUCTED)))
361
 
        {
362
 
                foesz = bot_size_player(self.enemy);
363
 
                mysz = bot_size_player(self) + 5;
364
 
 
365
 
                if (foesz > mysz)
366
 
                {
367
 
                        if (teamplay)
368
 
                        {
369
 
                                if (random() < 0.02)
370
 
                                {
371
 
                                        bot_start_topic(5);
372
 
                                        self.b_chattime = 1;
373
 
                                }
374
 
                        }
375
 
                        
376
 
                        return;
377
 
                }
378
 
                else if (mysz < 140)
379
 
                        return;
380
 
                else if (self.avoid)
381
 
                {
382
 
                        if (self.avoid.velocity)
383
 
                                v = self.avoid.velocity;
384
 
                        else
385
 
                                v = normalize(self.avoid.origin - self.origin);
386
 
                        v1_x = v_y;
387
 
                        v1_y = v_y * -1;
388
 
                        v2_x = v_y;
389
 
                        v2_y = v_y * -1;
390
 
                        foedist = vlen(self.avoid.origin - (self.origin + v1));
391
 
                        if (foedist < vlen(self.avoid.origin - (self.origin + v2)))
392
 
                                frik_walkmove(v2);
393
 
                        else
394
 
                                frik_walkmove(v1);
395
 
                }
396
 
                else if (!self.enemy.flags & FL_MONSTER)
397
 
                {
398
 
                        if (foedist + 32 <  v_x)
399
 
                                frik_walkmove(self.origin - org);
400
 
                        else if (foedist - 32 >  v_x)
401
 
                                frik_walkmove(org - self.origin);
402
 
                        else if (self.wallhug)
403
 
                                frik_walkmove(v_right);
404
 
                        else
405
 
                                frik_walkmove(v_right * -1);
406
 
                }
407
 
        }
408
 
        else
409
 
        {
410
 
                foesz = bot_size_player(self.enemy);
411
 
                mysz = bot_size_player(self) + 5;
412
 
 
413
 
                if (foesz > mysz)
414
 
                        return;
415
 
                else if (mysz < 140)
416
 
                        return;
417
 
                self.keys = self.keys & 960;
418
 
        }
419
 
}
420
 
 
421