#ifndef BOT_UTIL_H
#define BOT_UTIL_H
long RandomLong(long from, long to);
float RandomFloat(float from, float to);
void lsrand(unsigned long initial_seed);
void AnglesToVectors(vec angles, vec &forward, vec &right, vec &up);
float WrapXAngle(float angle);
float WrapYZAngle(float angle);
float GetDistance(vec v1, vec v2);
float Get2DDistance(vec v1, vec v2);
bool IsVisible(vec v1, vec v2, dynent *tracer = NULL, bool SkipTags=false);
bool IsValidFile(const char *szFileName);
bool FileIsOlder(const char *szFileName1, const char *szFileName2);
vec PredictPos(vec pos, vec vel, float Time);
vec Normalize(vec v);
inline void makevec(vec *v, float x, float y, float z) { v->x=x; v->y=y; v->z=z; }
inline bool UnderWater(const vec &o) { return hdr.waterlevel>o.z-0.5f; }
inline bool InWater(const vec &o) { return hdr.waterlevel>=o.z; }
float GetYawDiff(float curyaw, vec v1, vec v2);
vec CrossProduct(const vec &a, const vec &b);
int GetDirection(const vec &angles, const vec &v1, const vec &v2);
float GetCubeFloor(int x, int y);
float GetCubeHeight(int x, int y);
const char *SkillNrToSkillName(short skillnr);
bool IsInGame(dynent *d);
// ==================================================================
// Code of TLinkedList - Start
// ==================================================================
template <class C> class TLinkedList
{
public:
struct node_s
{
C Entry;
node_s *next;
node_s *prev;
node_s(void) : next(NULL), prev(NULL)
{
//memset(&Entry, 0, sizeof(Entry));
};
};
// member functions
void AddNode(C entry)
{
if (!pNodeList)
{
pNodeList = new node_s;
pNodeList->Entry = entry;
pNodeList->next = NULL;
pNodeList->prev = NULL;
pLastNode = pNodeList;
iNodeCount = 1;
}
else
{
pLastNode->next = new node_s;
pLastNode->next->prev = pLastNode;
pLastNode = pLastNode->next;
pLastNode->Entry = entry;
pLastNode->next = NULL;
iNodeCount++;
}
}
void PushNode(C Entry)
{
if (!pNodeList)
{
pNodeList = new node_s;
pNodeList->Entry = Entry;
pNodeList->next = NULL;
pNodeList->prev = NULL;
pLastNode = pNodeList;
iNodeCount = 1;
}
else
{
node_s *pNew = new node_s;
pNew->Entry = Entry;
pNew->prev = NULL;
pNew->next = pNodeList;
pNodeList->prev = pNew;
pNodeList = pNew;
iNodeCount++;
}
}
void DeleteEntry(C Entry)
{
node_s *pNode = pNodeList;
if (!pNode)
return;
if (pNode->Entry == Entry) // first node
{
if (pNodeList == pLastNode)
pLastNode = NULL;
pNodeList = pNodeList->next;
if (pNodeList)
pNodeList->prev = NULL;
pNode->next = NULL;
delete pNode;
pNode = NULL;
iNodeCount--;
return;
}
if (Entry == pLastNode->Entry) // last node
{
pNode = pLastNode;
pLastNode = pLastNode->prev;
pLastNode->next = NULL;
pNode->next = NULL;
pNode->prev = NULL;
delete pNode;
pNode = NULL;
iNodeCount--;
return;
}
// node is somewhere in the middle
pNode = SearchNode(Entry);
if (!pNode)
return;
node_s *pPrevNode = pNode->prev;
if (!pPrevNode)
return;
// unlink pNode
pNode->next->prev = pPrevNode;
pPrevNode->next = pNode->next;
pNode->next = NULL;
pNode->prev = NULL;
delete pNode;
pNode = NULL;
iNodeCount--;
}
void DeleteNode(node_s *pNode)
{
if (!pNode)
return;
if (pNodeList == pNode) // first node
{
if (pNodeList == pLastNode)
pLastNode = pNodeList->next;
pNodeList = pNodeList->next;
if (pNodeList)
pNodeList->prev = NULL;
pNode->next = NULL;
delete pNode;
pNode = NULL;
iNodeCount--;
return;
}
if (pNode == pLastNode) // last node
{
pNode = pLastNode;
pLastNode = pLastNode->prev;
pLastNode->next = NULL;
pNode->next = NULL;
pNode->prev = NULL;
delete pNode;
pNode = NULL;
iNodeCount--;
return;
}
// node is somewhere in the middle
node_s *pPrevNode = pNode->prev;
if (!pPrevNode)
return;
// unlink pNode
pNode->next->prev = pPrevNode;
pPrevNode->next = pNode->next;
pNode->next = NULL;
pNode->prev = NULL;
delete pNode;
pNode = NULL;
iNodeCount--;
}
void DeleteAllNodes(void)
{
node_s *pNode = pNodeList;
node_s *pTemp;
while (pNode != NULL)
{
pTemp = pNode;
pNode = pNode->next;
pTemp->next = NULL;
pTemp->prev = NULL;
delete pTemp;
}
pNodeList = pLastNode = NULL;
iNodeCount = 0;
}
void Reset(void) // Special case, doesn't delete existing nodes
{
pNodeList = pLastNode = NULL;
iNodeCount = 0;
}
node_s *SearchNode(C Entry)
{
node_s *pNode = pNodeList;
while(pNode)
{
if (pNode->Entry == Entry)
return pNode;
pNode = pNode->next;
}
return NULL;
}
C Pop(void)
{
if (!pNodeList)
return static_cast<C>(NULL);
C Entry = pNodeList->Entry;
DeleteNode(pNodeList);
return Entry;
}
node_s *GetFirst(void) {
return pNodeList;
};
node_s *GetLast(void) { return pLastNode; };
void EditEntry(C OrigEntry, C NewVal)
{
node_s *pNode = SearchNode(OrigEntry);
if (pNode)
pNode->Entry = NewVal;
}
bool IsInList(C Entry)
{
return (SearchNode(Entry) != NULL);
}
bool Empty(void) { return (pNodeList == NULL); };
int NodeCount(void) { return iNodeCount; };
// construction/destruction
TLinkedList(void)
{
pNodeList = NULL;
pLastNode = NULL;
iNodeCount = 0;
};
~TLinkedList(void)
{
DeleteAllNodes();
};
//fixmebot
//private:
node_s *pNodeList;
node_s *pLastNode;
int iNodeCount;
};
// ==================================================================
// Code of TLinkedList - End
// ==================================================================
// ==================================================================
// Code of TPriorList - Begin
// ==================================================================
template <class C, class D=int> class TPriorList
{
public:
struct node_s
{
C Entry;
D Priority;
node_s *next;
node_s(C Ent, D Prior) : Entry(Ent), Priority(Prior), next(NULL) {};
};
TPriorList(void) : pHeadNode(NULL), pLastNode(NULL), iNodeCount(0) {};
~TPriorList(void) { Clear(); };
void AddEntry(C Entry, D Prior)
{
if (!pHeadNode)
{
pHeadNode = new node_s(Entry, Prior);
pLastNode = pHeadNode;
iNodeCount=1;
}
else
{
iNodeCount++;
node_s *pNew = new node_s(Entry, Prior);
node_s *pNode = pHeadNode;
node_s *pPrev = NULL;
while(pNode)
{
if (Prior < pNode->Priority)
{
if (!pPrev)
{
pNew->next = pNode;
pHeadNode = pNew;
}
else
{
pPrev->next = pNew;
pNew->next = pNode;
}
break;
}
pPrev = pNode;
pNode = pNode->next;
}
if (!pNode)
{
pLastNode = pNew;
if (pPrev)
pPrev->next = pNew;
}
}
}
C Pop(void)
{
if (!pHeadNode)
return static_cast<C>(NULL);
C Entry = pHeadNode->Entry;
DeleteNode(pHeadNode);
return Entry;
}
void Clear(void)
{
node_s *pTemp;
while(pHeadNode)
{
pTemp = pHeadNode;
pHeadNode = pHeadNode->next;
delete pTemp;
}
pHeadNode = pLastNode = NULL;
}
bool IsInList(C Entry, D Prior)
{
node_s *pNode = pHeadNode;
while(pNode)
{
if (pNode->Entry == Entry)
return true;
if (Prior < pNode->Priority)
return false;
pNode = pNode->next;
}
return false;
}
bool Empty(void) { return (pHeadNode == NULL); }
node_s *GetFirst(void) { return pHeadNode; }
private:
node_s *pHeadNode;
node_s *pLastNode;
int iNodeCount;
node_s *GetPrevNode(node_s *pNode)
{
node_s *pTemp = pHeadNode;
while(pTemp)
{
if (pTemp->next == pNode)
return pTemp;
pTemp = pTemp->next;
}
return NULL;
}
void DeleteNode(node_s *pNode)
{
if (!pNode)
return;
if (pHeadNode == pNode) // first node
{
if (pHeadNode == pLastNode)
pLastNode = pHeadNode->next;
pHeadNode = pHeadNode->next;
pNode->next = NULL;
delete pNode;
pNode = NULL;
iNodeCount--;
return;
}
if (pNode == pLastNode) // last node
{
pNode = pLastNode;
pLastNode->next = NULL;
pNode->next = NULL;
delete pNode;
pNode = NULL;
iNodeCount--;
return;
}
// node is somewhere in the middle
node_s *pPrevNode = GetPrevNode(pNode);
if (!pPrevNode)
return;
// unlink pNode
pPrevNode->next = pNode->next;
pNode->next = NULL;
delete pNode;
pNode = NULL;
iNodeCount--;
}
};
// ==================================================================
// Code of TPriorList - End
// ==================================================================
// ==================================================================
// Code of TMultiChoice - Begin
// ==================================================================
template <class C> class TMultiChoice
{
struct SMultiChoice
{
int MinVal;
int MaxVal;
C Choice;
SMultiChoice(void) : MinVal(0), MaxVal(0){};
};
int TotalVal;
TLinkedList<SMultiChoice*> *pChoiceList;
public:
TMultiChoice(void) : TotalVal(0) // Constructor
{
pChoiceList = new TLinkedList<SMultiChoice*>;
};
~TMultiChoice(void) // Destructor
{
while(pChoiceList->Empty() == false)
{
SMultiChoice *pEntry = pChoiceList->Pop();
if (pEntry)
delete pEntry;
else
break;
}
delete pChoiceList;
pChoiceList = NULL;
}
void Insert(C Choice, short Percent = 50)
{
if (Percent == 0)
return;
SMultiChoice *pChoiceEntry = new SMultiChoice;
pChoiceEntry->MinVal = TotalVal;
pChoiceEntry->MaxVal = TotalVal + Percent;
pChoiceEntry->Choice = Choice;
pChoiceList->AddNode(pChoiceEntry);
TotalVal += Percent;
};
bool FindSelection(SMultiChoice *MS, int Choice)
{
if ((Choice >= MS->MinVal) && (Choice < MS->MaxVal))
{
return true;
}
return false;
}
void ClearChoices(void)
{
TotalVal = 0;
while(pChoiceList->Empty() == false)
delete pChoiceList->Pop();
}
bool GetSelection(C &Var)
{
int Choice = RandomLong(0, (TotalVal - 1));
typename TLinkedList<SMultiChoice*>::node_s *pNode = pChoiceList->GetFirst();
while(pNode)
{
if ((Choice >= pNode->Entry->MinVal) && (Choice < pNode->Entry->MaxVal))
{
Var = pNode->Entry->Choice;
return true;
}
pNode = pNode->next;
}
return false;
}
};
// ==================================================================
// Code of TMutiChoice - End
// ==================================================================
#endif
Advertisement
153
pages
Bot util.h
Advertisement