自学教程：C++ stackPopParams函数代码示例

// Add a droid to a groupBOOL scrGroupAddDroid(void){	DROID_GROUP		*psGroup;	DROID			*psDroid;	if (!stackPopParams(2, ST_GROUP, &psGroup, ST_DROID, &psDroid))	{		return FALSE;	}	ASSERT((PTRVALID(psGroup, sizeof(DROID_GROUP)),		"scrGroupAdd: Invalid group pointer"));	ASSERT((PTRVALID(psDroid, sizeof(DROID)),		"scrGroupAdd: Invalid droid pointer"));	if (psDroid == NULL)	{		return FALSE;	}	if (psDroid->droidType == DROID_COMMAND)	{		ASSERT((FALSE,			"scrGroupAdd: cannot add a command droid to a group"));		return FALSE;	}	if (psDroid->droidType == DROID_TRANSPORTER)	{		ASSERT((FALSE,			"scrGroupAdd: cannot add a transporter to a group"));		return FALSE;	}	grpJoin(psGroup, psDroid);	return TRUE;}

// Add a droid to a groupbool scrGroupAddDroid(void){	DROID_GROUP		*psGroup;	DROID			*psDroid;	if (!stackPopParams(2, ST_GROUP, &psGroup, ST_DROID, &psDroid))	{		return false;	}	ASSERT(psGroup != NULL,	       "scrGroupAdd: Invalid group pointer");	ASSERT(psDroid != NULL,	       "scrGroupAdd: Invalid droid pointer");	if (psDroid == NULL)	{		return false;	}	if (psDroid->droidType == DROID_COMMAND)	{		debug(LOG_ERROR,		      "scrGroupAdd: cannot add a command droid to a group");		return false;	}	if (psDroid->droidType == DROID_TRANSPORTER || psDroid->droidType == DROID_SUPERTRANSPORTER)	{		debug(LOG_ERROR,		      "scrGroupAdd: cannot add a transporter to a group");		return false;	}	psGroup->add(psDroid);	return true;}

// set droid target ignore typesbool scrSetDroidTarIgnore(void){	UDWORD	pref;	if (!stackPopParams(1, VAL_INT, &pref))	{		return false;	}	ASSERT((SCR_DT_COMMAND		== pref) ||	       (SCR_DT_SENSOR			== pref) ||	       (SCR_DT_CONSTRUCT		== pref) ||	       (SCR_DT_REPAIR			== pref) ||	       (SCR_DT_WEAP_GROUND	== pref) ||	       (SCR_DT_WEAP_AIR		== pref) ||	       (SCR_DT_WEAP_IDF		== pref) ||	       (SCR_DT_WEAP_ALL		== pref) ||	       (SCR_DT_LIGHT			== pref) ||	       (SCR_DT_MEDIUM			== pref) ||	       (SCR_DT_HEAVY			== pref) ||	       (SCR_DT_SUPER_HEAVY	== pref) ||	       (SCR_DT_TRACK			== pref) ||	       (SCR_DT_HTRACK			== pref) ||	       (SCR_DT_WHEEL			== pref) ||	       (SCR_DT_LEGS			== pref) ||	       (SCR_DT_GROUND			== pref) ||	       (SCR_DT_VTOL			== pref) ||	       (SCR_DT_HOVER			== pref) ,	       "scrSetUnitTarIgnore: unknown ignore target");	scrDroidIgnore |= pref;	return true;}

// returns number of idle droids in a group.bool scrIdleGroup(void){	DROID_GROUP *psGroup;	DROID		*psDroid;	UDWORD		count = 0;	if (!stackPopParams(1, ST_GROUP, &psGroup))	{		return false;	}	ASSERT_OR_RETURN(false, psGroup != NULL, "Invalid group pointer");	for (psDroid = psGroup->psList; psDroid; psDroid = psDroid->psGrpNext)	{		if (psDroid->order.type == DORDER_NONE || (psDroid->order.type == DORDER_GUARD && psDroid->order.psObj == NULL))		{			count++;		}	}	scrFunctionResult.v.ival = (SDWORD)count;	if (!stackPushResult(VAL_INT, &scrFunctionResult))	{		return false;	}	return true;}

