← Back to branch summary

~ubuntu-branches/debian/stretch/assaultcube-data/stretch

« back to all changes in this revision

Viewing changes to source/src/bot/bot_util.h

  • Committer: Bazaar Package Importer
  • Author(s): Gonéri Le Bouder, Ansgar Burchardt, Gonéri Le Bouder
  • Date: 2010-04-02 23:37:55 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100402233755-kf74fxwlu634o6vg
Tags: 1.0.4+repack1-1
[ Ansgar Burchardt ]
* debian/control: fix typo in short description

[ Gonéri Le Bouder ]
* Upgrade to 1.0.4
* bump standards-version to 3.8.4
* Add Depends: ${misc:Depends} just to avoid a lintian warning
* Add a debian/source/format file for the same reason

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/src/bot/bot_util.h
 
1
#ifndef BOT_UTIL_H
 
2
#define BOT_UTIL_H
 
3
 
 
4
// Structure for storing traceresults
 
5
struct traceresult_s
 
6
{
 
7
     vec end;
 
8
     bool collided;
 
9
};
 
10
 
 
11
long RandomLong(long from, long to);
 
12
float RandomFloat(float from, float to);
 
13
void lsrand(unsigned long initial_seed);
 
14
 
 
15
void AnglesToVectors(vec angles, vec &forward, vec &right, vec &up);
 
16
float WrapXAngle(float angle);
 
17
float WrapYZAngle(float angle);
 
18
void TraceLine(vec from, vec to, dynent *pTracer, bool CheckPlayers, traceresult_s *tr,
 
19
               bool SkipTags=false);
 
20
float GetDistance(vec v1, vec v2);
 
21
float Get2DDistance(vec v1, vec v2);
 
22
bool IsVisible(vec v1, vec v2, dynent *tracer = NULL, bool SkipTags=false);
 
23
bool IsValidFile(const char *szFileName);
 
24
bool FileIsOlder(const char *szFileName1, const char *szFileName2);
 
25
vec PredictPos(vec pos, vec vel, float Time);
 
26
vec Normalize(vec v);
 
27
inline void makevec(vec *v, float x, float y, float z) { v->x=x; v->y=y; v->z=z; }
 
28
inline bool UnderWater(const vec &o) { return hdr.waterlevel>o.z-0.5f; }
 
29
inline bool InWater(const vec &o) { return hdr.waterlevel>=o.z; }
 
30
float GetYawDiff(float curyaw, vec v1, vec v2);
 
31
vec CrossProduct(const vec &a, const vec &b);
 
32
int GetDirection(const vec &angles, const vec &v1, const vec &v2);
 
33
float GetCubeFloor(int x, int y);
 
34
float GetCubeHeight(int x, int y);
 
35
const char *SkillNrToSkillName(short skillnr);
 
36
bool IsInGame(dynent *d);
 
37
 
 
38
// ==================================================================
 
39
// Code of TLinkedList - Start
 
40
// ==================================================================
 
41
 
 
42
template <class C> class TLinkedList
 
