C4PlayerControlAssignment Class Reference

#include <C4PlayerControl.h>

Public Types
enum	TriggerModes {   CTM_Default = 0 , CTM_Hold = 1 << 0 , CTM_Release = 1 << 1 , CTM_AlwaysUnhandled = 1 << 2 ,   CTM_HandleDownStatesOnly = 1 << 3 , CTM_ClearRecentKeys = 1 << 4 }

Public Member Functions
	C4PlayerControlAssignment ()
	~C4PlayerControlAssignment ()=default
void	CompileFunc (StdCompiler *pComp)
void	CopyKeyFrom (const C4PlayerControlAssignment &src_assignment)
bool	ResolveRefs (class C4PlayerControlAssignmentSet *pParentSet, C4PlayerControlDefs *pControlDefs)
bool	IsComboMatched (const C4PlayerControlRecentKeyList &DownKeys, const C4PlayerControlRecentKeyList &RecentKeys) const
void	SetInherited (bool to_val)
void	SetInheritedAssignment (const C4PlayerControlAssignment *to_val)
void	ResetKeyToInherited ()
bool	IsKeyChanged () const
void	SetControlName (const char *control_name)
void	SetKey (const C4KeyCodeEx &key)
bool	operator== (const C4PlayerControlAssignment &cmp) const
bool	operator< (const C4PlayerControlAssignment &cmp) const
const char *	GetControlName () const
int32_t	GetControl () const
const char *	GetGUIName (const C4PlayerControlDefs &defs) const
const char *	GetGUIDesc (const C4PlayerControlDefs &defs) const
bool	IsGUIDisabled () const
int32_t	GetGUIGroup () const
bool	IsRefsResolved () const
void	ResetRefsResolved ()
bool	IsAlwaysUnhandled () const
int32_t	GetTriggerMode () const
const C4KeyCodeEx &	GetTriggerKey () const
bool	HasCombo () const
bool	IsOverrideAssignments () const
bool	IsInherited () const
const C4PlayerControlAssignment *	GetInheritedAssignment () const
StdStrBuf	GetKeysAsString (bool human_readable, bool short_name) const

Detailed Description

Definition at line 142 of file C4PlayerControl.h.

Member Enumeration Documentation

TriggerModes

enum C4PlayerControlAssignment::TriggerModes

Enumerator
CTM_Default
CTM_Hold
CTM_Release
CTM_AlwaysUnhandled
CTM_HandleDownStatesOnly
CTM_ClearRecentKeys

Definition at line 146 of file C4PlayerControl.h.

    {
        CTM_Default = 0,              // standard behaviour: The control will be triggered
        CTM_Hold = 1 << 0,        // the control will be put into "down"-mode
        CTM_Release = 1 << 1,        // the hold mode of the control will be released
        CTM_AlwaysUnhandled = 1 << 2,  // the key will not block handling of other keys even if it got handled
        CTM_HandleDownStatesOnly = 1 << 3, // used when an already handled release key is processed to reset down states of overridden keys only
        CTM_ClearRecentKeys = 1 << 4  // if this assignment is triggered, RecentKeys are reset so no more combos can be generated
    };

Constructor & Destructor Documentation

C4PlayerControlAssignment()

C4PlayerControlAssignment::C4PlayerControlAssignment ( )

inline

Definition at line 190 of file C4PlayerControl.h.

                                :
        TriggerKey()
    {}

~C4PlayerControlAssignment()

C4PlayerControlAssignment::~C4PlayerControlAssignment ( )

default

Member Function Documentation

CompileFunc()

void C4PlayerControlAssignment::CompileFunc

(

StdCompiler *

pComp

)

Definition at line 206 of file C4PlayerControl.cpp.