// Give a group an orderbool scrOrderGroup(void){	DROID_GROUP		*psGroup;	DROID_ORDER		order;	if (!stackPopParams(2, ST_GROUP, &psGroup, VAL_INT, &order))	{		return false;	}	ASSERT(psGroup != NULL,	       "scrOrderGroup: Invalid group pointer");	if (order != DORDER_STOP &&	    order != DORDER_RETREAT &&	    order != DORDER_DESTRUCT &&	    order != DORDER_RTR &&	    order != DORDER_RTB &&	    order != DORDER_RUN)	{		ASSERT(false,		       "scrOrderGroup: Invalid order");		return false;	}	debug(LOG_NEVER, "group %p (%u) order %d", psGroup, psGroup->getNumMembers(), order);	psGroup->orderGroup(order);	return true;}

// Give a Droid an order with a statbool scrOrderDroidStatsLoc(void){	DROID			*psDroid;	DROID_ORDER		order;	SDWORD			x,y, statIndex;	BASE_STATS		*psStats;	if (!stackPopParams(5, ST_DROID, &psDroid, VAL_INT, &order, ST_STRUCTURESTAT, &statIndex,						   VAL_INT, &x, VAL_INT, &y))	{		return false;	}	if (statIndex < 0 || statIndex >= (SDWORD)numStructureStats)	{		ASSERT( false, "Invalid structure stat" );		return false;	}	ASSERT_OR_RETURN( false, statIndex < numStructureStats, "Invalid range referenced for numStructureStats, %d > %d", statIndex, numStructureStats);	psStats = (asStructureStats + statIndex);	ASSERT_OR_RETURN( false, psDroid != NULL, "Invalid Unit pointer" );	ASSERT_OR_RETURN( false, psStats != NULL, "Invalid object pointer" );	if (psDroid == NULL)	{		return false;	}	if ((x < 0) || (x > (SDWORD)mapWidth*TILE_UNITS) ||		(y < 0) || (y > (SDWORD)mapHeight*TILE_UNITS))	{		ASSERT( false, "Invalid location" );		return false;	}	if (order != DORDER_BUILD)	{		ASSERT( false, "Invalid order" );		return false;	}	// Don't allow scripts to order structure builds if players structure	// limit has been reached.	if (!IsPlayerStructureLimitReached(psDroid->player))	{		// HACK: FIXME: Looks like a script error in the player*.slo files		// buildOnExactLocation() which references previously destroyed buildings from		// _stat = rebuildStructStat[_count]  causes this.		if (strcmp(psStats->pName, "A0ADemolishStructure") == 0)		{			// I don't feel like spamming a ASSERT here, we *know* it is a issue. 			return true;		}		orderDroidStatsLocDir(psDroid, order, psStats, x, y, 0, ModeQueue);	}	return true;}

//-----------------------// New functions//-----------------------bool scrActionDroidObj(void){	DROID			*psDroid;	DROID_ACTION		action;	BASE_OBJECT		*psObj;	if (!stackPopParams(3, ST_DROID, &psDroid, VAL_INT, &action, ST_BASEOBJECT, &psObj))	{		debug(LOG_ERROR, "scrActionDroidObj: failed to pop");		return false;	}	ASSERT(psDroid != NULL,	       "scrOrderUnitObj: Invalid unit pointer");	ASSERT(psObj != NULL,	       "scrOrderUnitObj: Invalid object pointer");	if (psDroid == NULL || psObj == NULL)	{		return false;	}	if (action != DACTION_DROIDREPAIR)	{		debug(LOG_ERROR, "scrActionDroidObj: this action is not supported");		return false;	}	syncDebug("TODO: Synchronise this!");	actionDroid(psDroid, action, psObj);	return true;}

