Parent Directory | Revision Log
Revision 44 - (view) (download)
1 : | ian | 1 | /* AMX Mod X misc. |
2 : | * | ||
3 : | * by the AMX Mod X Development Team | ||
4 : | * originally developed by OLO | ||
5 : | * | ||
6 : | * This file is provided as is (no warranties). | ||
7 : | */ | ||
8 : | |||
9 : | #if defined _amxmisc_included | ||
10 : | #endinput | ||
11 : | #endif | ||
12 : | #define _amxmisc_included | ||
13 : | |||
14 : | #if !defined _amxmodx_included | ||
15 : | #if defined AMXMOD_BCOMPAT | ||
16 : | #include <amxmod> | ||
17 : | #else | ||
18 : | #include <amxmodx> | ||
19 : | #endif | ||
20 : | #endif | ||
21 : | |||
22 : | #if defined AMXMOD_BCOMPAT | ||
23 : | #if defined _translator_included | ||
24 : | #define SIMPLE_T(%1) _T(%1) | ||
25 : | #else | ||
26 : | #define SIMPLE_T(%1) %1 | ||
27 : | #endif | ||
28 : | #endif | ||
29 : | |||
30 : | stock is_user_admin(id) | ||
31 : | { | ||
32 : | ian | 17 | new __flags=get_user_flags(id); |
33 : | return (__flags>0 && !(__flags&ADMIN_USER)); | ||
34 : | ian | 1 | } |
35 : | |||
36 : | ian | 17 | stock cmd_access(id, level, cid, num, bool:accesssilent = false) |
37 : | ian | 1 | { |
38 : | new has_access = 0; | ||
39 : | if ( id==(is_dedicated_server()?0:1) ) | ||
40 : | { | ||
41 : | has_access = 1; | ||
42 : | } | ||
43 : | else if ( level==ADMIN_ADMIN ) | ||
44 : | { | ||
45 : | if ( is_user_admin(id) ) | ||
46 : | { | ||
47 : | has_access = 1; | ||
48 : | } | ||
49 : | } | ||
50 : | else if ( get_user_flags(id) & level ) | ||
51 : | { | ||
52 : | has_access = 1; | ||
53 : | } | ||
54 : | else if (level == ADMIN_ALL) | ||
55 : | { | ||
56 : | has_access = 1; | ||
57 : | } | ||
58 : | |||
59 : | if ( has_access==0 ) | ||
60 : | { | ||
61 : | ian | 17 | if (!accesssilent) |
62 : | { | ||
63 : | ian | 1 | #if defined AMXMOD_BCOMPAT |
64 : | ian | 17 | console_print(id, SIMPLE_T("You have no access to that command.")); |
65 : | ian | 1 | #else |
66 : | ian | 17 | console_print(id,"%L",id,"NO_ACC_COM"); |
67 : | ian | 1 | #endif |
68 : | ian | 17 | } |
69 : | ian | 1 | return 0; |
70 : | } | ||
71 : | if (read_argc() < num) | ||
72 : | { | ||
73 : | new hcmd[32], hinfo[128], hflag; | ||
74 : | get_concmd(cid,hcmd,31,hflag,hinfo,127,level); | ||
75 : | #if defined AMXMOD_BCOMPAT | ||
76 : | console_print(id, SIMPLE_T("Usage: %s %s"), hcmd, SIMPLE_T(hinfo)); | ||
77 : | #else | ||
78 : | console_print(id,"%L: %s %s",id,"USAGE",hcmd,hinfo); | ||
79 : | #endif | ||
80 : | return 0; | ||
81 : | } | ||
82 : | |||
83 : | return 1; | ||
84 : | } | ||
85 : | |||
86 : | stock access(id,level) | ||
87 : | { | ||
88 : | ian | 17 | if (level==ADMIN_ADMIN) |
89 : | ian | 1 | { |
90 : | return is_user_admin(id); | ||
91 : | } | ||
92 : | ian | 17 | else if (level==ADMIN_ALL) |
93 : | { | ||
94 : | return 1; | ||
95 : | } | ||
96 : | ian | 1 | |
97 : | return (get_user_flags(id) & level); | ||
98 : | } | ||
99 : | |||
100 : | /* Flags: | ||
101 : | * 1 - obey immunity | ||
102 : | * 2 - allow yourself | ||
103 : | * 4 - must be alive | ||
104 : | * 8 - can't be bot */ | ||
105 : | ian | 17 | #define CMDTARGET_OBEY_IMMUNITY (1<<0) |
106 : | #define CMDTARGET_ALLOW_SELF (1<<1) | ||
107 : | #define CMDTARGET_ONLY_ALIVE (1<<2) | ||
108 : | #define CMDTARGET_NO_BOTS (1<<3) | ||
109 : | stock cmd_target(id,const arg[],flags = CMDTARGET_OBEY_IMMUNITY) | ||
110 : | ian | 1 | { |
111 : | new player = find_player("bl",arg); | ||
112 : | if (player) | ||
113 : | { | ||
114 : | if ( player != find_player("blj",arg) ) | ||
115 : | { | ||
116 : | #if defined AMXMOD_BCOMPAT | ||
117 : | console_print(id, SIMPLE_T("There are more clients matching to your argument")); | ||
118 : | #else | ||
119 : | console_print(id,"%L",id,"MORE_CL_MATCHT"); | ||
120 : | #endif | ||
121 : | return 0; | ||
122 : | } | ||
123 : | } | ||
124 : | else if ( ( player = find_player("c",arg) )==0 && arg[0]=='#' && arg[1] ) | ||
125 : | { | ||
126 : | player = find_player("k",str_to_num(arg[1])); | ||
127 : | } | ||
128 : | if (!player) | ||
129 : | { | ||
130 : | #if defined AMXMOD_BCOMPAT | ||
131 : | console_print(id, SIMPLE_T("Client with that name or userid not found")); | ||
132 : | #else | ||
133 : | console_print(id,"%L",id,"CL_NOT_FOUND"); | ||
134 : | #endif | ||
135 : | return 0; | ||
136 : | } | ||
137 : | ian | 17 | if (flags & CMDTARGET_OBEY_IMMUNITY) |
138 : | ian | 1 | { |
139 : | ian | 17 | if ((get_user_flags(player) & ADMIN_IMMUNITY) && |
140 : | ((flags & CMDTARGET_ALLOW_SELF) ? (id != player) : true) ) | ||
141 : | ian | 1 | { |
142 : | new imname[32]; | ||
143 : | get_user_name(player,imname,31); | ||
144 : | #if defined AMXMOD_BCOMPAT | ||
145 : | console_print(id, SIMPLE_T("Client ^"%s^" has immunity"), imname); | ||
146 : | #else | ||
147 : | console_print(id,"%L",id,"CLIENT_IMM",imname); | ||
148 : | #endif | ||
149 : | return 0; | ||
150 : | } | ||
151 : | } | ||
152 : | ian | 17 | if (flags & CMDTARGET_ONLY_ALIVE) |
153 : | ian | 1 | { |
154 : | if (!is_user_alive(player)) | ||
155 : | { | ||
156 : | new imname[32]; | ||
157 : | get_user_name(player,imname,31); | ||
158 : | #if defined AMXMOD_BCOMPAT | ||
159 : | console_print(id, SIMPLE_T("That action can't be performed on dead client ^"%s^""), imname); | ||
160 : | #else | ||
161 : | console_print(id,"%L",id,"CANT_PERF_DEAD",imname); | ||
162 : | #endif | ||
163 : | return 0; | ||
164 : | } | ||
165 : | } | ||
166 : | ian | 17 | if (flags & CMDTARGET_NO_BOTS) |
167 : | ian | 1 | { |
168 : | if (is_user_bot(player)) | ||
169 : | { | ||
170 : | new imname[32]; | ||
171 : | get_user_name(player,imname,31); | ||
172 : | #if defined AMXMOD_BCOMPAT | ||
173 : | console_print(id, SIMPLE_T("That action can't be performed on bot ^"%s^""), imname); | ||
174 : | #else | ||
175 : | console_print(id,"%L",id,"CANT_PERF_BOT",imname); | ||
176 : | #endif | ||
177 : | return 0; | ||
178 : | } | ||
179 : | } | ||
180 : | return player; | ||
181 : | } | ||
182 : | |||
183 : | ian | 17 | /** |
184 : | * Standard method to show activity to clients connected to the server. | ||
185 : | * This depends on the amx_show_activity cvar. See documentation for more details. | ||
186 : | * | ||
187 : | * @param id The user id of the person doing the action. | ||
188 : | * @param name The name of the person doing the action. | ||
189 : | * @param fmt The format string to display. Do not put the "ADMIN:" prefix in this. | ||
190 : | */ | ||
191 : | stock show_activity( id, const name[], const fmt[], any:... ) | ||
192 : | ian | 1 | { |
193 : | ian | 17 | static __amx_show_activity; |
194 : | if (__amx_show_activity == 0) | ||
195 : | { | ||
196 : | __amx_show_activity = get_cvar_pointer("amx_show_activity"); | ||
197 : | |||
198 : | // if still not found, then register the cvar as a dummy | ||
199 : | if (__amx_show_activity == 0) | ||
200 : | { | ||
201 : | __amx_show_activity = register_cvar("amx_show_activity", "2"); | ||
202 : | } | ||
203 : | } | ||
204 : | #if defined AMXMOD_BCOMPAT | ||
205 : | ian | 1 | new buffer[128]; |
206 : | format_args( buffer , 127 , 2 ); | ||
207 : | ian | 17 | #else |
208 : | new prefix[10]; | ||
209 : | if (is_user_admin(id)) | ||
210 : | ian | 1 | { |
211 : | ian | 17 | copy(prefix, charsmax(prefix), "ADMIN"); |
212 : | } | ||
213 : | else | ||
214 : | { | ||
215 : | copy(prefix, charsmax(prefix), "PLAYER"); | ||
216 : | } | ||
217 : | new buffer[512]; | ||
218 : | ian | 44 | vformat(buffer, charsmax(buffer), fmt, 4); |
219 : | ian | 17 | #endif |
220 : | switch(get_pcvar_num(__amx_show_activity)) | ||
221 : | { | ||
222 : | ian | 1 | #if defined AMXMOD_BCOMPAT |
223 : | ian | 17 | case 2: // show name to all |
224 : | { | ||
225 : | ian | 1 | client_print(0, print_chat, "%s %s: %s", is_user_admin(id) ? SIMPLE_T("ADMIN") : SIMPLE_T("PLAYER"), name, buffer); |
226 : | ian | 17 | } |
227 : | case 1: // hide name to all | ||
228 : | { | ||
229 : | ian | 1 | client_print(0, print_chat, "%s: %s", is_user_admin(id) ? SIMPLE_T("ADMIN") : SIMPLE_T("PLAYER"), buffer); |
230 : | ian | 17 | } |
231 : | ian | 1 | #else |
232 : | ian | 17 | case 5: // hide name only to admins, show nothing to normal users |
233 : | { | ||
234 : | new __maxclients=get_maxplayers(); | ||
235 : | |||
236 : | |||
237 : | ian | 44 | for (new i=1; i<=__maxclients; i++) |
238 : | ian | 17 | { |
239 : | if (is_user_connected(i)) | ||
240 : | { | ||
241 : | if (is_user_admin(i)) | ||
242 : | { | ||
243 : | client_print(i, print_chat, "%L: %s", i, prefix, buffer); | ||
244 : | } | ||
245 : | } | ||
246 : | } | ||
247 : | } | ||
248 : | case 4: // show name only to admins, show nothing to normal users | ||
249 : | { | ||
250 : | new __maxclients=get_maxplayers(); | ||
251 : | |||
252 : | ian | 44 | for (new i=1; i<=__maxclients; i++) |
253 : | ian | 17 | { |
254 : | if (is_user_connected(i)) | ||
255 : | { | ||
256 : | if (is_user_admin(i)) | ||
257 : | { | ||
258 : | client_print(i, print_chat, "%L %s: %s", i, prefix, name, buffer); | ||
259 : | } | ||
260 : | } | ||
261 : | } | ||
262 : | } | ||
263 : | case 3: // show name only to admins, hide name from normal users | ||
264 : | { | ||
265 : | new __maxclients=get_maxplayers(); | ||
266 : | |||
267 : | ian | 44 | for (new i=1; i<=__maxclients; i++) |
268 : | ian | 17 | { |
269 : | if (is_user_connected(i)) | ||
270 : | { | ||
271 : | if (is_user_admin(i)) | ||
272 : | { | ||
273 : | client_print(i, print_chat, "%L %s: %s", i, prefix, name, buffer); | ||
274 : | } | ||
275 : | else | ||
276 : | { | ||
277 : | client_print(i, print_chat, "%L: %s", i, prefix, buffer); | ||
278 : | } | ||
279 : | } | ||
280 : | } | ||
281 : | } | ||
282 : | case 2: // show name to all | ||
283 : | { | ||
284 : | client_print(0, print_chat, "%L %s: %s", LANG_PLAYER, prefix , name , buffer ); | ||
285 : | } | ||
286 : | case 1: // hide name to all | ||
287 : | { | ||
288 : | client_print(0, print_chat, "%L: %s", LANG_PLAYER, prefix, buffer ); | ||
289 : | } | ||
290 : | ian | 1 | #endif |
291 : | } | ||
292 : | } | ||
293 : | |||
294 : | ian | 17 | /** |
295 : | * Standard method to show activity to one single client. | ||
296 : | * This is useful for messages that get pieced together by many language keys. | ||
297 : | * This depends on the amx_show_activity cvar. See documentation for more details. | ||
298 : | * | ||
299 : | * @param idtarget The user id of the person to display to. 0 is invalid. | ||
300 : | * @param idadmin The user id of the person doing the action. | ||
301 : | * @param name The name of the person doing the action. | ||
302 : | * @param fmt The format string to display. Do not put the "ADMIN:" prefix in this. | ||
303 : | */ | ||
304 : | stock show_activity_id(idtarget, idadmin, const name[], const fmt[], any:...) | ||
305 : | { | ||
306 : | if (idtarget == 0 || | ||
307 : | !is_user_connected(idtarget) ) | ||
308 : | { | ||
309 : | return; | ||
310 : | } | ||
311 : | |||
312 : | static __amx_show_activity; | ||
313 : | if (__amx_show_activity == 0) | ||
314 : | { | ||
315 : | __amx_show_activity = get_cvar_pointer("amx_show_activity"); | ||
316 : | |||
317 : | // if still not found, then register the cvar as a dummy | ||
318 : | if (__amx_show_activity == 0) | ||
319 : | { | ||
320 : | __amx_show_activity = register_cvar("amx_show_activity", "2"); | ||
321 : | } | ||
322 : | } | ||
323 : | |||
324 : | static prefix[10]; | ||
325 : | if (is_user_admin(idadmin)) | ||
326 : | { | ||
327 : | copy(prefix, charsmax(prefix), "ADMIN"); | ||
328 : | } | ||
329 : | else | ||
330 : | { | ||
331 : | copy(prefix, charsmax(prefix), "PLAYER"); | ||
332 : | } | ||
333 : | |||
334 : | static buffer[512]; | ||
335 : | vformat(buffer, charsmax(buffer), fmt, 5); | ||
336 : | |||
337 : | |||
338 : | switch(get_pcvar_num(__amx_show_activity)) | ||
339 : | { | ||
340 : | case 5: // hide name only to admins, show nothing to normal users | ||
341 : | { | ||
342 : | if ( is_user_admin(idtarget) ) | ||
343 : | { | ||
344 : | client_print(idtarget, print_chat, "%L: %s", idtarget, prefix, buffer); | ||
345 : | } | ||
346 : | } | ||
347 : | case 4: // show name only to admins, show nothing to normal users | ||
348 : | { | ||
349 : | if ( is_user_admin(idtarget) ) | ||
350 : | { | ||
351 : | client_print(idtarget, print_chat, "%L %s: %s", idtarget, prefix, name, buffer); | ||
352 : | } | ||
353 : | } | ||
354 : | case 3: // show name only to admins, hide name from normal users | ||
355 : | { | ||
356 : | if ( is_user_admin(idtarget) ) | ||
357 : | { | ||
358 : | client_print(idtarget, print_chat, "%L %s: %s", idtarget, prefix, name, buffer); | ||
359 : | } | ||
360 : | else | ||
361 : | { | ||
362 : | client_print(idtarget, print_chat, "%L: %s", idtarget, prefix, buffer); | ||
363 : | } | ||
364 : | } | ||
365 : | case 2: // show name to all | ||
366 : | { | ||
367 : | client_print(idtarget, print_chat, "%L %s: %s", idtarget, prefix, name, buffer); | ||
368 : | } | ||
369 : | case 1: // hide name to all | ||
370 : | { | ||
371 : | client_print(idtarget, print_chat, "%L: %s", idtarget, prefix, buffer); | ||
372 : | } | ||
373 : | } | ||
374 : | } | ||
375 : | /** | ||
376 : | * Standard method to show activity to one single client with normal language keys. | ||
377 : | * These keys need to be in the format of standard AMXX keys: | ||
378 : | * eg: ADMIN_KICK_1 = ADMIN: kick %s | ||
379 : | * ADMIN_KICK_2 = ADMIN %s: kick %s | ||
380 : | * This depends on the amx_show_activity cvar. See documentation for more details. | ||
381 : | * | ||
382 : | * @param KeyWithoutName The language key that does not have the name field. | ||
383 : | * @param KeyWithName The language key that does have the name field. | ||
384 : | * @param __AdminName The name of the person doing the action. | ||
385 : | * @extra Pass any extra format arguments for the language key in the variable arguments list. | ||
386 : | */ | ||
387 : | stock show_activity_key(const KeyWithoutName[], const KeyWithName[], const ___AdminName[], any:...) | ||
388 : | { | ||
389 : | // The variable gets used via vformat, but the compiler doesn't know that, so it still cries. | ||
390 : | #pragma unused ___AdminName | ||
391 : | static __amx_show_activity; | ||
392 : | if (__amx_show_activity == 0) | ||
393 : | { | ||
394 : | __amx_show_activity = get_cvar_pointer("amx_show_activity"); | ||
395 : | |||
396 : | // if still not found, then register the cvar as a dummy | ||
397 : | if (__amx_show_activity == 0) | ||
398 : | { | ||
399 : | __amx_show_activity = register_cvar("amx_show_activity", "2"); | ||
400 : | } | ||
401 : | } | ||
402 : | |||
403 : | new buffer[512]; | ||
404 : | new keyfmt[256]; | ||
405 : | new i; | ||
406 : | |||
407 : | new __maxclients=get_maxplayers(); | ||
408 : | |||
409 : | switch( get_pcvar_num(__amx_show_activity) ) | ||
410 : | { | ||
411 : | case 5: // hide name to admins, display nothing to normal players | ||
412 : | while (i++ < __maxclients) | ||
413 : | { | ||
414 : | if ( is_user_connected(i) ) | ||
415 : | { | ||
416 : | if ( is_user_admin(i) ) | ||
417 : | { | ||
418 : | LookupLangKey(keyfmt, charsmax(keyfmt), KeyWithoutName, i); | ||
419 : | |||
420 : | // skip the "adminname" argument if not showing name | ||
421 : | vformat(buffer, charsmax(buffer), keyfmt, 4); | ||
422 : | client_print(i, print_chat, "%s", buffer); | ||
423 : | } | ||
424 : | } | ||
425 : | } | ||
426 : | case 4: // show name only to admins, display nothing to normal players | ||
427 : | while (i++ < __maxclients) | ||
428 : | { | ||
429 : | if ( is_user_connected(i) ) | ||
430 : | { | ||
431 : | if ( is_user_admin(i) ) | ||
432 : | { | ||
433 : | LookupLangKey(keyfmt, charsmax(keyfmt), KeyWithName, i); | ||
434 : | vformat(buffer, charsmax(buffer), keyfmt, 3); | ||
435 : | client_print(i, print_chat, "%s", buffer); | ||
436 : | } | ||
437 : | } | ||
438 : | } | ||
439 : | case 3: // show name only to admins, hide name from normal users | ||
440 : | while (i++ < __maxclients) | ||
441 : | { | ||
442 : | if ( is_user_connected(i) ) | ||
443 : | { | ||
444 : | if ( is_user_admin(i) ) | ||
445 : | { | ||
446 : | LookupLangKey(keyfmt, charsmax(keyfmt), KeyWithName, i); | ||
447 : | vformat(buffer, charsmax(buffer), keyfmt, 3); | ||
448 : | } | ||
449 : | else | ||
450 : | { | ||
451 : | LookupLangKey(keyfmt, charsmax(keyfmt), KeyWithoutName, i); | ||
452 : | |||
453 : | // skip the "adminname" argument if not showing name | ||
454 : | vformat(buffer, charsmax(buffer), keyfmt, 4); | ||
455 : | } | ||
456 : | client_print(i, print_chat, "%s", buffer); | ||
457 : | } | ||
458 : | } | ||
459 : | case 2: // show name to all users | ||
460 : | while (i++ < __maxclients) | ||
461 : | { | ||
462 : | if ( is_user_connected(i) ) | ||
463 : | { | ||
464 : | LookupLangKey(keyfmt, charsmax(keyfmt), KeyWithName, i); | ||
465 : | vformat(buffer, charsmax(buffer), keyfmt, 3); | ||
466 : | client_print(i, print_chat, "%s", buffer); | ||
467 : | } | ||
468 : | } | ||
469 : | case 1: // hide name from all users | ||
470 : | while (i++ < __maxclients) | ||
471 : | { | ||
472 : | if ( is_user_connected(i) ) | ||
473 : | { | ||
474 : | LookupLangKey(keyfmt, charsmax(keyfmt), KeyWithoutName, i); | ||
475 : | |||
476 : | // skip the "adminname" argument if not showing name | ||
477 : | vformat(buffer, charsmax(buffer), keyfmt, 4); | ||
478 : | client_print(i, print_chat, "%s", buffer); | ||
479 : | } | ||
480 : | } | ||
481 : | |||
482 : | } | ||
483 : | } | ||
484 : | |||
485 : | ian | 1 | stock colored_menus() |
486 : | { | ||
487 : | new mod_name[32]; | ||
488 : | get_modname(mod_name,31); | ||
489 : | |||
490 : | return ( equal(mod_name,"cstrike") || equal(mod_name,"czero") || equal(mod_name,"dod") ); | ||
491 : | } | ||
492 : | |||
493 : | stock cstrike_running() | ||
494 : | { | ||
495 : | new mod_name[32]; | ||
496 : | get_modname(mod_name,31); | ||
497 : | |||
498 : | return ( equal(mod_name,"cstrike") || equal(mod_name,"czero") || equal(mod_name,"csv15") || equal(mod_name,"cs13") ); | ||
499 : | } | ||
500 : | |||
501 : | stock is_running(const mod[]) | ||
502 : | { | ||
503 : | new mod_name[32]; | ||
504 : | get_modname(mod_name,31); | ||
505 : | |||
506 : | return equal(mod_name,mod); | ||
507 : | } | ||
508 : | |||
509 : | stock get_basedir(name[],len) | ||
510 : | { | ||
511 : | return get_localinfo("amxx_basedir",name,len); | ||
512 : | } | ||
513 : | |||
514 : | stock get_configsdir(name[],len) | ||
515 : | { | ||
516 : | return get_localinfo("amxx_configsdir",name,len); | ||
517 : | } | ||
518 : | |||
519 : | stock get_datadir(name[],len) | ||
520 : | { | ||
521 : | return get_localinfo("amxx_datadir",name,len); | ||
522 : | } | ||
523 : | |||
524 : | stock register_menu(const title[],keys,const function[],outside=0) | ||
525 : | { | ||
526 : | register_menucmd(register_menuid(title,outside),keys,function); | ||
527 : | } | ||
528 : | |||
529 : | /* Backwards Compatibility | ||
530 : | * don't use it! */ | ||
531 : | stock get_customdir(name[],len) | ||
532 : | { | ||
533 : | return get_localinfo("amxx_configsdir",name,len); | ||
534 : | } | ||
535 : | |||
536 : | /* Add a menu item to Menus Front-End plugin ("amxmodmenu"): | ||
537 : | * MENU_TEXT: Text that will be shown for this item in menu | ||
538 : | * MENU_CMD: Command that should be executed to start menu | ||
539 : | * MENU_ACCESS: Access required for menu | ||
540 : | * MENU_PLUGIN: The exact case-insensitive name of plugin holding the menu command | ||
541 : | */ | ||
542 : | stock AddMenuItem(const MENU_TEXT[], const MENU_CMD[], const MENU_ACCESS, const MENU_PLUGIN[]) | ||
543 : | { | ||
544 : | AddMenuItem_call(MENU_TEXT, MENU_CMD, MENU_ACCESS, MENU_PLUGIN, false); | ||
545 : | } | ||
546 : | /* Just like above, but add menu item to "amx_menu", that should also be accessible by non-admins. | ||
547 : | */ | ||
548 : | stock AddClientMenuItem(const MENU_TEXT[], const MENU_CMD[], const MENU_ACCESS, const MENU_PLUGIN[]) | ||
549 : | { | ||
550 : | AddMenuItem_call(MENU_TEXT, MENU_CMD, MENU_ACCESS, MENU_PLUGIN, true); | ||
551 : | } | ||
552 : | |||
553 : | // Internal function used by above stocks. | ||
554 : | stock AddMenuItem_call(const MENU_TEXT[], const MENU_CMD[], const MENU_ACCESS, const MENU_PLUGIN[], const bool:ADD_TO_CLIENT_MENU) | ||
555 : | { | ||
556 : | new pluginid = is_plugin_loaded("Menus Front-End"); | ||
557 : | if (pluginid == -1) { | ||
558 : | log_amx("Can't add menu item ^"%s^" from plugin ^"%s^" to menu set because the Menus Front-End plugin itself is not loaded!", MENU_TEXT, MENU_PLUGIN); | ||
559 : | return; // Menus Front-End doesn't exist, return. | ||
560 : | } | ||
561 : | |||
562 : | new filename[64], b[1]; | ||
563 : | get_plugin(pluginid, filename, 63, b, 0, b, 0, b, 0, b, 0); | ||
564 : | |||
565 : | new status = callfunc_begin(ADD_TO_CLIENT_MENU ? "AddClientMenu" : "AddMenu", filename); | ||
566 : | new bool:failed = true; | ||
567 : | switch (status) | ||
568 : | { | ||
569 : | case 1: failed = false; | ||
570 : | case 0: log_amx("Run time error! (AddMenuItem_call failed)"); | ||
571 : | case -2: log_amx("Function not found! (AddMenuItem_call failed)"); | ||
572 : | case -1: log_amx("Plugin not found! (AddMenuItem_call failed)"); | ||
573 : | } | ||
574 : | if (failed) | ||
575 : | { | ||
576 : | return; | ||
577 : | } | ||
578 : | // Item text | ||
579 : | callfunc_push_str(MENU_TEXT); | ||
580 : | // Cmd | ||
581 : | callfunc_push_str(MENU_CMD); | ||
582 : | // Access | ||
583 : | callfunc_push_int(MENU_ACCESS); | ||
584 : | // Menu exists in this plugin | ||
585 : | callfunc_push_str(MENU_PLUGIN); | ||
586 : | |||
587 : | callfunc_end(); | ||
588 : | } | ||
589 : | |||
590 : | |||
591 : | stock constraint_offset(low, high, seed, offset) | ||
592 : | { | ||
593 : | new numElements = high - low + 1; | ||
594 : | offset += seed - low; | ||
595 : | |||
596 : | if (offset >= 0) | ||
597 : | { | ||
598 : | return low + (offset % numElements); | ||
599 : | } | ||
600 : | else | ||
601 : | { | ||
602 : | return high - (abs(offset) % numElements) + 1; | ||
603 : | } | ||
604 : | |||
605 : | return 0; // Makes the compiler happy -_- | ||
606 : | } | ||
607 : | ian | 17 | |
608 : | /* Returns true if the user has ANY of the provided flags | ||
609 : | * false if they have none | ||
610 : | */ | ||
611 : | stock has_flag(id, const flags[]) | ||
612 : | { | ||
613 : | return (get_user_flags(id) & read_flags(flags)); | ||
614 : | } | ||
615 : | /* Returns true if the user has ALL of the provided flags | ||
616 : | * false otherwise | ||
617 : | */ | ||
618 : | stock has_all_flags(id, const flags[]) | ||
619 : | { | ||
620 : | new FlagsNumber=read_flags(flags); | ||
621 : | return ((get_user_flags(id) & FlagsNumber)==FlagsNumber); | ||
622 : | } |
Contact | ViewVC Help |
Powered by ViewVC 1.0.4 |