43
{
 
44
public:
 
45
     struct node_s
 
46
     {
 
47
          C Entry;
 
48
          node_s *next;
 
49
          node_s *prev;
 
50
 
 
51
          node_s(void) : next(NULL), prev(NULL)
 
52
          {
 
53
               //memset(&Entry, 0, sizeof(Entry));
 
54
          };
 
55
     };
 
56
 
 
57
     // member functions
 
58
 
 
59
     void AddNode(C entry)
 
60
     {
 
61
          if (!pNodeList)
 
62
          {
 
63
               pNodeList = new node_s;
 
64
               pNodeList->Entry = entry;
 
65
               pNodeList->next = NULL;
 
66
               pNodeList->prev = NULL;
 
67
               pLastNode = pNodeList;
 
68
               iNodeCount = 1;
 
69
          }
 
70
          else
 
71
          {
 
72
               pLastNode->next = new node_s;
 
73
               pLastNode->next->prev = pLastNode;
 
74
               pLastNode = pLastNode->next;
 
75
               pLastNode->Entry = entry;
 
76
               pLastNode->next = NULL;
 
77
               iNodeCount++;
 
78
          }
 
79
     }
 
80
 
 
81
     void PushNode(C Entry)
 
82
     {
 
83
          if (!pNodeList)
 
84
          {
 
85
               pNodeList = new node_s;
 
86
               pNodeList->Entry = Entry;
 
87
               pNodeList->next = NULL;
 
88
               pNodeList->prev = NULL;
 
89
               pLastNode = pNodeList;
 
90
               iNodeCount = 1;
 
91
          }
 
92
          else
 
93
          {
 
94
               node_s *pNew = new node_s;
 
95
               pNew->Entry = Entry;
 
96
               pNew->prev = NULL;
 
97
               pNew->next = pNodeList;
 
98
               pNodeList->prev = pNew;
 
99
               pNodeList = pNew;
 
100
               iNodeCount++;
 
101
          }
 
102
     }
 
103
 
 
104
     void DeleteEntry(C Entry)
 
105
     {
 
106
          node_s *pNode = pNodeList;
 
107
          if (!pNode)
 
108
               return;
 
109
 
 
110
          if (pNode->Entry == Entry) // first node
 
111
          {
 
112
               if (pNodeList == pLastNode)
 
113
                    pLastNode = NULL;
 
114
 
 
115
               pNodeList = pNodeList->next;
 
116
               if (pNodeList)
 
117
                    pNodeList->prev = NULL;
 
118
               pNode->next = NULL;
 
119
               delete pNode;
 
120
               pNode = NULL;
 
121
               iNodeCount--;
 
122
               return;
 
123
          }
 
124
 
 
125
          if (Entry == pLastNode->Entry) // last node
 
126
          {
 
127
               pNode = pLastNode;
 
128
               pLastNode = pLastNode->prev;
 
129
               pLastNode->next = NULL;
 
130
 
 
131
               pNode->next = NULL;
 
132
               pNode->prev = NULL;
 
133
               delete pNode;
 
134
               pNode = NULL;
 
135
               iNodeCount--;
 
136
               return;
 
137
          }
 
138
 
 
139
          // node is somewhere in the middle
 
140
          pNode = SearchNode(Entry);
 
141
 
 
142
          if (!pNode)
 
143
               return;
 
144
 
 
145
          node_s *pPrevNode = pNode->prev;
 
146
 
 
147
          if (!pPrevNode)
 
148
               return;
 
149
 
 
150
          // unlink pNode
 
151
          pNode->next->prev = pPrevNode;
 
152
          pPrevNode->next = pNode->next;
 
153
 
 
154
          pNode->next = NULL;
 
155
          pNode->prev = NULL;
 
156
          delete pNode;
 
157
          pNode = NULL;
 
158
          iNodeCount--;
 
159
     }
 
160
 
 
161
     void DeleteNode(node_s *pNode)
 
162
     {
 
163
          if (!pNode)
 
164
               return;
 
165
 
 
166
          if (pNodeList == pNode) // first node
 
167
          {
 
168
               if (pNodeList == pLastNode)
 
169
                    pLastNode = pNodeList->next;
 
170
 
 
171
               pNodeList = pNodeList->next;
 
172
               if (pNodeList)
 
173
                    pNodeList->prev = NULL;
 
174
               pNode->next = NULL;
 
175
               delete pNode;
 
176
               pNode = NULL;
 
177
               iNodeCount--;
 
178
               return;
 
179
          }
 
180
 
 
181
          if (pNode == pLastNode) // last node
 
182
          {
 
183
               pNode = pLastNode;
 
184
               pLastNode = pLastNode->prev;
 
185
               pLastNode->next = NULL;
 
186
 
 
187
               pNode->next = NULL;
 
188
               pNode->prev = NULL;
 
189
               delete pNode;
 
190
               pNode = NULL;
 
191
               iNodeCount--;
 
192
               return;
 
193
          }
 
194
 
 
195
          // node is somewhere in the middle
 
196
 
 
197
          node_s *pPrevNode = pNode->prev;
 
198
 
 
199
          if (!pPrevNode)
 
200
               return;
 
201
 
 
202
          // unlink pNode
 
203
          pNode->next->prev = pPrevNode;
 
204
          pPrevNode->next = pNode->next;
 
205
 
 
206
          pNode->next = NULL;
 
207
          pNode->prev = NULL;
 
208
          delete pNode;
 
209
          pNode = NULL;
 
210
          iNodeCount--;
 
211
     }
 
212
 
 
213
     void DeleteAllNodes(void)
 
214
     {
 
215
          node_s *pNode = pNodeList;
 
216
          node_s *pTemp;
 
217
          while (pNode != NULL)
 
218
          {
 
219
               pTemp = pNode;
 
220
               pNode = pNode->next;
 
221
               pTemp->next = NULL;
 
222
               pTemp->prev = NULL;
 
223
               delete pTemp;
 
224
          }
 
225
          pNodeList = pLastNode = NULL;
 
226
          iNodeCount = 0;
 
227
     }
 
228
 
 
229
     void Reset(void) // Special case, doesn't delete existing nodes
 
230
     {
 
231
          pNodeList = pLastNode = NULL;
 
232
          iNodeCount = 0;
 
233
     }
 
234
 
 
235
     node_s *SearchNode(C Entry)
 
236
     {
 
237
          node_s *pNode = pNodeList;
 
238
          while(pNode)
 
239
          {
 
240
               if (pNode->Entry == Entry)
 
241
                    return pNode;
 
242
               pNode = pNode->next;
 
243
          }
 
244
          return NULL;
 
245
     }
 
246
 
 
247
     C Pop(void)
 
248
     {
 
249
          if (!pNodeList)
 
250
               return static_cast<C>(NULL);
 
251
 
 
252
          C Entry = pNodeList->Entry;
 
253
          DeleteNode(pNodeList);
 
254
          return Entry;
 
255
     }
 
256
 
 
257
     node_s *GetFirst(void) {
 
258
                 return pNodeList;
 
259
         };
 
260
     node_s *GetLast(void) { return pLastNode; };
 
261
 
 
262
     void EditEntry(C OrigEntry, C NewVal)
 
263
     {
 
264
          node_s *pNode = SearchNode(OrigEntry);
 
265
 
 
266
          if (pNode)
 
267
               pNode->Entry = NewVal;
 
268
     }
 
269
 
 
270
     bool IsInList(C Entry)
 
271
     {
 
272
          return (SearchNode(Entry) != NULL);
 
273
     }
 
274
 
 
275
     bool Empty(void)          { return (pNodeList == NULL); };
 
276
     int NodeCount(void)      { return iNodeCount; };
 
277
 
 
278
 
 
279
     // construction/destruction
 
280
     TLinkedList(void)
 
281
     {
 
282
          pNodeList = NULL;
 
283
          pLastNode = NULL;
 
284
          iNodeCount = 0;
 
285
     };
 
286
 
 
287
     ~TLinkedList(void)
 
288
     {
 
289
          DeleteAllNodes();
 
290
     };
 
291
 
 
292
         //fixmebot
 
293
//private:
 
294
     node_s *pNodeList;
 
295
     node_s *pLastNode;
 
296
     int iNodeCount;
 
297
};
 