// set prefered droid target typesBOOL scrSetDroidTarPref(void){	UDWORD	pref;	if (!stackPopParams(1, VAL_INT, &pref))	{		return FALSE;	}	ASSERT(( (SCR_DT_COMMAND		== pref) ||			 (SCR_DT_SENSOR			== pref) ||			 (SCR_DT_CONSTRUCT		== pref) ||			 (SCR_DT_REPAIR			== pref) ||			 (SCR_DT_WEAP_GROUND	== pref) ||			 (SCR_DT_WEAP_AIR		== pref) ||			 (SCR_DT_WEAP_IDF		== pref) ||			 (SCR_DT_WEAP_ALL		== pref) ||			 (SCR_DT_LIGHT			== pref) ||			 (SCR_DT_MEDIUM			== pref) ||			 (SCR_DT_HEAVY			== pref) ||			 (SCR_DT_SUPER_HEAVY	== pref) ||			 (SCR_DT_TRACK			== pref) ||			 (SCR_DT_HTRACK			== pref) ||			 (SCR_DT_WHEEL			== pref) ||			 (SCR_DT_LEGS			== pref) ||			 (SCR_DT_GROUND			== pref) ||			 (SCR_DT_VTOL			== pref) ||			 (SCR_DT_HOVER			== pref) ,		"scrSetUnitTarPref: unknown target preference"));		scrDroidPref |= pref;	return TRUE;}

// Deal with a CALL_NEWDROIDBOOL scrCBNewDroid(void){	SDWORD		player;	DROID		**ppsDroid;	STRUCTURE	**ppsStructure;	BOOL	triggered = false;	if (!stackPopParams(3, VAL_INT, &player, VAL_REF|ST_DROID, &ppsDroid, VAL_REF|ST_STRUCTURE, &ppsStructure))	{		return false;	}	if (psScrCBNewDroid == NULL)	{		// eh? got called without setting the new droid		ASSERT( false, "scrCBNewUnit: no unit has been set" );		triggered = false;		*ppsDroid = NULL;		*ppsStructure  = NULL;	}	else if (psScrCBNewDroid->player == (UDWORD)player)	{		triggered = true;		*ppsDroid = psScrCBNewDroid;		*ppsStructure  = psScrCBNewDroidFact;	}	scrFunctionResult.v.bval = triggered;	if (!stackPushResult(VAL_BOOL, &scrFunctionResult))	{		return false;	}	return true;}

// Give a droid an orderBOOL scrOrderDroid(void){	DROID			*psDroid;	SDWORD			order;	if (!stackPopParams(2, ST_DROID, &psDroid, VAL_INT, &order))	{		return FALSE;	}	ASSERT((PTRVALID(psDroid, sizeof(DROID)),		"scrOrderUnit: Invalid unit pointer"));	if (psDroid == NULL)	{		return FALSE;	}	if (order != DORDER_STOP &&		order != DORDER_RETREAT &&		order != DORDER_DESTRUCT &&		order != DORDER_RTR &&		order != DORDER_RTB &&		order != DORDER_RUN)	{		ASSERT((FALSE,			"scrOrderUnit: Invalid order"));		return FALSE;	}	orderDroid(psDroid, order);	return TRUE;}

// set prefered structure target typesBOOL scrSetStructTarPref(void){	UDWORD	pref;	if (!stackPopParams(1, VAL_INT, &pref))	{		return FALSE;	}	ASSERT(( (SCR_ST_HQ					== pref) ||			 (SCR_ST_FACTORY			== pref) ||			 (SCR_ST_POWER_GEN			== pref) ||			 (SCR_ST_RESOURCE_EXTRACTOR	== pref) ||			 (SCR_ST_WALL				== pref) ||			 (SCR_ST_RESEARCH			== pref) ||			 (SCR_ST_REPAIR_FACILITY	== pref) ||			 (SCR_ST_COMMAND_CONTROL	== pref) ||			 (SCR_ST_CYBORG_FACTORY		== pref) ||			 (SCR_ST_VTOL_FACTORY		== pref) ||			 (SCR_ST_REARM_PAD			== pref) ||			 (SCR_ST_SENSOR				== pref) ||			 (SCR_ST_DEF_GROUND			== pref) ||			 (SCR_ST_DEF_AIR			== pref) ||			 (SCR_ST_DEF_IDF			== pref) ||			 (SCR_ST_DEF_ALL			== pref) ,		"scrSetStructTarPref: unknown target preference"));	scrStructPref |= pref;	return TRUE;}

