entladeskript

// Script für Getreidesilo / Grain Silo von Alcaron
// Copyright Uwe Nagel (aka OpAmp), Mail: opamp@gmx.net
// Juni 2012, Version 1.0 (Beta)
//
// Danke auch an Mick. :)
// -
//
// Ich möchte mich bei allen Scriptern bedanken, welche ihre Scripte nicht verschlüsselt haben, es ist sehr lehrreich, Danke!
// Dieses Script wurde ohne Kommentare veröffentlicht, da es sonst min. 50% größer wäre.
// Wenn jemand das Script mit den Kommentaren haben möchte, dann kann er sich gerne an mich wenden


include "BaseIndustry.gs"
include "world.gs"
// ************************************************************************************
include "vehicle.gs"
// ************************************************************************************


class grainbw isclass BaseIndustry
{
// ###################################################################################################
// ###################################### Varialben deklarieren ######################################
// ###################################################################################################


// ########## Konstanten vor besetzen


// ########## Globale Variable
// Hier werden die Variablen für die Queues definiert
// Für jede Queue, die du in deiner Industrie benutzt, mußt du hier eine Variable deklarieren
ProductQueue grain1queue;// Variable für die Produkt-Queue Grain1
ProductQueue grain2queue;// Variable für die Produkt-Queue Grain2


// In der 'string-table' werden die Ziele, bzw. Zielnamen abgelegt
// Man kann es auch hard im Script kodieren, würde ich nicht machen. ;-)
StringTable myStringTable = GetAsset().GetStringTable();// Zeiger auf die "String-Table" holen


// die beiden folgenden Variablen werden für die interne Steuerung gebraucht.
bool scriptletEnabled = true;// Merken, ob Scriptsteuerung laufen sollen
bool mflag = false;// Läuft die Loop schon?


// Diese Variable wird für den Frachtbrief gebraucht, denn Trainz von Zeit zu Zeit erstellt.
int grain1WBRemain = 0;// Variable für den Frachtbrief


// ########## Funktionen deklarieren
thread void GueterMain(void);


// ####################################################################################################
// ########################### ABLADEN und BELADEN ##################################################
// ####################################################################################################


// Die folgende Methode ist die Haupt-Untersuchung, ob Das Fahrzeug, welches gerade im Trigger ist, beladen oder entladen werden soll.
// Wenn diese Methode ein 'true' zurück gibt, werden die weiteren methoden auf gerufen
// Wird hier ein 'false' zurück gegeben, macht Trainz nichts mehr mit dem Wagen.
// ########## Untersuchen, ob sich das derzeitige Fahrzeug entladen, bzw. beladen läßt, während es steht
bool TriggerSupportsStoppedLoad(Vehicle actvehicle, string triggerName)
{
// Interface.Print("Einsprung - " + triggerName);
// Als erstes wird abgefragt, ob das Fahrzeug im Trigge, ein Wagen ist und keine Lok
if (actvehicle.GetEngineType() == actvehicle.ENGINE_NONE)// Haben wir einen Wagen vor uns?
{
// Hat der Zug einen 'Ablade' Befehl?
// Hier wird der Fall grain1 abladen behandelt
if (itc.IsTrainCommand(actvehicle.GetMyTrain(), Industry.UNLOAD_COMMAND))// Hat das Fahzeug einen Unload-Befehl?
{
// Interface.Print("Abladen");
// Hat der Wagen auch grain1 geladen?
// Denn wir können/dürfen hier nur grain1 abladen.
if (actvehicle.CanUnloadProductToQueue(grain1queue))// Kann das Produkt des Wagens hier auch entladen werden?
{
// Interface.Print("grain1 kann abgeladen werden");
// Ist der Wagen auch im grain1-Trigger?
// Der Name "trig_grain1" muß in der Config vorkommen
if (triggerName == "trig_grain1")// Sind wir im Trigger für grain1 abladen?
{
// Interface.Print("Trigger-grain1");
return true;// dann abladen lassen
}
}
}
// Hat der Zug eine Lade-Befehl?
// Hier wird der Fall grain laden behandelt
else if (itc.IsTrainCommand(actvehicle.GetMyTrain(), Industry.UNLOAD_COMMAND))// Hat das Fahzeug einen Unload-Befehl?
{
// Interface.Print("Abladen");
// Hat der Wagen auch grain2 geladen?
// Denn wir können/dürfen hier nur grain1 abladen.
if (actvehicle.CanUnloadProductToQueue(grain2queue))// Kann das Produkt des Wagens hier auch entladen werden?
{
// Interface.Print("grain2 kann abgeladen werden");
// Ist der Wagen auch im grain2-Trigger?
// Der Name "trig_grain2" muß in der Config vorkommen
if (triggerName == "trig_grain2")// Sind wir im Trigger für grain1 abladen?
{
// Interface.Print("Trigger-grain2");
return true;// dann abladen lassen
}
}
}
}
return false;// Hier darf nicht entladen werden
}


// ########## Fahrzeug evtl. entladen/beladen, während es steht
void PerformStoppedLoad(Vehicle actvehicle, string triggerName)
{
if (triggerName == "trig_grain1")// Soll grain1 abgeladen werden
{
int grain1Available = grain1queue.GetQueueSpace();// Platz in der grain1queue holen
LoadingReport report = CreateUnloadingReport(grain1queue, grain1Available);// LoadingReport für grain1queue erstellen
// ************************************************************************************
// ************************************************************************************
// ************************************************************************************
intdirection;
direction = actvehicle.GetRelationToTrack(me, "entladegleis1");
if (direction == Vehicle.DIRECTION_FORWARD)
report.sideFlags = LoadingReport.RIGHT_SIDE;
else if (direction == Vehicle.DIRECTION_BACKWARD)
report.sideFlags = LoadingReport.LEFT_SIDE;
// ************************************************************************************
// ************************************************************************************
// ************************************************************************************
// Wenn der nachfolgende Befehl ausgeführt wird, so wird intern auch erst 'BeginUnload' aufgerufen,
// dann wird das Produkt vom Wagen in die Industriequeue überführt
// danach wird dann 'EndUnload' auf gerufen.
// Und dann geht es nach diesem Befehl weiter
actvehicle.UnloadProduct(report);// Fahrzeug entladen
if (grain1WBRemain > 0)// Gibt es einen Frachtbrief mit einer Mengenangabe
{
grain1WBRemain = grain1WBRemain - report.amount;// Dann auch davon abziehen, damit die Menge erfüllt werden kann
}
}


if (triggerName == "trig_grain2")// Soll grain2 abgeladen werden
{
int grain1Available = grain2queue.GetQueueSpace();// Platz in der grain2queue holen
LoadingReport report = CreateUnloadingReport(grain2queue, grain2Available);// LoadingReport für grain1queue erstellen
// ************************************************************************************
// ************************************************************************************
// ************************************************************************************
intdirection;
direction = actvehicle.GetRelationToTrack(me, "entladegleis2");
if (direction == Vehicle.DIRECTION_FORWARD)
report.sideFlags = LoadingReport.RIGHT_SIDE;
else if (direction == Vehicle.DIRECTION_BACKWARD)
report.sideFlags = LoadingReport.LEFT_SIDE;
// ************************************************************************************
// ************************************************************************************
// ************************************************************************************
// Wenn der nachfolgende Befehl ausgeführt wird, so wird intern auch erst 'BeginUnload' aufgerufen,
// dann wird das Produkt vom Wagen in die Industriequeue überführt
// danach wird dann 'EndUnload' auf gerufen.
// Und dann geht es nach diesem Befehl weiter
actvehicle.UnloadProduct(report);// Fahrzeug entladen
if (grain1WBRemain > 0)// Gibt es einen Frachtbrief mit einer Mengenangabe
{
grain2WBRemain = grain2WBRemain - report.amount;// Dann auch davon abziehen, damit die Menge erfüllt werden kann
}
}




// ########## Das Abladen beginnt
float BeginUnload(LoadingReport report)
{
// Wenn du in deiner Industrie keine Aktionen machen möchtest, die VOR dem übertragen der Produkte stattfindest,
// kannst du diese Methode auch weg lassen
// Der Wert hinter 'return' setzt eine Wartezeit fest, darf auch NULL sein
return 1.0;// Nach 1 Sekunde weiter machen
}


// ########## Das Abladen ist beendet
float EndUnload(LoadingReport report)
{
// Wenn du in deiner Industrie keine Aktionen machen möchtest, die NACH dem übertragen der Produkte stattfindest,
// kannst du diese Methode auch weg lassen
// Der Wert hinter 'return' setzt eine Wartezeit fest, darf auch NULL sein
return 1.0;// Nach 1 Sekunde weiter machen
}


// ########## Das Laden beginnt
float BeginLoad(LoadingReport report)
{
// Wenn du in deiner Industrie keine Aktionen machen möchtest, die VOR dem übertragen der Produkte stattfindest,
// kannst du diese Methode auch weg lassen
// Der Wert hinter 'return' setzt eine Wartezeit fest, darf auch NULL sein
return 1.0;// Nach 1 Sekunde weiter machen
}


// ########## Das Laden ist beendet
float EndLoad(LoadingReport report)
{
// Wenn du in deiner Industrie keine Aktionen machen möchtest, die NACH dem übertragen der Produkte stattfindest,
// kannst du diese Methode auch weg lassen
// Der Wert hinter 'return' setzt eine Wartezeit fest, darf auch NULL sein
return 1.0;// Nach 1,0 Sekunden weiter machen
}


// ########## Bedingungen abfragen und evtl. einen Frachtbrief generieren für die grain1
public Requirement[] GetRequirements(void)
{
Requirement[] ret = new Requirement[0];
// ACHTUNG, hier mußt du die Zahlen deiner Queue-Größe anpassen
// Die Prozentzahlen in den Kommentaren ist nur als ungefähre Größe zu betrachten. Diese Prozentzahlen benutzt Auran auch in ihren Industrien
// Du kannst es auch anders machen.
if (grain1queue.GetQueueCount() < 258000 or grain1WBRemain > 0)// Ist weniger als 25% grain1 und die Frachtmenge noch nicht auf gefüllt?
{
ResourceRequirement req = new ResourceRequirement();// Neues Feld anlegen
req.resource = grain1queue.GetProductFilter().GetProducts()[0];// Das Produkt aus der grain1-Queue holen
req.amount = 891936;// Wir fordern die 50% der Queue-Menge als grain1 an
if (grain1queue.GetQueueCount() < 258000 and grain1WBRemain == 0)// Weniger als 25% da und auch keine Reserve?
{
grain1WBRemain = 516000;// Menge im Frachtbrief 50% der grain1queue
}
req.dst = me;// An welche Industrie soll geliefert werden
req.dstQueue = grain1queue;// Welche Queue soll auf gefüllt werden
ret[ret.size()] = req;// Array kopieren
}
return ret;// Werte zurück geben
}


// ########## Bedingungen abfragen und evtl. einen Frachtbrief generieren für die grain2
public Requirement[] GetRequirements(void)
{
Requirement[] ret = new Requirement[0];
// ACHTUNG, hier mußt du die Zahlen deiner Queue-Größe anpassen
// Die Prozentzahlen in den Kommentaren ist nur als ungefähre Größe zu betrachten. Diese Prozentzahlen benutzt Auran auch in ihren Industrien
// Du kannst es auch anders machen.
if (grain2queue.GetQueueCount() < 258000 or grain2WBRemain > 0)// Ist weniger als 25% grain1 und die Frachtmenge noch nicht auf gefüllt?
{
ResourceRequirement req = new ResourceRequirement();// Neues Feld anlegen
req.resource = grain2queue.GetProductFilter().GetProducts()[0];// Das Produkt aus der grain2-Queue holen
req.amount = 891936;// Wir fordern die 50% der Queue-Menge als grain2 an
if (grain2queue.GetQueueCount() < 258000 and grain2WBRemain == 0)// Weniger als 25% da und auch keine Reserve?
{
grain2WBRemain = 516000;// Menge im Frachtbrief 50% der grain2queue
}
req.dst = me;// An welche Industrie soll geliefert werden
req.dstQueue = grain2queue;// Welche Queue soll auf gefüllt werden
ret[ret.size()] = req;// Array kopieren
}
return ret;// Werte zurück geben
}
// ####################################################################################################
// ####################################### Allgemeiner Teil ###########################################
// ####################################################################################################


// ########## Hauptschleife
thread void GueterMain(void)
{
// Hier wird noch einmal die Semaphore abgefragt, da es unter ungünstigen Umständen vorkommen kann, daß Init zweimal aufgerufen wird
// und dazwischen eine gewisse Zeit vergeht und dann der 'thread' zwei mal läuft
if (mflag)// Läuft der Thread schon einmal?
{
return;// Dann raus hier
}
mflag = true;// Der Theard läuft jetzt
Message msg;
// Eine Warteschleife, die nur aktiv wird, wenn irgend eine Message herrein kommt.
// Diese werden in dieser Schleife dann ab gearbeitet
// Ganz wichtig ist hier der Befehl 'continue'. Fehlt dieser am Ende eines Blockes, wird die Schleife beendet
// und ab dem Moment werden keine Messages mehr verarbeitet
// Man was habe ich schon gesucht und nur diesen Befehl vergessen. :-(
wait()// Auf Messages warten
{
// Durch die beiden Folgenden messages legt Trainz fest, ob sich das Objekt im aktivem Modus (Driver)
// oder in Ediroe befindet, dann werden die Prozesse ab geschaltet
// Scriptsteuereung enabled
on "Scriptlet-Enabled", "1", msg:
{
if (!scriptletEnabled)// Haben wir es uns richtig gemerkt?
{
scriptletEnabled = true;// Zustandt merken
SetProcessEnabled("rauch_config", true);// Prozess starten "rauch"
}
continue;// weiter machen
}
// Scriptsteuerung disebled
on "Scriptlet-Enabled", "0", msg:
{
if (scriptletEnabled)// Haben wir es uns richtig gemerkt?
{
scriptletEnabled = false;// Zustandt merken
SetProcessEnabled("rauch_config", false);// Prozess beende "rauch"
}
continue;// weiter machen
}
// Prozess wird gestartet
on "Process-Start", "rauch_config":
{
// Hier kannst du Aktionen unter bringen, die gestartet werden sollen, wenn der Prozess beginnt zu arbeiten
// Bei dir wäre es angebracht, rauch aufsteigen zu lassen
continue;// weiter machen
}
// Prozess wird beendet
on "Process-Stop", "rauch_config":
{
// Hier kannst du Aktionen unter bringen, die beendet werden sollen, bzw. müssen, wenn der Prozess nicht m,ehr läuft
// Bei dir wäre es angebracht, rauch nicht mehr aufsteigen zu lassen
continue;// weiter machen
}
// Signalsound wieder entsperren für Gleis 0
}
}


// ########## Beschreibung zum Driver-Menue hinzu fügen
public void AppendDriverDestinations(string[] destNames, string[] destTracks)
{
// grain1 abladen
// In der 'string-table' in der Config sollte hinter "grain1abladen" der Zielname deiner Industrie stehen.
// Kannst es auch hard kodieren, dann sieht es so aus:
//destNames[destNames.size()] = "Mein Ziel";
destNames[destNames.size()] = myStringTable.GetString("grain1abladen");// Ziel-Name aus "String-Table" eintragen
// Hier muß der Name des Tracks stehen, auf dem sich die Entladestelle befindet
destTracks[destTracks.size()] = "entladegleis1";// und zugehörigen Track-Namen eintragen


// grain2 abladen
// In der 'string-table' in der Config sollte hinter "grain2abladen" der Zielname deiner Industrie stehen.
// Kannst es auch hard kodieren, dann sieht es so aus:
//destNames[destNames.size()] = "Mein Ziel";
destNames[destNames.size()] = myStringTable.GetString("grain2abladen");// Ziel-Name aus "String-Table" eintragen
// Hier muß der Name des Tracks stehen, auf dem sich die Entladestelle befindet
destTracks[destTracks.size()] = "entladegleis2";// und zugehörigen Track-Namen eintragen


// grain laden
// Siehe oben
//destNames[destNames.size()] = myStringTable.GetString("grainladen");// Ziel-Name aus "String-Table" eintragen
// Nun wieder der Track, auf dem sich die Verladesstelle befindet.
// Da bei dir beide Ladestellen sich auf dem gleichem Gleis befinden, muß bei dir hier der gleiche Trackname wie oben stehen
// Habe aber zur Demonstartion es erst einmal anders geschrieben
//destTracks[destTracks.size()] = "ladegleis";// und zugehörigen Track-Namen eintragen
}


// ####################################################################################################
// ############################################### INIT ###############################################
// ####################################################################################################
public void Init(void)
{
inherited();// Init
// Globale interne Trainz-Variablen, werden hier gesetzt, siehe Kommentar
useGenericViewDetails = true;// Benutze den Standart-Auran Dialog
usePipeAnimation = true;// Wir haben mehr Zeit zum Laden


// Hier werden den Variablen der Queues reale Queues aus deiner Config zugewiesen
// Dabei muß der String, hier "grain1" und "grain2", genaus so geschrieben werden, wie deine Queues in der Config heißen
grain1queue = GetQueue("grain1queue_config");// Zeiger auf die Produkt-Queue grain1
grain2queue = GetQueue("grain2queue_config");// Zeiger auf die Produkt-Queue grain2


// Hier wird der Prozess über das Script definiert und gleichzeitig die Produkte in den Dialog überführt
// Dabei sind "grain1_config" und "grain2_config" die Produkte, welche du in der Queue benutzt, müssen mit diesen Namen in der 'kuid-table' stehen und auf die entsprechenden KUIDs verweisen
// "grain1queue_config" und "grain2queue_config" sind die zugehörigen Queues, welche die Produkte aufnehmen und auch so in der Config drin stehen
// "rauch_config" ist der Name des Prozesses aus deiner Config
// Der letzte Parameter legt fest, ob es eine INPUT oder OUTPUT für den Prozess ist
AddAssetToIndustryProductInfo("grain1_config", "grain1queue_config", "rauch_config", true);// Process und Queue einbinden (Input, grain1)
AddAssetToIndustryProductInfo("grain2_config", "grain2queue_config", "rauch_config", true);// Process und Queue einbinden (Input, grain2)
//AddAssetToIndustryProductInfo("grain_config", "grainqueue_config", "rauch_config", false);// Process und Queue einbinden (Output, Grain )


// Ab hier wird die Hauptroutine aufgerufen
// Durch die Semaphore wird verhindert, das der 'thread' zweimal gestartet werden kann.
// Passiert unter bestimmten Umständen manches mal, nicht schlimm, aber unschön. (Bug in Trainz)
if (!mflag)// Läuft der Message Theard noch nicht?
{


GueterMain();// dann Thread aufrufen, welcher sich um die Messages kümmert
}
}
};

kuid                                    <kuid2:302662:11016:1>
username                                "Silo (Annahme)"
author                                  "Alcaron"
category-region                         "DE"
category-era                            "2000s"
trainz-build                            3.3
height-range                            -50,50
kind                                    "industry"
dighole                                 2,3
script                                  "grainbw"
class                                   "grainbw"
category-class                          "ZX"


obsolete-table
{
}


mesh-table
{
  default
  {
    mesh                                "silo.im"
    auto-create                         1
  }

  skala
  {
    mesh                                "skala/skala.im"
    anim                                "skala/skala.kin"
    auto-create                         1
    animation-loop-speed                0
  }
}


attached-track
{
  entladegleis1
  {
    track                               <kuid:523:1216>
    useadjoiningtracktype               0

    vertices
    {
      0                                 "a.track0a"
      1                                 "a.track0b"
      2                                 "a.track0c"
      3                                 "a.track0d"
      4                                 "a.track0e"
      5                                 "a.track0f"
      6                                 "a.track0g"
      7                                 "a.track0h"
      8                                 "a.track0i"
    }
  }

  entladegleis2
  {
    track                               <kuid:523:1216>
    useadjoiningtracktype               0

    vertices
    {
      0                                 "a.track1a"
      1                                 "a.track1b"
      2                                 "a.track1c"
      3                                 "a.track1d"
      4                                 "a.track1e"
      5                                 "a.track1f"
      6                                 "a.track1g"
      7                                 "a.track1h"
      8                                 "a.track1i"
    }
  }
}


string-table
{
  grain1abladen                         "Track 1 - Grain drop off"
  grain2abladen                         "Track 2 - Grain drop off"
}


string-table-de
{
  grain1abladen                         "Gleis 1 - Getreide abladen"
  grain2abladen                         "Gleis 2 - Getreide abladen"
}


attached-trigger
{
  trig_grain1
  {
    att                                 "a.trig0"
    radius                              1
  }

  trig_grain2
  {
    att                                 "a.trig1"
    radius                              1
  }
}


smoke0
{
  attachment                            "a.smoke0"
  mode                                  "time"
  color                                 25,25,25,220
  accel                                 0.5,0.3,0
  rate                                  5
  velocity                              2
  lifetime                              5
  minsize                               1
  maxsize                               5
  enabled                               0
}


smoke1
{
  attachment                            "a.smoke1"
  mode                                  "time"
  color                                 25,25,25,220
  accel                                 0.5,0.3,0
  rate                                  5
  velocity                              2
  lifetime                              5
  minsize                               1
  maxsize                               5
  enabled                               0
}


queues
{
  grain1queue
  {
    size                                1032000
    initial-count                       271500
    product-kuid                        <kuid:46162:60001>

    allowed-products
    {
      0                                 <kuid:46162:60001>
    }
  }

  grain2queue
  {
    size                                1032000
    initial-count                       271500
    product-kuid                        <kuid:46162:60001>

    allowed-products
    {
      0                                 <kuid:46162:60001>
    }
  }
}


processes
{
  grain1_config
  {
    start-enabled                       1
    duration                            30

    outputs
    {
      0
      {
        amount                          0
        queue                           "grain1queue"
      }
    }
  }

  grain2_config
  {
    start-enabled                       1
    duration                            30

    outputs
    {
      0
      {
        amount                          0
        queue                           "grain2queue"
      }
    }
  }
}


thumbnails
{
  0
  {
    image                               "preview.jpg"
    width                               240
    height                              180
  }
}


kuid-table
{
  grain                                 <kuid:46162:60001>
  0                                     <kuid:523:1216>
}