void FormSet::OnButtonOkClick()
{
SS port = TextPort_.GetText();
if (port.Length() == 0)
{
PopMessage(tcc_("请输入端口号"),800);
TextPort_.SetFocus();
return;
}
df::StringToInteger(port, G::main.listen_port);
G::main.hide_window = choice_[0].GetCheck();
TextPSW_.GetText(port);
if (port.Length() > 0)
{
Sha2Password(port);
G::main.access_psw = std::move(port);
}
G::WriteMainIni();
Close();
}
void C4Network2IRCClient::MarkMessageLogRead()
{
// set read marker to last message
pLogLastRead = pLogEnd;
iUnreadLogLength = 0;
// message buffer is smaller for messages already read: Remove old ones
while(iLogLength > C4NetIRCMaxReadLogLength)
PopMessage();
}
void FormProc::Kill()
{
int i = viewProc_.GetSelectIndex();
if (i < 0)
{
PopMessage(tcc_("请选择一个进程!"));
return;
}
SS id = viewProc_.GetText(i, 0);
con_->Send(Direct::KillProc, id);
}
void FormSet::OnAutoStartChoice()
{
if (choice_[1].GetCheck())
{
if (!reg_.SetValue(regVal, df::GetExeMenu()))
PopMessage(tcc_("开机自启失败!"));
}
else
{
reg_.DeleteValue(regVal);
}
}
void MainWindow::OpenImageCanvas(QString file_name)
{
QImage img = QImage(file_name);
if(img.isNull()){
PopMessage("Fail");
return;
}
CanvasWidgetContainer *canvas_widget_container = new CanvasWidgetContainer(file_name,img);
ui->mdiArea->addSubWindow(canvas_widget_container);
canvas_widget_container->show();
}
VOID AinMsgQueue::Release(VOID)
{
//! 执行最后队列的消息
list<AinMessage*> listMsg;
PopMessage(listMsg);
for(list<AinMessage*>::iterator ite = listMsg.begin(); listMsg.end() != ite; ite++)
{
if( NULL != *ite )
{
(*ite)->Run();
AinMessage::Release(&(*ite));
}
}
//! 定时为到的消息不执行了
map<DWORD, AinMessage*>::iterator ite = m_timeMsgQueue.begin();
for (; m_timeMsgQueue.end() != ite; ++ite)
{
AinMessage::Release(&(ite->second));
}
}
bool ReadFromRetQueue(const string &szQueue, char *pBuffer, int &nRetSize, string szIDCUser = "******",
string szAddr = "localhost")
{
bool bRet = false;
static const string szDynLabel = "DYNPARAM";
static const string szEnd = "DYNEND";
MQRECORD mrd = PopMessage(szQueue, 2000, szIDCUser, szAddr);
if(mrd != INVALID_VALUE)
{
string szLabel("");
svutil::TTime ct;
unsigned int len = 0;
if(GetMessageData(mrd, szLabel, ct, NULL, len))
{
if(szLabel == szDynLabel)
{
if(pBuffer && len <= static_cast<unsigned int>(nRetSize))
{
if(!::GetMessageData(mrd, szLabel, ct, pBuffer, len))
{
memset(pBuffer, 0, nRetSize);
}
else
{
nRetSize = len;
bRet = true;
}
}
}
else if(szLabel == szEnd)
{
bRet = true;
}
}
}
return bRet;
}
INT16 NextPatrolPoint(SOLDIERTYPE *pSoldier)
{
// patrol slot 0 is UNUSED, so max patrolCnt is actually only 9
if ((pSoldier->bPatrolCnt < 1) || (pSoldier->bPatrolCnt >= MAXPATROLGRIDS))
{
#ifdef BETAVERSION
sprintf(tempstr,"NextPatrolPoint: ERROR: Invalid patrol count = %d for %s",pSoldier->bPatrolCnt,pSoldier->name);
PopMessage(tempstr);
#endif
return(NOWHERE);
}
pSoldier->bNextPatrolPnt++;
// if there are no more patrol points, return back to the first one
if (pSoldier->bNextPatrolPnt > pSoldier->bPatrolCnt)
pSoldier->bNextPatrolPnt = 1; // ZERO is not used!
return(pSoldier->usPatrolGrid[pSoldier->bNextPatrolPnt]);
}
void C4Network2IRCClient::PushMessage(C4Network2IRCMessageType eType, const char *szSource, const char *szTarget, const char *szText)
{
// Create message
C4Network2IRCMessage *pMsg = new C4Network2IRCMessage(eType, szSource, szTarget, szText);
// Add to list
if (pLogEnd)
{
pLogEnd->Next = pMsg;
}
else
{
pLog = pMsg;
}
pLogEnd = pMsg;
// Count
iLogLength++;
iUnreadLogLength++;
while(iLogLength > C4NetIRCMaxLogLength)
PopMessage();
// Notify
if(pNotify)
pNotify->PushEvent(Ev_IRC_Message, this);
}
INT16 InternalGoAsFarAsPossibleTowards(SOLDIERTYPE *pSoldier, INT16 sDesGrid, INT8 bReserveAPs, INT8 bAction, INT8 fFlags )
{
INT16 sLoop,sAPCost;
INT16 sTempDest,sGoToGrid;
INT16 sOrigin;
UINT16 usMaxDist;
UINT8 ubDirection,ubDirsLeft,ubDirChecked[8],fFound = FALSE;
INT8 bAPsLeft, fPathFlags;
UINT8 ubRoomRequired = 0, ubTempRoom;
if ( bReserveAPs == -1 )
{
// default reserve points
if ( CREATURE_OR_BLOODCAT( pSoldier ) )
{
bReserveAPs = 0;
}
else
{
bReserveAPs = MAX_AP_CARRIED;
}
}
sTempDest = -1;
// obtain maximum roaming distance from soldier's sOrigin
usMaxDist = RoamingRange(pSoldier,&sOrigin);
if ( pSoldier->bOrders <= CLOSEPATROL && (pSoldier->bTeam == CIV_TEAM || pSoldier->ubProfile != NO_PROFILE ) )
{
if ( InARoom( pSoldier->usPatrolGrid[0], &ubRoomRequired ) )
{
// make sure this doesn't interfere with pathing for scripts
if ( pSoldier->sAbsoluteFinalDestination != NOWHERE )
{
ubRoomRequired = 0;
}
}
}
pSoldier->usUIMovementMode = DetermineMovementMode(pSoldier, bAction );
if ( pSoldier->usUIMovementMode == RUNNING && fFlags & FLAG_CAUTIOUS )
{
pSoldier->usUIMovementMode = WALKING;
}
#ifdef DEBUGDECISIONS
sprintf(tempstr,"%s wants to go towards %d (has range %d)",pSoldier->name,sDesGrid,usMaxDist);
AIPopMessage(tempstr);
#endif
// if soldier is ALREADY at the desired destination, quit right away
if (sDesGrid == pSoldier->sGridNo)
{
return(NOWHERE);
}
// don't try to approach go after noises or enemies actually in water
// would be too easy to throw rocks in water, etc. & distract the AI
if (Water(sDesGrid))
{
return(NOWHERE);
}
fPathFlags = 0;
if ( CREATURE_OR_BLOODCAT( pSoldier ) )
{ /*
if ( PythSpacesAway( pSoldier->sGridNo, sDesGrid ) <= PATH_CLOSE_RADIUS )
{
// then do a limited range path search and see if we can get there
gubNPCDistLimit = 10;
if ( !LegalNPCDestination( pSoldier, sDesGrid, ENSURE_PATH, NOWATER, fPathFlags) )
{
gubNPCDistLimit = 0;
return( NOWHERE );
}
else
{
// allow attempt to path without 'good enough' flag on
gubNPCDistLimit = 0;
}
}
else
{
*/
fPathFlags = PATH_CLOSE_GOOD_ENOUGH;
//}
}
// first step: try to find an OK destination at or near the desired gridno
if (!LegalNPCDestination(pSoldier,sDesGrid,ENSURE_PATH,NOWATER,fPathFlags))
{
#ifdef DEBUGDECISIONS
AIPopMessage("destination Grid # itself not valid, looking around it");
#endif
if ( CREATURE_OR_BLOODCAT( pSoldier ) )
{
// we tried to get close, failed; abort!
return( NOWHERE );
}
else
{
// else look at the 8 nearest gridnos to sDesGrid for a valid destination
// clear ubDirChecked flag for all 8 directions
for (ubDirection = 0; ubDirection < 8; ubDirection++)
ubDirChecked[ubDirection] = FALSE;
ubDirsLeft = 8;
// examine all 8 spots around 'sDesGrid'
// keep looking while directions remain and a satisfactory one not found
for (ubDirsLeft = 8; ubDirsLeft != 0; ubDirsLeft--)
{
if (fFound)
{
break;
}
// randomly select a direction which hasn't been 'checked' yet
do
{
ubDirection = (UINT8) Random(8);
}
while (ubDirChecked[ubDirection]);
ubDirChecked[ubDirection] = TRUE;
// determine the gridno 1 tile away from current friend in this direction
sTempDest = NewGridNo(sDesGrid,DirectionInc( (INT16)(ubDirection + 1) ));
// if that's out of bounds, ignore it & check next direction
if (sTempDest == sDesGrid)
continue;
if (LegalNPCDestination(pSoldier,sTempDest,ENSURE_PATH,NOWATER,0))
{
fFound = TRUE; // found a spot
#ifdef DEBUGDECISIONS
AINumMessage("Found a spot! ubDirection = ",ubDirection + 1);
#endif
break; // stop checking in other directions
}
}
if (!fFound)
{
#ifdef DEBUGDECISIONS
AINumMessage("Couldn't find OK destination around grid #",sDesGrid);
#endif
return(NOWHERE);
}
// found a good grid #, this becomes our actual desired grid #
sDesGrid = sTempDest;
}
}
// HAVE FOUND AN OK destination AND PLOTTED A VALID BEST PATH TO IT
#ifdef DEBUGDECISIONS
AINumMessage("Chosen legal destination is gridno ",sDesGrid);
AINumMessage("Tracing along path, pathRouteToGo = ",pSoldier->pathRouteToGo);
#endif
sGoToGrid = pSoldier->sGridNo; // start back where soldier is standing now
sAPCost = 0; // initialize path cost counter
// we'll only go as far along the plotted route as is within our
// permitted roaming range, and we'll stop as soon as we're down to <= 5 APs
for (sLoop = 0; sLoop < (pSoldier->usPathDataSize - pSoldier->usPathIndex); sLoop++)
{
// what is the next gridno in the path?
//sTempDest = NewGridNo( sGoToGrid,DirectionInc( (INT16) (pSoldier->usPathingData[sLoop] + 1) ) );
sTempDest = NewGridNo( sGoToGrid,DirectionInc( (INT16) (pSoldier->usPathingData[sLoop]) ) );
//NumMessage("sTempDest = ",sTempDest);
// this should NEVER be out of bounds
if (sTempDest == sGoToGrid)
{
#ifdef BETAVERSION
sprintf(tempstr,"GoAsFarAsPossibleTowards: ERROR - gridno along valid route is invalid! guynum %d, sTempDest = %d",pSoldier->ubID,sTempDest);
#ifdef RECORDNET
fprintf(NetDebugFile,"\n\t%s\n",tempstr);
#endif
PopMessage(tempstr);
SaveGame(ERROR_SAVE);
#endif
break; // quit here, sGoToGrid is where we are going
}
// if this takes us beyond our permitted "roaming range"
if (SpacesAway(sOrigin,sTempDest) > usMaxDist)
break; // quit here, sGoToGrid is where we are going
if ( ubRoomRequired )
{
if ( !( InARoom( sTempDest, &ubTempRoom ) && ubTempRoom == ubRoomRequired ) )
{
// quit here, limited by room!
break;
}
}
if ( (fFlags & FLAG_STOPSHORT) && SpacesAway( sDesGrid, sTempDest ) <= STOPSHORTDIST )
{
break; // quit here, sGoToGrid is where we are going
}
// if this gridno is NOT a legal NPC destination
// DONT'T test path again - that would replace the traced path! - Ian
// NOTE: It's OK to go *THROUGH* water to try and get to the destination!
if (!LegalNPCDestination(pSoldier,sTempDest,IGNORE_PATH,WATEROK,0))
break; // quit here, sGoToGrid is where we are going
// CAN'T CALL PathCost() HERE! IT CALLS findBestPath() and overwrites
// pathRouteToGo !!! Gotta calculate the cost ourselves - Ian
//
//ubAPsLeft = pSoldier->bActionPoints - PathCost(pSoldier,sTempDest,FALSE,FALSE,FALSE,FALSE,FALSE);
if (gfTurnBasedAI)
{
// if we're just starting the "costing" process (first gridno)
if (sLoop == 0)
{
/*
// first, add any additional costs - such as intermediate animations, etc.
switch(pSoldier->anitype[pSoldier->anim])
{
// in theory, no NPC should ever be in one of these animations as
// things stand (they don't medic anyone), but leave it for robustness
case START_AID :
case GIVING_AID : sAnimCost = AP_STOP_FIRST_AID;
break;
case TWISTOMACH :
case COLLAPSED : sAnimCost = AP_GET_UP;
break;
case TWISTBACK :
case UNCONSCIOUS : sAnimCost = (AP_ROLL_OVER + AP_GET_UP);
break;
default : sAnimCost = 0;
}
// this is our first cost
sAPCost += sAnimCost;
*/
if (pSoldier->usUIMovementMode == RUNNING)
{
sAPCost += AP_START_RUN_COST;
}
}
// ATE: Direction here?
sAPCost += EstimateActionPointCost( pSoldier, sTempDest, (INT8) pSoldier->usPathingData[sLoop], pSoldier->usUIMovementMode, (INT8) sLoop, (INT8) pSoldier->usPathDataSize );
bAPsLeft = pSoldier->bActionPoints - sAPCost;
}
// if after this, we have <= 5 APs remaining, that's far enough, break out
// (the idea is to preserve APs so we can crouch or react if
// necessary, and benefit from the carry-over next turn if not needed)
// This routine is NOT used by any GREEN AI, so such caution is warranted!
if ( gfTurnBasedAI && (bAPsLeft < bReserveAPs) )
break;
else
{
sGoToGrid = sTempDest; // we're OK up to here
// if exactly 5 APs left, don't bother checking any further
if ( gfTurnBasedAI && (bAPsLeft == bReserveAPs) )
break;
}
}
// if it turned out we couldn't go even 1 tile towards the desired gridno
if (sGoToGrid == pSoldier->sGridNo)
{
#ifdef DEBUGDECISIONS
sprintf(tempstr,"%s will go NOWHERE, path doesn't meet criteria",pSoldier->name);
AIPopMessage(tempstr);
#endif
return(NOWHERE); // then go nowhere
}
else
{
// possible optimization - stored path IS good if we're going all the way
if (sGoToGrid == sDesGrid)
{
pSoldier->bPathStored = TRUE;
pSoldier->sFinalDestination = sGoToGrid;
}
else if ( pSoldier->usPathIndex == 0 )
{
// we can hack this surely! -- CJC
pSoldier->bPathStored = TRUE;
pSoldier->sFinalDestination = sGoToGrid;
pSoldier->usPathDataSize = sLoop + 1;
}
#ifdef DEBUGDECISIONS
ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_BETAVERSION, L"%d to %d with %d APs left", pSoldier->ubID, sGoToGrid, pSoldier->bActionPoints );
#endif
return( sGoToGrid );
}
}
int TryToResumeMovement(SOLDIERTYPE *pSoldier, INT16 sGridno)
{
UINT8 ubGottaCancel = FALSE;
UINT8 ubSuccess = FALSE;
// have to make sure the old destination is still legal (somebody may
// have occupied the destination gridno in the meantime!)
if (LegalNPCDestination(pSoldier,sGridno,ENSURE_PATH,WATEROK,0))
{
#ifdef DEBUGDECISIONS
DebugAI( String( "%d CONTINUES MOVEMENT to gridno %d...\n",pSoldier->ubID,gridno ) );
#endif
pSoldier->bPathStored = TRUE; // optimization - Ian
// make him go to it (needed to continue movement across multiple turns)
NewDest(pSoldier,sGridno);
ubSuccess = TRUE;
// make sure that it worked (check that pSoldier->sDestination == pSoldier->sGridNo)
if (pSoldier->sDestination == sGridno)
{
ubSuccess = TRUE;
}
else
{
#ifdef BETAVERSION
sprintf(tempstr,"TryToResumeMovement: ERROR - NewDest failed for %s, action CANCELED",pSoldier->name);
#ifdef RECORDNET
fprintf(NetDebugFile,"\n\t%s\n",tempstr);
#endif
PopMessage(tempstr);
SaveGame(ERROR_SAVE);
#endif
// must work even for escorted civs, can't just set the flag
CancelAIAction(pSoldier,FORCE);
}
}
else
{
// don't black-list anything here, this situation can come up quite
// legally if another soldier gets in the way between turns
#ifdef BETAVERSION
sprintf(tempstr,"TryToResumeMovement: %d can't continue to gridno %d, no longer legal!",pSoldier->ubID,gridno);
#ifdef RECORDNET
fprintf(NetDebugFile,"\n\t%s\n",tempstr);
#endif
#ifdef DEBUGDECISIONS
AIPopMessage(tempstr);
#endif
#endif
if (!pSoldier->bUnderEscort)
{
CancelAIAction(pSoldier,DONTFORCE); // no need to force this
}
else
{
// this is an escorted NPC, don't want to just completely stop
// moving, try to find a nearby "next best" destination if possible
pSoldier->usActionData = GoAsFarAsPossibleTowards(pSoldier,sGridno,pSoldier->bAction);
// if it's not possible to get any closer
if (pSoldier->usActionData == NOWHERE)
{
ubGottaCancel = TRUE;
}
else
{
// change his desired destination to this new one
sGridno = pSoldier->usActionData;
// GoAsFar... sets pathStored TRUE only if he could go all the way
// make him go to it (needed to continue movement across multiple turns)
NewDest(pSoldier,sGridno);
// make sure that it worked (check that pSoldier->sDestination == pSoldier->sGridNo)
if (pSoldier->sDestination == sGridno)
ubSuccess = TRUE;
else
ubGottaCancel = TRUE;
}
if (ubGottaCancel)
{
// can't get close, gotta abort the movement!
CancelAIAction(pSoldier,FORCE);
// tell the player doing the escorting that civilian has stopped
//EscortedMoveCanceled(pSoldier,COMMUNICATE);
}
}
}
return(ubSuccess);
}
void C4Network2IRCClient::ClearMessageLog()
{
// Clear log
while(iLogLength)
PopMessage();
}
static void *
winMultiWindowWMProc (void *pArg)
{
WMProcArgPtr pProcArg = (WMProcArgPtr)pArg;
WMInfoPtr pWMInfo = pProcArg->pWMInfo;
/* Initialize the Window Manager */
winInitMultiWindowWM (pWMInfo, pProcArg);
#if CYGMULTIWINDOW_DEBUG
ErrorF ("winMultiWindowWMProc ()\n");
#endif
/* Loop until we explicity break out */
for (;;)
{
WMMsgNodePtr pNode;
/* Pop a message off of our queue */
pNode = PopMessage (&pWMInfo->wmMsgQueue);
if (pNode == NULL)
{
/* Bail if PopMessage returns without a message */
/* NOTE: Remember that PopMessage is a blocking function. */
ErrorF ("winMultiWindowWMProc - Queue is Empty?\n");
pthread_exit (NULL);
}
#if CYGMULTIWINDOW_DEBUG
ErrorF ("winMultiWindowWMProc - %d ms MSG: %d ID: %d\n",
GetTickCount (), (int)pNode->msg.msg, (int)pNode->msg.dwID);
#endif
/* Branch on the message type */
switch (pNode->msg.msg)
{
#if 0
case WM_WM_MOVE:
ErrorF ("\tWM_WM_MOVE\n");
break;
case WM_WM_SIZE:
ErrorF ("\tWM_WM_SIZE\n");
break;
#endif
case WM_WM_RAISE:
#if CYGMULTIWINDOW_DEBUG
ErrorF ("\tWM_WM_RAISE\n");
#endif
/* Raise the window */
XRaiseWindow (pWMInfo->pDisplay, pNode->msg.iWindow);
break;
case WM_WM_LOWER:
#if CYGMULTIWINDOW_DEBUG
ErrorF ("\tWM_WM_LOWER\n");
#endif
/* Lower the window */
XLowerWindow (pWMInfo->pDisplay, pNode->msg.iWindow);
break;
case WM_WM_MAP:
#if CYGMULTIWINDOW_DEBUG
ErrorF ("\tWM_WM_MAP\n");
#endif
{
XWindowAttributes attr;
char *pszName;
#if 0
XWMHints *pHints;
#endif
/* Get the window attributes */
XGetWindowAttributes (pWMInfo->pDisplay,
pNode->msg.iWindow,
&attr);
if (!attr.override_redirect)
{
/* Set the Windows window name */
GetWindowName(pWMInfo->pDisplay, pNode->msg.iWindow, &pszName);
SetWindowText (pNode->msg.hwndWindow, pszName);
free (pszName);
}
}
break;
case WM_WM_UNMAP:
#if CYGMULTIWINDOW_DEBUG
ErrorF ("\tWM_WM_UNMAP\n");
#endif
/* Unmap the window */
XUnmapWindow(pWMInfo->pDisplay, pNode->msg.iWindow);
break;
case WM_WM_KILL:
#if CYGMULTIWINDOW_DEBUG
ErrorF ("\tWM_WM_KILL\n");
#endif
{
int i, n, found = 0;
Atom *protocols;
/* --- */
if (XGetWMProtocols (pWMInfo->pDisplay,
pNode->msg.iWindow,
&protocols,
&n))
{
for (i = 0; i < n; ++i)
if (protocols[i] == pWMInfo->atmWmDelete)
++found;
XFree (protocols);
}
/* --- */
if (found)
SendXMessage (pWMInfo->pDisplay,
pNode->msg.iWindow,
pWMInfo->atmWmProtos,
pWMInfo->atmWmDelete);
else
XKillClient (pWMInfo->pDisplay,
pNode->msg.iWindow);
}
break;
case WM_WM_ACTIVATE:
#if CYGMULTIWINDOW_DEBUG
ErrorF ("\tWM_WM_ACTIVATE\n");
#endif
/* Set the input focus */
XSetInputFocus (pWMInfo->pDisplay,
pNode->msg.iWindow,
RevertToPointerRoot,
CurrentTime);
break;
case WM_WM_X_EVENT:
/* Process all X events in the Window Manager event queue */
FlushXEvents (pWMInfo);
break;
default:
ErrorF ("winMultiWindowWMProc - Unknown Message.\n");
pthread_exit (NULL);
break;
}
/* Free the retrieved message */
free (pNode);
/* Flush any pending events on our display */
XFlush (pWMInfo->pDisplay);
}
/* Free the condition variable */
pthread_cond_destroy (&pWMInfo->wmMsgQueue.pcNotEmpty);
/* Free the mutex variable */
pthread_mutex_destroy (&pWMInfo->wmMsgQueue.pmMutex);
/* Free the passed-in argument */
free (pProcArg);
#if CYGMULTIWINDOW_DEBUG
ErrorF("-winMultiWindowWMProc ()\n");
#endif
}
void MakeClosestEnemyChosenOne()
{
UINT32 cnt;
INT16 sPathCost, sShortestPath = 1000;
INT8 bOldKeys = -1;
UINT8 ubClosestEnemy = NOBODY;
SOLDIERTYPE * pSoldier;
INT8 bPanicTrigger;
INT16 sPanicTriggerGridNo;
if ( ! (gTacticalStatus.fPanicFlags & PANIC_TRIGGERS_HERE) )
{
#ifdef BETAVERSION
PopMessage("MakeClosestEnemyChosenOne: ERROR - Panic Trigger is NOWHERE");
#endif
return;
}
if (!NeedToRadioAboutPanicTrigger() )
{
// no active panic triggers
return;
}
// consider every enemy, looking for the closest capable, unbusy one
for (cnt = 0; cnt < guiNumMercSlots; cnt++)
{
pSoldier = MercSlots[cnt];
if (!pSoldier) // if this merc is inactive, or not here
{
continue;
}
// if this merc is unconscious, or dead
if (pSoldier->bLife < OKLIFE)
{
continue; // next soldier
}
// if this guy's too tired to go
if (pSoldier->bBreath < OKBREATH)
{
continue; // next soldier
}
if ( gWorldSectorX == TIXA_SECTOR_X && gWorldSectorY == TIXA_SECTOR_Y )
{
if ( pSoldier->ubProfile != WARDEN )
{
continue;
}
}
else
{
// only consider for army guys
if (pSoldier->bTeam != ENEMY_TEAM )
{
continue;
}
}
// if this guy is in battle with opponent(s)
if (pSoldier->bOppCnt > 0)
{
continue; // next soldier
}
// if this guy is still in serious shock
if (pSoldier->bShock > 2)
{
continue; // next soldier
}
if ( pSoldier->bLevel != 0 )
{
// screw having guys on the roof go for panic triggers!
continue; // next soldier
}
bPanicTrigger = ClosestPanicTrigger( pSoldier );
if (bPanicTrigger == -1)
{
continue; // next soldier
}
sPanicTriggerGridNo = gTacticalStatus.sPanicTriggerGridNo[ bPanicTrigger ];
if (sPanicTriggerGridNo == NOWHERE)
{
// this should never happen!
continue;
}
// remember whether this guy had keys before
//bOldKeys = pSoldier->bHasKeys;
// give him keys to see if with them he can get to the panic trigger
pSoldier->bHasKeys = (pSoldier->bHasKeys << 1) | 1;
// we now path directly to the panic trigger
// if he can't get to a spot where he could get at the panic trigger
/*
if ( FindAdjacentGridEx( pSoldier, gTacticalStatus.sPanicTriggerGridno, &ubDirection, &sAdjSpot, FALSE, FALSE ) == -1 )
{
pSoldier->bHasKeys = bOldKeys;
continue; // next merc
}
*/
// ok, this enemy appears to be eligible
// FindAdjacentGrid set HandGrid for us. If we aren't at that spot already
if (pSoldier->sGridNo != sPanicTriggerGridNo)
{
// get the AP cost for this enemy to go to target position
sPathCost = PlotPath( pSoldier, sPanicTriggerGridNo, FALSE, FALSE, FALSE, WALKING, FALSE, FALSE, 0);
}
else
{
sPathCost = 0;
}
// set his keys value back to what it was before this hack
pSoldier->bHasKeys = (pSoldier->bHasKeys >> 1 );
// if he can get there (or is already there!)
if (sPathCost || (pSoldier->sGridNo == sPanicTriggerGridNo))
{
if (sPathCost < sShortestPath)
{
sShortestPath = sPathCost;
ubClosestEnemy = pSoldier->ubID;
}
}
//else
//NameMessage(pSoldier,"can't get there...");
}
// if we found have an eligible enemy, make him our "chosen one"
if (ubClosestEnemy < NOBODY)
{
gTacticalStatus.ubTheChosenOne = ubClosestEnemy; // flag him as the chosen one
#ifdef TESTVERSION
NumMessage("TEST MSG: The chosen one is ",TheChosenOne);
#endif
pSoldier = MercPtrs[gTacticalStatus.ubTheChosenOne];
if ( pSoldier->bAlertStatus < STATUS_RED )
{
pSoldier->bAlertStatus = STATUS_RED;
CheckForChangingOrders( pSoldier );
}
SetNewSituation( pSoldier ); // set new situation for the chosen one
pSoldier->bHasKeys = (pSoldier->bHasKeys << 1) | 1; // cheat and give him keys to every door
//pSoldier->bHasKeys = TRUE;
}
#ifdef TESTVERSION
else
PopMessage("TEST MSG: Couldn't find anyone eligible to become TheChosenOne!");
#endif
}