Mehrere Probleme mit neuem Luftschiff

[Action]
Name=FloatIdle
Procedure=FLOAT
Directions=2
FlipDir=1
Delay=50
Facet=0,0,100,86
FacetTopFace=1
NextAction=FloatIdle
StartCall=FloatProcess
InLiquidAction=WaterLand

[Action]
Name=FloatPropel
Procedure=FLOAT
Directions=2
FlipDir=1
Length=11
Delay=1
Facet=0,0,100,86
FacetTopFace=1
NextAction=FloatPropel
StartCall=FlightProcess
Sound=Propel
InLiquidAction=WaterLand

[Action]
Name=Turn
Procedure=FLOAT
Directions=2
FlipDir=1
Length=24
Delay=2
Facet=0,86,100,86
FacetTopFace=1
NextAction=FloatPropel
StartCall=TurnStart
EndCall=TurnEnd
Sound=Propel

[Action]
Name=DropOff
Procedure=NONE
Directions=2
FlipDir=1
Delay=60
Facet=0,0,100,86
FacetTopFace=1
NextAction=FloatIdle
Sound=Fusing

[Action]
Name=WaterLand
Procedure=NONE
Directions=2
FlipDir=1
Facet=0,0,100,86
FacetTopFace=1
NextAction=WaterLand

[Action]
Name=WaterLaunch
Procedure=FLOAT
Directions=2
FlipDir=1
Delay=50
Facet=0,0,100,86
FacetTopFace=1
NextAction=FloatIdle
StartCall=FloatProcess
 
[Action]
Name=OpenDoor
Length=5
Delay=1
Facet=1100,0,14,21
FacetBase=1
NextAction=DoorOpen
StartCall=SoundOpenDoor

[Action]
Name=DoorOpen
Delay=5
Facet=1160,0,14,21
FacetBase=1
NextAction=CloseDoor
StartCall=OpenEntrance
EndCall=CloseEntrance

[Action]
Name=CloseDoor
Length=5
Delay=1
Facet=1100,0,14,21
FacetBase=1
NextAction=Idle
EndCall=AfterDoorClose
StartCall=SoundCloseDoor
Reverse=1

/*-- Bombus --*/

#strict
#include DOOR

local fSignalState;   // 1=Load, 0=Unload

func Initialize(){
   SetEntrance(1); //Eingang aktivieren
   turn_end_dir = -1;
   FloatIdleDown();
}

   //Vertexes mitdrehen, WO SOLL DAS EINGEFÜGT WERDEN
   /*var rotVert;
   if(GetDir()==0)rotVert=-1;  //Nach Links gerichtet
   else rotVert=1;                  //Nach Rechts gerichtet

   SetVertex(int Index,0,GetVertex(int Index,0)*rotVert);*/

/* Türsteuerung */

protected func SoundOpenDoor()  { Sound("OpenDoor"); }
protected func SoundCloseDoor() { Sound("CloseDoor"); }

protected func AfterDoorClose()
{
   //if(fSignalState) SetAction("SignalArrive",fSignalState);
   //fSignalState=0;
}

local turn_end_dir;

/* Drehung */

private func TurnStart()
{
   // Alle Clonks die das Luftschiff anfassen registrieren
   var controllers = FindObjects(Find_Action("Push"), Find_ActionTarget(this()));
   AddEffect("IntTurn", this(), 1, 1, this(), 0, controllers);
}

protected func FxIntTurnStart(object target, int number, int temp, array controllers)
{
   if(temp) return(0);

   // Alle luftschiffanfassenden Clonks
   EffectVar(0, target, number) = controllers;
   // Deren initiale Position auf dem Luftschiff...
   EffectVar(1, target, number) = CreateArray(GetLength(controllers));
   // ... die hier ermittelt wird
   for(var i = 0; i < GetLength(controllers); ++ i)
      EffectVar(1, target, number)[i] = controllers[i]->GetX() - GetX();
}

