src/auxlib/aux.cxx

/*      $Id: aux.cxx 328 2004-10-24 03:18:50Z dawalker $
  Copyright 2003-2004 Association of Computing Machinery

  This file is part of MechMania X.

    MechMania X is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of the
  License, or (at your option) any later version.
  
  MechMania X is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with MechMania X; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  USA
*/

#include <mmx.hh>
#include <sharedlib/util.hh>
#include <auxlib/game.hh>
#include <auxlib/action.hh>
#include <auxlib/sub.hh>
#include <auxlib/destroyer.hh>
#include <auxlib/carrier.hh>
#include <math.h>

using namespace std;
namespace mmx
{
  Ship *BetterGame::MakeNewShip(int id, Team &team, const ShipStats &stats)
  {
    Ship *ret = NULL, *tmp;

    tmp = Game::MakeNewShip(id, team, stats);
    switch (stats.type)
    {
    case SHIP_SUB:
      ret = new BetterSub(static_cast<Sub &>(*tmp));
      break;
    case SHIP_DESTROYER:
      ret = new BetterDestroyer(static_cast<Destroyer &>(*tmp));
      break;
    case SHIP_CARRIER:
      ret = new BetterCarrier(static_cast<Carrier &>(*tmp));
      break;
    }
    delete tmp;
    return ret;
  }

  Error BetterGame::EndTurn()
  {
    Error e(Game::EndTurn());
    Action *act;

    if (e != ENone)
      return e;
    if (events.empty())
      return e;
    for (act = events.top();
        !events.empty() && act->isCurrent(turn);
        act = events.top())
    {
      events.pop();
      if (act->ship.act != act)
      {
        delete act;
        continue;
      }
      if (act->revaluate(*this) == 1)
        events.push(act);
      else
      {
        act->ship.act = NULL;
        delete act;
      }
    }
    return e;
  }

  bool BetterGame::InDeathZone(const Point &pos, const Team &team) const
  {
    if(team.Id() == 1)
    {
      if(pos.x > (GetMap().Width() / 2.0) - GetRules().deathzonesize)
        return true;
    }
    else if (team.Id() == 0)
    {
      if(pos.x < ((-GetMap().Width() / 2.0) + GetRules().deathzonesize))
        return true;
    }
    return false;
  }

  bool BetterGame::InRepairZone(const Point &pos, const Team &team) const
  {
    if(team.Id() == 1)
    {
      if(pos.x > (GetMap().Width() / 2.0) - GetRules().repairzonesize)
        return true;
    }
    else if (team.Id() == 0)
    {
      if(pos.x < ((-GetMap().Width() / 2.0) + GetRules().repairzonesize))
        return true;
    }
    return false;
  }

  BetterShip::~BetterShip()
  {
    if (act)
      delete act;
  }

  Error BetterShip::SetRudder(double ang)
  {
    if (act)
      act = NULL;
    return dynamic_cast<Ship *>(this)->Ship::SetRudder(ang);
  }

  Error BetterShip::SetSpeed(double spd)
  {
    if (act && !dynamic_cast<AngleAction *>(act))
      act = NULL;
    return dynamic_cast<Ship *>(this)->Ship::SetSpeed(spd);
  }

  void BetterShip::SetAngle(double ang, double speed)
  {
    act = new AngleAction(*this, ang, speed);
    if (act->revaluate(MyGame()) != 1)
    {
      delete act;
      act = NULL;
    }
    else
      static_cast<BetterGame &>(MyGame()).events.push(act);
  }

  void BetterShip::MoveToDumb(const Point &pt, double speed)
  {
    act = new MoveAction(*this, pt, speed);
    if (act->revaluate(MyGame()) != 1)
    {
      delete act;
      act = NULL;
    }
    else
      static_cast<BetterGame &>(MyGame()).events.push(act);
  }

  void BetterShip::MoveTo(const Point &pt, double speed)
  {
    act = new PathfindAction(*this, pt, speed);
    if (act->revaluate(MyGame()) != 1)
    {
      delete act;
      act = NULL;
    }
    else
      static_cast<BetterGame &>(MyGame()).events.push(act);
  }

#define TWOPI ((double)2.0 * M_PI)
  AngleAction::AngleAction(BetterShip &shp, double ang, double turnspeed)
    : Action(shp), angle(ang), tspeed(turnspeed)
  {
    if (!turnspeed)
      tspeed = ship.MyGame().GetRules().maxrudderang;
  }

  int AngleAction::revaluate(Game &game)
  {
    Ship &shp(dynamic_cast<Ship &>(ship));
    double twist = angle - shp.Angle();

    twist -= TWOPI * floor((twist + M_PI) / TWOPI);
    if (twist > tspeed)
    {
      Error err(shp.Ship::SetRudder(tspeed));
      if (err != ENone)
        return -1;
      turn = game.Turn() + (int)(twist / tspeed);
      return 1;
    }
    if (twist < -tspeed)
    {
      Error err(shp.Ship::SetRudder(-tspeed));
      if (err != ENone)
        return -1;
      turn = game.Turn() + (int)(twist / -tspeed);
      return 1;
    }
    if (twist < .0000000001 && twist > -.0000000001)
    {
      if (shp.Rudder())
        if (shp.Ship::SetRudder(0) != ENone)
          return -1;
      return 0;
    }
    turn = game.Turn() + 1;
    return shp.Ship::SetRudder(twist) == ENone ? 1 : -1;
  }