298
 
 
299
// ==================================================================
 
300
// Code of TLinkedList - End
 
301
// ==================================================================
 
302
 
 
303
// ==================================================================
 
304
// Code of TPriorList - Begin
 
305
// ==================================================================
 
306
 
 
307
template <class C, class D=int> class TPriorList
 
308
{
 
309
public:
 
310
     struct node_s
 
311
     {
 
312
          C Entry;
 
313
          D Priority;
 
314
          node_s *next;
 
315
 
 
316
          node_s(C Ent, D Prior) : Entry(Ent), Priority(Prior), next(NULL) {};
 
317
     };
 
318
 
 
319
     TPriorList(void) : pHeadNode(NULL), pLastNode(NULL) {};
 
320
     ~TPriorList(void) { Clear(); };
 
321
 
 
322
     void AddEntry(C Entry, D Prior)
 
323
     {
 
324
          if (!pHeadNode)
 
325
          {
 
326
               pHeadNode = new node_s(Entry, Prior);
 
327
               pLastNode = pHeadNode;
 
328
               iNodeCount=1;
 
329
          }
 
330
          else
 
331
          {
 
332
               iNodeCount++;
 
333
               node_s *pNew = new node_s(Entry, Prior);
 
334
               node_s *pNode = pHeadNode;
 
335
               node_s *pPrev = NULL;
 
336
 
 
337
               while(pNode)
 
338
               {
 
339
                    if (Prior < pNode->Priority)
 
340
                    {
 
341
                         if (!pPrev)
 
342
                         {
 
343
                              pNew->next = pNode;
 
344
                              pHeadNode = pNew;
 
345
                         }
 
346
                         else
 
347
                         {
 
348
                              pPrev->next = pNew;
 
349
                              pNew->next = pNode;
 
350
                         }
 
351
                         break;
 
352
                    }
 
353
                    pPrev = pNode;
 
354
                    pNode = pNode->next;
 
355
               }
 
356
 
 
357
               if (!pNode)
 
358
               {
 
359
                    pLastNode = pNew;
 
360
                    if (pPrev)
 
361
                         pPrev->next = pNew;
 
362
               }
 
363
          }
 
364
     }
 
365
 
 
366
     C Pop(void)
 
367
     {
 
368
          if (!pHeadNode)
 
369
               return static_cast<C>(NULL);
 
370
 
 
371
          C Entry = pHeadNode->Entry;
 
372
          DeleteNode(pHeadNode);
 
373
          return Entry;
 
374
     }
 
375
 
 
376
     void Clear(void)
 
377
     {
 
378
          node_s *pTemp;
 
379
          while(pHeadNode)
 
380
          {
 
381
               pTemp = pHeadNode;
 
382
               pHeadNode = pHeadNode->next;
 
383
               delete pTemp;
 
384
          }
 
385
 
 
386
          pHeadNode = pLastNode = NULL;
 
387
     }
 
388
 
 
389
     bool IsInList(C Entry, D Prior)
 
390
     {
 
391
          node_s *pNode = pHeadNode;
 
392
          while(pNode)
 
393
          {
 
394
               if (pNode->Entry == Entry)
 
395
                    return true;
 
396
 
 
397
               if (Prior < pNode->Priority)
 
398
                    return false;
 
399
 
 
400
               pNode = pNode->next;
 
401
          }
 
402
 
 
403
          return false;
 
404
     }
 
405
 
 
406
     bool Empty(void) { return (pHeadNode == NULL); }
 
407
     node_s *GetFirst(void) { return pHeadNode; }
 
408
private:
 
409
     node_s *pHeadNode;
 
410
     node_s *pLastNode;
 
411
     int iNodeCount;
 
412
 
 
413
     node_s *GetPrevNode(node_s *pNode)
 
414
     {
 
415
          node_s *pTemp = pHeadNode;
 
416
          while(pTemp)
 
417
          {
 
418
               if (pTemp->next == pNode)
 
419
                    return pTemp;
 
420
               pTemp = pTemp->next;
 
421
          }
 
422
 
 
423
          return NULL;
 
424
     }
 
425
 
 
426
     void DeleteNode(node_s *pNode)
 
427
     {
 
428
          if (!pNode)
 
429
               return;
 
430
 
 
431
          if (pHeadNode == pNode) // first node
 
432
          {
 
433
               if (pHeadNode == pLastNode)
 
434
                    pLastNode = pHeadNode->next;
 
435
 
 
436
               pHeadNode = pHeadNode->next;
 
437
               pNode->next = NULL;
 
438
               delete pNode;
 
439
               pNode = NULL;
 
440
               iNodeCount--;
 
441
               return;
 
442
          }
 
443
 
 
444
          if (pNode == pLastNode) // last node
 
445
          {
 
446
               pNode = pLastNode;
 
447
               pLastNode->next = NULL;
 
448
 
 
449
               pNode->next = NULL;
 
450
               delete pNode;
 
451
               pNode = NULL;
 
452
               iNodeCount--;
 
453
               return;
 
454
          }
 
455
 
 
456
          // node is somewhere in the middle
 
457
 
 
458
          node_s *pPrevNode = GetPrevNode(pNode);
 
459
          if (!pPrevNode)
 
460
               return;
 
461
 
 
462
          // unlink pNode
 
463
          pPrevNode->next = pNode->next;
 
464
          pNode->next = NULL;
 
465
          delete pNode;
 
466
          pNode = NULL;
 
467
          iNodeCount--;
 
468
     }
 
469
};
 
