lse.base.locomotive.gs

/* LSE_FILE_HEADER */

include "locomotive.gs"

include "lse.init.gs"

include "lse.pneum.vehicle.gs"

include "lse.dev.device.gs"

include "lse.base.cabin.gs"


final static class LseUpdate
{
    public float time;
    public float dt;

    final public void BeginUpdate(float time, float dt)
    {
        me.time = time;
        me.dt = dt;
    }
};


final class LseCabinControlState
{
    public float Value   = 0.0;
    public bool  Visible = true;
    public float Fade    = 0.0;
    public bool  Locked  = false;
};


class LseStdVehicleGraphScheme isclass LseStdLocomotiveScheme {};


class LseLocomotive isclass Locomotive, LseInit, LpeVehicle
{
    public LseStdVehicleGraphScheme PneumaticScheme;

    public LpeScheme Lpe_GetPneumaticScheme() { return cast <LpeScheme> PneumaticScheme; }

    define public int PositionSingle = 0;
    define public int PositionFrontmost = 1;
    define public int PositionRearmost = 2;
    define public int PositionInternal = 3;

    final public int GetPosition();

    final public void AddDevice(string deviceName, LseDevDevice device);
    final public LseDevDevice GetDevice(string deviceName);
    final public void AddDeviceUpdates(LseDevDevice dev, int flags, bool useCabinUpdates);
    final public void AddDeviceUpdates(LseDevDevice dev, int flags);
    public void AddDeviceControlHandler(LseDevCabinDevice device, string controlName);
    public thread void CreateDeviceThread(LseDevDevice src, string threadName);

    final public bool CheckCabin();
    final public LseCabin GetCabin();
    final public void AttachCabin(LseCabin cabin);

    final public int GetControlId(string controlName);
    final public LseCabinControlState GetControlState(int controlId);
    final public void SetControlState(int controlId);
    final public void ProcessControl(CabinControl srcControl, float value);

    final public int GetPosition()
    {
        Vehicle[] trainVehicles = GetMyTrain().GetVehicles();
        int trainVehiclesSize = trainVehicles.size();

        if (trainVehiclesSize <= 1)
            return PositionSingle;
        if (trainVehicles[0] == me)
            return PositionFrontmost;
        if (trainVehicles[trainVehiclesSize - 1] == me)
            return PositionRearmost;
        return PositionInternal;
    }

    // ****************************************************
    // Device management
    //

    LseDevDevice[] _devices;
    LlIndexMap     _deviceNames;

    int[] _deviceIdsUpdateFrame;
    int[] _deviceIdsUpdateFast;
    int[] _deviceIdsUpdateMidi;
    int[] _deviceIdsUpdateSlow;
    int[] _deviceIdsUpdateCabinFrame;
    int[] _deviceIdsUpdateCabinFast;
    int[] _deviceIdsUpdateCabinMidi;
    int[] _deviceIdsUpdateCabinSlow;

    LlIndexMap _controlHandlers;

    final public void AddDevice(string deviceName, LseDevDevice device)
    {
        int deviceId = _devices.size();
        _devices[deviceId] = device;

        if (!LlStr.IsEmpty(deviceName))
            _deviceNames.SetIndex(deviceName, deviceId);

        device.Id = deviceId;

        device.Init(me);
    }

    final public LseDevDevice GetDevice(string deviceName)
    {
        int id = _deviceNames.GetIndex(deviceName);
        if (id >= 0)
            return _devices[id];
        return null;
    }

