/**
** Handle point to point missile.
**
** @param missile Missile pointer.
**
** @return true if goal is reached, false else.
*/
bool PointToPointMissile(Missile &missile)
{
if (MissileInitMove(missile) == true) {
return true;
}
Assert(missile.Type != NULL);
Assert(missile.TotalStep != 0);
const PixelPos diff = (missile.destination - missile.source);
missile.position = missile.source + diff * missile.CurrentStep / missile.TotalStep;
if (missile.Type->Smoke.Missile && (missile.CurrentStep || missile.State > 1)) {
const PixelPos position = missile.position + missile.Type->size / 2;
MakeMissile(*missile.Type->Smoke.Missile, position, position);
}
if (missile.Type->SmokeParticle && (missile.CurrentStep || missile.State > 1)) {
const PixelPos position = missile.position + missile.Type->size / 2;
missile.Type->SmokeParticle->pushPreamble();
missile.Type->SmokeParticle->pushInteger(position.x);
missile.Type->SmokeParticle->pushInteger(position.y);
missile.Type->SmokeParticle->run();
}
if (missile.Type->Pierce) {
MissileHandlePierce(missile, Map.MapPixelPosToTilePos(missile.position));
}
return false;
}
/**
** Calculate parabolic trajectories.
**
** @param missile Missile pointer.
**
** @return 1 if target is reached, 0 otherwise
**
** @todo Find good values for ZprojToX and Y
*/
static int ParabolicMissile(Missile *missile)
{
int orig_x; // position before moving.
int orig_y; // position before moving.
int xstep;
int ystep;
int k; // Coefficient of the parabol.
int zprojToX; // Projection of Z axis on axis X.
int zprojToY; // Projection of Z axis on axis Y.
int z; // should be missile->Z later.
int x;
int y;
k = -2048; //-1024; // Should be initialised by an other method (computed with distance...)
zprojToX = 4;
zprojToY = 1024;
if (MissileInitMove(missile) == 1) {
return 1;
}
Assert(missile->Type != NULL);
orig_x = missile->X;
orig_y = missile->Y;
xstep = missile->DX - missile->SourceX;
ystep = missile->DY - missile->SourceY;
Assert(missile->TotalStep != 0);
xstep = xstep * 1000 / missile->TotalStep;
ystep = ystep * 1000 / missile->TotalStep;
missile->X = missile->SourceX + xstep * missile->CurrentStep / 1000;
missile->Y = missile->SourceY + ystep * missile->CurrentStep / 1000;
Assert(k != 0);
z = missile->CurrentStep * (missile->TotalStep - missile->CurrentStep) / k;
// Until Z is used for drawing, modify X and Y.
missile->X += z * zprojToX / 64;
missile->Y += z * zprojToY / 64;
MissileNewHeadingFromXY(missile, missile->X - orig_x, missile->Y - orig_y);
if (missile->Type->SmokeMissile && missile->CurrentStep) {
x = missile->X + missile->Type->Width / 2;
y = missile->Y + missile->Type->Height / 2;
MakeMissile(missile->Type->SmokeMissile, x, y, x, y);
}
return 0;
}
/**
** Calculate parabolic trajectories.
**
** @param missile Missile pointer.
**
** @return 1 if target is reached, 0 otherwise
**
** @todo Find good values for ZprojToX and Y
*/
static int ParabolicMissile(Missile &missile)
{
int k; // Coefficient of the parabol.
int zprojToX; // Projection of Z axis on axis X.
int zprojToY; // Projection of Z axis on axis Y.
int z; // should be missile.Z later.
k = -2048; //-1024; // Should be initialised by an other method (computed with distance...)
zprojToX = 4;
zprojToY = 1024;
if (MissileInitMove(missile) == 1) {
return 1;
}
Assert(missile.Type != NULL);
const PixelPos orig_pos = missile.position;
Assert(missile.TotalStep != 0);
const PixelPos diff = (missile.destination - missile.source);
missile.position = missile.source + diff * missile.CurrentStep / missile.TotalStep;
Assert(k != 0);
z = missile.CurrentStep * (missile.TotalStep - missile.CurrentStep) / k;
// Until Z is used for drawing, modify X and Y.
missile.position.x += z * zprojToX / 64;
missile.position.y += z * zprojToY / 64;
missile.MissileNewHeadingFromXY(missile.position - orig_pos);
if (missile.Type->Smoke.Missile && missile.CurrentStep) {
const PixelPos position = missile.position + missile.Type->size / 2;
MakeMissile(*missile.Type->Smoke.Missile, position, position);
}
if (missile.Type->SmokeParticle && missile.CurrentStep) {
const PixelPos position = missile.position + missile.Type->size / 2;
missile.Type->SmokeParticle->pushPreamble();
missile.Type->SmokeParticle->pushInteger(position.x);
missile.Type->SmokeParticle->pushInteger(position.y);
missile.Type->SmokeParticle->run();
}
if (missile.Type->Pierce) {
MissileHandlePierce(missile, Map.MapPixelPosToTilePos(missile.position));
}
return 0;
}
/**
** Handle point to point missile.
**
** @param missile Missile pointer.
**
** @return 1 if goal is reached, 0 else.
*/
static int PointToPointMissile(Missile *missile)
{
int xstep;
int ystep;
int x;
int y;
if (MissileInitMove(missile) == 1) {
return 1;
}
Assert(missile->Type != NULL);
Assert(missile->TotalStep != 0);
xstep = (missile->DX - missile->SourceX) * 1024 / missile->TotalStep;
ystep = (missile->DY - missile->SourceY) * 1024 / missile->TotalStep;
missile->X = missile->SourceX + xstep * missile->CurrentStep / 1024;
missile->Y = missile->SourceY + ystep * missile->CurrentStep / 1024;
if (missile->Type->SmokeMissile && missile->CurrentStep) {
x = missile->X + missile->Type->Width / 2;
y = missile->Y + missile->Type->Height / 2;
MakeMissile(missile->Type->SmokeMissile, x, y, x, y);
}
return 0;
}
/**
** Handle point to point missile.
**
** @param missile Missile pointer.
**
** @return true if goal is reached, false else.
*/
bool PointToPointMissile(Missile &missile)
{
MissileInitMove(missile);
if (missile.TotalStep == 0) {
return true;
}
Assert(missile.Type != NULL);
Assert(missile.TotalStep != 0);
const PixelPos diff = (missile.destination - missile.source);
const PixelPrecise sign(diff.x >= 0 ? 1.0 : -1.0, diff.y >= 0 ? 1.0 : -1.0); // Remember sign to move into correct direction
const PixelPrecise oldPos((double)missile.position.x, (double)missile.position.y); // Remember old position
PixelPrecise pos(oldPos);
missile.position = missile.source + diff * missile.CurrentStep / missile.TotalStep;
for (; pos.x * sign.x <= missile.position.x * sign.x
&& pos.y * sign.y <= missile.position.y * sign.y;
pos.x += (double)diff.x * missile.Type->SmokePrecision / missile.TotalStep,
pos.y += (double)diff.y * missile.Type->SmokePrecision / missile.TotalStep) {
const PixelPos position((int)pos.x + missile.Type->size.x / 2,
(int)pos.y + missile.Type->size.y / 2);
if (missile.Type->Smoke.Missile && (missile.CurrentStep || missile.State > 1)) {
Missile *smoke = MakeMissile(*missile.Type->Smoke.Missile, position, position);
if (smoke && smoke->Type->NumDirections > 1) {
smoke->MissileNewHeadingFromXY(diff);
}
}
if (missile.Type->SmokeParticle && (missile.CurrentStep || missile.State > 1)) {
missile.Type->SmokeParticle->pushPreamble();
missile.Type->SmokeParticle->pushInteger(position.x);
missile.Type->SmokeParticle->pushInteger(position.y);
missile.Type->SmokeParticle->run();
}
if (missile.Type->Pierce) {
const PixelPos posInt((int)pos.x, (int)pos.y);
MissileHandlePierce(missile, Map.MapPixelPosToTilePos(posInt));
}
}
// Handle wall blocking and kill first enemy
for (pos = oldPos; pos.x * sign.x <= missile.position.x * sign.x
&& pos.y * sign.y <= missile.position.y * sign.y;
pos.x += (double)diff.x / missile.TotalStep,
pos.y += (double)diff.y / missile.TotalStep) {
const PixelPos position((int)pos.x + missile.Type->size.x / 2,
(int)pos.y + missile.Type->size.y / 2);
const Vec2i tilePos(Map.MapPixelPosToTilePos(position));
if (Map.Info.IsPointOnMap(tilePos) && MissileHandleBlocking(missile, position)) {
return true;
}
if (missile.Type->MissileStopFlags) {
if (!Map.Info.IsPointOnMap(tilePos)) { // gone outside
missile.TTL = 0;
return false;
}
const CMapField &mf = *Map.Field(tilePos);
if (missile.Type->MissileStopFlags & mf.Flags) { // incompatible terrain
missile.position = position;
missile.MissileHit();
missile.TTL = 0;
return false;
}
}
}
if (missile.CurrentStep == missile.TotalStep) {
missile.position = missile.destination;
return true;
}
return false;
}
/**
** Calculate parabolic trajectories.
**
** @param missile Missile pointer.
**
** @return true if target is reached, false otherwise
**
** @todo Find good values for ZprojToX and Y
*/
static bool ParabolicMissile(Missile &missile)
{
// Should be initialised by an other method (computed with distance...)
const double k = -missile.Type->ParabolCoefficient; // Coefficient of the parabol.
const double zprojToX = 4.0; // Projection of Z axis on axis X.
const double zprojToY = 1024.0; // Projection of Z axis on axis Y.
double z; // should be missile.Z later.
MissileInitMove(missile);
if (missile.TotalStep == 0) {
return true;
}
Assert(missile.Type != NULL);
const PixelPos orig_pos = missile.position;
Assert(missile.TotalStep != 0);
const PixelPos diff = (missile.destination - missile.source);
const PixelPrecise sign(diff.x >= 0 ? 1 : -1, diff.y >= 0 ? 1 : -1); // Remember sign to move into correct direction
PixelPrecise pos(missile.position.x, missile.position.y); // Remember old position
missile.position = missile.source + diff * missile.CurrentStep / missile.TotalStep;
Assert(k != 0);
z = (double)missile.CurrentStep * (missile.TotalStep - missile.CurrentStep) / k;
// Until Z is used for drawing, modify X and Y.
missile.position.x += (int)(z * zprojToX / 64.0);
missile.position.y += (int)(z * zprojToY / 64.0);
missile.MissileNewHeadingFromXY(missile.position - orig_pos);
for (; pos.x * sign.x <= missile.position.x * sign.x
&& pos.y * sign.y <= missile.position.y * sign.y;
pos.x += (double)diff.x * missile.Type->SmokePrecision / missile.TotalStep,
pos.y += (double)diff.y * missile.Type->SmokePrecision / missile.TotalStep) {
if (missile.Type->Smoke.Missile && missile.CurrentStep) {
const PixelPos position((int)pos.x + missile.Type->size.x / 2,
(int)pos.y + missile.Type->size.y / 2);
Missile *smoke = MakeMissile(*missile.Type->Smoke.Missile, position, position);
if (smoke && smoke->Type->NumDirections > 1) {
smoke->MissileNewHeadingFromXY(diff);
}
}
if (missile.Type->SmokeParticle && missile.CurrentStep) {
const PixelPos position((int)pos.x + missile.Type->size.x / 2,
(int)pos.y + missile.Type->size.y / 2);
missile.Type->SmokeParticle->pushPreamble();
missile.Type->SmokeParticle->pushInteger(position.x);
missile.Type->SmokeParticle->pushInteger(position.y);
missile.Type->SmokeParticle->run();
}
if (missile.Type->Pierce) {
const PixelPos position((int)pos.x, (int)pos.y);
MissileHandlePierce(missile, Map.MapPixelPosToTilePos(position));
}
}
if (missile.CurrentStep == missile.TotalStep) {
missile.position = missile.destination;
return true;
}
return false;
}