{
    if (!pComp->Name("Assignment")) { pComp->NameEnd(); pComp->excNotFound("Assignment"); }
    pComp->Value(mkNamingAdapt(mkSTLContainerAdapt(KeyCombo), "Key", KeyComboVec()));
    pComp->Value(mkNamingAdapt(fComboIsSequence, "ComboIsSequence", false));
    pComp->Value(mkNamingAdapt(mkParAdapt(sControlName, StdCompiler::RCT_Idtf), "Control", "None"));
    pComp->Value(mkNamingAdapt(mkParAdapt(sGUIName, StdCompiler::RCT_All), "GUIName", ""));
    pComp->Value(mkNamingAdapt(mkParAdapt(sGUIDesc, StdCompiler::RCT_All), "GUIDesc", ""));
    pComp->Value(mkNamingAdapt(iGUIGroup,"GUIGroup",0));
    pComp->Value(mkNamingAdapt(fGUIDisabled, "GUIDisabled", false));
    pComp->Value(mkNamingAdapt(iPriority, "Priority", 0));
    const StdBitfieldEntry<int32_t> TriggerModeNames[] =
    {
        { "Default",      CTM_Default  },
        { "Hold",         CTM_Hold     },
        { "Release",      CTM_Release  },
        { "AlwaysUnhandled", CTM_AlwaysUnhandled  },
        { "ClearRecentKeys", CTM_ClearRecentKeys  },
        { nullptr, 0 }
    };
    pComp->Value(mkNamingAdapt(mkBitfieldAdapt< int32_t>(iTriggerMode, TriggerModeNames), "TriggerMode", CTM_Default));
    pComp->Value(mkNamingAdapt(fOverrideAssignments, "OverrideAssignments", false));
    pComp->NameEnd();
    // newly loaded structures are not resolved
    if (pComp->isDeserializer()) fRefsResolved = false;
}

References CTM_AlwaysUnhandled, CTM_ClearRecentKeys, CTM_Default, CTM_Hold, CTM_Release, StdCompiler::excNotFound(), StdCompiler::isDeserializer(), mkNamingAdapt(), mkParAdapt(), mkSTLContainerAdapt(), StdCompiler::Name(), StdCompiler::NameEnd(), StdCompiler::RCT_All, StdCompiler::RCT_Idtf, and StdCompiler::Value().

Here is the call graph for this function:

CopyKeyFrom()

void C4PlayerControlAssignment::CopyKeyFrom

(

const C4PlayerControlAssignment &

src_assignment

)

Definition at line 257 of file C4PlayerControl.cpp.

{
    // just copy key settings; keep control and priorities
    KeyCombo = src_assignment.KeyCombo;
    TriggerKey = src_assignment.TriggerKey;
    fComboIsSequence = src_assignment.fComboIsSequence;
    if (!src_assignment.fRefsResolved) fRefsResolved = false;
}

Referenced by ResetKeyToInherited().

Here is the caller graph for this function:

GetControl()

int32_t C4PlayerControlAssignment::GetControl ( ) const

inline

Definition at line 209 of file C4PlayerControl.h.

{ return iControl; }

Referenced by GetGUIDesc(), and GetGUIName().

Here is the caller graph for this function:

GetControlName()

const char* C4PlayerControlAssignment::GetControlName ( ) const

inline

Definition at line 208 of file C4PlayerControl.h.

{ return sControlName.getData(); }

References StdStrBuf::getData().

Referenced by ResolveRefs().

Here is the call graph for this function:

Here is the caller graph for this function:

GetGUIDesc()

const char * C4PlayerControlAssignment::GetGUIDesc

(

const C4PlayerControlDefs &

defs

)

const

Definition at line 456 of file C4PlayerControl.cpp.

{
    // local desc?
    if (sGUIDesc.getLength()) return sGUIDesc.getData();
    // otherwise, fall back to def
    const C4PlayerControlDef *def = defs.GetControlByIndex(GetControl());
    if (def) return def->GetGUIDesc();
    // no def and no desc...
    return nullptr;
}

References GetControl(), C4PlayerControlDefs::GetControlByIndex(), StdStrBuf::getData(), C4PlayerControlDef::GetGUIDesc(), and StdStrBuf::getLength().

Here is the call graph for this function:

GetGUIGroup()

int32_t C4PlayerControlAssignment::GetGUIGroup

(

)

const

Definition at line 472 of file C4PlayerControl.cpp.

{
    return iGUIGroup;
}

GetGUIName()

const char * C4PlayerControlAssignment::GetGUIName

(

const C4PlayerControlDefs &

defs

)

const

Definition at line 440 of file C4PlayerControl.cpp.

{
    // local name?
    if (sGUIName.getLength())
    {
        // special: None defaults to empty name
        if (sGUIName == "None") return "";
        return sGUIName.getData();
    }
    // otherwise, fall back to def
    const C4PlayerControlDef *def = defs.GetControlByIndex(GetControl());
    if (def) return def->GetGUIName();
    // no def and no name...
    return nullptr;
}

References GetControl(), C4PlayerControlDefs::GetControlByIndex(), StdStrBuf::getData(), C4PlayerControlDef::GetGUIName(), and StdStrBuf::getLength().