    final public void AddDeviceUpdates(LseDevDevice dev, int flags, bool useCabinUpdates)
    {
        int devId = dev.Id;
        if (useCabinUpdates)
        {
            if (flags & LseDevDevice.UpdateFlagFrame)
                _deviceIdsUpdateCabinFrame[_deviceIdsUpdateCabinFrame.size()] = devId;

            if (flags & LseDevDevice.UpdateFlagFast)
                _deviceIdsUpdateCabinFast[_deviceIdsUpdateCabinFast.size()] = devId;

            if (flags & LseDevDevice.UpdateFlagMidi)
                _deviceIdsUpdateCabinMidi[_deviceIdsUpdateCabinMidi.size()] = devId;

            if (flags & LseDevDevice.UpdateFlagSlow)
                _deviceIdsUpdateCabinSlow[_deviceIdsUpdateCabinSlow.size()] = devId;
        }
        else
        {
            if (flags & LseDevDevice.UpdateFlagFrame)
                _deviceIdsUpdateFrame[_deviceIdsUpdateFrame.size()] = devId;

            if (flags & LseDevDevice.UpdateFlagFast)
                _deviceIdsUpdateFast[_deviceIdsUpdateFast.size()] = devId;

            if (flags & LseDevDevice.UpdateFlagMidi)
                _deviceIdsUpdateMidi[_deviceIdsUpdateMidi.size()] = devId;

            if (flags & LseDevDevice.UpdateFlagSlow)
                _deviceIdsUpdateSlow[_deviceIdsUpdateSlow.size()] = devId;
        }
    }

    final public void AddDeviceUpdates(LseDevDevice dev, int flags)
    {
        AddDeviceUpdates(dev, flags, false);
    }

    public void AddDeviceControlHandler(LseDevCabinDevice device, string controlName)
    {
        _controlHandlers.SetIndex(controlName, device.Id);
    }

    int maximumDeviceThreads = 20;
    int _deviceThreads = 0;

    public thread void CreateDeviceThread(LseDevDevice src, string threadName)
    {
        if (++_deviceThreads < maximumDeviceThreads)
        {
            src.ThreadEnter(me, threadName);
            --_deviceThreads;
        }
        else
            LlUtil.ThrowException(me,
                                  "DeviceThreadPoolUnderflow",
                                  "Could not create thread '" + threadName +
                                  "' for device id " + src.Id +
                                  " - limit exceeded");
    }

    // ****************************************************
    // Cabin handling
    //

    int _cabinId = -1;
    bool _cabinInit = false;
    float _lastCabinCheckTime = -1.0;

    LseCabin _cabin;

    CabinControl[]             _controlList;
    LseCabinControlState[]  _controlStateList;
    LlIndexMap                 _controlNames;

    final void InitCabin()
    {
        _cabin.InitSim();
        _cabin.InitSimFinalize();

        CabinControl[] cabinControls = _cabin.GetControls();
        _controlList = new CabinControl[_controlStateList.size()];

        int i;
        for (i = 0; i < cabinControls.size(); ++i)
        {
            if (!cabinControls[i])
                continue;

            int controlId = GetControlId(cabinControls[i].GetName());

            cabinControls[i].SetValue(_controlStateList[controlId].Value);
            _cabin.SetMeshVisible(cabinControls[i].GetName(),
                                 _controlStateList[controlId].Visible,
                                 0.0);
            cabinControls[i].SetLocked(_controlStateList[controlId].Locked);

            _controlList[controlId] = cabinControls[i];

            ProcessControl(cabinControls[i], _controlStateList[controlId].Value);
        }

        _cabinInit = true;
    }

    final public bool CheckCabin()
    {
        if (_cabinId < 0)
            return false;

        float t = World.GetSeconds();

        if (_lastCabinCheckTime == t)
            return true;
        _lastCabinCheckTime = t;

        _cabin = cast<LseCabin> Router.GetGameObject(_cabinId);
        if (_cabin)
        {
            if (!_cabinInit)
                InitCabin();
            return true;
        }

        if (_cabin)
        {
            _cabin = null;
            _cabinInit = false;
            _cabinId = -1;

            int i;
            for (i = 0; i < _controlList.size(); ++i)
                _controlList[i] = null;
        }
        return false;
    }

    final public LseCabin GetCabin()
    {
        CheckCabin();
        return _cabin;
    }

