void Team::removeFromRoster(MoverPtr mover)
{
for(size_t i = 0; i < rosterSize; i++)
if(roster[i] == mover->getWatchID())
{
roster[i] = roster[--rosterSize];
break;
}
}
bool MoverGroup::isMember(MoverPtr mover)
{
if (!mover)
return (false);
GameObjectWatchID moverWID = mover->getWatchID();
for (size_t i = 0; i < numMovers; i++)
if (moverWIDs[i] == moverWID)
return (true);
return (false);
}
bool MoverGroup::add(MoverPtr mover)
{
if (numMovers == MAX_MOVERGROUP_COUNT)
{
Fatal(0, " MoverGroup.add: Group too big ");
//----------------------------------------
// Should we choose to remove the fatal...
return (false);
}
moverWIDs[numMovers++] = mover->getWatchID();
mover->setGroupId(id, true);
return (true);
}
long MoverGroup::setPoint (MoverPtr mover) {
if (isMember(mover)) {
#ifdef USE_IFACE
if (pointHandle)
theInterface->setPoint(pointHandle, false);
#endif
pointWID = mover->getWatchID();
#ifdef USE_IFACE
theInterface->setPoint(mover->getPartId(), true);
#endif
}
return(NO_ERR);
}
void Team::buildRoster(void)
{
//---------------------------------------------------------------------
// This function builds a roster for the team from the movers currently
// registered in the object manager. It assumes the teamId is already
// set for each mover, and compares this team's id to that of the
// objects to determine which objects belong on this team...
rosterSize = 0;
for(size_t i = 0; i < ObjectManager->getNumMovers(); i++)
{
MoverPtr mover = ObjectManager->getMover(i);
if(mover->getTeamId() == id)
roster[rosterSize++] = mover->getWatchID();
}
// numMechs = objClassTally[0];
// numVehicles = objClassTally[1];
// numElementals = objClassTally[2];
}
bool MoverGroup::remove (MoverPtr mover) {
GameObjectWatchID moverWID = mover->getWatchID();
if (moverWID == pointWID) {
disband();
return(true);
}
else {
for (long i = 0; i < numMovers; i++)
if (moverWIDs[i] == moverWID) {
mover->setGroupId(-1, true);
moverWIDs[i] = moverWIDs[numMovers - 1];
moverWIDs[numMovers - 1] = 0;
numMovers--;
return(true);
}
}
return(false);
}
void TriggerAreaManager::setHit (MoverPtr mover) {
#if 1
for (long i = 0; i < MAX_TRIGGER_AREAS; i++) {
if (triggerAreas[i].type == TRIGGER_AREA_NONE)
continue;
if (mover->cellPositionRow >= triggerAreas[i].dim[0])
if (mover->cellPositionRow < triggerAreas[i].dim[2])
if (mover->cellPositionCol >= triggerAreas[i].dim[1])
if (mover->cellPositionCol < triggerAreas[i].dim[3])
switch (triggerAreas[i].type) {
case TRIGGER_AREA_MOVER:
if (triggerAreas[i].param > 0) {
if (mover->getWatchID() == triggerAreas[i].param)
triggerAreas[i].hit = true;
}
else
triggerAreas[i].hit = true;
break;
case TRIGGER_AREA_TEAM:
if (mover->getTeamId() == triggerAreas[i].param) {
triggerAreas[i].hit = true;
//sprintf(s, "AREA HIT: %d", i);
//DEBUGWINS_print(s, 0);
}
break;
case TRIGGER_AREA_GROUP:
if (mover->getGroupId() == triggerAreas[i].param)
triggerAreas[i].hit = true;
break;
case TRIGGER_AREA_COMMANDER:
if (mover->getCommanderId() == triggerAreas[i].param)
triggerAreas[i].hit = true;
break;
}
}
#else
long areaHandle = map[mover->cellPositionRow / 3][mover->cellPositionCol / 3];
if (areaHandle > 0) {
switch (triggerAreas[areaHandle].type) {
case TRIGGER_AREA_MOVER:
if (triggerAreas[areaHandle].param > 0) {
if (mover->getWatchID() == triggerAreas[areaHandle].param)
triggerAreas[areaHandle].hit = true;
}
else
triggerAreas[areaHandle].hit = true;
break;
case TRIGGER_AREA_TEAM:
if (mover->getTeamId() == triggerAreas[areaHandle].param)
triggerAreas[areaHandle].hit = true;
break;
case TRIGGER_AREA_GROUP:
if (mover->getGroupId() == triggerAreas[areaHandle].param)
triggerAreas[areaHandle].hit = true;
break;
case TRIGGER_AREA_COMMANDER:
if (mover->getCommanderId() == triggerAreas[areaHandle].param)
triggerAreas[areaHandle].hit = true;
break;
}
}
#endif
}
long MoverGroup::handleTacticalOrder (TacticalOrder tacOrder, long priority, Stuff::Vector3D* jumpGoalList, bool queueGroupOrder) {
if (numMovers == 0)
return(NO_ERR);
if (queueGroupOrder)
tacOrder.pack(NULL, NULL);
//bool processOrder = true;
bool isJump = false;
bool isMove = false;
Stuff::Vector3D goalList[MAX_MOVERGROUP_COUNT];
Stuff::Vector3D location = tacOrder.getWayPoint(0);
//MoverPtr pointVehicle = getPoint();
if (tacOrder.code == TACTICAL_ORDER_ATTACK_OBJECT)
if (tacOrder.attackParams.method == ATTACKMETHOD_DFA) {
//-------------------------------------------------
// Let's just make it a move/jump order, for now...
tacOrder.code = TACTICAL_ORDER_JUMPTO_OBJECT;
tacOrder.moveParams.wait = false;
tacOrder.moveParams.wayPath.mode[0] = TRAVEL_MODE_SLOW;
GameObjectPtr target = ObjectManager->getByWatchID(tacOrder.targetWID);
Assert(tacOrder.targetWID != 0, 0, " DFA AttackObject WID is 0 ");
if (!target)
return(NO_ERR);
tacOrder.setWayPoint(0, target->getPosition());
}
if (tacOrder.code == TACTICAL_ORDER_JUMPTO_OBJECT) {
tacOrder.code = TACTICAL_ORDER_JUMPTO_POINT;
GameObjectPtr target = ObjectManager->get(tacOrder.targetWID);
Assert(tacOrder.targetWID != 0, 0, " DFA AttackObject WID is 0 ");
if (!target)
return(NO_ERR);
tacOrder.setWayPoint(0, target->getPosition());
}
//vector_3d offsetTable[MAX_GROUPMOVE_OFFSETS];
//long numOffsets = 0;
switch (tacOrder.code) {
case TACTICAL_ORDER_WAIT:
break;
case TACTICAL_ORDER_MOVETO_POINT:
case TACTICAL_ORDER_MOVETO_OBJECT: {
Fatal(0, "Need to support jumpGoalList (and goalList) for MOVETO as well in mc2 ");
isMove = true;
//-----------------------------------------------------------
// Sort by distance to destination. Their selectionIndex will
// be set to modify this goal...
SortListPtr list = Mover::sortList;
if (list) {
list->clear(false);
long moverCount = 0;
for (long i = 0; i < numMovers; i++) {
MoverPtr mover = getMover(i);
Assert(mover != NULL, moverWIDs[i], " MoverGroup.handleTacticalOrder: NULL mover ");
if (!mover->isDisabled()) {
list->setId(moverCount, i);
list->setValue(moverCount, mover->distanceFrom(location));
moverCount++;
}
}
list->sort(false);
//--------------------------------
// Let's build the offset table...
/*
numOffsets = moverCount - 1;
if (numOffsets > MAX_GROUPMOVE_OFFSETS)
numOffsets = MAX_GROUPMOVE_OFFSETS;
long offsetsStart = GroupMoveOffsetsIndex[numOffsets - 1];
for (i = 0; i < numOffsets; i++)
offsetTable[i] = relativePositionToPoint(location, GroupMoveOffsets[offsetsStart + i][0], GroupMoveOffsets[offsetsStart + i][1], RELPOS_FLAG_PASSABLE_START);
*/
//-----------------------------------
// Now, calc the order of movement...
long curIndex = 1;
for (i = 0; i < moverCount; i++) {
MoverPtr mover = getMover(list->getId(i));
if (mover->getWatchID() == pointWID)
mover->selectionIndex = 0;
else
mover->selectionIndex = curIndex++;
}
}
}
break;
case TACTICAL_ORDER_JUMPTO_POINT:
case TACTICAL_ORDER_JUMPTO_OBJECT: {
//-----------------------------------------------------------
// Sort by distance to destination. Their selectionIndex will
// be set to modify this goal...
isJump = true;
//-------------------------------------------------------------------------
// We can assume that all movers in this group are jump-capable. Otherwise,
// the group wouldn't be allowed to jump by the interface. In addition,
// we KNOW that all movers in this group can jump to the selected
// goal (of course, they won't due to terrain and crowding)...
GameObjectPtr target = ObjectManager->getByWatchID(tacOrder.targetWID);
if (jumpGoalList)
for (long j = 0; j < numMovers; j++)
goalList[j] = jumpGoalList[j];
else
calcJumpGoals(tacOrder.getWayPoint(0), goalList, target);
for (long i = 0; i < numMovers; i++) {
MoverPtr mover = getMover(i);
bool canJump = (goalList[i].x > -99000.0);
if (canJump)
mover->selectionIndex = 0;
else
mover->selectionIndex = -2;
}
}
break;
case TACTICAL_ORDER_TRAVERSE_PATH:
case TACTICAL_ORDER_PATROL_PATH:
case TACTICAL_ORDER_ESCORT:
case TACTICAL_ORDER_FOLLOW:
case TACTICAL_ORDER_GUARD:
case TACTICAL_ORDER_STOP:
case TACTICAL_ORDER_POWERUP:
case TACTICAL_ORDER_POWERDOWN:
case TACTICAL_ORDER_WAYPOINTS_DONE:
case TACTICAL_ORDER_EJECT:
case TACTICAL_ORDER_ATTACK_OBJECT:
case TACTICAL_ORDER_ATTACK_POINT:
case TACTICAL_ORDER_HOLD_FIRE:
case TACTICAL_ORDER_WITHDRAW:
case TACTICAL_ORDER_CAPTURE:
case TACTICAL_ORDER_LOAD_INTO_CARRIER:
case TACTICAL_ORDER_REFIT:
case TACTICAL_ORDER_RECOVER:
case TACTICAL_ORDER_GETFIXED:
break;
default: {
char s[256];
sprintf(s, "Unit::handleTacticalOrder->Bad TacOrder Code (%d)", tacOrder.code);
Assert(false, tacOrder.code, s);
return(1);
}
}
tacOrder.unitOrder = true;
for (long i = 0; i < numMovers; i++) {
MoverPtr mover = getMover(i);
if (mover && !mover->isDisabled()) {
if (mover->selectionIndex == -2) {
mover->selectionIndex = -1;
continue;
}
tacOrder.selectionIndex = mover->selectionIndex;
if (tacOrder.selectionIndex != -1) {
if (isMove)
tacOrder.setWayPoint(0, location);
else if (isJump)
tacOrder.setWayPoint(0, goalList[i]);
tacOrder.delayedTime = scenarioTime + (mover->selectionIndex * DelayedOrderTime);
}
switch (tacOrder.origin) {
case ORDER_ORIGIN_PLAYER:
if (queueGroupOrder)
mover->getPilot()->addQueuedTacOrder(tacOrder);
else {
if (mover->getPilot()->getNumTacOrdersQueued())
//This is a hack to simply trigger the execution of
//the queued orders. The current order is ignored (and
//is simply used for this trigger)...
mover->getPilot()->executeTacOrderQueue();
else
mover->getPilot()->setPlayerTacOrder(tacOrder);
}
break;
case ORDER_ORIGIN_COMMANDER:
mover->getPilot()->setGeneralTacOrder(tacOrder);
break;
case ORDER_ORIGIN_SELF:
mover->getPilot()->setAlarmTacOrder(tacOrder, priority);
break;
}
mover->selectionIndex = -1;
}
}
return(NO_ERR);
}
void Team::addToRoster(MoverPtr mover)
{
if(mover)
roster[rosterSize++] = mover->getWatchID();
}