Here is the call graph for this function:

GetInheritedAssignment()

const C4PlayerControlAssignment* C4PlayerControlAssignment::GetInheritedAssignment ( ) const

inline

Definition at line 222 of file C4PlayerControl.h.

{ return inherited_assignment; }

GetKeysAsString()

StdStrBuf C4PlayerControlAssignment::GetKeysAsString	(	bool	human_readable,
		bool	short_name
	)		const

Definition at line 422 of file C4PlayerControl.cpp.

{
    // create a short, human-readable string of the assigned key
    // to be displayed e.g. in tutorial messages explaining controls
    StdStrBuf result;
    if (!KeyCombo.size()) return result;
    // trigger key
    KeyComboVec::const_iterator i=KeyCombo.begin();
    result.Take(i->Key.ToString(human_readable, short_name));
    // extra keys of combo
    while (++i != KeyCombo.end())
    {
        result.AppendChar(fComboIsSequence ? ',' : '+');
        result.Append(i->Key.ToString(human_readable, short_name));
    }
    return result;
}

References StdStrBuf::Append(), StdStrBuf::AppendChar(), and StdStrBuf::Take().

Here is the call graph for this function:

GetTriggerKey()

const C4KeyCodeEx& C4PlayerControlAssignment::GetTriggerKey ( ) const

inline

Definition at line 218 of file C4PlayerControl.h.

{ return TriggerKey; }

GetTriggerMode()

int32_t C4PlayerControlAssignment::GetTriggerMode ( ) const

inline

Definition at line 217 of file C4PlayerControl.h.

{ return iTriggerMode; }

HasCombo()

bool C4PlayerControlAssignment::HasCombo ( ) const

inline

Definition at line 219 of file C4PlayerControl.h.

{ return KeyCombo.size()>1; }

Referenced by IsComboMatched().

Here is the caller graph for this function:

IsAlwaysUnhandled()

bool C4PlayerControlAssignment::IsAlwaysUnhandled ( ) const

inline

Definition at line 216 of file C4PlayerControl.h.

{ return !!(iTriggerMode & CTM_AlwaysUnhandled); }

References CTM_AlwaysUnhandled.

IsComboMatched()

bool C4PlayerControlAssignment::IsComboMatched	(	const C4PlayerControlRecentKeyList &	DownKeys,
		const C4PlayerControlRecentKeyList &	RecentKeys
	)		const

Definition at line 363 of file C4PlayerControl.cpp.

{
    assert(HasCombo());
    // check if combo is currently fulfilled (assuming TriggerKey is already matched)
    if (fComboIsSequence)
    {
        C4TimeMilliseconds tKeyLast = C4TimeMilliseconds::Now();
        // combo is a sequence: The last keys of RecentKeys must match the sequence
        // the last ComboKey is the TriggerKey, which is omitted because it has already been matched and is not to be found in RecentKeys yet
        auto i = KeyCombo.rbegin()+1;
        for (auto ri = RecentKeys.rbegin(); i!=KeyCombo.rend(); ++ri)
        {
            // no more keys pressed but combo didn't end? -> no combo match
            if (ri == RecentKeys.rend()) return false;
            const C4PlayerControlRecentKey &rk = *ri;
            // user waited for too long?
            C4TimeMilliseconds tKeyRecent = rk.tTime;
            if (tKeyLast - tKeyRecent > C4PlayerControl::MaxSequenceKeyDelay) return false;
            // key doesn't match?
            const KeyComboItem &k = *i;
            if (!(rk.matched_key == k.Key))
            {
                // mouse movement commands do not break sequences
                if (Key_IsMouse(rk.matched_key.Key) && Key_GetMouseEvent(rk.matched_key.Key) == KEY_MOUSE_Move) continue;
                return false;
            }
            // key OK
            ++i;
        }
    }
    else
    {
        // combo requires keys to be down simultanuously: check that all keys of the combo are in the down-list
        for (const auto & k : KeyCombo)
        {
            bool fFound = false;
            for (const auto & dk : DownKeys)
            {
                if (dk.matched_key == k.Key) { fFound = true; break; }
            }
            if (!fFound) return false;
        }
    }
    // combo OK!
    return true;
}

References HasCombo(), C4KeyCodeEx::Key, Key_GetMouseEvent(), Key_IsMouse(), KEY_MOUSE_Move, C4PlayerControlRecentKey::matched_key, C4PlayerControl::MaxSequenceKeyDelay, C4TimeMilliseconds::Now(), and C4PlayerControlRecentKey::tTime.

