int exec(int op, int a, int b)
{
int c;
if (op < 0)
{
op = abs(op);
c = a;
a = b;
b = c;
}
switch (op)
{
case 0:
{
return -a;
break;
}
case 1:
{
return a + b;
break;
}
case 2:
{
return a - b;
break;
}
case 3:
{
return a*b;
break;
}
case 4:
{
if (b == 0)
return 0;
else
return a/b;
break;
}
case 5:
{
return abs(a);
break;
}
case 6:
{
return _Pow_int(a, b);
break;
}
case 7:
case 13:
case 77:
{
if (b == 0)
return 0;
else
return a%b;
break;
}
case 8:
{
return __max(a, b);
break;
}
case 9:
{
return __min(a, b);
break;
}
case 10:
{
switch (abs(b) % 8)
{
case 0: return abs(a)*sizeof(char); break;
case 1: return abs(a)*sizeof(signed char); break;
case 2: return abs(a)*sizeof(short); break;
case 3: return abs(a)*sizeof(unsigned int); break;
case 4: return abs(a)*sizeof(long); break;
case 5: return abs(a)*sizeof(unsigned long long); break;
case 6: return abs(a)*sizeof(float); break;
case 7: return abs(a)*sizeof(double); break;
}
}
case 11:
{
if (a == 0)
return 0;
else
return 9 * M_PI*cosf(a*b) / a;
break;
}
default:
{
if (op < 100)
{
return op % abs(a + 1) + op % abs(b + 1);
}
else
{
return -1;
}
}
}
}
static int __int_pow(int base, int p)
{
return _Pow_int(base, p);
}
int ASTAR_FindPathWithTimeLimit(int from, int to, int *pathlist)
{
int PathPointCount = 0;
std::vector<int>OpenList;
std::vector<int>PathList;
int startTime = trap_Milliseconds();
// UQ1: Because this A* is only used to hunt enemies, limit the over-all range on requests to save CPU time...
if (Distance(gWPArray[from]->origin, gWPArray[to]->origin) > 4096.0f) return -1;
if (!PATHING_IGNORE_FRAME_TIME && trap_Milliseconds() - FRAME_TIME > 300)
{// Never path on an already long frame time...
return -1;
}
// Initialize...
ASTAR_InitSASNodes();
OpenList.clear();
PathList.clear();
int i=0;
pASNode[from].bIsOpen=true;
pASNode[from].G=0;
OpenList.push_back(from);
for(i = 0; i < gWPNum; i++)
{
pASNode[i].H=(int)sqrtl(_Pow_int(gWPArray[i]->origin[0] - gWPArray[to]->origin[0], 2)
+ _Pow_int(gWPArray[i]->origin[1] - gWPArray[to]->origin[1], 2)
+ _Pow_int(gWPArray[i]->origin[2] - gWPArray[to]->origin[2], 2));
}
while(1)
{
bool bFoundPath=false;
bool HaveNotClosed = false;
for(i = 0; i < OpenList.size(); i++)
{
if(!pASNode[OpenList[i]].bIsClosed)
{
if(OpenList[i]==to)
{
bFoundPath=true;
break;
}
HaveNotClosed = true;
break;
}
}
if(bFoundPath)
break;
if(!HaveNotClosed || trap_Milliseconds() - startTime > 500) // UQ1: Try limiting by timer, if we dont have one by now, we shouldn't bother!
{
//G_Printf("JKG A*: Failed to find a normal path - trying backup A*\n");
return -1; // Failed...
//return DOM_FindIdealPathtoWP(NULL, from, to, -1, pathlist);
}
int MinFIndex=-1;
int MinF=99999999;
for(i=0;i<OpenList.size();i++)
{
if(!pASNode[OpenList[i]].bIsClosed)
{
if(OpenList[i]==to)
{
bFoundPath=true;
break;
}
}
int tempI=OpenList[i];
if(!pASNode[tempI].bIsClosed)
{
int tempF=pASNode[tempI].G+pASNode[to].H;
if(tempF<MinF)
{
MinF=tempF;
MinFIndex=tempI;
}
}
}
if(bFoundPath)
break;
for(int j=0;j<pASNode[MinFIndex].NeighborCount;j++)
{
SASNode *pTempChild=&pASNode[pASNode[MinFIndex].Neighbor[j]];
if(pTempChild->bIsOpen)
{
if(pTempChild->G>pASNode[MinFIndex].G+pASNode[MinFIndex].NeighborDistance[j])
{
pTempChild->G=pASNode[MinFIndex].G+pASNode[MinFIndex].NeighborDistance[j];
pTempChild->ParentIndex=MinFIndex;
}
}
else
{
pTempChild->bIsOpen=true;
OpenList.push_back(pASNode[MinFIndex].Neighbor[j]);
pTempChild->ParentIndex=MinFIndex;
pTempChild->G=pASNode[MinFIndex].G+pASNode[MinFIndex].NeighborDistance[j];
}
}
pASNode[MinFIndex].bIsClosed=true;
}
int tempIndex = to;
PathList.push_back(tempIndex);
while(tempIndex != from)
{
pathlist[PathPointCount] = tempIndex;
PathPointCount++;
tempIndex=pASNode[tempIndex].ParentIndex;
PathList.push_back(tempIndex);
}
pathlist[PathPointCount] = from;
PathPointCount++;
/*
G_Printf("=====================================================================");
G_Printf("Path (length %i) found was:\n", PathPointCount);
for (i = 0; i < PathPointCount; i++)
{
if (i == PathPointCount - 1)
G_Printf("%i (goal) ", pathlist[i]);
else
G_Printf("%i (dist to next %f) ", pathlist[i], Distance(gWPArray[pathlist[i]]->origin, gWPArray[pathlist[i+1]]->origin));
}
G_Printf("\n");
G_Printf("=====================================================================");
*/
//PathPointCount=PathList.size();
return PathPointCount;
}
int ASTAR_ShortenPath(int old_pathlist_size, int *old_pathlist, int *pathlist)
{
int PathPointCount = 0;
std::vector<int>OpenList;
std::vector<int>PathList;
int startTime = trap_Milliseconds();
ORIGINAL_SIZE = old_pathlist_size;
// Initialize...
ASTAR_InitSASNodesShorten(old_pathlist_size, old_pathlist);
//G_Printf("Path is %i nodes from node %i to node %i.\n", old_pathlist_size, old_pathlist[old_pathlist_size-1], old_pathlist[0]);
OpenList.clear();
PathList.clear();
int i=0;
pASNode[old_pathlist[old_pathlist_size-1]].bIsOpen=true;
pASNode[old_pathlist[old_pathlist_size-1]].G=0;
OpenList.push_back(old_pathlist[old_pathlist_size-1]);
for(i = 0; i < old_pathlist_size; i++)
{
pASNode[old_pathlist[i]].H=(int)sqrtl(_Pow_int(gWPArray[i]->origin[0] - gWPArray[old_pathlist[0]]->origin[0], 2)
+ _Pow_int(gWPArray[i]->origin[1] - gWPArray[old_pathlist[0]]->origin[1], 2)
+ _Pow_int(gWPArray[i]->origin[2] - gWPArray[old_pathlist[0]]->origin[2], 2));
}
while(1)
{
bool bFoundPath=false;
int NotClosedCount=0;
for(i = 0; i < OpenList.size(); i++)
{
if(!pASNode[OpenList[i]].bIsClosed)
{
if(OpenList[i]==old_pathlist[0])
{
bFoundPath=true;
break;
}
NotClosedCount++;
}
}
if(bFoundPath)
break;
if(NotClosedCount==0 || trap_Milliseconds()-startTime > 1000)
{
//G_Printf("JKG A*: Failed to find a normal path - trying backup A*\n");
return -1; // Failed...
//return DOM_FindIdealPathtoWP(NULL, from, to, -1, pathlist);
}
int MinFIndex=-1;
int MinF=99999999;
for(i=0;i<OpenList.size();i++)
{
int tempI=OpenList[i];
if(!pASNode[tempI].bIsClosed)
{
int tempF=pASNode[tempI].G+pASNode[old_pathlist[0]].H;
if(tempF<MinF)
{
MinF=tempF;
MinFIndex=tempI;
}
}
}
for(int j=0;j<pASNode[MinFIndex].NeighborCount;j++)
{
SASNode *pTempChild=&pASNode[pASNode[MinFIndex].Neighbor[j]];
if(pTempChild->bIsOpen)
{
if(pTempChild->G>pASNode[MinFIndex].G+pASNode[MinFIndex].NeighborDistance[j])
{
pTempChild->G=pASNode[MinFIndex].G+pASNode[MinFIndex].NeighborDistance[j];
pTempChild->ParentIndex=MinFIndex;
}
}
else
{
pTempChild->bIsOpen=true;
OpenList.push_back(pASNode[MinFIndex].Neighbor[j]);
pTempChild->ParentIndex=MinFIndex;
pTempChild->G=pASNode[MinFIndex].G+pASNode[MinFIndex].NeighborDistance[j];
}
}
pASNode[MinFIndex].bIsClosed=true;
if(bFoundPath)
break;
}
int tempIndex = old_pathlist[0];
PathList.push_back(tempIndex);
while(tempIndex != old_pathlist[old_pathlist_size-1])
{
pathlist[PathPointCount] = tempIndex;
PathPointCount++;
tempIndex=pASNode[tempIndex].ParentIndex;
PathList.push_back(tempIndex);
}
pathlist[PathPointCount] = old_pathlist[old_pathlist_size-1];
PathPointCount++;
/*
G_Printf("=====================================================================");
G_Printf("Path (length %i) found was:\n", PathPointCount);
for (i = 0; i < PathPointCount; i++)
{
if (i == PathPointCount - 1)
G_Printf("%i (goal) ", pathlist[i]);
else
G_Printf("%i (dist to next %f) ", pathlist[i], Distance(gWPArray[pathlist[i]]->origin, gWPArray[pathlist[i+1]]->origin));
}
G_Printf("\n");
G_Printf("=====================================================================");
*/
//PathPointCount=PathList.size();
return PathPointCount;
}
int ASTAR_FindPath(int from, int to, int *pathlist)
{
int PathPointCount = 0;
std::vector<int>OpenList;
std::vector<int>PathList;
//
// This version is completely unrestricted. ONLY use it if a path is EXTREMELY important! Pussible huge CPU spikes...
//
// Initialize...
ASTAR_InitSASNodes();
OpenList.clear();
PathList.clear();
int i=0;
pASNode[from].bIsOpen=true;
pASNode[from].G=0;
OpenList.push_back(from);
for(i = 0; i < gWPNum; i++)
{
pASNode[i].H=(int)sqrtl(_Pow_int(gWPArray[i]->origin[0] - gWPArray[to]->origin[0], 2)
+ _Pow_int(gWPArray[i]->origin[1] - gWPArray[to]->origin[1], 2)
+ _Pow_int(gWPArray[i]->origin[2] - gWPArray[to]->origin[2], 2));
}
while(1)
{
bool bFoundPath=false;
int NotClosedCount=0;
for(i = 0; i < OpenList.size(); i++)
{
if(!pASNode[OpenList[i]].bIsClosed)
{
if(OpenList[i]==to)
{
bFoundPath=true;
break;
}
NotClosedCount++;
}
}
if(bFoundPath)
break;
if(NotClosedCount==0)
{
//G_Printf("JKG A*: Failed to find a normal path - trying backup A*\n");
return -1; // Failed...
//return DOM_FindIdealPathtoWP(NULL, from, to, -1, pathlist);
}
int MinFIndex=-1;
int MinF=99999999;
for(i=0;i<OpenList.size();i++)
{
int tempI=OpenList[i];
if(!pASNode[tempI].bIsClosed)
{
int tempF=pASNode[tempI].G+pASNode[to].H;
if(tempF<MinF)
{
MinF=tempF;
MinFIndex=tempI;
}
}
}
for(int j=0;j<pASNode[MinFIndex].NeighborCount;j++)
{
SASNode *pTempChild=&pASNode[pASNode[MinFIndex].Neighbor[j]];
if(pTempChild->bIsOpen)
{
if(pTempChild->G>pASNode[MinFIndex].G+pASNode[MinFIndex].NeighborDistance[j])
{
pTempChild->G=pASNode[MinFIndex].G+pASNode[MinFIndex].NeighborDistance[j];
pTempChild->ParentIndex=MinFIndex;
}
}
else
{
pTempChild->bIsOpen=true;
OpenList.push_back(pASNode[MinFIndex].Neighbor[j]);
pTempChild->ParentIndex=MinFIndex;
pTempChild->G=pASNode[MinFIndex].G+pASNode[MinFIndex].NeighborDistance[j];
}
}
pASNode[MinFIndex].bIsClosed=true;
if(bFoundPath)
break;
}
int tempIndex = to;
PathList.push_back(tempIndex);
while(tempIndex != from)
{
pathlist[PathPointCount] = tempIndex;
PathPointCount++;
tempIndex=pASNode[tempIndex].ParentIndex;
PathList.push_back(tempIndex);
}
pathlist[PathPointCount] = from;
PathPointCount++;
/*
G_Printf("=====================================================================");
G_Printf("Path (length %i) found was:\n", PathPointCount);
for (i = 0; i < PathPointCount; i++)
{
if (i == PathPointCount - 1)
G_Printf("%i (goal) ", pathlist[i]);
else
G_Printf("%i (dist to next %f) ", pathlist[i], Distance(gWPArray[pathlist[i]]->origin, gWPArray[pathlist[i+1]]->origin));
}
G_Printf("\n");
G_Printf("=====================================================================");
*/
//PathPointCount=PathList.size();
return PathPointCount;
}