protected func FxIntTurnTimer(object target, int number, int time)
{
   // Laenge der Turn-Action bestimmen
   var delay = GetActMapVal("Delay", "Turn");
   var phases = GetActMapVal("Length", "Turn");
   // Schon vorbei
   if(time == delay * phases) return(-1);
   // Eine Sinus-Kurve von -90 bis +90 Grad hernehmen um die neue Position
   // der Clonks auf dem Luftschiff zu bestimmen.
   var sin_phase = (time * 180 / (phases * delay)) - 90;
   var pos_phase = Sin(sin_phase, 50) + 50;
   // Clonkpositionen anpassen
   var controller_count = GetLength(EffectVar(0, target, number));
   for(var i = 0; i < controller_count; ++ i)
   {
      var controller = EffectVar(0, target, number)[i];
      var pos = EffectVar(1, target, number)[i];

      // Koennte sein, dass ein Controller verloren geht
      if(!controller) continue;
      // Koennte auch sein, dass er kein Controller mehr ist
      if(controller->GetAction() ne "Push" || controller->GetActionTarget() != this())
      {
         // Dann nichts mehr mit ihm anstellen, selbst wenn er das Luftschiff
         // wieder anfaesst - er koennte es an einer anderen Position tun und
         // dann beamen wir ihn komisch auf dem Luftschiff rum. Lieber nicht.
         EffectVar(0, target, number)[i] = 0;
         continue;
      }

      // Dir anpassen wenn Haelfte der Turn-Action vorbei
      if(time == delay * phases / 2)
         controller->SetDir(GetDir());

      // Neue Position ermitteln (Sinusfoermig um den Luftschiff-Mittelpunkt)
      var pos_t = -pos * 2;
      controller->SetPosition(GetX() + pos - (pos*2 * pos_phase / 100), controller->GetY());
   }
}

protected func FxIntTurnStop(object target, int number, bool temp)
{
   if(temp) return(0);
   var length = GetLength(EffectVar(0, target, number));

   // Nochmal alle Controller durchgehen
   for(var i = 0; i < length; ++ i)
   {
      var object = EffectVar(0, target, number)[i];
      var pos = EffectVar(1, target, number)[i];

      // Und an fertige Position tun, zur Sicherheit, wenn es noch Controller sind
      if(!object) continue;
      if(object->GetAction() S= "Push" && object->GetActionTarget() == this())
         object->SetPosition(GetX() - pos, object->GetY());
   }
}

private func TurnEnd()
{
   if(turn_end_dir != -1)
   {
      SetDirection(turn_end_dir);
      turn_end_dir = -1;
   }
}

/* 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 automatisch)
   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);
}

//Wird ausgeführt wenn angefasst und bewegt wird
/*protected func ControlUpdate(object controller, int comdir, bool dig, bool throw)
{
   SetDirection(comdir);
}*/

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

//Muss raus damit man überhaupt erstmal einsteigen kann.
//Hat sich mit der Funktion oben 'gebissen'
/* 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);
}

//wird aufgerufen wenn das Luftschiff nicht benutzt wird um es auf dem Boden zu halten
private func FloatIdleDown()
{
   if (GetAction()ne"FloatIdle")
      SetAction("FloatIdle");
   SetComDir(COMD_Down());
   ClearCommand();
   return(1);
}

/* Signalsteuerung */

public func SignalCall(object pSignal,bool fLoad)
{
  // Bei fLoad = 1 einladen, Status sichern
  if(fSignalState = fLoad) return(SignalLoad());
  // sonst ausladen
  else return(SignalUnload());
}

// Einladen
private func SignalLoad()
{
  var pObj;
  // Gegenstände, Fahrzeuge suchen...
  while(pObj = FindObject(0,-11,-6,20,20,OCF_Collectible()|OCF_Grab(),0,0,NoContainer(),pObj))
    // ...Zugmaschine und Waggon nicht...
    if(GetID(pObj)!=STMG && GetID(pObj)!=WAGN)
      // ...einladen
      SetCommand(pObj,"Enter",this());
  return(1);
}

// Ausladen
private func SignalUnload()
{
  // Nur bei Inhalt
  if(!ContentsCount()) return();
  // Alles raus
  for(var pContents,i=0; pContents = Contents(i); ++i)
    SetCommand(pContents,"Exit");
  return(1);
}

public func SignalDepart(object pSignal)
{
  // Beim Ausladen nix
  if(!fSignalState) return(1);
  // Einladen stoppen
  var pObj;
  while(pObj = FindObject(0,-20,-20,40,40,OCF_Collectible()|OCF_Grab()|OCF_CrewMember(),0,0,NoContainer(),pObj))
    if(GetCommand(pObj)S="Enter")
      SetCommand(pObj, "None");
  fSignalState = 0;
  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(BLMP); }