    final public void AttachCabin(LseCabin cabin)
    {
        if (cabin == null or cabin.GetParentObject() != me)
            return;

        _cabinId = cabin.GetId();
    }

    final public int GetControlId(string controlName)
    {
        int id = _controlNames.GetIndex(controlName);
        if (id < 0)
        {
            id = _controlStateList.size();
            _controlStateList[id] = new LseCabinControlState();
            _controlList[id] = null;
            _controlNames.SetIndex(controlName, id);
        }
        return id;
    }

    final public LseCabinControlState GetControlState(int controlId)
    {
        if (_controlList[controlId])
        {
            _controlStateList[controlId].Visible = _controlList[controlId].IsVisible();
            _controlStateList[controlId].Value = _controlList[controlId].GetValue();
            _controlStateList[controlId].Locked = _controlList[controlId].IsLocked();
        }

        return _controlStateList[controlId];
    }

    final public void SetControlState(int controlId)
    {
        if (!_controlList[controlId])
            return;

        _controlList[controlId].SetValue(_controlStateList[controlId].Value);
        _controlList[controlId].SetLocked(_controlStateList[controlId].Locked);
        GetCabin().SetMeshVisible(_controlList[controlId].GetName(),
                                  _controlStateList[controlId].Visible,
                                  _controlStateList[controlId].Fade);
    }

    final public void ProcessControl(CabinControl srcControl, float value)
    {
        string srcControlName = srcControl.GetName();

        int processingDeviceId = _controlHandlers.GetIndex(srcControlName);

        if (processingDeviceId >= 0)
        {
            int controlId = GetControlId(srcControlName);
            LseDevCabinDevice device = cast <LseDevCabinDevice> _devices[processingDeviceId];
            device.ProcessControl(srcControlName,
                                  GetControlState(controlId),
                                  value);

            SetControlState(controlId);

            /* DEBUG */
            Interface.Print("ProcessControlInput: " + srcControlName + " -> " + processingDeviceId);
            // */
        }
        /* DEBUG */
        else
            Interface.Print("ProcessControlInput: " + srcControlName + " - unhandled");
        // */
    }

    // ****************************************************
    // Update handling
    //

    void UpdateFrame()
    {
        int i;
        int count = _deviceIdsUpdateFrame.size();
        for (i = 0; i < count; ++i)
            _devices[_deviceIdsUpdateFrame[i]].UpdateFrame();
    }

    void UpdateFast()
    {
        int i;
        int count = _deviceIdsUpdateFast.size();
        for (i = 0; i < count; ++i)
            _devices[_deviceIdsUpdateFast[i]].UpdateFast();
    }

    void UpdateMidi()
    {
        int i;
        int count = _deviceIdsUpdateMidi.size();
        for (i = 0; i < count; ++i)
            _devices[_deviceIdsUpdateMidi[i]].UpdateMidi();
    }

    void UpdateSlow()
    {
        int i;
        int count = _deviceIdsUpdateSlow.size();
        for (i = 0; i < count; ++i)
            _devices[_deviceIdsUpdateSlow[i]].UpdateSlow();
    }

    public void UpdateCabinFrame()
    {
        int i;
        int count = _deviceIdsUpdateCabinFrame.size();
        for (i = 0; i < count; ++i)
            _devices[_deviceIdsUpdateCabinFrame[i]].UpdateFrame();
    }

    public void UpdateCabinFast()
    {
        int i;
        int count = _deviceIdsUpdateCabinFast.size();
        for (i = 0; i < count; ++i)
            _devices[_deviceIdsUpdateCabinFast[i]].UpdateFast();
    }

    public void UpdateCabinMidi()
    {
        int i;
        int count = _deviceIdsUpdateCabinMidi.size();
        for (i = 0; i < count; ++i)
            _devices[_deviceIdsUpdateCabinMidi[i]].UpdateMidi();
    }

