P_CHAR Monster_EnergyVortex::findBestTarget() { int targetAttract = -1; P_CHAR target = 0; if ( !m_npc ) { return target; } // Search for targets in our list of current targets first QList<cFightInfo*> fights = m_npc->fights(); foreach ( cFightInfo* info, fights ) { P_CHAR victim = info->victim(); if ( victim == m_npc ) { victim = info->attacker(); } // We don't already attack the target, right? if ( victim != target ) { // See if it's a target we want unsigned int dist = m_npc->dist(victim); int attract = (victim->intelligence() + victim->skillValue(MAGERY) / 10) / (wpMin<unsigned int>(65535, dist) + 1); if ( attract > targetAttract && validTarget( victim, dist ) ) { target = victim; targetAttract = attract; } } }
// Find prey for this predator P_CHAR Animal_Predator::findPrey() { unsigned int distance = ~0; P_CHAR target = 0; if ( !m_npc ) { return target; } // Search for targets in our list of current targets first QList<cFightInfo*> fights( m_npc->fights() ); foreach ( cFightInfo* info, fights ) { P_CHAR victim = info->victim(); if ( victim == m_npc ) { victim = info->attacker(); } // We don't already attack the target, right? if ( victim != target ) { // See if it's a target we want unsigned int dist = m_npc->dist( victim ); if ( dist < distance && validTarget( victim, dist, false ) ) { target = victim; distance = dist; } } }
/* Check if any of our weapons can hit the target... */ bool checkAnyWeaponsTarget(BASE_OBJECT *psObject, BASE_OBJECT *psTarget) { DROID *psDroid = (DROID *) psObject; for (int i = 0; i < psDroid->numWeaps; i++) { if (validTarget(psObject, psTarget, i)) { return true; } } return false; }
float Action_MoveToTarget::preCondition() { /* * Moving to the target has the following preconditions: * - A target has been set. * - The NPC is not in combat range. * * Here we take the fuzzy logic into account. * If the npc is injured, the chance of fighting will decrease. */ if ( !m_ai ) { return 0.0f; } P_CHAR currentVictim = m_ai->currentVictim(); if ( !currentVictim || !validTarget( m_npc, currentVictim ) ) { return 0.0f; } Q_UINT8 range = 1; P_ITEM weapon = m_npc->getWeapon(); if ( weapon ) { if ( weapon->hasTag( "range" ) ) { range = weapon->getTag( "range" ).toInt(); } else if ( weapon->basedef() ) { range = weapon->basedef()->getIntProperty( "range", 1 ); } } if ( m_npc->inRange( currentVictim, range ) ) return 0.0f; // 1.0 = Full Health, 0.0 = Dead float diff = 1.0 - wpMax<float>( 0, ( m_npc->maxHitpoints() - m_npc->hitpoints() ) / ( float ) m_npc->maxHitpoints() ); if ( diff <= m_npc->criticalHealth() / 100.0 ) { return 0.0; } return 1.0; }
float Action_MoveToTarget::postCondition() { /* * Moving to the target has the following postconditions: * - The target is not set anymore. * - The NPC is within fight range. * - The NPC is not injured above the critical line. */ if ( !m_ai ) { return 1.0f; } P_CHAR currentVictim = m_ai->currentVictim(); if ( !currentVictim || !validTarget( m_npc, currentVictim ) ) return 1.0f; Q_UINT8 range = 1; P_ITEM weapon = m_npc->getWeapon(); if ( weapon ) { if ( weapon->hasTag( "range" ) ) { range = weapon->getTag( "range" ).toInt(); } else if ( weapon->basedef() ) { range = weapon->basedef()->getIntProperty( "range", 1 ); } } if ( m_npc->inRange( currentVictim, range ) ) return 1.0f; // 1.0 = Full Health, 0.0 = Dead float diff = 1.0 - wpMax<float>( 0, ( m_npc->maxHitpoints() - m_npc->hitpoints() ) / ( float ) m_npc->maxHitpoints() ); if ( diff <= m_npc->criticalHealth() / 100.0 ) { return 1.0; } return 0.0; }
/* Fire a weapon at something */ bool combFire(WEAPON *psWeap, BASE_OBJECT *psAttacker, BASE_OBJECT *psTarget, int weapon_slot) { WEAPON_STATS *psStats; UDWORD damLevel; UDWORD firePause; SDWORD longRange; DROID *psDroid = NULL; int compIndex; CHECK_OBJECT(psAttacker); CHECK_OBJECT(psTarget); ASSERT(psWeap != NULL, "Invalid weapon pointer"); /* Watermelon:dont shoot if the weapon_slot of a vtol is empty */ if (psAttacker->type == OBJ_DROID && isVtolDroid(((DROID *)psAttacker))) { if (((DROID *)psAttacker)->sMove.iAttackRuns[weapon_slot] >= getNumAttackRuns(((DROID *)psAttacker), weapon_slot)) { objTrace(psAttacker->id, "VTOL slot %d is empty", weapon_slot); return false; } } /* Get the stats for the weapon */ compIndex = psWeap->nStat; ASSERT_OR_RETURN( false , compIndex < numWeaponStats, "Invalid range referenced for numWeaponStats, %d > %d", compIndex, numWeaponStats); psStats = asWeaponStats + compIndex; // check valid weapon/prop combination if (!validTarget(psAttacker, psTarget, weapon_slot)) { return false; } /*see if reload-able weapon and out of ammo*/ if (psStats->reloadTime && !psWeap->ammo) { if (gameTime - psWeap->lastFired < weaponReloadTime(psStats, psAttacker->player)) { return false; } //reset the ammo level psWeap->ammo = psStats->numRounds; } /* See when the weapon last fired to control it's rate of fire */ firePause = weaponFirePause(psStats, psAttacker->player); // increase the pause if heavily damaged switch (psAttacker->type) { case OBJ_DROID: psDroid = (DROID *)psAttacker; damLevel = PERCENT(psDroid->body, psDroid->originalBody); break; case OBJ_STRUCTURE: damLevel = PERCENT(((STRUCTURE *)psAttacker)->body, structureBody((STRUCTURE *)psAttacker)); break; default: damLevel = 100; break; } if (damLevel < HEAVY_DAMAGE_LEVEL) { firePause += firePause; } if (gameTime - psWeap->lastFired <= firePause) { /* Too soon to fire again */ return false; } // add a random delay to the fire // With logical updates, a good graphics gard no longer gives a better ROF. // TODO Should still replace this with something saner, such as a ±1% random deviation in reload time. int fireChance = gameTime - (psWeap->lastFired + firePause); if (gameRand(RANDOM_PAUSE) > fireChance) { return false; } if (psTarget->visible[psAttacker->player] != UBYTE_MAX) { // Can't see it - can't hit it objTrace(psAttacker->id, "combFire(%u[%s]->%u): Object has no indirect sight of target", psAttacker->id, psStats->pName, psTarget->id); return false; } /* Check we can see the target */ if (psAttacker->type == OBJ_DROID && !isVtolDroid((DROID *)psAttacker) && (proj_Direct(psStats) || actionInsideMinRange(psDroid, psTarget, psStats))) { if(!lineOfFire(psAttacker, psTarget, weapon_slot, true)) { // Can't see the target - can't hit it with direct fire objTrace(psAttacker->id, "combFire(%u[%s]->%u): Droid has no direct line of sight to target", psAttacker->id, ((DROID *)psAttacker)->aName, psTarget->id); return false; } } else if ((psAttacker->type == OBJ_STRUCTURE) && (((STRUCTURE *)psAttacker)->pStructureType->height == 1) && proj_Direct(psStats)) { // a bunker can't shoot through walls if (!lineOfFire(psAttacker, psTarget, weapon_slot, true)) { // Can't see the target - can't hit it with direct fire objTrace(psAttacker->id, "combFire(%u[%s]->%u): Structure has no direct line of sight to target", psAttacker->id, ((STRUCTURE *)psAttacker)->pStructureType->pName, psTarget->id); return false; } } else if ( proj_Direct(psStats) ) { // VTOL or tall building if (!lineOfFire(psAttacker, psTarget, weapon_slot, false)) { // Can't see the target - can't hit it with direct fire objTrace(psAttacker->id, "combFire(%u[%s]->%u): Tall object has no direct line of sight to target", psAttacker->id, psStats->pName, psTarget->id); return false; } } Vector3i deltaPos = psTarget->pos - psAttacker->pos; // if the turret doesn't turn, check if the attacker is in alignment with the target if (psAttacker->type == OBJ_DROID && !psStats->rotate) { uint16_t targetDir = iAtan2(removeZ(deltaPos)); int dirDiff = abs(angleDelta(targetDir - psAttacker->rot.direction)); if (dirDiff > FIXED_TURRET_DIR) { return false; } } /* Now see if the target is in range - also check not too near */ int dist = iHypot(removeZ(deltaPos)); longRange = proj_GetLongRange(psStats); /* modification by CorvusCorax - calculate shooting angle */ int min_angle = 0; // only calculate for indirect shots if (!proj_Direct(psStats) && dist > 0) { min_angle = arcOfFire(psAttacker,psTarget,weapon_slot,true); // prevent extremely steep shots min_angle = std::min(min_angle, DEG(PROJ_ULTIMATE_PITCH)); // adjust maximum range of unit if forced to shoot very steep if (min_angle > DEG(PROJ_MAX_PITCH)) { //do not allow increase of max range though if (iSin(2*min_angle) < iSin(2*DEG(PROJ_MAX_PITCH))) // If PROJ_MAX_PITCH == 45, then always iSin(2*min_angle) <= iSin(2*DEG(PROJ_MAX_PITCH)), and the test is redundant. { longRange = longRange * iSin(2*min_angle) / iSin(2*DEG(PROJ_MAX_PITCH)); } } } int baseHitChance = 0; if ((dist <= psStats->shortRange) && (dist >= psStats->minRange)) { // get weapon chance to hit in the short range baseHitChance = weaponShortHit(psStats,psAttacker->player); } else if ((dist <= longRange && dist >= psStats->minRange) || (psAttacker->type == OBJ_DROID && !proj_Direct(psStats) && actionInsideMinRange(psDroid, psTarget, psStats))) { // get weapon chance to hit in the long range baseHitChance = weaponLongHit(psStats,psAttacker->player); // adapt for height adjusted artillery shots if (min_angle > DEG(PROJ_MAX_PITCH)) { baseHitChance = baseHitChance * iCos(min_angle) / iCos(DEG(PROJ_MAX_PITCH)); } } else { /* Out of range */ objTrace(psAttacker->id, "combFire(%u[%s]->%u): Out of range", psAttacker->id, psStats->pName, psTarget->id); return false; } // apply experience accuracy modifiers to the base //hit chance, not to the final hit chance int resultHitChance = baseHitChance; // add the attacker's experience if (psAttacker->type == OBJ_DROID) { SDWORD level = getDroidEffectiveLevel((DROID *) psAttacker); // increase total accuracy by EXP_ACCURACY_BONUS % for each experience level resultHitChance += EXP_ACCURACY_BONUS * level * baseHitChance / 100; } // subtract the defender's experience if (psTarget->type == OBJ_DROID) { SDWORD level = getDroidEffectiveLevel((DROID *) psTarget); // decrease weapon accuracy by EXP_ACCURACY_BONUS % for each experience level resultHitChance -= EXP_ACCURACY_BONUS * level * baseHitChance / 100; } // fire while moving modifiers if (psAttacker->type == OBJ_DROID && ((DROID *)psAttacker)->sMove.Status != MOVEINACTIVE) { switch (psStats->fireOnMove) { case FOM_NO: // Can't fire while moving return false; break; case FOM_PARTIAL: resultHitChance = FOM_PARTIAL_ACCURACY_PENALTY * resultHitChance / 100; break; case FOM_YES: // can fire while moving break; } } /* -------!!! From that point we are sure that we are firing !!!------- */ /* note when the weapon fired */ psWeap->lastFired = gameTime; /* reduce ammo if salvo */ if (psStats->reloadTime) { psWeap->ammo--; } // increment the shots counter psWeap->shotsFired++; // predicted X,Y offset per sec Vector3i predict = psTarget->pos; //Watermelon:Target prediction if (isDroid(psTarget)) { DROID *psDroid = castDroid(psTarget); int32_t flightTime; if (proj_Direct(psStats) || dist <= psStats->minRange) { flightTime = dist / psStats->flightSpeed; } else { int32_t vXY, vZ; // Unused, we just want the flight time. flightTime = projCalcIndirectVelocities(dist, deltaPos.z, psStats->flightSpeed, &vXY, &vZ, min_angle); } if (psTarget->lastHitWeapon == WSC_EMP) { int empTime = EMP_DISABLE_TIME - (gameTime - psTarget->timeLastHit); CLIP(empTime, 0, EMP_DISABLE_TIME); if (empTime >= EMP_DISABLE_TIME * 9/10) { flightTime = 0; /* Just hit. Assume they'll get hit again */ } else { flightTime = MAX(0, flightTime - empTime); } } predict += Vector3i(iSinCosR(psDroid->sMove.moveDir, psDroid->sMove.speed*flightTime / GAME_TICKS_PER_SEC), 0); } /* Fire off the bullet to the miss location. The miss is only visible if the player owns the target. (Why? - Per) */ // What bVisible really does is to make the projectile audible even if it misses you. Since the target is NULL, proj_SendProjectile can't check if it was fired at you. bool bVisibleAnyway = psTarget->player == selectedPlayer; // see if we were lucky to hit the target bool isHit = gameRand(100) <= resultHitChance; if (isHit) { /* Kerrrbaaang !!!!! a hit */ objTrace(psAttacker->id, "combFire: [%s]->%u: resultHitChance=%d, visibility=%hhu : ", psStats->pName, psTarget->id, resultHitChance, psTarget->visible[psAttacker->player]); syncDebug("hit=(%d,%d,%d)", predict.x, predict.y, predict.z); } else /* Deal with a missed shot */ { const int minOffset = 5; int missDist = 2 * (100 - resultHitChance) + minOffset; Vector3i miss = Vector3i(iSinCosR(gameRand(DEG(360)), missDist), 0); predict += miss; psTarget = NULL; // Missed the target, so don't expect to hit it. objTrace(psAttacker->id, "combFire: Missed shot by (%4d,%4d)", miss.x, miss.y); syncDebug("miss=(%d,%d,%d)", predict.x, predict.y, predict.z); } // Make sure we don't pass any negative or out of bounds numbers to proj_SendProjectile CLIP(predict.x, 0, world_coord(mapWidth - 1)); CLIP(predict.y, 0, world_coord(mapHeight - 1)); proj_SendProjectileAngled(psWeap, psAttacker, psAttacker->player, predict, psTarget, bVisibleAnyway, weapon_slot, min_angle); return true; }
// check if something is attacking us P_CHAR Action_Defend::findAttacker() { if ( !m_ai ) { return 0; } P_CHAR attacker = m_npc->attackTarget(); unsigned int distance = ~0; // check our current target if ( attacker && validTarget( m_npc, attacker ) ) { m_ai->setcurrentVictimSer( attacker->serial() ); return attacker; } // check our current victim attacker = m_ai->currentVictim(); if ( !attacker ) { m_ai->setcurrentVictimSer( INVALID_SERIAL ); } // is it still valid? if ( attacker && invalidTarget( m_npc, attacker ) ) { attacker = 0; m_ai->setcurrentVictimSer( INVALID_SERIAL ); m_npc->fight( 0 ); } if ( m_ai->getnextVictimCheck() < Server::instance()->time() ) { // Don't switch if we can hit it... if ( !attacker || attacker->dist( m_npc ) > 1 ) { // Search for attackers in our list of current fights QPtrList<cFightInfo> fights = m_npc->fights(); for ( cFightInfo*info = fights.first(); info; info = fights.next() ) { //are they attacking us? P_CHAR victim = info->victim(); if ( victim == m_npc ) { victim = info->attacker(); } // We don't already attack the target, right? if ( victim != attacker ) { // See if it's a target we want unsigned int dist = m_npc->dist( victim ); if ( dist < distance && validTarget( m_npc, victim, dist ) ) { attacker = victim; distance = dist; } } } // we found someone attacking us, so let's defend! if ( attacker ) { m_ai->setcurrentVictimSer( attacker->serial() ); m_npc->fight( attacker ); } } m_ai->setnextVictimCheck( Server::instance()->time() + 1500 ); } return attacker; }
/* Fire a weapon at something */ bool combFire(WEAPON *psWeap, BASE_OBJECT *psAttacker, BASE_OBJECT *psTarget, int weapon_slot) { WEAPON_STATS *psStats; UDWORD firePause; SDWORD longRange; int compIndex; CHECK_OBJECT(psAttacker); CHECK_OBJECT(psTarget); ASSERT(psWeap != NULL, "Invalid weapon pointer"); /* Watermelon:dont shoot if the weapon_slot of a vtol is empty */ if (psAttacker->type == OBJ_DROID && isVtolDroid(((DROID *)psAttacker))) { if (psWeap->usedAmmo >= getNumAttackRuns(((DROID *)psAttacker), weapon_slot)) { objTrace(psAttacker->id, "VTOL slot %d is empty", weapon_slot); return false; } } /* Get the stats for the weapon */ compIndex = psWeap->nStat; ASSERT_OR_RETURN( false , compIndex < numWeaponStats, "Invalid range referenced for numWeaponStats, %d > %d", compIndex, numWeaponStats); psStats = asWeaponStats + compIndex; // check valid weapon/prop combination if (!validTarget(psAttacker, psTarget, weapon_slot)) { return false; } unsigned fireTime = gameTime - deltaGameTime + 1; // Can fire earliest at the start of the tick. // See if reloadable weapon. if (psStats->reloadTime) { unsigned reloadTime = psWeap->lastFired + weaponReloadTime(psStats, psAttacker->player); if (psWeap->ammo == 0) // Out of ammo? { fireTime = std::max(fireTime, reloadTime); // Have to wait for weapon to reload before firing. if (gameTime < fireTime) { return false; } } if (reloadTime <= fireTime) { //reset the ammo level psWeap->ammo = psStats->numRounds; } } /* See when the weapon last fired to control it's rate of fire */ firePause = weaponFirePause(psStats, psAttacker->player); firePause = std::max(firePause, 1u); // Don't shoot infinitely many shots at once. fireTime = std::max(fireTime, psWeap->lastFired + firePause); if (gameTime < fireTime) { /* Too soon to fire again */ return false; } if (psTarget->visible[psAttacker->player] != UBYTE_MAX) { // Can't see it - can't hit it objTrace(psAttacker->id, "combFire(%u[%s]->%u): Object has no indirect sight of target", psAttacker->id, psStats->pName, psTarget->id); return false; } /* Check we can hit the target */ bool tall = (psAttacker->type == OBJ_DROID && isVtolDroid((DROID *)psAttacker)) || (psAttacker->type == OBJ_STRUCTURE && ((STRUCTURE *)psAttacker)->pStructureType->height > 1); if (proj_Direct(psStats) && !lineOfFire(psAttacker, psTarget, weapon_slot, tall)) { // Can't see the target - can't hit it with direct fire objTrace(psAttacker->id, "combFire(%u[%s]->%u): No direct line of sight to target", psAttacker->id, objInfo(psAttacker), psTarget->id); return false; } Vector3i deltaPos = psTarget->pos - psAttacker->pos; // if the turret doesn't turn, check if the attacker is in alignment with the target if (psAttacker->type == OBJ_DROID && !psStats->rotate) { uint16_t targetDir = iAtan2(removeZ(deltaPos)); int dirDiff = abs(angleDelta(targetDir - psAttacker->rot.direction)); if (dirDiff > FIXED_TURRET_DIR) { return false; } } /* Now see if the target is in range - also check not too near */ int dist = iHypot(removeZ(deltaPos)); longRange = proj_GetLongRange(psStats); int min_angle = 0; // Calculate angle for indirect shots if (!proj_Direct(psStats) && dist > 0) { min_angle = arcOfFire(psAttacker,psTarget,weapon_slot,true); // prevent extremely steep shots min_angle = std::min(min_angle, DEG(PROJ_ULTIMATE_PITCH)); // adjust maximum range of unit if forced to shoot very steep if (min_angle > DEG(PROJ_MAX_PITCH)) { //do not allow increase of max range though if (iSin(2*min_angle) < iSin(2*DEG(PROJ_MAX_PITCH))) // If PROJ_MAX_PITCH == 45, then always iSin(2*min_angle) <= iSin(2*DEG(PROJ_MAX_PITCH)), and the test is redundant. { longRange = longRange * iSin(2*min_angle) / iSin(2*DEG(PROJ_MAX_PITCH)); } } } int baseHitChance = 0; if (dist <= longRange && dist >= psStats->minRange) { // get weapon chance to hit in the long range baseHitChance = weaponLongHit(psStats,psAttacker->player); // adapt for height adjusted artillery shots if (min_angle > DEG(PROJ_MAX_PITCH)) { baseHitChance = baseHitChance * iCos(min_angle) / iCos(DEG(PROJ_MAX_PITCH)); } } else { /* Out of range */ objTrace(psAttacker->id, "combFire(%u[%s]->%u): Out of range", psAttacker->id, psStats->pName, psTarget->id); return false; } // apply experience accuracy modifiers to the base //hit chance, not to the final hit chance int resultHitChance = baseHitChance; // add the attacker's experience if (psAttacker->type == OBJ_DROID) { SDWORD level = getDroidEffectiveLevel((DROID *) psAttacker); // increase total accuracy by EXP_ACCURACY_BONUS % for each experience level resultHitChance += EXP_ACCURACY_BONUS * level * baseHitChance / 100; } // subtract the defender's experience if (psTarget->type == OBJ_DROID) { SDWORD level = getDroidEffectiveLevel((DROID *) psTarget); // decrease weapon accuracy by EXP_ACCURACY_BONUS % for each experience level resultHitChance -= EXP_ACCURACY_BONUS * level * baseHitChance / 100; } // fire while moving modifiers if (psAttacker->type == OBJ_DROID && ((DROID *)psAttacker)->sMove.Status != MOVEINACTIVE) { switch (psStats->fireOnMove) { case FOM_NO: // Can't fire while moving return false; break; case FOM_PARTIAL: resultHitChance = FOM_PARTIAL_ACCURACY_PENALTY * resultHitChance / 100; break; case FOM_YES: // can fire while moving break; } } /* -------!!! From that point we are sure that we are firing !!!------- */ // Add a random delay to the next shot. // TODO Add deltaFireTime to the time it takes to fire next. If just adding to psWeap->lastFired, it might put it in the future, causing assertions. And if not sometimes putting it in the future, the fire rate would be lower than advertised. //int fireJitter = firePause/100; // ±1% variation in fire rate. //int deltaFireTime = gameRand(fireJitter*2 + 1) - fireJitter; /* note when the weapon fired */ psWeap->lastFired = fireTime; /* reduce ammo if salvo */ if (psStats->reloadTime) { psWeap->ammo--; } // increment the shots counter psWeap->shotsFired++; // predicted X,Y offset per sec Vector3i predict = psTarget->pos; //Watermelon:Target prediction if (isDroid(psTarget) && castDroid(psTarget)->sMove.bumpTime == 0) { DROID *psDroid = castDroid(psTarget); int32_t flightTime; if (proj_Direct(psStats) || dist <= psStats->minRange) { flightTime = dist * GAME_TICKS_PER_SEC / psStats->flightSpeed; } else { int32_t vXY, vZ; // Unused, we just want the flight time. flightTime = projCalcIndirectVelocities(dist, deltaPos.z, psStats->flightSpeed, &vXY, &vZ, min_angle); } if (psTarget->lastHitWeapon == WSC_EMP) { int playerEmpTime = getEmpDisableTime(psTarget->player); int empTime = playerEmpTime - (gameTime - psTarget->timeLastHit); CLIP(empTime, 0, playerEmpTime); if (empTime >= playerEmpTime * 9/10) { flightTime = 0; /* Just hit. Assume they'll get hit again */ } else { flightTime = MAX(0, flightTime - empTime); } } predict += Vector3i(iSinCosR(psDroid->sMove.moveDir, psDroid->sMove.speed*flightTime / GAME_TICKS_PER_SEC), 0); if (!isFlying(psDroid)) { predict.z = map_Height(removeZ(predict)); // Predict that the object will be on the ground. } } /* Fire off the bullet to the miss location. The miss is only visible if the player owns the target. (Why? - Per) */ // What bVisible really does is to make the projectile audible even if it misses you. Since the target is NULL, proj_SendProjectile can't check if it was fired at you. bool bVisibleAnyway = psTarget->player == selectedPlayer; // see if we were lucky to hit the target bool isHit = gameRand(100) <= resultHitChance; if (isHit) { /* Kerrrbaaang !!!!! a hit */ objTrace(psAttacker->id, "combFire: [%s]->%u: resultHitChance=%d, visibility=%d", psStats->pName, psTarget->id, resultHitChance, (int)psTarget->visible[psAttacker->player]); syncDebug("hit=(%d,%d,%d)", predict.x, predict.y, predict.z); } else /* Deal with a missed shot */ { const int minOffset = 5; int missDist = 2 * (100 - resultHitChance) + minOffset; Vector3i miss = Vector3i(iSinCosR(gameRand(DEG(360)), missDist), 0); predict += miss; psTarget = NULL; // Missed the target, so don't expect to hit it. objTrace(psAttacker->id, "combFire: Missed shot by (%4d,%4d)", miss.x, miss.y); syncDebug("miss=(%d,%d,%d)", predict.x, predict.y, predict.z); } // Make sure we don't pass any negative or out of bounds numbers to proj_SendProjectile CLIP(predict.x, 0, world_coord(mapWidth - 1)); CLIP(predict.y, 0, world_coord(mapHeight - 1)); proj_SendProjectileAngled(psWeap, psAttacker, psAttacker->player, predict, psTarget, bVisibleAnyway, weapon_slot, min_angle, fireTime); return true; }
/* See if there is a target in range */ BOOL aiChooseTarget(BASE_OBJECT *psObj, BASE_OBJECT **ppsTarget, int weapon_slot, BOOL bUpdateTarget, UWORD *targetOrigin) { BASE_OBJECT *psTarget = NULL; DROID *psCommander; SDWORD curTargetWeight=-1; UWORD tmpOrigin = ORIGIN_UNKNOWN; if (targetOrigin) { *targetOrigin = ORIGIN_UNKNOWN; } /* Get the sensor range */ switch (psObj->type) { case OBJ_DROID: if (((DROID *)psObj)->asWeaps[weapon_slot].nStat == 0) { return false; } if (((DROID *)psObj)->asWeaps[0].nStat == 0 && ((DROID *)psObj)->droidType != DROID_SENSOR) { // Can't attack without a weapon return false; } break; case OBJ_STRUCTURE: if (((STRUCTURE *)psObj)->numWeaps == 0 || ((STRUCTURE *)psObj)->asWeaps[0].nStat == 0) { // Can't attack without a weapon return false; } break; default: break; } /* See if there is a something in range */ if (psObj->type == OBJ_DROID) { BASE_OBJECT *psCurrTarget = ((DROID *)psObj)->psActionTarget[0]; /* find a new target */ int newTargetWeight = aiBestNearestTarget((DROID *)psObj, &psTarget, weapon_slot, NULL); /* Calculate weight of the current target if updating; but take care not to target * ourselves... */ if (bUpdateTarget && psCurrTarget != psObj) { curTargetWeight = targetAttackWeight(psCurrTarget, psObj, weapon_slot); } if (newTargetWeight >= 0 // found a new target && (!bUpdateTarget // choosing a new target, don't care if current one is better || curTargetWeight <= 0 // attacker had no valid target, use new one || newTargetWeight > curTargetWeight + OLD_TARGET_THRESHOLD) // updating and new target is better && validTarget(psObj, psTarget, weapon_slot) && (aiDroidHasRange((DROID *)psObj, psTarget, weapon_slot) || (secondaryGetState((DROID *)psObj, DSO_HALTTYPE) != DSS_HALT_HOLD))) { ASSERT(!isDead(psTarget), "aiChooseTarget: Droid found a dead target!"); *ppsTarget = psTarget; return true; } } else if (psObj->type == OBJ_STRUCTURE) { WEAPON_STATS *psWStats = NULL; int tarDist, longRange = 0; BOOL bCommanderBlock = false; ASSERT(((STRUCTURE *)psObj)->asWeaps[weapon_slot].nStat > 0, "no weapons on structure"); psWStats = ((STRUCTURE *)psObj)->asWeaps[weapon_slot].nStat + asWeaponStats; longRange = proj_GetLongRange(psWStats); // see if there is a target from the command droids psTarget = NULL; psCommander = cmdDroidGetDesignator(psObj->player); if (!proj_Direct(psWStats) && (psCommander != NULL) && aiStructHasRange((STRUCTURE *)psObj, (BASE_OBJECT *)psCommander, weapon_slot)) { // there is a commander that can fire designate for this structure // set bCommanderBlock so that the structure does not fire until the commander // has a target - (slow firing weapons will not be ready to fire otherwise). bCommanderBlock = true; // I do believe this will never happen, check for yourself :-) debug(LOG_NEVER,"Commander %d is good enough for fire designation", psCommander->id); if (psCommander->action == DACTION_ATTACK && psCommander->psActionTarget[0] != NULL && !aiObjectIsProbablyDoomed(psCommander->psActionTarget[0])) { // the commander has a target to fire on if (aiStructHasRange((STRUCTURE *)psObj, psCommander->psActionTarget[0], weapon_slot)) { // target in range - fire on it tmpOrigin = ORIGIN_COMMANDER; psTarget = psCommander->psActionTarget[0]; } else { // target out of range - release the commander block bCommanderBlock = false; } } } // indirect fire structures use sensor towers first tarDist = longRange * longRange; if (psTarget == NULL && !bCommanderBlock && !proj_Direct(psWStats)) { psTarget = aiSearchSensorTargets(psObj, weapon_slot, psWStats, &tmpOrigin); } if (psTarget == NULL && !bCommanderBlock) { BASE_OBJECT *psCurr; gridStartIterate(psObj->pos.x, psObj->pos.y, PREVIOUS_DEFAULT_GRID_SEARCH_RADIUS); psCurr = gridIterate(); while (psCurr != NULL) { /* Check that it is a valid target */ if (psCurr->type != OBJ_FEATURE && !aiObjectIsProbablyDoomed(psCurr) && aiStructHasRange((STRUCTURE *)psObj, psCurr, weapon_slot) && !aiCheckAlliances(psCurr->player, psObj->player) && validTarget(psObj, psCurr, weapon_slot) && psCurr->visible[psObj->player]) { // See if in sensor range and visible int distSq = objPosDiffSq(psCurr->pos, psObj->pos); if (distSq < tarDist || (psTarget && psTarget->type == OBJ_STRUCTURE && ((STRUCTURE *)psTarget)->status != SS_BUILT) || (psTarget && aiObjIsWall(psTarget) && !aiObjIsWall(psCurr))) { tmpOrigin = ORIGIN_VISUAL; psTarget = psCurr; tarDist = distSq; } } psCurr = gridIterate(); } } if (psTarget) { ASSERT(!psTarget->died, "aiChooseTarget: Structure found a dead target!"); if (targetOrigin) { *targetOrigin = tmpOrigin; } *ppsTarget = psTarget; return true; } } return false; }
// Find the best nearest target for a droid // Returns integer representing target priority, -1 if failed SDWORD aiBestNearestTarget(DROID *psDroid, BASE_OBJECT **ppsObj, int weapon_slot, UWORD *targetOrigin) { SDWORD bestMod = 0,newMod, failure = -1; BASE_OBJECT *psTarget = NULL, *friendlyObj, *bestTarget = NULL, *iter, *targetInQuestion, *tempTarget; BOOL electronic = false; STRUCTURE *targetStructure; WEAPON_EFFECT weaponEffect; UWORD tmpOrigin = ORIGIN_UNKNOWN; // reset origin if (targetOrigin) { *targetOrigin = ORIGIN_UNKNOWN; } //don't bother looking if empty vtol droid if (vtolEmpty(psDroid)) { return failure; } /* Return if have no weapons */ // The ai orders a non-combat droid to patrol = crash without it... if ((psDroid->asWeaps[0].nStat == 0 || psDroid->numWeaps == 0) && psDroid->droidType != DROID_SENSOR) { return failure; } // Check if we have a CB target to begin with if (!proj_Direct(asWeaponStats + psDroid->asWeaps[weapon_slot].nStat)) { WEAPON_STATS *psWStats = psWStats = psDroid->asWeaps[weapon_slot].nStat + asWeaponStats; bestTarget = aiSearchSensorTargets((BASE_OBJECT *)psDroid, weapon_slot, psWStats, &tmpOrigin); bestMod = targetAttackWeight(bestTarget, (BASE_OBJECT *)psDroid, weapon_slot); } weaponEffect = ((WEAPON_STATS *)(asWeaponStats + psDroid->asWeaps[weapon_slot].nStat))->weaponEffect; electronic = electronicDroid(psDroid); // Range was previously 9*TILE_UNITS. Increasing this doesn't seem to help much, though. Not sure why. gridStartIterate(psDroid->pos.x, psDroid->pos.y, psDroid->sensorRange + 6*TILE_UNITS); for (iter = gridIterate(); iter != NULL; iter = gridIterate()) { friendlyObj = NULL; targetInQuestion = iter; /* This is a friendly unit, check if we can reuse its target */ if(aiCheckAlliances(targetInQuestion->player,psDroid->player)) { friendlyObj = targetInQuestion; targetInQuestion = NULL; /* Can we see what it is doing? */ if(friendlyObj->visible[psDroid->player]) { if(friendlyObj->type == OBJ_DROID) { DROID *friendlyDroid = (DROID *)friendlyObj; /* See if friendly droid has a target */ tempTarget = friendlyDroid->psActionTarget[0]; if(tempTarget && !aiObjectIsProbablyDoomed(tempTarget)) { //make sure a weapon droid is targeting it if(friendlyDroid->numWeaps > 0) { // make sure this target wasn't assigned explicitly to this droid if(friendlyDroid->order != DORDER_ATTACK) { // make sure target is near enough if (aiDroidHasRange(psDroid, tempTarget, weapon_slot)) { targetInQuestion = tempTarget; //consider this target } } } } } else if(friendlyObj->type == OBJ_STRUCTURE) { tempTarget = ((STRUCTURE*)friendlyObj)->psTarget[0]; if (tempTarget && !aiObjectIsProbablyDoomed(tempTarget) && aiDroidHasRange(psDroid, tempTarget, weapon_slot)) { targetInQuestion = tempTarget; } } } } if (targetInQuestion != NULL && targetInQuestion != (BASE_OBJECT *)psDroid // in case friendly unit had me as target && (targetInQuestion->type == OBJ_DROID || targetInQuestion->type == OBJ_STRUCTURE || targetInQuestion->type == OBJ_FEATURE) && targetInQuestion->visible[psDroid->player] && !aiCheckAlliances(targetInQuestion->player,psDroid->player) && validTarget((BASE_OBJECT *)psDroid, targetInQuestion, weapon_slot) && aiDroidHasRange(psDroid, targetInQuestion, weapon_slot)) { if (targetInQuestion->type == OBJ_DROID) { // in multiPlayer - don't attack Transporters with EW if (bMultiPlayer) { // if not electronic then valid target if (!electronic || (electronic && ((DROID *)targetInQuestion)->droidType != DROID_TRANSPORTER)) { //only a valid target if NOT a transporter psTarget = targetInQuestion; } } else { psTarget = targetInQuestion; } } else if (targetInQuestion->type == OBJ_STRUCTURE) { STRUCTURE *psStruct = (STRUCTURE *)targetInQuestion; if (electronic) { /* don't want to target structures with resistance of zero if using electronic warfare */ if (validStructResistance((STRUCTURE *)targetInQuestion)) { psTarget = targetInQuestion; } } else if (psStruct->asWeaps[weapon_slot].nStat > 0) { // structure with weapons - go for this psTarget = targetInQuestion; } else if ((psStruct->pStructureType->type != REF_WALL && psStruct->pStructureType->type != REF_WALLCORNER) || driveModeActive() || (bMultiPlayer && !isHumanPlayer(psDroid->player))) { psTarget = targetInQuestion; } } else if (targetInQuestion->type == OBJ_FEATURE && gameTime - psDroid->lastFrustratedTime < FRUSTRATED_TIME && ((FEATURE *)targetInQuestion)->psStats->damageable && !(game.scavengers && psDroid->player == 7)) // hack to avoid scavs blowing up their nice feature walls { psTarget = targetInQuestion; } /* Check if our weapon is most effective against this object */ if(psTarget != NULL && psTarget == targetInQuestion) //was assigned? { newMod = targetAttackWeight(psTarget, (BASE_OBJECT *)psDroid, weapon_slot); /* Remember this one if it's our best target so far */ if( newMod >= 0 && (newMod > bestMod || bestTarget == NULL)) { bestMod = newMod; tmpOrigin = ORIGIN_ALLY; bestTarget = psTarget; } } } } if (bestTarget) { ASSERT(!bestTarget->died, "aiBestNearestTarget: AI gave us a target that is already dead."); targetStructure = visGetBlockingWall((BASE_OBJECT *)psDroid, bestTarget); /* See if target is blocked by a wall; only affects direct weapons */ if (proj_Direct(asWeaponStats + psDroid->asWeaps[weapon_slot].nStat) && targetStructure) { //are we any good against walls? if(asStructStrengthModifier[weaponEffect][targetStructure->pStructureType->strength] >= 100) //can attack atleast with default strength { bestTarget = (BASE_OBJECT *)targetStructure; //attack wall } } if (targetOrigin) { *targetOrigin = tmpOrigin; } *ppsObj = bestTarget; return bestMod; } return failure; }
/** Search the global list of sensors for a possible target for psObj. */ static BASE_OBJECT *aiSearchSensorTargets(BASE_OBJECT *psObj, int weapon_slot, WEAPON_STATS *psWStats, UWORD *targetOrigin) { int longRange = proj_GetLongRange(psWStats); int tarDist = longRange * longRange; BOOL foundCB = false; int minDist = psWStats->minRange * psWStats->minRange; BASE_OBJECT *psSensor, *psTarget = NULL; if (targetOrigin) { *targetOrigin = ORIGIN_UNKNOWN; } for (psSensor = apsSensorList[0]; psSensor; psSensor = psSensor->psNextFunc) { BASE_OBJECT *psTemp = NULL; bool isCB = false; bool isRD = false; if (!aiCheckAlliances(psSensor->player, psObj->player)) { continue; } else if (psSensor->type == OBJ_DROID) { DROID *psDroid = (DROID *)psSensor; ASSERT_OR_RETURN(false, psDroid->droidType == DROID_SENSOR, "A non-sensor droid in a sensor list is non-sense"); psTemp = psDroid->psTarget; isCB = cbSensorDroid(psDroid); isRD = objRadarDetector((BASE_OBJECT *)psDroid); } else if (psSensor->type == OBJ_STRUCTURE) { STRUCTURE *psCStruct = (STRUCTURE *)psSensor; // skip incomplete structures if (psCStruct->status != SS_BUILT) { continue; } psTemp = psCStruct->psTarget[0]; isCB = structCBSensor(psCStruct); isRD = objRadarDetector((BASE_OBJECT *)psCStruct); } if (!psTemp || aiObjectIsProbablyDoomed(psTemp) || !validTarget(psObj, psTemp, 0) || aiCheckAlliances(psTemp->player, psObj->player)) { continue; } if (aiObjHasRange(psObj, psTemp, weapon_slot) && visibleObject(psSensor, psTemp, false)) { int distSq = objPosDiffSq(psTemp->pos, psObj->pos); // Need to be in range, prefer closer targets or CB targets if ((isCB > foundCB || (isCB == foundCB && distSq < tarDist)) && distSq > minDist) { tarDist = distSq; psTarget = psTemp; if (targetOrigin) { *targetOrigin = ORIGIN_SENSOR; } if (isCB) { if (targetOrigin) { *targetOrigin = ORIGIN_CB_SENSOR; } foundCB = true; // got CB target, drop everything and shoot! } else if (isRD) { if (targetOrigin) { *targetOrigin = ORIGIN_RADAR_DETECTOR; } } } } } return psTarget; }
/* See if there is a target in range */ bool aiChooseTarget(BASE_OBJECT *psObj, BASE_OBJECT **ppsTarget, int weapon_slot, bool bUpdateTarget, TARGET_ORIGIN *targetOrigin) { BASE_OBJECT *psTarget = NULL; DROID *psCommander; SDWORD curTargetWeight = -1; TARGET_ORIGIN tmpOrigin = ORIGIN_UNKNOWN; if (targetOrigin) { *targetOrigin = ORIGIN_UNKNOWN; } switch (psObj->type) { case OBJ_DROID: if (((DROID *)psObj)->asWeaps[weapon_slot].nStat == 0) { return false; } if (((DROID *)psObj)->asWeaps[0].nStat == 0 && ((DROID *)psObj)->droidType != DROID_SENSOR) { return false; // Can't target without a weapon or sensor } break; case OBJ_STRUCTURE: if (((STRUCTURE *)psObj)->numWeaps == 0 || ((STRUCTURE *)psObj)->asWeaps[0].nStat == 0) { // Can't attack without a weapon return false; } break; default: break; } /* See if there is a something in range */ if (psObj->type == OBJ_DROID) { BASE_OBJECT *psCurrTarget = ((DROID *)psObj)->psActionTarget[0]; /* find a new target */ int newTargetWeight = aiBestNearestTarget((DROID *)psObj, &psTarget, weapon_slot); /* Calculate weight of the current target if updating; but take care not to target * ourselves... */ if (bUpdateTarget && psCurrTarget != psObj) { curTargetWeight = targetAttackWeight(psCurrTarget, psObj, weapon_slot); } if (newTargetWeight >= 0 // found a new target && (!bUpdateTarget // choosing a new target, don't care if current one is better || curTargetWeight <= 0 // attacker had no valid target, use new one || newTargetWeight > curTargetWeight + OLD_TARGET_THRESHOLD) // updating and new target is better && validTarget(psObj, psTarget, weapon_slot) && aiDroidHasRange((DROID *)psObj, psTarget, weapon_slot)) { ASSERT(!isDead(psTarget), "Droid found a dead target!"); *ppsTarget = psTarget; return true; } } else if (psObj->type == OBJ_STRUCTURE) { WEAPON_STATS *psWStats = NULL; bool bCommanderBlock = false; ASSERT(((STRUCTURE *)psObj)->asWeaps[weapon_slot].nStat > 0, "no weapons on structure"); psWStats = ((STRUCTURE *)psObj)->asWeaps[weapon_slot].nStat + asWeaponStats; int longRange = proj_GetLongRange(psWStats, psObj->player); // see if there is a target from the command droids psTarget = NULL; psCommander = cmdDroidGetDesignator(psObj->player); if (!proj_Direct(psWStats) && (psCommander != NULL) && aiStructHasRange((STRUCTURE *)psObj, (BASE_OBJECT *)psCommander, weapon_slot)) { // there is a commander that can fire designate for this structure // set bCommanderBlock so that the structure does not fire until the commander // has a target - (slow firing weapons will not be ready to fire otherwise). bCommanderBlock = true; // I do believe this will never happen, check for yourself :-) debug(LOG_NEVER, "Commander %d is good enough for fire designation", psCommander->id); if (psCommander->action == DACTION_ATTACK && psCommander->psActionTarget[0] != NULL && !psCommander->psActionTarget[0]->died) { // the commander has a target to fire on if (aiStructHasRange((STRUCTURE *)psObj, psCommander->psActionTarget[0], weapon_slot)) { // target in range - fire on it tmpOrigin = ORIGIN_COMMANDER; psTarget = psCommander->psActionTarget[0]; } else { // target out of range - release the commander block bCommanderBlock = false; } } } // indirect fire structures use sensor towers first if (psTarget == NULL && !bCommanderBlock && !proj_Direct(psWStats)) { psTarget = aiSearchSensorTargets(psObj, weapon_slot, psWStats, &tmpOrigin); } if (psTarget == NULL && !bCommanderBlock) { int targetValue = -1; int tarDist = INT32_MAX; int srange = longRange; if (!proj_Direct(psWStats) && srange > objSensorRange(psObj)) { // search radius of indirect weapons limited by their sight, unless they use // external sensors to provide fire designation srange = objSensorRange(psObj); } static GridList gridList; // static to avoid allocations. gridList = gridStartIterate(psObj->pos.x, psObj->pos.y, srange); for (GridIterator gi = gridList.begin(); gi != gridList.end(); ++gi) { BASE_OBJECT *psCurr = *gi; /* Check that it is a valid target */ if (psCurr->type != OBJ_FEATURE && !psCurr->died && !aiCheckAlliances(psCurr->player, psObj->player) && validTarget(psObj, psCurr, weapon_slot) && psCurr->visible[psObj->player] == UBYTE_MAX && aiStructHasRange((STRUCTURE *)psObj, psCurr, weapon_slot)) { int newTargetValue = targetAttackWeight(psCurr, psObj, weapon_slot); // See if in sensor range and visible int distSq = objPosDiffSq(psCurr->pos, psObj->pos); if (newTargetValue < targetValue || (newTargetValue == targetValue && distSq >= tarDist)) { continue; } tmpOrigin = ORIGIN_VISUAL; psTarget = psCurr; tarDist = distSq; targetValue = newTargetValue; } } } if (psTarget) { ASSERT(!psTarget->died, "Structure found a dead target!"); if (targetOrigin) { *targetOrigin = tmpOrigin; } *ppsTarget = psTarget; return true; } } return false; }
static P_CHAR findBestTarget( P_NPC npc ) { int targetAttract = -1; P_CHAR target = 0; // Search for targets in our list of current targets first QPtrList<cFightInfo> fights = npc->fights(); for ( cFightInfo*info = fights.first(); info; info = fights.next() ) { P_CHAR victim = info->victim(); if ( victim == npc ) { victim = info->attacker(); } // We don't already attack the target, right? if ( victim != target ) { // See if it's a target we want unsigned int dist = npc->dist(victim); int attract = (victim->strength() + victim->skillValue(TACTICS) / 10) / (wpMin<unsigned int>(65535, dist) + 1); if ( attract > targetAttract && validTarget( npc, victim, dist ) ) { target = victim; targetAttract = attract; } } } /* Attack the target with the highest ((Strength + Tactics) / Distance) value. */ // If we're not tamed, we attack other players as well. if ( !npc->isTamed() ) { MapCharsIterator ri = MapObjects::instance()->listCharsInCircle( npc->pos(), VISRANGE ); for ( P_CHAR pChar = ri.first(); pChar; pChar = ri.next() ) { // We limit ourself to players and pets owned by players. P_PLAYER victim = dynamic_cast<P_PLAYER>( pChar ); P_NPC npcVictim = dynamic_cast<P_NPC>( pChar ); // We don't already attack the target, right? if ( victim && victim != target ) { // See if it's a target we want unsigned int dist = npc->dist(victim); int attract = (victim->strength() + victim->skillValue(TACTICS) / 10) / (wpMin<unsigned int>(65535, dist) + 1); if ( attract > targetAttract && validTarget( npc, victim, dist ) ) { target = victim; targetAttract = attract; } } else if ( npcVictim && npcVictim->owner() && npcVictim != target ) { // See if it's a target we want unsigned int dist = npc->dist(victim); int attract = (npcVictim->strength() + npcVictim->skillValue(TACTICS) / 10) / (wpMin<unsigned int>(65535, dist) + 1); if ( attract > targetAttract && validTarget( npc, npcVictim, dist ) ) { target = npcVictim; targetAttract = attract; } } } } return target; }