Luftschiff fliegt nicht

/*-- Luftschiff --*/

#strict

local turn_end_dir;

/* Steuerung */

private func DoDirection(int comdir)
{
  var cur_comdir = GetComDir();
  if(GetAction() S= "FloatIdle") cur_comdir = COMD_Stop;

  cur_comdir = ComDirTransform(cur_comdir, comdir);
  //while(cur_comdir == COMD_Stop)
  //  cur_comdir = ComDirTransform(cur_comdir, comdir);

  SetDirection(cur_comdir);
}

private func ClearDir(bool fX)
{
  if(fX && GetXDir())
  {
    if(GetXDir() > 0) SetXDir(GetXDir() - 1);
    else SetXDir(GetXDir() + 1);
  }
  if(!fX && GetYDir())
  {
    if(GetYDir() > 0) SetYDir(GetYDir() - 1);
    else SetYDir(GetYDir() + 1);
  }
}

private func SetDirection(int comdir)
{
  // Richtungsaenderung nach oben/unten geht auch mit "Turn", aber eine
  // ComDir-Aenderung, die wieder eine Turn-Action erfordern wuerde muss
  // warten, bis die jetzige Turn-Action fertig ist.
  if(GetAction() S= "Turn")
  {
    turn_end_dir = comdir;
    if(comdir == COMD_Stop || (ComDirLike(comdir, COMD_Right) && GetDir() == DIR_Left) || (ComDirLike(comdir, COMD_Left) && GetDir() == DIR_Right))
    {
      return(0);
    }
  }

  // ComDir uebernehmen
  SetComDir(comdir);

  // Angebrachte Action setzen
  if(GetAction() ne "Turn" && GetAction() ne "WaterLaunch")
  {
    if(comdir != COMD_Stop && GetAction() ne "FloatPropel")
      SetAction("FloatPropel");
    if(comdir == COMD_Stop && GetAction() ne "FloatIdle")
      SetAction("FloatIdle");
  }

  // Vorherige ClearDirs wegtun
  ClearScheduleCall(this(), "ClearDir");
  // Wenn Bewegung in nur eine Richtung, dann Bewegung in die andere
  // Richtung aufgeben (macht FLOAT-Prozedur nicht automagisch)
  if(comdir == COMD_Down || comdir == COMD_Up)
    ScheduleCall(this(), "ClearDir", 1, Abs(GetXDir()), true);
  if(comdir == COMD_Left || comdir == COMD_Right || comdir == COMD_Stop)
  {
    ScheduleCall(this(), "ClearDir", 1, Abs(GetYDir()), false);

    // Bei Bewegung nur in X-Richtung ein wenig schaukeln
    if(!GetEffect("IntWindYDir", this()))
      AddEffect("IntWindYDir", this(), 1, 10, this());
  }
  else
  {
    if(GetEffect("IntWindYDir", this()))
      RemoveEffect("IntWindYDir", this());
  }

  if(ComDirLike(comdir, COMD_Right) && GetDir() == DIR_Left)
  {
    SetDir(DIR_Right);
    SetAction("Turn");
  }

  if(ComDirLike(comdir, COMD_Left) && GetDir() == DIR_Right)
  {
    SetDir(DIR_Left);
    SetAction("Turn");
  }

  // Beim Landen auf COMD_Down lassen, sonst hopst das Luftschiff schnell
  // wieder in die Luft
  if(comdir == COMD_Stop && GBackSolid(0, GetObjHeight()/2+2))
    SetComDir(COMD_Down);
}

protected func ControlUpdate(object controller, int comdir, bool dig, bool throw)
{
  SetDirection(comdir);
}

protected func ControlUp(object controller)      // hoch
{
  [$TxtAscend$]
  ClearCommand();
  if (GetAction()S="DropOff") return(0);
  if (GetAction()S="WaterLand") SetAction("WaterLaunch");

  if(!GetPlrCoreJumpAndRunControl(controller->GetController()))
    DoDirection(COMD_Up);
}

protected func ControlDownSingle(object controller)  // runter
{
  [$TxtDescend$|Method=Classic]
  if (GetAction()S="DropOff") return(0);
  if(!GetPlrCoreJumpAndRunControl(controller->GetController()))
  {
    ClearCommand();
    DoDirection(COMD_Down);
  }
}

protected func ControlDown(object controller)
{
  [$TxtDescend$|Method=JumpAndRun]
  // Lediglich fuer das Kommandosymbol bei JnR-Steuerung
}

protected func ControlRight(object controller)      // rechts
{
  [$TxtTurnright$]
  ClearCommand();

  if(!GetPlrCoreJumpAndRunControl(controller->GetController()))
  {
    if (GetAction()S="DropOff") return(0);
    if (GetAction()S="Turn") return(0);
    SetAction("FloatPropel");
    DoDirection(COMD_Right);
  }
}