    public void UpdateCabinSlow()
    {
        int i;
        int count = _deviceIdsUpdateCabinSlow.size();
        for (i = 0; i < count; ++i)
            _devices[_deviceIdsUpdateCabinSlow[i]].UpdateSlow();
    }

    float updateFastInterval = 0.1;
    float updateMidiInterval = 0.3;
    float updateSlowInterval = 1.0;

    bool _mainThread = false;
    bool _aiSystemsRunning = false;

    final thread void _main()
    {
        float lastUpdateTime = World.GetTimeElapsed();
        float lastFastUpdateTime = lastUpdateTime;
        float lastMidiUpdateTime = lastUpdateTime;
        float lastSlowUpdateTime = lastUpdateTime;

        Sleep(0.001);

        while (_mainThread)
        {
            float time = World.GetTimeElapsed();
            float dt = time - lastUpdateTime;

            CheckCabin();

            LseUpdate.BeginUpdate(time, dt);
            UpdateFrame();
            lastUpdateTime = time;

            while ((dt = time - lastFastUpdateTime) > updateFastInterval)
            {
                LseUpdate.BeginUpdate(time, dt);
                UpdateFast();
                lastFastUpdateTime = lastFastUpdateTime + dt;
            }

            while ((dt = time - lastMidiUpdateTime) > updateMidiInterval)
            {
                LseUpdate.BeginUpdate(time, dt);
                UpdateMidi();
                lastMidiUpdateTime = lastMidiUpdateTime + dt;
            }

            while ((dt = time - lastSlowUpdateTime) > updateSlowInterval)
            {
                LseUpdate.BeginUpdate(time, dt);
                UpdateSlow();
                lastSlowUpdateTime = lastSlowUpdateTime + dt;
            }

            Sleep(0.001);
        }
    }

    final public void NotifyTrainChanged(Train prevTrain, Train nextTrain)
    {
        inherited(prevTrain, nextTrain);
    }

    void InitSim()
    {
        _devices     = new LseDevDevice[0];
        _deviceNames = new LlIndexMap();

        _deviceIdsUpdateFrame      = new int[0];
        _deviceIdsUpdateFast       = new int[0];
        _deviceIdsUpdateMidi       = new int[0];
        _deviceIdsUpdateSlow       = new int[0];
        _deviceIdsUpdateCabinFrame = new int[0];
        _deviceIdsUpdateCabinFast  = new int[0];
        _deviceIdsUpdateCabinMidi  = new int[0];
        _deviceIdsUpdateCabinSlow  = new int[0];

        _controlHandlers = new LlIndexMap();

        _controlList      = new CabinControl[0];
        _controlStateList = new LseCabinControlState[0];
        _controlNames     = new LlIndexMap();

        PneumaticScheme = new LseStdVehicleGraphScheme();
        PneumaticScheme.Init(me);

        SetMaximumTractiveEffort(0.0);
        SetWheelslipTractionMultiplier(1.0);
        SetWheelslipMomentumMultiplier(1.0);
        SetSandingTractionMultiplier(1.0);
        SetTractionMultiplier(1.0);

        //SetMaximumCouplerCompressionStress(3300.0);
        //SetMaximumCouplerExpansionStress(3000.0);
        //SetMaximumCoupleVelocity(12.9 * Train.KPH_TO_MPS);
        //SetCouplerBreakageEnabled(true);
    }

    void InitSimFinalize()
    {
    }

    void RcUserInit()
    {
        inherited();

        InitSim();
        InitSimFinalize();

        _mainThread = true;
        _main();

        Sleep(0.5);
    }

    void RcUserTerm()
    {
        inherited();

        _mainThread = false;

        Sleep(0.5);
    }

    void RcAutoInit()
    {
        inherited();
    }

    void RcAutoTerm()
    {
        inherited();
    }

    final public void Init(Asset asset)
    {
        inherited(asset);

        me.LseInit();

        LpeLoader.Load();
    }
};