home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2007 September / maximum-cd-2007-09.iso / Assets / data / AssaultCube_v0.93.exe / source / src / bot / bot_util.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-12-07  |  14.6 KB  |  569 lines
  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. 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
  569.