Skip to content

Commit c7ab72e

Browse files
ArKaNeMaNArKaNeMaN
committed
Some refactors
1 parent d440a10 commit c7ab72e

7 files changed

Lines changed: 117 additions & 124 deletions

File tree

‎amxmodx/scripting/VipM/Core/Objects/Limits/Type.inc‎

Lines changed: 26 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -149,36 +149,36 @@ Trie:LimitType_ReadParams(const T_LimitType:type, const JSON:paramsJson) {
149149

150150
LimitType_SetEventListener(
151151
const T_LimitType:type,
152-
const E_LimitEvent:iEvent,
153-
const PluginId,
154-
const sFuncName[]
152+
const E_LimitEvent:event,
153+
const pluginIndex,
154+
const func[]
155155
) {
156156
new typeObject[S_LimitType];
157157
LimitType__Get(type, typeObject);
158158

159-
if (typeObject[LimitType_Events][iEvent] >= 0) {
160-
DestroyForward(typeObject[LimitType_Events][iEvent]);
159+
if (typeObject[LimitType_Events][event] >= 0) {
160+
DestroyForward(typeObject[LimitType_Events][event]);
161161
}
162162

163-
typeObject[LimitType_Events][iEvent] = LimitType__MakeEventForward(iEvent, PluginId, sFuncName);
163+
typeObject[LimitType_Events][event] = LimitType__MakeEventForward(event, pluginIndex, func);
164164

165-
if (typeObject[LimitType_Events][iEvent] < 0) {
166-
abort(AMX_ERR_PARAMS, "[ERROR] Can't create forward for func '%s' in plugin #%d.", sFuncName, PluginId);
165+
if (typeObject[LimitType_Events][event] < 0) {
166+
abort(AMX_ERR_PARAMS, "[ERROR] Can't create forward for func '%s' in plugin #%d.", func, pluginIndex);
167167
}
168168

169169
LimitType__Set(typeObject);
170170
}
171171

172-
static LimitType__MakeEventForward(const E_LimitEvent:iEvent, const PluginId, const sFuncName[]) {
173-
switch (iEvent) {
174-
case Limit_OnRead: // (const JSON:jCfg, Trie:tParams)
175-
return CreateOneForward(PluginId, sFuncName, FP_CELL, FP_CELL);
172+
static LimitType__MakeEventForward(const E_LimitEvent:event, const pluginIndex, const func[]) {
173+
switch (event) {
174+
case Limit_OnRead: // (const JSON:jCfg, Trie:p)
175+
return CreateOneForward(pluginIndex, func, FP_CELL, FP_CELL);
176176

177-
case Limit_OnCheck: // (const Trie:tParams, const UserId)
178-
return CreateOneForward(PluginId, sFuncName, FP_CELL, FP_CELL);
177+
case Limit_OnCheck: // (const Trie:p, const playerIndex)
178+
return CreateOneForward(pluginIndex, func, FP_CELL, FP_CELL);
179179
}
180180

181-
abort(AMX_ERR_GENERAL, "[ERROR] Invalid event index (%d).", iEvent);
181+
abort(AMX_ERR_GENERAL, "[ERROR] Invalid event index (%d).", event);
182182
return -1;
183183
}
184184

@@ -189,7 +189,7 @@ bool:LimitType_IsStatic(const T_LimitType:type) {
189189
return typeObject[LimitType_Static];
190190
}
191191

192-
LimitType_SetStaticValue(const T_LimitType:type, const bool:bValue, const UserId = 0) {
192+
LimitType_SetStaticValue(const T_LimitType:type, const bool:value, const playerIndex = 0) {
193193
new typeObject[S_LimitType];
194194
LimitType__Get(type, typeObject);
195195

@@ -198,36 +198,36 @@ LimitType_SetStaticValue(const T_LimitType:type, const bool:bValue, const UserId
198198
return;
199199
}
200200

201-
if (UserId > 0) {
202-
BitSetIf(typeObject[LimitType_StaticValue], UserId - 1, bValue);
201+
if (playerIndex > 0) {
202+
BitSetIf(typeObject[LimitType_StaticValue], playerIndex - 1, value);
203203
} else {
204-
typeObject[LimitType_StaticValue] = bValue;
204+
typeObject[LimitType_StaticValue] = value;
205205
}
206206

207207
LimitType__Set(typeObject);
208208
}
209209

210-
bool:LimitType_Execute(const T_LimitType:type, const Trie:tParams, const UserId = 0) {
210+
bool:LimitType_Execute(const T_LimitType:type, const Trie:p, const playerIndex = 0) {
211211
new typeObject[S_LimitType];
212212
LimitType__Get(type, typeObject);
213213

214-
new bool:bRes = false;
214+
new bool:res = false;
215215
if (typeObject[LimitType_Static]) {
216216
if (typeObject[LimitType_ForPlayer]) {
217-
bRes = BitIs(typeObject[LimitType_StaticValue], UserId - 1);
217+
res = BitIs(typeObject[LimitType_StaticValue], playerIndex - 1);
218218
} else {
219-
bRes = !!typeObject[LimitType_StaticValue];
219+
res = !!typeObject[LimitType_StaticValue];
220220
}
221221
} else {
222222
if (typeObject[LimitType_Events][Limit_OnCheck] < 0) {
223223
abort(AMX_ERR_GENERAL, "'Limit_OnCheck' event listener for non-static limit type '%s' must be implemented.", typeObject[LimitType_Name]);
224-
bRes = false;
224+
res = false;
225225
} else {
226-
ExecuteForward(typeObject[LimitType_Events][Limit_OnCheck], bRes, tParams, UserId);
226+
ExecuteForward(typeObject[LimitType_Events][Limit_OnCheck], res, p, playerIndex);
227227
}
228228
}
229229

230-
return bRes;
230+
return res;
231231
}
232232

233233
T_LimitType:PCSingle_ObjVipmLimitType(const JSON:objectJson, const key[], const T_LimitType:def = Invalid_LimitType, const bool:dotNot = false, const bool:orFail = false) {

‎amxmodx/scripting/VipM/Core/Objects/Limits/Unit.inc‎

Lines changed: 27 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -18,48 +18,48 @@ enum _:S_LimitUnit {
1818
Trie:LimitUnit_Params,
1919
}
2020

21-
static Array:g_aLimitUnits = Invalid_Array;
21+
static Array:LimitUnits = Invalid_Array;
2222

2323
LimitUnit_Init() {
2424
CallOnce();
2525
log_amx("Init limit units...");
2626

2727
LimitType_Init();
2828

29-
g_aLimitUnits = ArrayCreate(S_LimitUnit, 1);
29+
LimitUnits = ArrayCreate(S_LimitUnit, 1);
3030

3131
Forwards_RegAndCall("VipM_Limits_OnInited", ET_IGNORE);
3232
log_amx("Limit units inited.");
3333
}
3434

3535
LimitUnit_GetCount() {
36-
return ArraySizeSafe(g_aLimitUnits);
36+
return ArraySizeSafe(LimitUnits);
3737
}
3838

39-
static T_LimitUnit:LimitUnit__Construct(const T_LimitType:iLimitType, const Trie:params) {
40-
if (g_aLimitUnits == Invalid_Array) {
39+
static T_LimitUnit:LimitUnit__Construct(const T_LimitType:type, const Trie:p) {
40+
if (LimitUnits == Invalid_Array) {
4141
abort(AMX_ERR_GENERAL, "Attempt to create limit unit before init.");
4242
return Invalid_LimitUnit;
4343
}
4444

45-
new LimitUnit[S_LimitUnit];
45+
new unitObject[S_LimitUnit];
4646

47-
LimitUnit[LimitUnit_Type] = iLimitType;
48-
LimitUnit[LimitUnit_Params] = params;
47+
unitObject[LimitUnit_Type] = type;
48+
unitObject[LimitUnit_Params] = p;
4949

50-
return T_LimitUnit:ArrayPushArray(g_aLimitUnits, LimitUnit);
50+
return T_LimitUnit:ArrayPushArray(LimitUnits, unitObject);
5151
}
5252

53-
static bool:LimitUnit__Get(const T_LimitUnit:iLimitUnit, LimitUnit[S_LimitUnit], const bool:bOrFail = true) {
54-
if (_:iLimitUnit < 0 || _:iLimitUnit >= LimitUnit_GetCount()) {
55-
if (bOrFail) {
56-
abort(AMX_ERR_NOTFOUND, "Invalid limit unit index (%d).", iLimitUnit);
53+
static bool:LimitUnit__Get(const T_LimitUnit:limit, unitObject[S_LimitUnit], const bool:orFail = true) {
54+
if (_:limit < 0 || _:limit >= LimitUnit_GetCount()) {
55+
if (orFail) {
56+
abort(AMX_ERR_NOTFOUND, "Invalid limit unit index (%d).", limit);
5757
}
5858

5959
return false;
6060
}
6161

62-
ArrayGetArray(g_aLimitUnits, _:iLimitUnit, LimitUnit);
62+
ArrayGetArray(LimitUnits, _:limit, unitObject);
6363
return true;
6464
}
6565

@@ -78,16 +78,16 @@ T_LimitUnit:LimitUnit_Read(const JSON:valueJson) {
7878
return Invalid_LimitUnit;
7979
}
8080

81-
new Trie:params = Invalid_Trie;
81+
new Trie:p = Invalid_Trie;
8282
if (!LimitType_IsStatic(type)) {
83-
params = LimitType_ReadParams(type, linked);
84-
if (params == Invalid_Trie) {
83+
p = LimitType_ReadParams(type, linked);
84+
if (p == Invalid_Trie) {
8585
PCJson_FreeLinked(linked);
8686
return Invalid_LimitUnit;
8787
}
8888
}
8989

90-
cached = LimitUnit__Construct(type, params);
90+
cached = LimitUnit__Construct(type, p);
9191
if (linkPath[0] != EOS && cached != Invalid_LimitUnit) {
9292
TrieSetCell(cache, linkPath, cached);
9393
}
@@ -96,31 +96,31 @@ T_LimitUnit:LimitUnit_Read(const JSON:valueJson) {
9696
return cached;
9797
}
9898

99-
Array:LimitUnit_ReadList(const JSON:limitsJson, &Array:limits = Invalid_Array) {
100-
if (limits == Invalid_Array) {
101-
limits = ArrayCreate(1, 1);
99+
Array:LimitUnit_ReadList(const JSON:limitsJson, &Array:append = Invalid_Array) {
100+
if (append == Invalid_Array) {
101+
append = ArrayCreate(1, 1);
102102
}
103103

104104
if (!json_is_array(limitsJson)) {
105105
new T_LimitUnit:limit = LimitUnit_Read(limitsJson);
106106
if (limit != Invalid_LimitUnit) {
107-
ArrayPushCell(limits, limit);
107+
ArrayPushCell(append, limit);
108108
}
109109
} else {
110110
json_array_foreach_value (limitsJson: i => limitJson) {
111-
limits = LimitUnit_ReadList(limitJson, limits);
111+
append = LimitUnit_ReadList(limitJson, append);
112112
json_free(limitJson);
113113
}
114114
}
115115

116-
return limits;
116+
return append;
117117
}
118118

119119
bool:LimitUnit_Execute(const T_LimitUnit:limit, const UserId = 0) {
120-
new LimitUnit[S_LimitUnit];
121-
LimitUnit__Get(limit, LimitUnit);
120+
new unitObject[S_LimitUnit];
121+
LimitUnit__Get(limit, unitObject);
122122

123-
return LimitType_Execute(LimitUnit[LimitUnit_Type], LimitUnit[LimitUnit_Params], UserId);
123+
return LimitType_Execute(unitObject[LimitUnit_Type], unitObject[LimitUnit_Params], UserId);
124124
}
125125

126126
bool:LimitUnit_ExecuteList(

‎amxmodx/scripting/VipM/Core/Objects/Modules/Type.inc‎

Lines changed: 4 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -173,11 +173,6 @@ ModuleType_SetEventListener(
173173
new typeObject[S_ModuleType];
174174
ModuleType__Get(type, typeObject);
175175

176-
if (event == Module_OnCompareParams) {
177-
log_amx("[WARNING] Event 'Module_OnCompareParams' is deprecated and will not be fired.");
178-
return;
179-
}
180-
181176
if (typeObject[ModuleType_Events][event] >= 0) {
182177
DestroyForward(typeObject[ModuleType_Events][event]);
183178
}
@@ -257,3 +252,7 @@ Trie:ModuleType_MergeParams(const T_ModuleType:type, const Trie:tParams1, const
257252

258253
return tRes;
259254
}
255+
256+
T_ModuleType:PCSingle_ObjVipmModuleType(const JSON:objectJson, const key[], const T_ModuleType:def = Invalid_ModuleType, const bool:dotNot = false, const bool:orFail = false) {
257+
return PCSingle_ObjCell(objectJson, key, VIPM_PARAM_TYPE_MODULE_TYPE_NAME, def, dotNot, orFail);
258+
}

‎amxmodx/scripting/VipM/Core/Objects/Modules/Unit.inc‎

Lines changed: 18 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -18,66 +18,42 @@ enum _:S_ModuleUnit {
1818
Trie:ModuleUnit_Params,
1919
}
2020

21-
static Array:g_aModuleUnits = Invalid_Array;
21+
static Array:ModuleUnits = Invalid_Array;
2222

2323
ModuleUnit_Init() {
2424
CallOnce();
2525
log_amx("Init module units...");
2626

2727
ModuleType_Init();
2828

29-
g_aModuleUnits = ArrayCreate(S_ModuleUnit, 1);
29+
ModuleUnits = ArrayCreate(S_ModuleUnit, 1);
3030

3131
Forwards_RegAndCall("VipM_Modules_OnInited", ET_IGNORE);
3232
log_amx("Module units inited.");
3333
}
3434

3535
ModuleUnit_GetCount() {
36-
return ArraySizeSafe(g_aModuleUnits);
36+
return ArraySizeSafe(ModuleUnits);
3737
}
3838

39-
static T_ModuleUnit:ModuleUnit__Construct(const T_ModuleType:iModuleType, const Trie:tParams) {
40-
if (g_aModuleUnits == Invalid_Array) {
39+
static T_ModuleUnit:ModuleUnit__Construct(const T_ModuleType:type, const Trie:p) {
40+
if (ModuleUnits == Invalid_Array) {
4141
abort(AMX_ERR_GENERAL, "Attempt to create module unit before init.");
4242
return Invalid_ModuleUnit;
4343
}
4444

45-
new ModuleUnit[S_ModuleUnit];
45+
new unitObject[S_ModuleUnit];
4646

47-
ModuleUnit[ModuleUnit_Type] = iModuleType;
48-
ModuleUnit[ModuleUnit_Params] = tParams;
47+
unitObject[ModuleUnit_Type] = type;
48+
unitObject[ModuleUnit_Params] = p;
4949

50-
ModuleType_MarkAsUsed(iModuleType);
50+
ModuleType_MarkAsUsed(type);
5151

52-
return T_ModuleUnit:ArrayPushArray(g_aModuleUnits, ModuleUnit);
52+
return T_ModuleUnit:ArrayPushArray(ModuleUnits, unitObject);
5353
}
5454

55-
// static ModuleUnit__Get(const T_ModuleUnit:iModuleUnit, ModuleUnit[S_ModuleUnit]) {
56-
// ArrayGetArray(g_aModuleUnits, _:iModuleUnit, ModuleUnit);
57-
// }
58-
5955
static any:ModuleUnit__GetValue(const T_ModuleUnit:iModuleUnit, const iCell) {
60-
return ArrayGetCell(g_aModuleUnits, _:iModuleUnit, iCell);
61-
}
62-
63-
static T_ModuleType:ModuleUnit__ReadType(const JSON:jModuleUnit) {
64-
new sModuleTypeName[VIPM_MODULES_TYPE_NAME_MAX_LEN];
65-
PCSingle_ObjString(jModuleUnit, "Module", sModuleTypeName, charsmax(sModuleTypeName));
66-
trim(sModuleTypeName);
67-
68-
if (!sModuleTypeName[0]) {
69-
PCJson_ErrorForFile(jModuleUnit, "Module type name not specified.");
70-
return Invalid_ModuleType;
71-
}
72-
73-
new T_ModuleType:iModuleType = ModuleType_Find(sModuleTypeName);
74-
75-
if (iModuleType == Invalid_ModuleType) {
76-
PCJson_ErrorForFile(jModuleUnit, "Module type '%s' not found.", sModuleTypeName);
77-
return Invalid_ModuleType;
78-
}
79-
80-
return iModuleType;
56+
return ArrayGetCell(ModuleUnits, _:iModuleUnit, iCell);
8157
}
8258

8359
T_ModuleUnit:ModuleUnit_Read(const JSON:valueJson) {
@@ -89,7 +65,7 @@ T_ModuleUnit:ModuleUnit_Read(const JSON:valueJson) {
8965
return cached;
9066
}
9167

92-
new T_ModuleType:type = ModuleUnit__ReadType(linked);
68+
new T_ModuleType:type = PCSingle_ObjVipmModuleType(linked, "Module", .orFail = true);
9369
if (type == Invalid_ModuleType) {
9470
PCJson_FreeLinked(linked);
9571
return Invalid_ModuleUnit;
@@ -154,16 +130,16 @@ ModuleUnit_GetTypeName(const T_ModuleUnit:iModuleUnit, sOut[], const iOutLen) {
154130
// return sName;
155131
// }
156132

157-
Trie:ModuleUnit_FreeParamsIfTemp(&Trie:tParams) {
158-
if (tParams == Invalid_Trie) {
159-
return tParams;
133+
Trie:ModuleUnit_FreeParamsIfTemp(&Trie:p) {
134+
if (p == Invalid_Trie) {
135+
return p;
160136
}
161137

162-
if (TrieKeyExists(tParams, VIPM_MODULES_PARAMS_TEMP_MARK_KEY)) {
163-
TrieDestroy(tParams);
138+
if (TrieKeyExists(p, VIPM_MODULES_PARAMS_TEMP_MARK_KEY)) {
139+
TrieDestroy(p);
164140
}
165141

166-
return tParams;
142+
return p;
167143
}
168144

169145
Trie:ModuleUnit_Merge(const T_ModuleUnit:iModuleUnit, const Trie:tParams1, const Trie:tParams2) {

‎amxmodx/scripting/VipM/DefaultObjects/ParamType/ModuleType.inc‎

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
#include <amxmodx>
2+
#include <json>
3+
#include <ParamsController>
4+
#include <VipModular>
5+
6+
#include "VipM/Core/Objects/Modules/Type"
7+
8+
DefaultObjects_ParamType_ModuleType_Register() {
9+
ParamsController_RegSimpleType(VIPM_PARAM_TYPE_MODULE_TYPE_NAME, "@DefaultObjects_ParamType_ModuleType_OnRead");
10+
}
11+
12+
bool:@DefaultObjects_ParamType_ModuleType_OnRead(const JSON:valueJson) {
13+
new typeName[VIPM_MODULES_TYPE_NAME_MAX_LEN];
14+
PCSingle_ShortString(valueJson, typeName, charsmax(typeName));
15+
trim(typeName);
16+
17+
if (typeName[0] == EOS) {
18+
return PCJson_LogForFile(valueJson, "WARNING", "Module type name not specified.");
19+
}
20+
21+
new T_ModuleType:type = ModuleType_Find(typeName);
22+
if (type == Invalid_ModuleType) {
23+
return PCJson_LogForFile(valueJson, "WARNING", "Module type '%s' not found.", typeName);
24+
}
25+
26+
return ParamsController_SetCell(type);
27+
}

0 commit comments

Comments
 (0)