LTrackSearch

include "lutil.gs"


class LTrackSearchCursor
{
    public bool EndOfTrack() { return true; }
    public object GetObject() { return null; }
    public bool GetFacing() { return false; }
    public float GetDistance() { return 0.0f; }
};


class LTrackSearchObserver
{
    public GSTrackSearch Begin() { return cast <GSTrackSearch> null; }
    public bool Next(LTrackSearchCursor cursor) { return false; }
    public void End(LTrackSearchCursor cursor) {}
};


final class LTrackSearchEngine isclass LTrackSearchCursor
{
    public float MaxSearchDistance = 5000.0f;
    public float SearchRestartDistance = 5000.0f;

    public int SleepIterations = 10000;

    public LTrackSearchObserver Observer;
    public GameObject Thread;

    public GSTrackSearch Search;

    public bool Run();

    public float TotalDistance = 0.0f;


    // ****************************************************
    //
    //    I M P L E M E N T A T I O N
    //
    // ****************************************************

    int ops = 0;
    bool eot = true;

    final void IncOps()
    {
        if (++ops >= SleepIterations) {
            if (Thread)
                Thread.Sleep(0.0001f);
            ops = 0;
        }
    }

    public bool Run()
    {
        if (!Observer or !(Search = Observer.Begin()))
            return false;
        float totalDistance = 0.0f;
        eot = false;
        bool hasNext;
        while (hasNext = Search.SearchNextObject()) {
            float distance = TotalDistance + Search.GetDistance();
            if (distance > MaxSearchDistance)
                break;
            if (!Observer.Next(me))
                break;
            if(distance >= SearchRestartDistance) {
                Trackside obj = cast <Trackside> Search.GetObject();
                if (obj) {
                    TotalDistance = distance;
                    Search = obj.BeginTrackSearch(Search.GetFacingRelativeToSearchDirection());
                }
            }
            IncOps();
        }
        eot = !hasNext;
        Observer.End(me);
        return hasNext;
    }

    public object GetObject()
    {
        if (Search)
            return Search.GetObject();
        return null;
    }

    public bool GetFacing()
    {
        if (Search)
            return Search.GetFacingRelativeToSearchDirection();
        return false;
    }

    public float GetDistance()
    {
        if (Search)
            return Search.GetDistance() + TotalDistance;
        return 0.0f;
    }

    public bool EndOfTrack() { return eot; }
};


final static class LTrackSearch
{
    public bool Begin(LTrackSearchObserver observer, float maxDist, float restartDist, int sleepIters)
    {
        LTrackSearchEngine engine = new LTrackSearchEngine();
        if (maxDist > 0.0f)
            engine.MaxSearchDistance = maxDist;
        if (restartDist > 0.0f)
            engine.SearchRestartDistance = restartDist;
        if (sleepIters > 0)
            engine.SleepIterations = sleepIters;
        engine.Observer = observer;
        engine.Thread = Router.GetCurrentThreadGameObject();
        return engine.Run();
    }

    public bool Begin(LTrackSearchObserver observer, float maxDist, float restartDist)
    {
        LTrackSearchEngine engine = new LTrackSearchEngine();
        if (maxDist > 0.0f)
            engine.MaxSearchDistance = maxDist;
        if (restartDist > 0.0f)
            engine.SearchRestartDistance = restartDist;
        engine.Observer = observer;
        engine.Thread = null;
        return engine.Run();
    }
};