  MoveAction::MoveAction(BetterShip &shp, const Point &pt, double speed)
    : Action(shp), dest(pt), ang(NULL), mspeed(speed)
  {
    if (!speed)
      mspeed = dynamic_cast<Ship &>(shp).Stats()->maxspeed;
  }

  int MoveAction::revaluate(Game &game)
  {
    Ship &shp(dynamic_cast<Ship &>(ship));
    double d = (shp.Pos() - dest).dist2();
    int a;

    if (d < .0000000000001)
    {
      if (shp.Speed())
        if (shp.Ship::SetSpeed(0.0) != ENone)
          return -1;
      return 0;
    }
    if (!ang)
      ang = new AngleAction(ship, MMX_GET_ANGLE(shp.Pos(), dest), 0.0);
    a = ang->revaluate(game);
    if (a == 1)
    {
      if (shp.Ship::SetSpeed(0.0) != ENone)
        return -1;
      turn = ang->turn;
      return 1;
    } 
    else if (a == -1)
      return -1;
    d = sqrt(d);
    if (d > mspeed)
    {
      turn = game.Turn() + (int)(d / mspeed);
      if (shp.Ship::SetSpeed(mspeed) != ENone)
        return -1;
      return 1;
    }
    turn = game.Turn() + 1;
    return shp.Ship::SetSpeed(d) == ENone ? 1 : -1;
  }

  MoveAction::~MoveAction()
  {
    if (ang)
      delete ang; 
  }

  PathfindAction::PathfindAction(BetterShip &shp, const Point &pt, double speed)
    : Action(shp), dest(pt), init(false), mve(NULL), mspeed(speed)
  {
    if (!speed)
      mspeed = dynamic_cast<Ship &>(shp).Stats()->maxspeed;
  }

  int PathfindAction::revaluate(Game &game)
  {
    if (!init)
    {
      if (dest.x > game.GetMap().Width() / 2.0 ||
          dest.x < -game.GetMap().Width() / 2.0 ||
          dest.y > game.GetMap().Height() / 2.0 ||
          dest.y < -game.GetMap().Height() / 2.0 /*||
          game.GetMap().Hit(dest)*/)
        return -1;
      init = true;
    }
    if (!mve)
    {
      Point nextp(nextStep(game, dest));
      mve = new MoveAction(ship, nextp, mspeed);
    }
    int a = mve->revaluate(game);
    if (a == 0)
    {
      if (mve)
        delete mve;
      Point nextp(nextStep(game, dest));
      mve = new MoveAction(ship, nextp, mspeed);
      a = mve->revaluate(game);
    }
    if (a == 1)
      turn = mve->turn;
    return a;
  }

  Point PathfindAction::nextStep(const Game &game, const Point &pt)
  {
    Ship &shp(dynamic_cast<Ship &>(ship));
    Point ret(game.GetMap().Hit(shp.Pos(), pt));
    Island *is;
    int min = 0, max = 0, a;

    if (ret == pt)
      return pt;
    is = game.GetMap().Hit(ret);
    if (!is)
    {
      dprintf(stderr, "Error: Intersection (%f,%f) of (%f,%f) and (%f,%f) not \"in\" an island!\n", MMXDLEVEL_ERROR, ret.x, ret.y, shp.Pos().x, shp.Pos().y, pt.x, pt.y);
      for (a = 0; (unsigned)a < game.GetMap().Islands().size(); a++)
        dprintf(stderr, "In() of island %d is %d\n", MMXDLEVEL_INFO, a, game.GetMap().Islands()[a].In(ret));
      return Point(0,0);
    }
    Point minp(is->Points()[min]), maxp(is->Points()[max]);
    Point off(shp.Pos());
    off -= is->Centroid();
    off.x *= .00001;
    off.y *= .00001;
    minp -= shp.Pos();
    maxp -= shp.Pos();
    for (a = 0; (unsigned)a < is->Points().size(); a++)
    {
      Point dp(is->Points()[a]);
      dp -= shp.Pos();
      dp -= off;
      if (maxp.x * dp.y - dp.x * maxp.y > 0)
      {
        maxp = dp;
        max = a;
      }
      else if (minp.x * dp.y - dp.x * minp.y < 0)
      {
        minp = dp;
        min = a;
      }
    }
    if (sqrt(minp.dist2()) + sqrt((pt - is->Points()[min]).dist2()) < sqrt(maxp.dist2()) + sqrt((pt - is->Points()[max]).dist2()))
      ret = is->Points()[min];
    else
      ret = is->Points()[max];
    ret.x += (ret.x - is->Centroid().x) * .000000001;
    ret.y += (ret.y - is->Centroid().y) * .000000001;
    return nextStep(game, ret);
  }

  PathfindAction::~PathfindAction()
  {
    if (mve)
      delete mve; 
  }
};

---