GridList GridInfoDialog::getSelectedGrids()
{
QTableWidget* table(m_dialog.gridTable);
GridList grids;
QList<QTableWidgetItem*> items(table->selectedItems());
QList<QTableWidgetItem*>::iterator iter;
int row, col;
for (iter = items.begin(); iter != items.end(); ++iter) {
row = (*iter)->row();
col = (*iter)->column();
if (col == 0 && row >= 0 && row < m_gridList->size()) grids.append((*m_gridList)[row]);
}
return grids;
}
static void updateSpotters()
{
static GridList gridList; // static to avoid allocations.
for (int i = 0; i < apsInvisibleViewers.size(); i++)
{
SPOTTER *psSpot = apsInvisibleViewers.at(i);
if (psSpot->expiryTime != 0 && psSpot->expiryTime < gameTime)
{
delete psSpot;
apsInvisibleViewers.erase(apsInvisibleViewers.begin() + i);
continue;
}
// else, ie if not expired, show objects around it
gridList = gridStartIterateUnseen(world_coord(psSpot->pos.x), world_coord(psSpot->pos.y), psSpot->sensorRadius, psSpot->player);
for (GridIterator gi = gridList.begin(); gi != gridList.end(); ++gi)
{
BASE_OBJECT *psObj = *gi;
// Tell system that this side can see this object
setSeenBy(psObj, psSpot->player, UBYTE_MAX);
}
}
}
/* See if there is a target in range for Sensor objects*/
bool aiChooseSensorTarget(BASE_OBJECT *psObj, BASE_OBJECT **ppsTarget)
{
int sensorRange = objSensorRange(psObj);
unsigned int radSquared = sensorRange * sensorRange;
bool radarDetector = objRadarDetector(psObj);
if (!objActiveRadar(psObj) && !radarDetector)
{
ASSERT(false, "Only to be used for sensor turrets!");
return false;
}
/* See if there is something in range */
if (psObj->type == OBJ_DROID)
{
BASE_OBJECT *psTarget = NULL;
if (aiBestNearestTarget((DROID *)psObj, &psTarget, 0) >= 0)
{
/* See if in sensor range */
const int xdiff = psTarget->pos.x - psObj->pos.x;
const int ydiff = psTarget->pos.y - psObj->pos.y;
const unsigned int distSq = xdiff * xdiff + ydiff * ydiff;
// I do believe this will never happen, check for yourself :-)
debug(LOG_NEVER, "Sensor droid(%d) found possible target(%d)!!!", psObj->id, psTarget->id);
if (distSq < radSquared)
{
*ppsTarget = psTarget;
return true;
}
}
}
else // structure
{
BASE_OBJECT *psTemp = NULL;
int tarDist = SDWORD_MAX;
static GridList gridList; // static to avoid allocations.
gridList = gridStartIterate(psObj->pos.x, psObj->pos.y, objSensorRange(psObj));
for (GridIterator gi = gridList.begin(); gi != gridList.end(); ++gi)
{
BASE_OBJECT *psCurr = *gi;
// Don't target features or doomed/dead objects
if (psCurr->type != OBJ_FEATURE && !psCurr->died && !aiObjectIsProbablyDoomed(psCurr, false))
{
if (!aiCheckAlliances(psCurr->player, psObj->player) && !aiObjIsWall(psCurr))
{
// See if in sensor range and visible
const int xdiff = psCurr->pos.x - psObj->pos.x;
const int ydiff = psCurr->pos.y - psObj->pos.y;
const unsigned int distSq = xdiff * xdiff + ydiff * ydiff;
if (distSq < radSquared && psCurr->visible[psObj->player] == UBYTE_MAX && distSq < tarDist)
{
psTemp = psCurr;
tarDist = distSq;
}
}
}
}
if (psTemp)
{
ASSERT(!psTemp->died, "aiChooseSensorTarget gave us a dead target");
*ppsTarget = psTemp;
return true;
}
}
return false;
}
/* 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;
}
// Find the best nearest target for a droid.
// If extraRange is higher than zero, then this is the range it accepts for movement to target.
// Returns integer representing target priority, -1 if failed
int aiBestNearestTarget(DROID *psDroid, BASE_OBJECT **ppsObj, int weapon_slot, int extraRange)
{
SDWORD bestMod = 0, newMod, failure = -1;
BASE_OBJECT *psTarget = NULL, *bestTarget = NULL, *tempTarget;
bool electronic = false;
STRUCTURE *targetStructure;
WEAPON_EFFECT weaponEffect;
TARGET_ORIGIN tmpOrigin = 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 = psDroid->asWeaps[weapon_slot].nStat + asWeaponStats;
bestTarget = aiSearchSensorTargets((BASE_OBJECT *)psDroid, weapon_slot, psWStats, &tmpOrigin);
bestMod = targetAttackWeight(bestTarget, (BASE_OBJECT *)psDroid, weapon_slot);
}
weaponEffect = (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.
int droidRange = std::min(aiDroidRange(psDroid, weapon_slot) + extraRange, objSensorRange(psDroid) + 6 * TILE_UNITS);
static GridList gridList; // static to avoid allocations.
gridList = gridStartIterate(psDroid->pos.x, psDroid->pos.y, droidRange);
for (GridIterator gi = gridList.begin(); gi != gridList.end(); ++gi)
{
BASE_OBJECT *friendlyObj = NULL;
BASE_OBJECT *targetInQuestion = *gi;
/* 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] == UBYTE_MAX)
{
if (friendlyObj->type == OBJ_DROID)
{
DROID *friendlyDroid = (DROID *)friendlyObj;
/* See if friendly droid has a target */
tempTarget = friendlyDroid->psActionTarget[0];
if (tempTarget && !tempTarget->died)
{
//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.type != DORDER_ATTACK)
{
targetInQuestion = tempTarget; //consider this target
}
}
}
}
else if (friendlyObj->type == OBJ_STRUCTURE)
{
tempTarget = ((STRUCTURE *)friendlyObj)->psTarget[0];
if (tempTarget && !tempTarget->died)
{
targetInQuestion = tempTarget;
}
}
}
}
if (targetInQuestion != NULL
&& targetInQuestion != 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] == UBYTE_MAX
&& !aiCheckAlliances(targetInQuestion->player, psDroid->player)
&& validTarget(psDroid, targetInQuestion, weapon_slot)
&& objPosDiffSq(psDroid, targetInQuestion) < droidRange * droidRange)
{
if (targetInQuestion->type == OBJ_DROID)
{
// in multiPlayer - don't attack Transporters with EW
if (bMultiPlayer)
{
// if not electronic then valid target
if (!electronic
|| (electronic
&& !isTransporter((DROID *)targetInQuestion)))
{
//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[0].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
&& psDroid->lastFrustratedTime > 0
&& gameTime - psDroid->lastFrustratedTime < FRUSTRATED_TIME
&& ((FEATURE *)targetInQuestion)->psStats->damageable
&& psDroid->player != scavengerPlayer()) // hack to avoid scavs blowing up their nice feature walls
{
psTarget = targetInQuestion;
objTrace(psDroid->id, "considering shooting at %s in frustration", objInfo(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, "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
}
}
*ppsObj = bestTarget;
return bestMod;
}
return failure;
}
void AtomGridCell::build_list()
{
// Build a list containing only vacuum cells
getlistcalled = true;
int sz = na*nb*nc;
bool* vac = new bool[sz];
int i;
for (i=0; i < sz; i++)
vac[i] = false;
int tot=0;
int grid_idx = 0;
for(i=mina; i <= maxa; i++) {
// std::cout << i << std::endl;
int j;
for(j=minb; j <= maxb; j++) {
// std::cout << j << "," << minc << "-" << maxc << ":";
int k;
for(k=minc; k <= maxc; grid_idx++, k++) {
if (!get(i,j,k)) {
// Optimization:
// If all neighbors are also vacuum, then don't add this one
// since its an interior cell
bool all_vac = true;
if (i > mina && i < maxa
&& j > minb && j < maxb
&& k > minc && k < maxc) {
int ii;
for(ii=-1; ii <= 1; ii++) {
int jj;
for(jj=-1; jj <= 1; jj++) {
int kk;
for(kk=-1; kk <= 1; kk++) {
if (get(i+ii,j+jj,k+kk)) {
// std::cout << "Not storing " << i << "," << j << "," << k
// << std::endl;
all_vac = false;
break;
}
}
if (!all_vac)
break;
}
if (!all_vac)
break;
}
} else {
all_vac = false;
}
if (!all_vac) {
// std::cout << "Storing " << i << "," << j << "," << k <<std::endl;
vac[grid_idx] = true;
tot++;
// std::cout << "1";
} // else std::cout << "2";
} // else std::cout << "0";
}
// std::cout << std::endl;
}
}
gridlist = new GridList(ag,tot);
grid_idx = 0;
int gi;
for(gi=mina; gi <= maxa; gi++) {
int gj;
for(gj=minb; gj <= maxb; gj++) {
int gk;
for(gk=minc; gk <= maxc; grid_idx++, gk++) {
if (vac[grid_idx]) {
// std::cout << "Adding " << i << "," << j << "," << k <<std::endl;
gridlist->add(gi,gj,gk);
}
}
}
}
// std::cout << "Gridlist storing " << tot << " of " << sz
// << " elements noneset=" << noneset << " count=" << count << std::endl;
delete [] vac;
}
int main(int argc, char *argv[])
{
char *f;
int dpr = 10;
GridNMC *gridbase;
GridList *list;
gridbase = new GridNMC();
list = new GridList(gridbase);
f = argv[1];
// First load the data
fprintf (stderr, "Archivo %s Datos %p %d\n", f, gridbase, gridbase->getN()); fflush(stderr);
list->setList(f);
if (list->size()<=0)
return 1;
fprintf (stderr, "Lista %d\n", list->size());
printf ("latitude = ");
for (int i=0; i < gridbase->getN(); i++) {
printf("%g", gridbase->la(i));
if (i < gridbase->getN()-1)
printf(", ");
else
printf(" ;\n");
if (i > 0 && i % dpr==0)
printf("\n");
}
printf ("longitude = ");
for (int i=0; i < gridbase->getN(); i++) {
printf("%g", gridbase->lo(i));
if (i < gridbase->getN()-1)
printf(", ");
else
printf(" ;\n");
if (i > 0 && i % dpr==0)
printf("\n");
}
for (int j=0; j < list->size(); j++)
{
GridData *d = list->getData(j);
fprintf(stderr, "Data %d %g %g %p\n", j, d->getMin(), d->getMax(), d->getData());
printf ("temperature =\n");
for (int i=0; i < gridbase->getN(); i++) {
printf("%g", d->getData(i));
if (i < gridbase->getN()-1)
printf(", ");
else
printf(" ;\n");
if (i > 0 && i % dpr==0)
printf("\n");
}
}
return 0;
}