// Give a group an order to an objectBOOL scrOrderGroupObj(void){	DROID_GROUP		*psGroup;	SDWORD			order;	BASE_OBJECT		*psObj;	if (!stackPopParams(3, ST_GROUP, &psGroup, VAL_INT, &order, ST_BASEOBJECT, &psObj))	{		return FALSE;	}	ASSERT((PTRVALID(psGroup, sizeof(DROID_GROUP)),		"scrOrderGroupObj: Invalid group pointer"));	ASSERT((PTRVALID(psObj, sizeof(BASE_OBJECT)),		"scrOrderGroupObj: Invalid object pointer"));	if (order != DORDER_ATTACK &&		order != DORDER_HELPBUILD &&		order != DORDER_DEMOLISH &&		order != DORDER_REPAIR &&		order != DORDER_OBSERVE &&		order != DORDER_EMBARK &&		order != DORDER_FIRESUPPORT)	{		ASSERT((FALSE,			"scrOrderGroupObj: Invalid order"));		return FALSE;	}	DBP1(("scrOrderGroupObj: group %p (%d) order %d,  obj type %d player %d id %d/n",		psGroup, grpNumMembers(psGroup), order, psObj->type, psObj->player, psObj->id));	orderGroupObj(psGroup, order, psObj);	return TRUE;}

// Give a group an order to a locationBOOL scrOrderGroupLoc(void){	DROID_GROUP		*psGroup;	SDWORD			order, x,y;	if (!stackPopParams(4, ST_GROUP, &psGroup, VAL_INT, &order, VAL_INT, &x, VAL_INT, &y))	{		return FALSE;	}	ASSERT((PTRVALID(psGroup, sizeof(DROID_GROUP)),		"scrOrderGroupLoc: Invalid group pointer"));	if (order != DORDER_MOVE &&		order != DORDER_SCOUT)	{		ASSERT((FALSE,			"scrOrderGroupLoc: Invalid order"));		return FALSE;	}	if (x < 0 || x > (SDWORD)(mapWidth << TILE_SHIFT) ||		y < 0 || y > (SDWORD)(mapHeight << TILE_SHIFT))	{		ASSERT((FALSE,			"scrOrderGroupLoc: Invalid location"));		return FALSE;	}	DBP1(("scrOrderGroupLoc: group %p (%d) order %d (%d,%d)/n",		psGroup, grpNumMembers(psGroup), order, x,y));	orderGroupLoc(psGroup, order, (UDWORD)x,(UDWORD)y);	return TRUE;}

// Give a group an orderBOOL scrOrderGroup(void){	DROID_GROUP		*psGroup;	SDWORD			order;	if (!stackPopParams(2, ST_GROUP, &psGroup, VAL_INT, &order))	{		return FALSE;	}	ASSERT((PTRVALID(psGroup, sizeof(DROID_GROUP)),		"scrOrderGroup: Invalid group pointer"));	if (order != DORDER_STOP &&		order != DORDER_RETREAT &&		order != DORDER_DESTRUCT &&		order != DORDER_RTR &&		order != DORDER_RTB &&		order != DORDER_RUN)	{		ASSERT((FALSE,			"scrOrderGroup: Invalid order"));		return FALSE;	}	DBP1(("scrOrderGroup: group %p (%d) order %d/n", psGroup, grpNumMembers(psGroup), order));	orderGroup(psGroup, order);	return TRUE;}

BOOL scrCBDroidTaken(void){	DROID		**ppsDroid;	BOOL	triggered = false;	if (!stackPopParams(1, VAL_REF|ST_DROID, &ppsDroid))	{		return false;	}	if (psScrCBDroidTaken == NULL)	{		triggered = false;		*ppsDroid = NULL;	}	else	{		triggered = true;		*ppsDroid = psScrCBDroidTaken;	}	scrFunctionResult.v.bval = triggered;	if (!stackPushResult(VAL_BOOL, &scrFunctionResult))	{		return false;	}	return true;}