protected func ControlLeft(object controller)        // links
{
  [$TxtTurnleft$]
  ClearCommand();

  if(!GetPlrCoreJumpAndRunControl(controller->GetController()))
  {
    if (GetAction()S="DropOff") return(0);
    if (GetAction()S="Turn") return(0);
    SetAction("FloatPropel");
    DoDirection(COMD_Left);
  }
}

protected func ControlCommand(string szCommand,object pTarget,int iX,int iY)
{
  // Pilot läßt los
  if (szCommand S= "UnGrab")
    return(0,ClearCommand(),NoPilotCheck());
  // Bewegungskommando vom Piloten
  if (szCommand S= "MoveTo")
    return(SetCommand(this(),szCommand,pTarget,iX,iY));
  return(0);
}

private func ClearCommand() { SetCommand(this(),"None"); }

/* Initialisierung */

protected func Initialize()
{
  turn_end_dir = -1;
  FloatIdleDown();
}

/* Aktivität */

protected func FxIntWindXDirTimer()
{
  if(GetAction() ne "FloatIdle" && GetAction() ne "WaterLand") return(-1);
  if(GetContact(0, -1, 8)) return;
  SetXDir(BoundBy(GetWind()/4, Max(GetXDir() - 2, -10), Min(GetXDir() + 2, 10)));
}

protected func FxIntWindYDirTimer()
{
  if(GBackSolid(0, GetObjHeight()/2+2)) return(-1);
  SetYDir(BoundBy(GetYDir() + RandomX(-GetYDir()) - 1 + Random(3), Max(GetYDir() - 1, -3), Min(GetYDir() + 1, 3)));
}

private func FloatProcess()
{
  if(!GetEffect("IntWindXDir", this()))
    AddEffect("IntWindXDir", this(), 1, 5, this());

  if(!GetEffect("IntWindYDir", this()) && !GBackSolid(0, GetObjHeight()/2+2))
  {
    AddEffect("IntWindYDir", this(), 1, 10, this());
  }

//  if(GetComDir() == COMD_Stop && GBackSolid(0, GetObjHeight()/2+2))
//    SetComDir(COMD_Down);

  NoPilotCheck();
  CheckCommandAction();
  return(1);
}

private func FlightProcess()
{
  NoPilotCheck();
  CheckCommandAction();
  return(1);
}

private func CheckCommandAction()
{
  // Propeller an für Kommando
  if (GetCommand())
    if (GetAction()S="FloatIdle")
      SetAction("FloatPropel");
  // Wenden nach rechts
  if (GetAction() eq "FloatPropel")
    if (Inside(GetComDir(),COMD_UpRight,COMD_DownRight))
      if (GetDir()==DIR_Left)
        { SetAction("Turn"); SetDir(DIR_Right); return(true); }
  // Wenden nach links
  if (GetAction() eq "FloatPropel")
    if (Inside(GetComDir(),COMD_DownLeft,COMD_UpLeft))
      if (GetDir()==DIR_Right)
        { SetAction("Turn"); SetDir(DIR_Left); return(true); }
  // Anhalten wenn Ziel erreicht
  if(!GetCommand() && !GetComDir())
    SetDirection(COMD_Stop);
  return(0); 
} 

private func NoPilotCheck()
{
  if (!FindObject(0,0,0,0,0,0,"Push",this()))
    return(FloatIdleDown());
  return(0);
}

private func FloatIdleDown()
{
  if (GetAction()ne"FloatIdle")
    SetAction("FloatIdle");
  SetComDir(COMD_Down());
  ClearCommand();
  return(1);
}

/* Trefferkontrolle */

protected func RejectCollect(id idObject, object pObj)
{
  // Pfeile vertragen sich nicht mit einem Luftschiff
  if (DefinitionCall(idObject,"IsArrow") )
  // Nur, wenn der Pfeil sich auch bewegt
  if(GetXDir(pObj) || GetYDir(pObj))
  {
    // bei brennendem Pfeil anzünden
    if(OnFire(pObj)) Incinerate();
    // ansonsten abstürzen
    else SetAction("DropOff");
    // in jedem Fall im Pfeil Hit auslösen (Sprengpfeil explodiert zB)
    ProtectedCall(pObj, "Hit");
    return(1);
  }
  return(1);
}

/* Angriff durch Vögel */

public func Poke()
{
  Sound("Rip");
  SetAction("DropOff");
  return(1);
}
 
/* Forschung */

public func GetResearchBase() { return(BALN); }