470
 
 
471
// ==================================================================
 
472
// Code of TPriorList - End
 
473
// ==================================================================
 
474
 
 
475
 
 
476
// ==================================================================
 
477
// Code of TMultiChoice - Begin
 
478
// ==================================================================
 
479
 
 
480
template <class C> class TMultiChoice
 
481
{
 
482
     struct SMultiChoice
 
483
     {
 
484
          int MinVal;
 
485
          int MaxVal;
 
486
          C Choice;
 
487
          SMultiChoice(void) : MinVal(0), MaxVal(0){};
 
488
     };
 
489
 
 
490
     int TotalVal;
 
491
     TLinkedList<SMultiChoice*> *pChoiceList;
 
492
 
 
493
public:
 
494
     TMultiChoice(void) : TotalVal(0) // Constructor
 
495
     {
 
496
             pChoiceList = new TLinkedList<SMultiChoice*>;
 
497
     };
 
498
 
 
499
     ~TMultiChoice(void) // Destructor
 
500
     {
 
501
          while(pChoiceList->Empty() == false)
 
502
          {
 
503
               SMultiChoice *pEntry = pChoiceList->Pop();
 
504
               if (pEntry)
 
505
                    delete pEntry;
 
506
               else
 
507
                    break;
 
508
          }
 
509
          delete pChoiceList;
 
510
          pChoiceList = NULL;
 
511
     }
 
512
 
 
513
     void Insert(C Choice, short Percent = 50)
 
514
     {
 
515
          if (Percent == 0)
 
516
               return;
 
517
 
 
518
          SMultiChoice *pChoiceEntry = new SMultiChoice;
 
519
 
 
520
          pChoiceEntry->MinVal = TotalVal;
 
521
          pChoiceEntry->MaxVal = TotalVal + Percent;
 
522
          pChoiceEntry->Choice = Choice;
 
523
 
 
524
          pChoiceList->AddNode(pChoiceEntry);
 
525
 
 
526
          TotalVal += Percent;
 
527
     };
 
528
 
 
529
     bool FindSelection(SMultiChoice *MS, int Choice)
 
530
     {
 
531
          if ((Choice >= MS->MinVal) && (Choice < MS->MaxVal))
 
532
          {
 
533
               return true;
 
534
          }
 
535
          return false;
 
536
     }
 
537
 
 
538
     void ClearChoices(void)
 
539
     {
 
540
          TotalVal = 0;
 
541
          while(pChoiceList->Empty() == false)
 
542
               delete pChoiceList->Pop();
 
543
     }
 
544
 
 
545
     bool GetSelection(C &Var)
 
546
     {
 
547
          int Choice = RandomLong(0, (TotalVal - 1));
 
548
          typename TLinkedList<SMultiChoice*>::node_s *pNode = pChoiceList->GetFirst();
 
549
 
 
550
          while(pNode)
 
551
          {
 
552
               if ((Choice >= pNode->Entry->MinVal) && (Choice < pNode->Entry->MaxVal))
 
553
               {
 
554
                    Var = pNode->Entry->Choice;
 
555
                    return true;
 
556
               }
 
557
               pNode = pNode->next;
 
558
          }
 
559
 
 
560
          return false;
 
561
     }
 
562
};
 
563
 
 
564
// ==================================================================
 
565
// Code of TMutiChoice - End
 
566
// ==================================================================
 
567
 
 
568
#endif