Dispatcher
From TrainzOnline
TBD: Update text
TBD: Repost or update additional informations after reposting the registered objectsoup. * CONTCRANE: Repost a goid list of reachable stacks. The contcrane itself informs the stacks about it's object data to update the maximum count of stackable containers. * CONTSTACK: ??? * CONTAINER: If a container has no stack place, randomly attach him to a free stack place and repost it. In case there is no one, repost an empty stack goid with place zero. TBD: What happens if the stack it attached to does not exist? Possibly handled as a free container?
Contents |
Asset files pre version 0.1
The files compile errorless and the messaging runs well. No more functionality implemented and tested in this pre version.
config.txt
kuid <kuid2:215489:110000:1>
username "aCTS DISPATCHER Library V1"
kind "Library"
category-class "YL"
trainz-build 4.6
description "aCTS DISPATCHER Library V1"
script "acts_dispatcher.gs"
class "acts_dispatcher"
thumbnails
{
0
{
image "acts_dispatcher_thumb.jpg"
width 240
height 180
}
}
acts_dispatcher.gs
include "acts_global_values.gs"
include "acts_tools_script.gs"
//-----------------------------------------------------------------------------
// aCTS Dispatcher V0.1 Central Script - acts_dispatcher
//-----------------------------------------------------------------------------
// X acts_dispatcher <-- acts_dispatcher_script
// X acts_dispatcher_script <-- acts_dispatcher_globals
// X acts_dispatcher_globals <-- acts_global_values
// acts_global_values <-- MapObject
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class acts_dispatcher_globals isclass acts_global_values
{
//---------------------------------------------------------------------------
// Store from dispatcher received object registration values to the
// respective dispatchers sub soup. The sub soups register ids run as int
// from 0 ... The received id -1 tells, that the object isn't yet
// registered.
//---------------------------------------------------------------------------
// Because the register id number list gets gaps while unregistering it will
// be nessecary to have some gap filling methods additionally. See
// AppendInsertUpdateObjectDataSoups and FindObjectSoupEntry methods.
//---------------------------------------------------------------------------
// AssetInstanceSoup {
// ObjectDataSoup { ... }, Only container, contstack, contcrane
// LocationSoup { ... }, Only container, contstack, contcrane
// OrientationSoup { ... }, Only container, contstack, contcrane
// SkinDataSoup { ... }, Only container
// ContentDataSoup { ... }, Only container
// X DispatcherDataSoup { ... } Only dispatcher
// X ContainerSoups { ... } Only dispatcher
// X ContstackSoups { ... } Only dispatcher
// X ContcraneSoups { ... } Only dispatcher
// }
//---------------------------------------------------------------------------
Soup ContainerSoups = Constructors.NewSoup();
Soup ContstackSoups = Constructors.NewSoup();
Soup ContcraneSoups = Constructors.NewSoup();
//---------------------------------------------------------------------------
Soup DispatcherDataSoup = Constructors.NewSoup();
//---------------------------------------------------------------------------
// ObjectDataSoup received from and posted to objects.
//---------------------------------------------------------------------------
// ObjectDataSoup { goid GameObjectID, type string, dispID int,
// length int, height int,
// stack goid, place int, Only container
// active bool, action string },
// activ: true means the object sended a register message while session run.
// All objects were set false while initialising dispatcher and if
// they stay false their entries will be deleted next initialising.
// actions: ["APPENDED", "INSERTED", "UPDATED"];
//---------------------------------------------------------------------------
GameObjectID dispgoid = me.GetGameObjectID();
string objecttype;
GameObjectID objectgoid;
//---------------------------------------------------------------------------
};
class acts_dispatcher_script isclass acts_dispatcher_globals
{
//---------------------------------------------------------------------------
public void SetProperties(Soup soup) // Callback method after Init method
{
inherited(soup);
//-------------------------------------------------------------------------
DispatcherDataSoup.Copy(soup.GetNamedSoup("DispatcherData"));
ContainerSoups.Copy(soup.GetNamedSoup("ContainerSoups"));
ContstackSoups.Copy(soup.GetNamedSoup("ContstackSoups"));
ContcraneSoups.Copy(soup.GetNamedSoup("ContcraneSoups"));
//-------------------------------------------------------------------------
isSetPropertiesMethodFinnished = true;
PostMessage(me,"OBJECTINIT","SETPROPS_FINNISH",0);
return;
}
//---------------------------------------------------------------------------
public Soup GetProperties(void) // Callback method before closing session
{
Soup soup = inherited();
//-------------------------------------------------------------------------
DispatcherDataSoup.SetNamedTag("firstrun",false);
//-------------------------------------------------------------------------
soup.SetNamedSoup("DispatcherData",DispatcherDataSoup);
soup.SetNamedSoup("ContainerSoups",ContainerSoups);
soup.SetNamedSoup("ContstackSoups",ContstackSoups);
soup.SetNamedSoup("ContcraneSoups",ContcraneSoups);
//-------------------------------------------------------------------------
return soup;
}
//---------------------------------------------------------------------------
public void WorldInitHandler(Message msg)
{
if (acts_debug) Interface.Log(Interface.GetTimeStamp()
+ " [" + dispgoid.SerialiseToString() + "]"
+ " DISPATCHER GOT WORLDINIT MESSAGE ["
+ msg.major+"] ["+msg.minor+"]");
//-------------------------------------------------------------------------
// If one of the two methods (Init or SetProperties) isn't finished yet,
// post "World","ModuleInit" message a little bit later again.
// So it is guaranteed that the Init and SetProperties methods are finished
// as well as the "World","ModuleInit" message tells to be save using the
// World.GetCurrentModule method.
//-------------------------------------------------------------------------
if (!(isSetPropertiesMethodFinnished and isInitMethodFinnished))
{
//----------------------------------------------------------------------
// While first run and before first session save for libraries the
// SetProperties methon will not run, whle no soup stored. If this case
// isn't handeled, the repost of "World","ModuleInit" runs infinitly.
//----------------------------------------------------------------------
if (!DispatcherDataSoup.GetNamedTagAsBool("firstrun"))
PostMessage(me, "World", "ModuleInit", 0.1);
}
//-------------------------------------------------------------------------
isWorldInitFinnished = true;
PostMessage(me, "OBJECTINIT", "WORLD_INIT_FINNISHED", 0.0);
//-------------------------------------------------------------------------
return;
}
//---------------------------------------------------------------------------
public void ObjectInitHandler(Message msg)
{
//-------------------------------------------------------------------------
// Until the Trainz core send the "World","ModuleInit" message it is not
// guarented to decide with the World.GetCurrentModule method to be in the
// returned module!
//-------------------------------------------------------------------------
if (acts_debug) Interface.Log(Interface.GetTimeStamp()
+ " [" + dispgoid.SerialiseToString() + "]"
+ " DISPATCHER GOT MESSAGE ["+msg.major+"] ["+msg.minor+"]");
//-------------------------------------------------------------------------*/
if (msg.dst==me and msg.major=="OBJECTINIT")
{
//-----------------------------------------------------------------------
if (msg.minor=="INIT_FINNISHED")
{
//---------------------------------------------------------------------
// Not used yet
//---------------------------------------------------------------------
}
//-----------------------------------------------------------------------
if (msg.minor=="SETPROPS_FINNISHED")
{
//---------------------------------------------------------------------
// If DispatcherDataSoup is empty, this is the first call unsaved call
//---------------------------------------------------------------------
if (DispatcherDataSoup.CountTags()==0)
DispatcherDataSoup.SetNamedTag("firstrun",true);
}
//-----------------------------------------------------------------------
if (msg.minor=="WORLD_INIT_FINNISHED")
{
//---------------------------------------------------------------------
// Do no module only, driver module only or surveyor module only
// related initiations
//---------------------------------------------------------------------
if (World.GetCurrentModule() == World.DRIVER_MODULE)
{
//-------------------------------------------------------------------
// Not used yet
//-------------------------------------------------------------------
}
//---------------------------------------------------------------------
if (World.GetCurrentModule() == World.SURVEYOR_MODULE)
{
//-------------------------------------------------------------------
// Not used yet
//-------------------------------------------------------------------
}
//---------------------------------------------------------------------
if (World.GetCurrentModule() == World.NO_MODULE)
{
//-------------------------------------------------------------------
// Not used yet
//-------------------------------------------------------------------
}
}
}
}
//---------------------------------------------------------------------------
// Search the objects soup for next free entry gap. Parameter dsp is the
// object's type dispatcher sub soup (ContainerSoups, ContstackSoups or
// ContcraneSoups). Method returns a soup.
// soup { entry int, action string, active bool }
//---------------------------------------------------------------------------
Soup FindObjectSoupEntry(GameObjectID goid, Soup dsp)
{
int entry;
string action;
Soup rsp = Constructors.NewSoup();
rsp.SetNamedTag("active",true);
int i;
for (i=0; i<dsp.CountTags(); i++)
{
entry = Str.ToInt(dsp.GetIndexedTagName(i));
Soup sp = dsp.GetNamedSoup(entry);
if (sp.GetNamedTagAsGameObjectID("goid")==goid) // TBD: goid compar ison
{
rsp.SetNamedTag("entry",entry);
rsp.SetNamedTag("action","UPDATED");
return rsp;
}
}
entry = actsTools.GetObjectSoupGap(dsp);
if (entry==dsp.CountTags()) rsp.SetNamedTag("action","APPENDED");
else rsp.SetNamedTag("action","INSERTED");
rsp.SetNamedTag("entry",entry);
return rsp;
}
//---------------------------------------------------------------------------
// Search the goid and update, insert or append the soup to register
// Parameter osp is the posted ObjectDataSoup. The other three are the
// dispatcher's object soups subsoups.
//---------------------------------------------------------------------------
void AppendInsertUpdateObjectDataSoups(Soup osp,
Soup ContSps, Soup StackSps, Soup CraneSps)
{
//-------------------------------------------------------------------------
string type = osp.GetNamedTag("type");
GameObjectID objgoid = osp.GetNamedTagAsGameObjectID("type");
Soup objsps = Constructors.NewSoup();
if (type == "CONTAINER") objsps = ContSps;
if (type == "CONTSTACK") objsps = StackSps;
if (type == "CONTCRANE") objsps = CraneSps;
Soup entry = FindObjectSoupEntry(objgoid, objsps);
// entry { entry int, active bool, action string }
// actions = ["APPENDED", "INSERTED", "UPDATED"];
osp.SetNamedTag("active", true);
osp.SetNamedTag("action", entry.GetNamedTag("action"));
objsps.SetNamedSoup(entry.GetNamedTagAsInt("entry"), osp);
//-------------------------------------------------------------------------
// Post retour that register is updated
//-------------------------------------------------------------------------
GameObject obj = Router.GetGameObject(objgoid);
PostMessage(obj, "DISPATCHER",
"OBJECTSOUP_" + entry.GetNamedTag("action"), osp, 0.0);
//-------------------------------------------------------------------------
if (acts_debug) Interface.Log(Interface.GetTimeStamp()
+ " [" + dispgoid.SerialiseToString() + "]"
+ " DISPATCHER OBJECTSOUP " + entry.GetNamedTag("action")
+ " " + type + " GOID [" + objgoid.SerialiseToString() + "]");
if (acts_debug) Interface.Log(Interface.GetTimeStamp()
+ " CONTENT OF " + entry.GetNamedTag("action") + " SOUP FROM GOID"
+ " [" + objgoid.SerialiseToString() + "]");
if (acts_debug) actsTools.ShowSoup(osp,"OSP=>");
//-------------------------------------------------------------------------*/
return;
}
//---------------------------------------------------------------------------
public void RegisterHandler(Message msg)
{
if (msg.dst==me and msg.major=="REGISTER")
{
//-----------------------------------------------------------------------
if (acts_debug) Interface.Log(Interface.GetTimeStamp()
+ " ["+dispgoid.SerialiseToString()+"]"
+ " DISPATCHER GOT MESSAGE FROM OBJECT ["
+ (cast<GameObject>msg.src).GetGameObjectID().SerialiseToString()
+ "] [" + msg.major + "] [" + msg.minor + "]");
//-----------------------------------------------------------------------*/
if (msg.minor=="REGISTER_ME")
{
//---------------------------------------------------------------------
// Update, insert or append the ObjectDataSoup
//---------------------------------------------------------------------
Soup RegDataSoup = Constructors.NewSoup();
RegDataSoup.Copy(cast<Soup>msg.paramSoup);
//---------------------------------------------------------------------
if (acts_debug) Interface.Log(Interface.GetTimeStamp()
+ " SOUP CONTENT OF 'DataSoup To Register' GOID"
+ " [" + dispgoid.SerialiseToString() + "]");
if (acts_debug) actsTools.ShowSoup(RegDataSoup,"=>");
//---------------------------------------------------------------------
AppendInsertUpdateObjectDataSoups(RegDataSoup,
ContainerSoups, ContstackSoups, ContcraneSoups);
//---------------------------------------------------------------------
// TBD: Repost or update additional informations
// * CONTCRANE: Repost a goid list of reachable stacks. The contcrane
// itself informs the stacks about it's object data to update the
// maximum count of stackable containers.
// * CONTSTACK: ???
// * CONTAINER: If a container has no stack place, randomly attach
// him to a free stack place and repost it. In case there is no
// one, repost an empty stack goid with place zero.
// TBD: What happens if the stack it attached to does not exist?
// Possibly handled as a free container?
//---------------------------------------------------------------------
}
//-----------------------------------------------------------------------
}
return;
}
};
class acts_dispatcher isclass acts_dispatcher_script
{
public void Init()
{
inherited();
//-------------------------------------------------------------------------
// Make shure that the right module is set for World.GetCurrentModle()
// (see world.gs lines 939ff.) to start driver only or surveyor only
// related initiations and tell me, if my Init and SetProperties methods
// are finished
//-------------------------------------------------------------------------
AddHandler(me, "World", "ModuleInit", "WorldInitHandler");
AddHandler(me, "OBJECTINIT", "", "ObjectInitHandler");
AddHandler(me, "REGISTER", "", "RegisterHandler");
//-------------------------------------------------------------------------
// Set asset special initial values
//-------------------------------------------------------------------------
objecttype = "DISPATCHER";
//-------------------------------------------------------------------------
isInitMethodFinnished = true;
PostMessage(me,"OBJECTINIT","INIT_FINNISHED",0.0); // Init method finnished
return;
}
};
acts_global_values.gs
include "mapobject.gs"
//-----------------------------------------------------------------------------
// Common aCTS values V0.1 - Dispatcher, Container, Stack, Crane Tools Script
//-----------------------------------------------------------------------------
class acts_global_values isclass MapObject
{
//---------------------------------------------------------------------------
// Global variables
//---------------------------------------------------------------------------
bool acts_debug = true;
//---------------------------------------------------------------------------
float baseboardwidth = 720;
//---------------------------------------------------------------------------
// Technical values from normatives
// --------------------------------------------------------------------------
int container_length_10ft = 2991; // in [mm]
int container_length_20ft = 6058; // in [mm]
int container_length_40ft = 12192; // in [mm]
int container_length_45ft = 13716; // in [mm]
int container_length_53ft = 16154; // in [mm]
// --------------------------------------------------------------------------
int container_width = 2438; // in [mm]
int container_height = 2591; // in [mm]
int container_deltahc = 305; // in [mm]
// --------------------------------------------------------------------------
bool isWorldInitFinnished = false;
bool isInitMethodFinnished = false;
bool isSetPropertiesMethodFinnished = false;
//---------------------------------------------------------------------------
};
acts_tools_script.gs.gs
include "acts_global_values.gs"
//-----------------------------------------------------------------------------
// Common aCTS methods V0.1 - Dispatcher, Container, Stack, Crane Tools Script
//-----------------------------------------------------------------------------
final static class actsTools isclass acts_global_values
{
//---------------------------------------------------------------------------
// Log soup content of a soup of soups only and without subsoups
//---------------------------------------------------------------------------
public void ShowSoup(Soup sp, string ind)
{
if (sp.CountTags()!=0)
{
int i;
for (i=0; i<sp.CountTags(); i++)
if (acts_debug) Interface.Log(ind + sp.GetIndexedTagName(i)
+ " ["+sp.GetNamedTag(sp.GetIndexedTagName(i))+"]");
}
return;
}
public void ShowSoups(Soup soup, string indent)
{
string ind = "="+indent;
int sc = soup.CountTags();
int i;
for (i=0; i<sc; i++)
{
if (acts_debug) Interface.Log(indent + i + ".SubSoup");
actsTools.ShowSoup(soup.GetNamedSoup(i),ind);
}
return;
}
//---------------------------------------------------------------------------
// Set all ObjectSoups active false and get the last insert gap
// TBD: Starting with a sorted soup
//---------------------------------------------------------------------------
public void ResetObjectSoups(Soup soup)
{
int i;
int gap = soup.CountTags();;
for (i=0; i<soup.CountTags(); i++)
{
int tn = Str.ToInt(soup.GetIndexedTagName(i));
Soup sp = soup.GetNamedSoup(tn);
if (sp.GetNamedTagAsBool("active"))
{
sp.SetNamedTag("active",false);
soup.SetNamedSoup(tn,sp);
} else soup.RemoveNamedTag(tn);
}
return;
}
//---------------------------------------------------------------------------
// Return the first indexed gap in existing objectsoups tagnames
//---------------------------------------------------------------------------
public int GetObjectSoupGap(Soup soup)
{
int i;
for (i=0; i<soup.CountTags(); i++)
if (soup.GetIndexForNamedTag(i)==-1) return i;
return soup.CountTags();
}
//---------------------------------------------------------------------------
// Generate soup representation from WorldCoordinate
//---------------------------------------------------------------------------
public Soup WCoordToSoup(WorldCoordinate pos)
{
Soup sp = Constructors.NewSoup();
sp.SetNamedTag("bbx",pos.baseboardX);
sp.SetNamedTag("bby",pos.baseboardY);
sp.SetNamedTag("px",pos.x);
sp.SetNamedTag("py",pos.y);
sp.SetNamedTag("pz",pos.z);
return sp;
}
//---------------------------------------------------------------------------
// Generate WorldCoordinate from its soup representation
//---------------------------------------------------------------------------
public WorldCoordinate WCoordFromSoup(Soup sp)
{
WorldCoordinate WC;
WC.baseboardX = sp.GetNamedTagAsInt("bbx");
WC.baseboardY = sp.GetNamedTagAsInt("bby");
WC.x = sp.GetNamedTagAsFloat("px");
WC.y = sp.GetNamedTagAsFloat("py");
WC.z = sp.GetNamedTagAsFloat("pz");
return WC;
}
//---------------------------------------------------------------------------
// Normalize the WC to baseboard width
//---------------------------------------------------------------------------
public WorldCoordinate WCoordNormalize(WorldCoordinate WC)
{
WorldCoordinate nWC;
//-------------------------------------------------------------------------
int bx = WC.x * 1000.0 / baseboardwidth; // Basebord delta
if (WC.x < 0.0) bx--;
nWC.baseboardX = WC.baseboardX + bx;
nWC.x = WC.x - bx * baseboardwidth;
//-------------------------------------------------------------------------
int by = WC.y * 1000.0 / baseboardwidth; // Basebord delta
if (WC.y < 0.0) by--;
nWC.baseboardY = WC.baseboardX + by;
nWC.y = WC.y - by * baseboardwidth;
//-------------------------------------------------------------------------
nWC.z = WC.z;
return nWC;
}
//---------------------------------------------------------------------------
// Adjust baseboard from one WorlCoordinate to another
//---------------------------------------------------------------------------
public WorldCoordinate
WCoordAdjustBaseboard(WorldCoordinate frWC, WorldCoordinate toWC)
{
WorldCoordinate adjWC;
//-------------------------------------------------------------------------
adjWC.x = toWC.x + (frWC.baseboardX - toWC.baseboardX)*baseboardwidth;
adjWC.baseboardX = frWC.baseboardX;
adjWC.y = toWC.y + (frWC.baseboardY - toWC.baseboardY)*baseboardwidth;
adjWC.baseboardY = frWC.baseboardY;
adjWC.z = toWC.z;
//-------------------------------------------------------------------------
return adjWC;
}
//---------------------------------------------------------------------------
// Generate soup representation from Orientation
//---------------------------------------------------------------------------
public Soup OrientationToSoup(Orientation rot)
{
Soup sp = Constructors.NewSoup();
sp.SetNamedTag("gx",rot.rx * 1800.0 / Math.PI);
sp.SetNamedTag("gy",rot.ry * 1800.0 / Math.PI);
sp.SetNamedTag("gz",rot.rz * 1800.0 / Math.PI);
sp.SetNamedTag("rx",rot.rx);
sp.SetNamedTag("ry",rot.ry);
sp.SetNamedTag("rz",rot.rz);
return sp;
}
//---------------------------------------------------------------------------
// Generate Orientation from its soup representation
//---------------------------------------------------------------------------
public Orientation OrientationFromSoup(Soup sp)
{
Orientation OR;
OR.rx = sp.GetNamedTagAsFloat("rx");
OR.ry = sp.GetNamedTagAsFloat("ry");
OR.rz = sp.GetNamedTagAsFloat("rz");
return OR;
}
//---------------------------------------------------------------------------
// Adjust location and orientation to even mm and even 1/10° inplace
//---------------------------------------------------------------------------
public bool AutoAdjustTransformation(WorldCoordinate W, Orientation O)
{
float rd;
bool changed = false;
if (W.x<0) rd=-0.0005; else rd=0.0005; // rounding to full [mm]
int wcx = (W.x+rd) * 1000.0;
if (W.y<0) rd=-0.0005; else rd=0.0005;
int wcy = (W.y+rd) * 1000.0;
if (W.z<0) rd=-0.0005; else rd=0.0005;
int wcz = (W.z+rd) * 1000.0;
// rounding to full [1/10°] - here only z-axis, x,y-axis are set to zero
// to make shure the CTS is horizontal plane
if (O.rz<0) rd=-0.5; else rd=0.5;
int orz = O.rz * 1800.0 / Math.PI + rd;
if (W.x != wcx/1000.0) {W.x = wcx/1000.0; changed=true; }
if (W.y != wcy/1000.0) {W.y = wcy/1000.0; changed=true; }
if(W.z != 0.0) { W.z = 0.0; changed=true; }
if(O.rx != 0.0) { O.rx = 0.0; changed=true; }
if(O.ry != 0.0) { O.ry = 0.0; changed=true; }
if(O.rz != orz * Math.PI / 1800.0)
{ O.rz = orz * Math.PI / 1800.0; changed=true; }
//-------------------------------------------------------------------------
return changed;
}
//---------------------------------------------------------------------------
// Auto adjust WorldCoordinate and Orientation to [mm] and [1/10°]
// Adjusts the object and returns original and adjusted WC and OR as soup.
//---------------------------------------------------------------------------
public Soup AutoAdjustMapObject(MapObject M)
{
//-------------------------------------------------------------------------
// M = cast<MapObject>(me);
//-------------------------------------------------------------------------
bool changed = false;
Soup sp = Constructors.NewSoup();
WorldCoordinate W = M.GetMapObjectPosition();
Orientation O = M.GetMapObjectOrientation();
sp.SetNamedSoup("OriginalLocationSoup", WCoordToSoup(W));
sp.SetNamedSoup("OriginalOrientationSoup", OrientationToSoup(O));
changed = AutoAdjustTransformation(W,O);
M.SetMapObjectPosition(W);
M.SetMapObjectOrientation(O);
sp.SetNamedSoup("AdjustedLocationSoup", WCoordToSoup(W));
sp.SetNamedSoup("AdjustedOrientationSoup", OrientationToSoup(O));
sp.SetNamedTag("changed", changed);
//-------------------------------------------------------------------------
return sp;
}
};
