client_keybinding.fos

#ifdef __CLIENT


/*
    LICENSE : DWTFYWIDC => Do What The Fuck You Want. I Don't Care.

    THANK : To Rotators to have shared their labour.
            To all the people involved in FOnline.

    TODO : UseItem* should parse pids from binding params.
           Test that binding doesn't override an old one.
           Add the rest of the keys to keymap.
*/

#include "client_keybinding_h.fos"

dictionary bindings;
dictionary keymap;

const string@[] AllowedKeys = {
    "FogOfWar",
    "ReloadWeapon",
    "AimHead",
    "AimEyes",
    "AimTorso",
    "AimRightArm",
    "AimLeftArm",
    "AimRightLeg",
    "AimLeftLeg",
    "AimGroin",
    "UseItem1",
    "UseItem2",
    "UseItem3",
    "UseItem4",
    "UseItem5",
    "UseItem6",
    "UseItem7",
    "UseItem8",
    "UseItem9"
};


class bindkey {
    uint8 key;
    bool ctrl;
    bool alt;
    bool shift;
    uint16 proto;

    void init () {
        this.ctrl = false;
        this.alt = false;
        this.shift = false;
        this.key = 0;
        this.proto = 0;
    }

    void run (uint bindproto)
    {
        ProcessKey(bindproto);
    }
}

void ProcessKey( uint bindproto )
{
    switch(bindproto) {
        case _FogOfWar:

            break;
        case _ReloadWeapon:
        
            break;
        case _AimHead:
    
            break;
        case _AimEyes:
    
            break;
        case _AimTorso:
    
            break;
        case _AimRightArm:
    
            break;
        case _AimLeftArm:
    
            break;
        case _AimRightLeg:
    
            break;
        case _AimLeftLeg:
    
            break;
        case _AimGroin:
    
            break;
        case _UseItem1:
    
            break;
        case _UseItem2:
    
            break;
        case _UseItem3:
    
            break;
        case _UseItem4:
    
            break;
        case _UseItem5:
    
            break;
        case _UseItem6:
    
            break;
        case _UseItem7:
    
            break;
        case _UseItem8:
    
            break;
        case _UseItem9:
    
            break;
    }
    return;
}

void InitKeyBinding() // export
{
    if( ReadKeybindingConfig() )
        Message("keybinding.cfg has been successfuly loaded.");
    else
        Message("Your binding is fugging broken my friend. :)");
    return;
}

void InitKeyMap()
{
    keymap.set("A", DIK_A);
    keymap.set("B", DIK_B);
    keymap.set("C", DIK_C);
    keymap.set("D", DIK_D);
    keymap.set("E", DIK_E);
    keymap.set("F", DIK_F);
    keymap.set("G", DIK_G);
    keymap.set("H", DIK_H);
    keymap.set("I", DIK_I);
    keymap.set("J", DIK_J);
    keymap.set("K", DIK_K);
    keymap.set("L", DIK_L);
    keymap.set("M", DIK_M);
    keymap.set("N", DIK_N);
    keymap.set("O", DIK_O);
    keymap.set("P", DIK_P);
    keymap.set("Q", DIK_Q);
    keymap.set("R", DIK_R);
    keymap.set("S", DIK_S);
    keymap.set("T", DIK_T);
    keymap.set("U", DIK_U);
    keymap.set("V", DIK_V);
    keymap.set("W", DIK_W);
    keymap.set("X", DIK_X);
    keymap.set("Y", DIK_Y);
    keymap.set("Z", DIK_Z);
    //keymap.set("Shift", DIK_LSHIFT);
    //keymap.set("Ctrl", DIK_LCONTROL);
    //keymap.set("Alt", DIK_LMENU);
}

void InitDefaultBinding()
{
    //                name,  ctrl,   alt,  shift, key
    SetBinding( "FogOfWar", false, true , false , DIK_F);
    SetBinding( "ReloadWeapon", false, false , false , DIK_R);
}

bool ReadKeybindingConfig()
{
    InitKeyMap();
    InitDefaultBinding();
    file f;
    string str;

    if(f.open("keybinding.cfg", "r") >= 0)
    {
        int    l = f.readString(f.getSize(), str);
        f.close();
    }
    else
        return false;

    string@[]@ lines = split(str, "\n");
    for(uint i = 0; i < lines.length(); i++)
    {
        string@[]@ bind = split(lines[i], "=");
        if(bind.length() > 1) {
            if ( AllowedKeyExists(bind[0]) )
            {
                //b(bind[0]);
                string@[]@ keys = split(bind[1], " ");
                bindkey keyhandle;
                for (uint i = 0; i < keys.length(); ++i)
                {
                    if( i == 0 )
                        keyhandle.init();
                    
                    if ( keys[i].length() > 5 ) {
                        Message("Failed to set binding :"+bind[0]);
                        return false;
                    }

                    if ( keys[i].length() > 2 && ( i == 0 || i == 1 ) ) {               // modifiers
                        if( keys[i] == "Ctrl" ) {
                            keyhandle.ctrl = true;
                        }
                        else if ( keys[i] == "Alt" ) {
                            keyhandle.alt = true;
                        }
                        else if( keys[i] == "Shift" ) {
                            keyhandle.shift = true;
                        }
                        else {
                            Message("Failed to set binding :"+bind[0]);
                            return false;
                        }
                    }

                    if ( keys[i].length() == 2 ) {           // key
                        if( keymap.get( keys[i][0], keyhandle.key ) ) {
                            if(SetBinding( bind[0], keyhandle ))
                                continue;
                            else
                                Message("Failed to set binding :"+bind[0]);
                        }
                        else {
                            Message("Failed to set binding :"+bind[0]);
                            return false;
                        }
                    }
                }
            }
        }
    }
    return true;
}