Here is the call graph for this function:

IsGUIDisabled()

bool C4PlayerControlAssignment::IsGUIDisabled

(

)

const

Definition at line 467 of file C4PlayerControl.cpp.

{
    return fGUIDisabled;
}

IsInherited()

bool C4PlayerControlAssignment::IsInherited ( ) const

inline

Definition at line 221 of file C4PlayerControl.h.

{ return is_inherited; }

IsKeyChanged()

bool C4PlayerControlAssignment::IsKeyChanged

(

)

const

Definition at line 238 of file C4PlayerControl.cpp.

{
    // no inherited assignment? Then the key is always custom
    if (!inherited_assignment) return true;
    // otherwise, compare
    return KeyCombo != inherited_assignment->KeyCombo || fComboIsSequence != inherited_assignment->fComboIsSequence;
}

IsOverrideAssignments()

bool C4PlayerControlAssignment::IsOverrideAssignments ( ) const

inline

Definition at line 220 of file C4PlayerControl.h.

{ return fOverrideAssignments; }

IsRefsResolved()

bool C4PlayerControlAssignment::IsRefsResolved ( ) const

inline

Definition at line 214 of file C4PlayerControl.h.

{ return fRefsResolved; }

Referenced by ResolveRefs().

Here is the caller graph for this function:

operator<()

bool C4PlayerControlAssignment::operator< ( const C4PlayerControlAssignment &  cmp ) const

inline

Definition at line 207 of file C4PlayerControl.h.

{ return iPriority > cmp.iPriority; } // assignments are processed in DESCENDING priority!

operator==()

bool C4PlayerControlAssignment::operator==

(

const C4PlayerControlAssignment &

cmp

)

const

Definition at line 410 of file C4PlayerControl.cpp.

{
    // doesn't compare resolved TriggerKey/iControl
    return KeyCombo == cmp.KeyCombo
           && sControlName == cmp.sControlName
           && sGUIName == cmp.sGUIName
           && sGUIDesc == cmp.sGUIDesc
           && fGUIDisabled == cmp.fGUIDisabled
           && iTriggerMode == cmp.iTriggerMode
           && iPriority == cmp.iPriority;
}

ResetKeyToInherited()

void C4PlayerControlAssignment::ResetKeyToInherited

(

)

Definition at line 233 of file C4PlayerControl.cpp.

{
    if (inherited_assignment) CopyKeyFrom(*inherited_assignment);
}

References CopyKeyFrom().

Here is the call graph for this function:

ResetRefsResolved()

void C4PlayerControlAssignment::ResetRefsResolved ( )

inline

Definition at line 215 of file C4PlayerControl.h.

{ fRefsResolved = false; } // Mark references to other assignments as not resolved

ResolveRefs()

bool C4PlayerControlAssignment::ResolveRefs	(	class C4PlayerControlAssignmentSet *	pParentSet,
		C4PlayerControlDefs *	pControlDefs
	)

Definition at line 266 of file C4PlayerControl.cpp.