/* Droid received stop order */BOOL scrCBDorderStop(void){	SDWORD		player;	DROID		**ppsDroid;	BOOL	triggered = false;	if (!stackPopParams(2, VAL_INT, &player, VAL_REF|ST_DROID, &ppsDroid))	{		debug(LOG_ERROR, "scrCBDorderStop: failed to pop");		return false;	}	if (psScrCBOrderDroid == NULL)	//if droid that received stop order was destroyed	{		ASSERT( false, "scrCBDorderStop: psScrCBOrderDroid is NULL" );		triggered = false;		*ppsDroid = NULL;	}	else if (psScrCBOrderDroid->player == (UDWORD)player)	{		triggered = true;		*ppsDroid = psScrCBOrderDroid;	}	scrFunctionResult.v.bval = triggered;	if (!stackPushResult(VAL_BOOL, &scrFunctionResult))	{		return false;	}	return true;}

//console callback//---------------------------BOOL scrCallConsole(void){	SDWORD	*player;	char	**ConsoleText = NULL;	if (!stackPopParams(2, VAL_REF | VAL_INT, &player, VAL_REF | VAL_STRING, &ConsoleText) )	{		debug(LOG_ERROR, "scrCallConsole(): stack failed");		return false;	}	if(*ConsoleText == NULL)	{		debug(LOG_ERROR, "scrCallConsole(): passed string was not initialized");		return false;	}	strcpy(*ConsoleText,ConsoleMsg);	*player = ConsolePlayer;	scrFunctionResult.v.bval = true;	if (!stackPushResult(VAL_BOOL, &scrFunctionResult))	{		debug(LOG_ERROR, "scrCallConsole(): stackPushResult failed");		return false;	}	return true;}

/* Droid reached destination point and stopped on its own */BOOL scrCBDorderReachedLocation(void){	SDWORD		player;	SDWORD		*Order = NULL;	DROID		**ppsDroid;	BOOL	triggered = false;	if (!stackPopParams(3, VAL_INT, &player, VAL_REF|ST_DROID, &ppsDroid		,VAL_REF | VAL_INT, &Order))	{		debug(LOG_ERROR, "scrCBDorderReachedLocation: failed to pop");		return false;	}	if (psScrCBOrderDroid == NULL)	//if droid was destroyed	{		ASSERT( false, "scrCBDorderReachedLocation: psScrCBOrderDroid is NULL" );		triggered = false;		*ppsDroid = NULL;	}	else if (psScrCBOrderDroid->player == (UDWORD)player)	{		triggered = true;		*ppsDroid = psScrCBOrderDroid;		*Order = psScrCBOrder;	}	scrFunctionResult.v.bval = triggered;	if (!stackPushResult(VAL_BOOL, &scrFunctionResult))	{		return false;	}	return true;}

// get a target from a cluster using the preferencesbool scrTargetInCluster(void){	SDWORD		tarPlayer, tarType, visPlayer, clusterID, cluster;	BASE_OBJECT	*psTarget;	if (!stackPopParams(2, VAL_INT, &clusterID, VAL_INT, &visPlayer))	{		return false;	}	if (clusterID < 0 || clusterID >= CLUSTER_MAX)	{		ASSERT(false, "scrTargetInCluster: invalid clusterID");		return false;	}	cluster = aClusterMap[clusterID];	tarPlayer = aClusterInfo[cluster] & CLUSTER_PLAYER_MASK;	tarType = (aClusterInfo[cluster] & CLUSTER_DROID) ? SCR_TAR_DROID : SCR_TAR_STRUCT;	psTarget = scrTargetInArea(tarPlayer, visPlayer, tarType, cluster,	        scrollMinX * TILE_UNITS, scrollMinY * TILE_UNITS,	        scrollMaxX * TILE_UNITS, scrollMaxY * TILE_UNITS);	scrFunctionResult.v.oval = psTarget;	if (!stackPushResult((INTERP_TYPE)ST_BASEOBJECT, &scrFunctionResult))	{		return false;	}	return true;}

BOOL scrCBVTOLRetarget(void){	SDWORD			player;	DROID			**ppsDroid;	if (!stackPopParams(2, VAL_INT, &player, VAL_REF|ST_DROID, &ppsDroid))	{		return false;	}	ASSERT_OR_RETURN(false, player < MAX_PLAYERS && player >= 0, "Invalid player %d", player);	if (player == psScrVtolRetarget->player)	{		*ppsDroid = psScrVtolRetarget;		scrFunctionResult.v.bval = true;	}	else	{		*ppsDroid = NULL;		scrFunctionResult.v.bval = false;	}	if (!stackPushResult(VAL_BOOL, &scrFunctionResult))	{		return false;	}	return true;}

bool scrDroidCanReach(void){	DROID			*psDroid;	int			x, y;	if (!stackPopParams(3, ST_DROID, &psDroid, VAL_INT, &x, VAL_INT, &y))	{		debug(LOG_ERROR, "Failed to pop parameters");		return false;	}	if (psDroid)	{		const PROPULSION_STATS *psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];		const Vector3i rPos(x, y, 0);		scrFunctionResult.v.bval = fpathCheck(psDroid->pos, rPos, psPropStats->propulsionType);		if (!stackPushResult(VAL_BOOL, &scrFunctionResult))		{			debug(LOG_ERROR, "stackPushResult failed");			return false;		}		return true;	}	return false;}

// deal with a CALL_DROID_DESTROYEDBOOL scrCBDroidDestroyed(void){	SDWORD			player;	BASE_OBJECT		**ppsObj;	BOOL			retval;	if (!stackPopParams(2, VAL_INT, &player, VAL_REF|ST_DROID, &ppsObj))	{		return false;	}	if ( (psCBObjDestroyed != NULL) &&		 (psCBObjDestroyed->player == (UDWORD)player) &&		 (psCBObjDestroyed->type == OBJ_DROID) )	{		retval = true;		*ppsObj = psCBObjDestroyed;	}	else	{		retval = false;		*ppsObj = NULL;	}	scrFunctionResult.v.bval = retval;	if (!stackPushResult(VAL_BOOL, &scrFunctionResult))	{		return false;	}	return true;}

// iterate through a groups membersbool scrIterateGroup(void){	DROID_GROUP	*psGroup;	DROID		*psDroid;	if (!stackPopParams(1, ST_GROUP, &psGroup))	{		return false;	}	if (psGroup != psScrIterateGroup)	{		debug(LOG_ERROR, "scrIterateGroup: invalid group, InitGroupIterate not called?");		return false;	}	if (psScrIterateGroupDroid != NULL)	{		psDroid = psScrIterateGroupDroid;		psScrIterateGroupDroid = psScrIterateGroupDroid->psGrpNext;	}	else	{		psDroid = NULL;	}	scrFunctionResult.v.oval = psDroid;	if (!stackPushResult((INTERP_TYPE)ST_DROID, &scrFunctionResult))	{		return false;	}	return true;}

// deal with a CALL_FEATURE_DESTROYEDBOOL scrCBFeatureDestroyed(void){	BASE_OBJECT		**ppsObj;	BOOL			retval;	if (!stackPopParams(1, VAL_REF|ST_FEATURE, &ppsObj))	{		return false;	}	if (psCBObjDestroyed != NULL)	{		retval = true;		*ppsObj = psCBObjDestroyed;	}	else	{		retval = false;		*ppsObj = NULL;	}	scrFunctionResult.v.bval = retval;	if (!stackPushResult(VAL_BOOL, &scrFunctionResult))	{		return false;	}	return true;}

// Give a droid an orderbool scrOrderDroid(void){	DROID			*psDroid;	DROID_ORDER		order;	if (!stackPopParams(2, ST_DROID, &psDroid, VAL_INT, &order))	{		return false;	}	ASSERT(psDroid != NULL,	       "scrOrderUnit: Invalid unit pointer");	if (psDroid == NULL)	{		return false;	}	if (order != DORDER_STOP &&	    order != DORDER_RETREAT &&	    order != DORDER_DESTRUCT &&	    order != DORDER_RTR &&	    order != DORDER_RTB &&	    order != DORDER_RUN &&	    order != DORDER_NONE)	{		ASSERT(false,		       "scrOrderUnit: Invalid order %d", order);		return false;	}	orderDroid(psDroid, order, ModeQueue);	return true;}

BOOL scrCBTransporterOffMap( void ){	SDWORD	player;	BOOL	retval;	DROID	*psTransporter;	if (!stackPopParams(1, VAL_INT, &player) )	{		return false;	}	psTransporter = transporterGetScriptCurrent();	if ( (psTransporter != NULL) &&		 (psTransporter->player == (UDWORD)player) )	{		retval = true;	}	else	{		retval = false;	}	scrFunctionResult.v.bval = retval;	if (!stackPushResult(VAL_BOOL, &scrFunctionResult))	{		return false;	}	return true;}

// set structure target ignore typesbool scrSetStructTarIgnore(void){	UDWORD	pref;	if (!stackPopParams(1, VAL_INT, &pref))	{		return false;	}	ASSERT((SCR_ST_HQ					== pref) ||	       (SCR_ST_FACTORY			== pref) ||	       (SCR_ST_POWER_GEN			== pref) ||	       (SCR_ST_RESOURCE_EXTRACTOR	== pref) ||	       (SCR_ST_WALL				== pref) ||	       (SCR_ST_RESEARCH			== pref) ||	       (SCR_ST_REPAIR_FACILITY	== pref) ||	       (SCR_ST_COMMAND_CONTROL	== pref) ||	       (SCR_ST_CYBORG_FACTORY		== pref) ||	       (SCR_ST_VTOL_FACTORY		== pref) ||	       (SCR_ST_REARM_PAD			== pref) ||	       (SCR_ST_SENSOR				== pref) ||	       (SCR_ST_DEF_GROUND			== pref) ||	       (SCR_ST_DEF_AIR			== pref) ||	       (SCR_ST_DEF_IDF			== pref) ||	       (SCR_ST_DEF_ALL			== pref) ,	       "scrSetStructTarIgnore: unknown ignore target");	scrStructIgnore |= pref;	return true;}

BOOL scrCBVtolOffMap(void){	SDWORD	player;	DROID	**ppsVtol;	BOOL	retval;	if (!stackPopParams(2, VAL_INT, &player, VAL_REF|ST_DROID, &ppsVtol))	{		return false;	}	if (psScrCBVtolOffMap == NULL)	{		ASSERT( false, "scrCBVtolAtBase: NULL vtol pointer" );		return false;	}	retval = false;	if (psScrCBVtolOffMap->player == player)	{		retval = true;		*ppsVtol = psScrCBVtolOffMap;	}	psScrCBVtolOffMap = NULL;	scrFunctionResult.v.bval = retval;	if (!stackPushResult(VAL_BOOL, &scrFunctionResult))	{		return false;	}	return true;}

// Add droids in an area to a groupbool scrGroupAddArea(void){	DROID_GROUP		*psGroup;	DROID			*psDroid;	SDWORD			x1, y1, x2, y2, player;	if (!stackPopParams(6, ST_GROUP, &psGroup, VAL_INT, &player,	        VAL_INT, &x1, VAL_INT, &y1, VAL_INT, &x2, VAL_INT, &y2))	{		return false;	}	ASSERT(psGroup != NULL,	       "scrGroupAdd: Invalid group pointer");	if (player < 0 || player >= MAX_PLAYERS)	{		ASSERT(false, "scrGroupAddArea: invalid player");		return false;	}	for (psDroid = apsDroidLists[player]; psDroid; psDroid = psDroid->psNext)	{		if (((SDWORD)psDroid->pos.x >= x1) && ((SDWORD)psDroid->pos.x <= x2) &&		    ((SDWORD)psDroid->pos.y >= y1) && ((SDWORD)psDroid->pos.y <= y2) &&		    psDroid->droidType != DROID_COMMAND &&		    (psDroid->droidType != DROID_TRANSPORTER && psDroid->droidType != DROID_SUPERTRANSPORTER))		{			psGroup->add(psDroid);		}	}	return true;}

// iterate through a groups membersBOOL scrIterateGroup(void){	DROID_GROUP	*psGroup;	DROID		*psDroid;	if (!stackPopParams(1, ST_GROUP, &psGroup))	{		return FALSE;	}	if (psGroup != psScrIterateGroup)	{		ASSERT((FALSE, "scrIterateGroup: invalid group, InitGroupIterate not called?"));		return FALSE;	}	if (psScrIterateGroupDroid != NULL)	{		psDroid = psScrIterateGroupDroid;		psScrIterateGroupDroid = psScrIterateGroupDroid->psGrpNext;	}	else	{		psDroid = NULL;	}	if (!stackPushResult(ST_DROID, (SDWORD)psDroid))	{		return FALSE;	}	return TRUE;}