bool SetBinding(string& name, bindkey@ keys)
{
    bindings.set(name, keys);
    return bindings.exists(name);
}

bool SetBinding(string& name, bool ctrl, bool alt, bool shift, uint8 key)
{
    bindkey keys;
    keys.ctrl = ctrl;
    keys.alt = alt;
    keys.shift = shift;
    keys.key = key;
    bindings.set(name, keys);
    return bindings.exists(name);
}

// SHIFT CTRL => WRONG
// in short 2 modifiers without a key wont be proccessed!
void TryBindings(bool ctrl, bool alt, bool shift, uint8 key) // export
{
    bindkey obj;
    for (uint i = 0; AllowedKeys.length() > i; i++)
    {
        if( bindings.exists(AllowedKeys[i]) )
        {
            bindings.get(AllowedKeys[i], obj);
            if( ctrl && obj.ctrl || ( ctrl && obj.ctrl && ( alt && obj.alt || shift && obj.shift ) ) ) {
                if( key == obj.key ) {
                    obj.run(i);
                    break;
                }
            }
            else if( alt && obj.alt || ( alt && obj.alt && ( ctrl && obj.ctrl || shift && obj.shift ) ) ) {
                if( key == obj.key ) {
                    obj.run(i);
                    break;
                }
            }
            else if( shift && obj.shift || ( shift && obj.shift && ( ctrl && obj.ctrl || alt && obj.alt ) ) ) {
                if( key == obj.key ) {
                    obj.run(i);
                    break;
                }
            }
            else {
                if( key == obj.key ) {
                    obj.run(i);
                    break;
                }
            }
        }
    }
}

void TryBinding(uint bindproto, bool ctrl, bool alt, bool shift, uint8 key) // export
{
    bindkey obj;
    if( bindings.exists(AllowedKeys[bindproto]) )
    {
        bindings.get(AllowedKeys[bindproto], obj);
        if( ctrl && obj.ctrl || ( ctrl && obj.ctrl && ( alt && obj.alt || shift && obj.shift ) ) ) {
            if( key == obj.key ) {
                obj.run(bindproto);
            }
        }
        else if( alt && obj.alt || ( alt && obj.alt && ( ctrl && obj.ctrl || shift && obj.shift ) ) ) {
            if( key == obj.key ) {
                obj.run(bindproto);
            }
        }
        else if( shift && obj.shift || ( shift && obj.shift && ( ctrl && obj.ctrl || alt && obj.alt ) ) ) {
            if( key == obj.key ) {
                obj.run(bindproto);
            }
        }
        else {
            if( key == obj.key ) {
                obj.run(bindproto);
            }
        }
    }
}

bool AllowedKeyExists(string@ name)
{
    bool found = false;
    for (uint i = 0; AllowedKeys.length() > i; i++)
    {
        if (name == AllowedKeys[i])
        {
            found = true;
            break;
        }
    }
    return found;
}

#endif

client_keybinding_h.fos

#include "_client_defines.fos"

// bindprotos
#define _FogOfWar        (0)
#define _ReloadWeapon    (1)
#define _AimHead         (2)
#define _AimEyes         (3)
#define _AimTorso        (4)
#define _AimRightArm     (5)
#define _AimLeftArm      (6)
#define _AimRightLeg     (7)
#define _AimLeftLeg      (8)
#define _AimGroin        (9)
#define _UseItem1        (10)
#define _UseItem2        (11)
#define _UseItem3        (12)
#define _UseItem4        (13)
#define _UseItem5        (14)
#define _UseItem6        (15)
#define _UseItem7        (16)
#define _UseItem8        (17)
#define _UseItem9        (18)

#ifdef _CLIENT_KEYBINDING
import void InitKeyBinding() from "client_keybinding";
import void TryBindings(bool ctrl, bool alt, bool shift, uint8 key) from "client_keybinding";
import void TryBinding(uint bindproto, bool ctrl, bool alt, bool shift, uint8 key) from "client_keybinding";
#endif