Simpliest relay ever

class DRelay isclass LseDevice
{
    LseSchemeElement coil;
    LseSchemeElement[] frontContacts;
    LseSchemeElement[] backContacts;
    LseSound sound;
    LseMesh mesh;
    float onDelay = 0.0f;
    float offDelay = 0.0f;

    define int STATE_OFF = 0;
    define int STATE_ON = 1;
    define int STATE_SWITCHING_ON = 2;
    define int STATE_SWITCHING_OFF = 3;

    float processTime = 0.0f;
    int state = STATE_OFF;

    public void SetProperties(Soup sp)
    {
        coil = SchemeMgr().GetElement(LData.GetString(sp, "coil", ""));

        if (LData.TryGetFloat("coil-resistance"))
            coil.SetResistance(LData.LastFloat());

        if (LData.TryGetFloat("on-current") {
            float onCurrent = LData.LastFloat();
            if (LData.TryGetFloat("off-current"))
                coil.SetCurrentHysteresis(onCurrent, LData.LastFloat());
            else
                coil.SetCurrentThreshold(onCurrent);
        }

        LseSchemeElement[] elems;

        if (LData.TryGetStringArray(sp, "front"))
            frontContacts = SchemeMgr().GetElements(LData.GetStringArray());
        else {
            elems = SchemeMgr().GetElements();
            int i, count = elems.size();
            frontContacts = new LseSchemeElement[0];
            for (i = 0; i < count; ++i)
                if (LStr.TryParseInt(elems[i].GetName()) and LStr.ParseInt() % 2 == 1)
                    frontContacts[frontContacts.size()] = elems[i];
        }

        if (LData.TryGetStringArray(sp, "back"))
            backContacts = SchemeMgr().GetElements(LData.GetStringArray());
        else {
            if (!elems)
                elems = SchemeMgr().GetElements();
            int i, count = elems.size();
            backContacts = new LseSchemeElement[0];
            for (i = 0; i < count; ++i)
                if (LStr.TryParseInt(elems[i].GetName()) and LStr.ParseInt() % 2 == 0)
                    backContacts[backContacts.size()] = elems[i];
        }

        if (LData.TryGetFloat("contact-resistance")) {
            float resistance = LData.LastFloat();
            SchemeMgr().SetResistance(frontContacts, resistance);
            SchemeMgr().SetResistance(backContacts, resistance);
        }

        if (LData.TryGetFloat("contact-off-resistance")) {
            float resistance = LData.LastFloat();
            SchemeMgr().SetResistance(frontContacts, resistance);
            SchemeMgr().SetResistance(backContacts, resistance);
        }

        sound = SoundMgr().GetSound(LData.GetString(sp, "sound", GetName()));
        mesh = MeshMgr().GetMesh(LData.GetString(sp, "mesh", GetName()));
        onDelay = LData.GetFloat(sp, "on-delay", onDelay);
        offDelay = LData.GetFloat(sp, "off-delay", offDelay);

        processTime = LData.GetFloat(sp, "process-time", processTime);
        state = LData.GetInt(sp, "state", state);

        SchemeMgr().SetConducting(frontContacts, state == STATE_ON);
        SchemeMgr().SetConducting(backContacts, state == STATE_OFF);
    }

    public Soup GetProperties()
    {
        Soup sp = Constructors.NewSoup();
        LData.Set(sp, "coil", coil.GetName());
        LData.Set(sp, "front", SchemeMgr().GetNames(frontContacts));
        LData.Set(sp, "back", SchemeMgr().GetNames(backContacts));
        LData.Set(sp, "sound", sound.GetName());
        LData.Set(sp, "mesh", mesh.GetName());
        LData.Set(sp, "on-delay", onDelay);
        LData.Set(sp, "off-delay", offDelay);
        LData.Set(sp, "process-time", processTime);
        LData.Set(sp, "state", state);
        return sp;
    }

    public void Update(float dt)
    {
        bool coilPowered = coil.GetCurrentState();

        int newState = state;
        while (true) {
            switch (state) {

                case STATE_OFF:
                    if (coilPowered) {
                        mesh.SetAnimationState("on", onDelay);
                        SchemeMgr().SetConducting(backContacts, false);
                        processTime = 0.0f;
                        newState = STATE_SWITCHING_ON;
                        break;
                    }
                    break;

                case STATE_SWITCHING_ON:
                    if (!coilPowered) {
                        processTime = offDelay * (1.0f - processTime / onDelay);
                        mesh.SetAnimationState("off", offDelay - processTime);
                        newState = STATE_SWITCHING_OFF;
                        break;
                    }
                    if (processTime >= onDelay) {
                        sound.TriggerEvent("on");
                        SchemeMgr().SetConducting(frontContacts, true);
                        newState = STATE_ON;
                        break;
                    }
                    processTime = processTime + dt;
                    break;


                case STATE_ON:
                    if (!coilPowered) {
                        mesh.SetAnimationState("off", offDelay);
                        SchemeMgr().SetConducting(frontContacts, false);
                        processTime = 0.0f;
                        newState = STATE_SWITCHING_OFF;
                        break;
                    }
                    break;

                case STATE_SWITCHING_OFF:
                    if (coilPowered) {
                        processTime = onDelay * (1.0f - processTime / offDelay);
                        mesh.SetAnimationState("off", onDelay - processTime);
                        newState = STATE_SWITCHING_OFF;
                        break;
                    }
                    if (processTime >= offDelay) {
                        sound.TriggerEvent("off");
                        SchemeMgr().SetConducting(backContacts, true);
                        newState = STATE_OFF;
                        break;
                    }
                    processTime = processTime + dt;
                    break;
            }
            if (newState == state)
                break;
            state = newState;
        }
    }
};