{
    // avoid circular chains
    static int32_t recursion_check = 0;
    if (recursion_check > 10)
    {
        LogFatal(FormatString("Maximum recursion limit reached while resolving player control assignments of set %s in assignment for key %s. This is probably due to a circular control chain.", pParentSet->GetName(), GetControlName()).getData());
        return false;
    }
    ++recursion_check;
    // resolve control name
    iControl = pControlDefs->GetControlIndexByIdentifier(sControlName.getData());
    // resolve keys
    KeyComboVec NewCombo;
    for (auto & rKeyComboItem : KeyCombo)
    {
        const char *szKeyName = rKeyComboItem.sKeyName.getData();
        // check if this is a key reference. A key reference must be preceded by CON_
        // it may also be preceded by modifiers (Shift+), which are already set in rKeyComboItem.Key.dwShift
        bool is_key_reference = false;
        int last_shift_delim_pos;
        if (szKeyName && *szKeyName)
        {
            if ((last_shift_delim_pos=SCharLastPos('+', szKeyName)) > -1) szKeyName += last_shift_delim_pos+1;
            if (SEqual2(szKeyName, "CON_"))
            {
                is_key_reference = true;
                szKeyName +=4;
            }
        }
        if (is_key_reference)
        {
            // this is a key reference
            // - find referenced target assignment
            C4PlayerControlAssignment *pRefAssignment = pParentSet->GetAssignmentByControlName(szKeyName);
            if (pRefAssignment)
            {
                // resolve itself if necessary
                if (!pRefAssignment->IsRefsResolved()) if (!pRefAssignment->ResolveRefs(pParentSet, pControlDefs)) { --recursion_check; return false; }
                // insert all keys of that combo into own combo
                // add any extra shift states from reference
                DWORD ref_shift = rKeyComboItem.Key.dwShift;
                if (ref_shift)
                {
                    for (auto assignment_combo_item : pRefAssignment->KeyCombo)
                    {
                        assignment_combo_item.Key.dwShift |= ref_shift;
                        NewCombo.push_back(assignment_combo_item);
                    }
                }
                else
                {
                    NewCombo.insert(NewCombo.end(), pRefAssignment->KeyCombo.begin(), pRefAssignment->KeyCombo.end());
                }
            }
            else
            {
                // undefined reference? Not fatal, but inform user
                LogF("WARNING: Control %s of set %s contains reference to unassigned control %s.", GetControlName(), pParentSet->GetName(), rKeyComboItem.sKeyName.getData());
                NewCombo.clear();
            }
        }
        else
        {
            // non-reference: check if the assignment was valid
#ifndef USE_CONSOLE
            if (rKeyComboItem.Key == KEY_Default)
                LogF(R"(WARNING: Control %s of set %s contains undefined key "%s".)", GetControlName(), pParentSet->GetName(), szKeyName);
#endif
            // ...and just keep this item.
            NewCombo.push_back(rKeyComboItem);
        }
    }
    KeyCombo = NewCombo;
    // adjust Control and Shift into key states for non-sequence combo keys
    // e.g. LeftControl,A should become LeftControl,Ctrl+A.
    if (KeyCombo.size() > 1 && !fComboIsSequence)
    {
        int32_t shift = 0;
        for (auto & i : KeyCombo)
        {
            if (i.Key.Key == K_CONTROL_L || i.Key.Key == K_CONTROL_R) shift |= KEYS_Control;
            if (i.Key.Key == K_SHIFT_L || i.Key.Key == K_SHIFT_R) shift |= KEYS_Shift;
            shift |= i.Key.dwShift;
        }
        for (auto & i : KeyCombo) i.Key.dwShift |= shift;
    }
    // remove control/shift duplications
    for (auto & i : KeyCombo) i.Key.FixShiftKeys();
    // the trigger key is always last of the chain
    if (KeyCombo.size()) TriggerKey = KeyCombo.back().Key; else TriggerKey = C4KeyCodeEx();
    // done
    fRefsResolved = true;
    --recursion_check;
    return true;
}

References FormatString(), C4PlayerControlAssignmentSet::GetAssignmentByControlName(), C4PlayerControlDefs::GetControlIndexByIdentifier(), GetControlName(), StdStrBuf::getData(), C4PlayerControlAssignmentSet::GetName(), IsRefsResolved(), C4KeyCodeEx::Key, KEY_Default, KEYS_Control, KEYS_Shift, LogF(), LogFatal(), ResolveRefs(), SCharLastPos(), and SEqual2().

Referenced by ResolveRefs().

Here is the call graph for this function:

Here is the caller graph for this function:

SetControlName()

void C4PlayerControlAssignment::SetControlName ( const char *  control_name )

inline

Definition at line 203 of file C4PlayerControl.h.

{ sControlName.Copy(control_name); }

References StdStrBuf::Copy().

Here is the call graph for this function:

SetInherited()

void C4PlayerControlAssignment::SetInherited ( bool  to_val )

inline

Definition at line 199 of file C4PlayerControl.h.

{ is_inherited = to_val; }

SetInheritedAssignment()

void C4PlayerControlAssignment::SetInheritedAssignment ( const C4PlayerControlAssignment *  to_val )

inline

Definition at line 200 of file C4PlayerControl.h.

{ inherited_assignment = to_val; }

SetKey()

void C4PlayerControlAssignment::SetKey

(

const C4KeyCodeEx &

key

)

Definition at line 246 of file C4PlayerControl.cpp.

{
    // set as one-key-combo
    KeyCombo.resize(1);
    KeyCombo[0].Key = key;
    KeyCombo[0].Key.fRepeated = false;
    KeyCombo[0].sKeyName.Clear();
    fComboIsSequence = false;
    TriggerKey = key;
}

---

The documentation for this class was generated from the following files:

• C4PlayerControl.h
• C4PlayerControl.cpp