From ab5c11f87604b5987692ec055f89b1235b542d60 Mon Sep 17 00:00:00 2001 From: Twilight Suzuka Date: Thu, 12 Jan 2006 03:55:49 +0000 Subject: [PATCH] Finally done!!! I finished what DS started: AMXx Mods may now patch/retreive memory of several varieties directly from the game .dll, mod .dll, or can go free and patch/retreive any peice of memory. I salute you DS. --- dlls/MemHack/MemConst.h | 48 + dlls/MemHack/MemHack.cpp | 18 + dlls/MemHack/MemHack.ncb | Bin 0 -> 134144 bytes dlls/MemHack/MemHack.sln | 21 + dlls/MemHack/MemHack.vcproj | 172 ++ dlls/MemHack/MemMisc.cpp | 101 + dlls/MemHack/MemMisc.h | 38 + dlls/MemHack/MemMiscNatives.cpp | 27 + dlls/MemHack/MemRead.cpp | 56 + dlls/MemHack/MemRead.h | 23 + dlls/MemHack/MemReadNatives.cpp | 78 + dlls/MemHack/MemWrite.cpp | 78 + dlls/MemHack/MemWrite.h | 23 + dlls/MemHack/MemWriteNatives.cpp | 72 + dlls/MemHack/amxxmodule.cpp | 3078 ++++++++++++++++++++++++++++++ dlls/MemHack/amxxmodule.h | 2241 ++++++++++++++++++++++ dlls/MemHack/memhack.inc | 20 + dlls/MemHack/memhack_const.inc | 23 + dlls/MemHack/moduleconfig.h | 463 +++++ 19 files changed, 6580 insertions(+) create mode 100644 dlls/MemHack/MemConst.h create mode 100644 dlls/MemHack/MemHack.cpp create mode 100644 dlls/MemHack/MemHack.ncb create mode 100644 dlls/MemHack/MemHack.sln create mode 100644 dlls/MemHack/MemHack.vcproj create mode 100644 dlls/MemHack/MemMisc.cpp create mode 100644 dlls/MemHack/MemMisc.h create mode 100644 dlls/MemHack/MemMiscNatives.cpp create mode 100644 dlls/MemHack/MemRead.cpp create mode 100644 dlls/MemHack/MemRead.h create mode 100644 dlls/MemHack/MemReadNatives.cpp create mode 100644 dlls/MemHack/MemWrite.cpp create mode 100644 dlls/MemHack/MemWrite.h create mode 100644 dlls/MemHack/MemWriteNatives.cpp create mode 100644 dlls/MemHack/amxxmodule.cpp create mode 100644 dlls/MemHack/amxxmodule.h create mode 100644 dlls/MemHack/memhack.inc create mode 100644 dlls/MemHack/memhack_const.inc create mode 100644 dlls/MemHack/moduleconfig.h diff --git a/dlls/MemHack/MemConst.h b/dlls/MemHack/MemConst.h new file mode 100644 index 00000000..d84b642a --- /dev/null +++ b/dlls/MemHack/MemConst.h @@ -0,0 +1,48 @@ +#ifndef __MEMCONST_H__ +#define __MEMCONST_H__ + +#ifdef __linux__ + #include +#endif + +#include "amxxmodule.h" + +// Define memory address type +#ifdef __amd64__ + typedef uint64_t maddress; +#else + typedef uint32_t maddress; +#endif + +// Number of bytes for different data types +#define BYTE_BYTES 1 +#define WORD_BYTES 2 +#define DWORD_BYTES 4 +#define QWORD_BYTES 8 +#define FLOAT_BYTES 4 + +// Return codes for MemoryProtect +#define MP_FAIL -1 +#define MP_OK 0 + +// Memory protection constants +#ifdef __linux__ + #define MPROT_CODE PROT_READ|PROT_EXEC + #define MPROT_DATA PROT_READ|PROT_WRITE + #define MPROT_RODATA PROT_READ + #define MPROT_CODE_EDIT PROT_READ|PROT_WRITE|PROT_EXEC + #define MPROT_RODATA_EDIT PROT_READ|PROT_WRITE +#else + #define MPROT_CODE PAGE_EXECUTE_READ + #define MPROT_DATA PAGE_READWRITE + #define MPROT_RODATA PAGE_READONLY + #define MPROT_CODE_EDIT PAGE_EXECUTE_READWRITE + #define MPROT_RODATA_EDIT PAGE_READWRITE +#endif + +// Memory area types +#define MEMTYPE_CODE 0 // Code (usually .text segment, requires mprotect or VirtualProtect) +#define MEMTYPE_DATA 1 // Data (usually .data segment, writable by default) +#define MEMTYPE_RODATA 2 // Read-Only Data (usually .rodata on Linux, .rdata on Windows) + +#endif // #ifndef __MEMHACK_H__ diff --git a/dlls/MemHack/MemHack.cpp b/dlls/MemHack/MemHack.cpp new file mode 100644 index 00000000..fee0a3de --- /dev/null +++ b/dlls/MemHack/MemHack.cpp @@ -0,0 +1,18 @@ +#include "MemMisc.h" + +extern AMX_NATIVE_INFO read_natives[]; +extern AMX_NATIVE_INFO write_natives[]; +extern AMX_NATIVE_INFO misc_natives[]; + +void OnAmxxAttach() +{ + // Get Base Addresses for dll and engine; exit if unavailable. + if(GetBaseAddresses() == false) return MF_LogError(NULL,AMX_ERR_MEMACCESS,"Unable to get base address of game or mod .dll!"); + + // Add natives if base is found. + MF_AddNatives(read_natives); + MF_AddNatives(write_natives); + MF_AddNatives(misc_natives); +} + + diff --git a/dlls/MemHack/MemHack.ncb b/dlls/MemHack/MemHack.ncb new file mode 100644 index 0000000000000000000000000000000000000000..8ed80be9550716f2f0e3fcaa7a0b293766b76e94 GIT binary patch literal 134144 zcmeEv2YeOPw)dVslYj&SDS{lTgc>?1XhITtLI|OXhL9W}5|WTYQ9-1M3L+|sTtKjb z9Z{|Y6crT|d%qU!-D|n_0^k2XbLPzK2)=jU^?mPs-_4odI(yB3)^2Ndn?1Al$|^3b zD61@+RuxI_mfopTBx}szNZ+n0DRmQ?WsDK{=|U)QmVkaGgWm$rsr|3jK&=M;AJ@R! zx>zJ0INZ|Bh9dSHuKm?&pjHF_HW~;wUtb;ix5;*GMr$=ts{v?WF~;-_PD3jY@mhit z#ff4EF=a&@+mMKZSjRx_%ET)Zw-KYa2>*mwm$)u*O%3dd#48df6RZ2A;>)!WZNyY! zL!OCaZADu#k60)z?L~Vri6#^#E9oO_(}C2XE}+h^tiKzQQ-Yyi^IoCN| zB)wcDZgg&RR!MRz#Usum&Q1wiB_4JjcFH7OT`X>PZg%EM_h_}a-MQVl26Z)v_Y$$m z+2o9t^tVQAbGA9xNPaIBTb-@W&r*Ib6C0h4&N2iRgm<~P*16UhFO~7N;(F(Lr>9i6 zt`IjkH#lo0on9%fajtP*km6V;ZgOsNUXbFrN^EhqI9Ew!a=qB>Y@VUL=N9J& zNiQ43toCBWmQphTFiGvbXv3`T3Q$#RwICJg(pqUC@ZX<6)ml*j1-g> zMaD#{5Y6<;$(coyGoqCLe_~<>SC>{X3Fxwysx{gbttUWTUOPtAO+LHLt%@0b5S zy<0V0M9+y#P!RKR-W;x_2!T#c6kw!)L6q1I!XQLsg3w6{2R$?f_hLGFeuljlZZo(x z!eQ8rK?q7r0AXMu5^%i&HZb^!D$&JRE7_jJC-z-9+o_oM&5DW zeU>nmR+b>%eU?y`9+pU!7M8FkAeKy)N|tbzYThs04#5{T5l|~oYfu|dTTnYtdk{-o z2T(GoBd8OI_oEA_D`)_y_E)O`w-AXf;&SJ5=L{51)=dw)M(lC+I0H~{1MFI{&ROTY zgTkuoD`IljiS^EUXCj0Gx$DJM&Q;D(6#M|YLHxz}i}R)w-i=~~v%*nP0Rp+LVy&~* z*^2fkz_y9|o%@{~Xe3-J5V_T>~`^(^O&<*iuVq2v2(GrP>OfExX-!ISt$9vQ#|NA=yXK` z5QMh_ZAdrK5DkQ`sj)f8yU@m@hyzku?nXP)Q|y=YvJ>r2FR=@aND$s%(KdA#6QuOr zgSM)N*oB5Akh@pd_?;!(wm3-h_Fv@I1M_;?aah6BfqO>|u|IJqddfUQrPT=4L%? zpLihQfrM*f>GQBB#DfVBCOjY0y@wqT4<|gFuq2i@4|`hdPS~B$59Lo`awBw}6{8Zz zCZ3%b#-11B6HiZEjCf=7l8}2*9G}?U!?XzJDuKN!`Xr_$&c!{#Ni4j-i4KW9YhZ7Q zL5W$3I`Z2E4LMz((xJQxH26hGX9Vf$45|q}-@--RduLMMX1l&B3kF5rF6Q~gP@jOr+l;2%&DI3POBHu3qe+=Ogujy|cuF)T5 z=$AAKR0Ns@Vt#%@xu}QycLfav`Pg`taa=D%eJ=-H2pWbwJPJi~Bvu#H0MrH)K4%;+ zA)HS^3D7CeZ;a)&E_B}zj+(@K{qcUotJ}}0s9{JZaetH$a4#(8~M8fd3hNA1_OT#emg^Nf5-V0T?D^Gu{^DAKwWVSI=%KI45r8YY4q z#GxV$%fSB~ajs{cz|Vu5i*SF$^)krkBfM{L-U#vBgLwBM9lH_kDeyZGX`BeTM-lcG z;Fkfv5`0IbgY+K!kV^-_s?nIQq&XN+C6CJ;y(og(C*p_ zQ~v=dCCqlm=uL)tGd*7V9C4YrT`GaCDHc zy5bugO0TfrW5jPb`btYJ3e!+2@BzJ;P@S7>gwG`jsSSZOw#OF9pldx9eD;!@)`E4x@<7gy> z*GBw|qg6_{9JCde;ut5Dp?0DK$M?g+a_vzA9~5sbr28X_ylz( zs0+!MA8H}?OISzrx5tU^MuhKCCvmoQw)L5Wbr$oid6qIVEZ0TMx8_^#N^)JrS=L!r zyRor89esaY^tRKj=~nZcFqR@_S~IQlMuoBNqRc9@4)zUWJuvn!w8mocOksZA@Oq2S z_0RS5$A__gqPx}Idaz>{OBIhOk0`g{eguApii_2Y)d!@sj1+fhcW8QMST09=XMAUD z7!t;E#XfDHc6z%omM7|(b z(La^+w^&5Ys5u7rH}JbuG}IgFbtiE`L?Q=P+d zYeaLsxxV7WFm|~pFbmAZlH3(yv$k0qfpQh3Wu5rI_`v9fekQ=yi#yoz7ek| zuPFCO_vl-3je3nbS4#7b;sxaeWw=z&e-)e5P3kNueZPr1dL8|cgdGy2&C%x5QoM&T z53B2YCEW{Um^sXRNy1dc)@}Xq>~KDGCCkh*6Q%UoN`{`Hzc00ub(9Ot3rt<|TVHt{ z$4{NY;T@;kpx&VVO-kPh%HufJNNr+!!F-(oNla@ z+PXeUFTIy;OYP}N%6xOa*SmVwIK`rG;vDc)42oz>2|U24Y%DI@ifdU9IWZ-%nQ zTw@+D`5mm3XeHW3QW+nrY&W(WgQR;jLfND5(HBVfC|fZs!}?shAET86`T@P8R0s2v z`c{3*lcH$}WAE zzFW%MH04G8MZF>`ELW^FwVGNTrM#6WiltZwq_(|GIT^=&QeCZ3Ox09VPYj1wt(=NO zZ4<`kDG6$V`k|z&vy>4yQlxh69OXFmIJI0#^CD#kj{Q;@TBok+{`Y((9mm1e z;dn1pj!}3d1r1oW#atKE^sjO{Q+G=gJC!{idjZ$nB8|jkYo0MK!FRd${dxCOs zr!wD|Z)8h#|2`!}OVRF^>e0hWwNY(Ml60_FN!3&JB~o~gDa*`dW^?JjJ)zvC-KF)C z>hIIaPsUHiol@O;R*7g4ZIpD6o>!tq)KFW6)BK|HqV}S;S85YqR+^ek%@xvE?^Q+D zbnQ*49{o)jW(+ePm+HscN{*hR-zc>uA1Z6jwPtUrkNQ}_OJnVEN%x;BnMS6uLyF_? z%D3vb>RxHA@{Q8p=x>Z^AI`_O%G=u8+CnLg@0E6DJ9Dp8{(e?|Rex2NNp0sLCCx}P zwo5wD)c5uG^^H<{Z>z~xvNb`{bAq}@+oN3~jnV6WRvU%DbJzIyg@KM)^kBAl2!{>QHN_HAf1s zi8{fWVC|OtHdphsJdH2WgYq0vuQIMOUXs$>PEFF2^afJ>=%|i0$C@joF+(@?EA1<7 zsN}bo+S}}Hek95DR`=?A^A7sAy3O2X?vngwtM6;?YtyCrk)tM?$!2BuuL>fNL`&QJ$h1FeoyKRs3bSpQgGDYd85)Gk&RYqvCh zo}n(%7wKaFIj=18eMU87#EU#=hQ7ry70 ztFM`_nfoQZtW{U&EA;OqJzt?dWjH>3txmp^R+^8O}9IqUb%F9-@rP5OQSNWLu!4azTrqZctqWYqib?l zSC6W7jk?BLQa+wgKgQ8Tde(hL?P7E>nn~Dm>W|uwS`%qJ`GPvo9BB5J+OQYZDf$#$ zmGbtIdcAqQd95@?dPU8!GORNt{k^8tX3LIePLEEZt)xYZ_d{_%@nmSF* zkmOow=PTzczovx4Yo+C?xvGgd_@JL|qb*UEC|z5Hv36Rvnyuza{l|$~IgYy0SSne& z+ql~>r2E@hyH3AOZzJ8`ZrUg2CuX&ztM1x4`Z;8mM*Vl0)~_Ws%)b&pyuwSOmT27cS5yq%)mgJZL#t2FI5<2U0AX$+UH?ZVMiN=v4u zn2MPubncH)0EScMpD@*)Y_}<)fG~kU7}6aC+lfayH>4jF}Ikjqzsr+4_wK7^6ze>-^ ztF=+eC?#LI=WDfQYBM!c(&<&&*~;0$J%@9I36lUfW`9F@BTE!HpVT_~|<&xoujenQ3;D z^n9CEu9xd4OMTA{?QZjK^L8n3JGDGLPjA^etmk{RtIVs+xzhORe(etZ4t==P4(-;y zGruzrO85Lh?H2tOJz0wPA?<7PYjdSkhW2W&>aXetrSKltT39WtHBw!DQY+C*^miq{ z&uH7t?dHc)8Gl~etL|05lXU-*<`|B#LaM*7YMpWDQkq}aW*f7OQBvD^P}`ty&>Kqk z{5|a*^Br@C6z@mcv+A?zRgz9W(;69#j8;-U{;qY_JL}g;<>hN_wmI7@l=AkycE57J zvPf!Uf6Atm|g5xR4ZyUYZtTq!R{dLqcv<$7Tl;-aG1;z!&%~IdfSMR6w(;7?VexSag-=&4$&wqGh6sIg%{P=8f%Tu zq_R=0kJLtLxl;X@rLQs87$-?>(`P^!4d5NBEBpY=ly)4t;R^L`TNzWhW>+OtoMn9>qxKRHJ$Lmrb zze?|I^|n?@<#dhyEsnL)7u~KV&>)bdvJ1O<$xf(r%X8mz(uRjYo|KBt74% zU!q;2y)X6Cx9cw%FByuY=k5ABZJqYHq`w{do5q{Q2&tUjt*_8lXp^Nj?63M$##2U` zbU*IZmugG3m!&#$zrNqtZ)j4xwp+hkyIi|TO7nyIYsPEF8B+OsM4zHf(N;-i_i_Dt z<9Z`cx^GYDZ{TPlwFgh>t*lnoqSWxa_owyc)^cl}ggv7#wia8HB)en*l^Hip^5Tr805Xk27pWZx{s+u1nPKGnqnxh}?h zd%pdhB-hPIx6@rLkV`QZ*bD3jrSjLq=wbJ8u|Te;QDT?a7f9jtHU`=QT`Z96W6ZVZ z+Vdp2e#QWMfQtok{f#-;Bj+|L-jj{)c6S#GMtMF3UKYxH`z$D z(_Ac&JKZ?jKHGj;iZ|crY4>!oKyHdL%bsO#l;oxwDRzpB1#*SPnf94>mejTv8B6RX zc6h&|##q~XqJ5$r-tVZfC^0(N9qieX-&w{odzn2#inrY8Y(Xmqo?xmX}~u2F0k+cTu{ve;;D zH+Qi>ZizA89&b02!dq@6+sQ5#$enK#+J$y|N$w(}qutTP0=bn&kzHihllq0##z=dl ziv@C*7#G_Y+jmRt)#b(zdx(n#a%+tXudrP6GK*`m0_-{CdFy$LYqJ9EdE-j!N{ef-0_+9jChI1P z>$d{zMPrq<%Hn#i0DH+;W392czAM09HZHL)vAEtVz+N%dT5Bz?{|c~IjVr7xEUpI& zu-A;$)@qCE!vgGY#@*K47T1df*z3m4*3A~zj|JEp#%Z);$*2mIc^b z#+}xk7T1~u*g<2bwbSC-vjBVBxX!xH;##x-d&juLy2Ikyv;ce8xZS$l;##!;d(XJm zy4K>_wE%nH*k*0BxRx!zJ}_>vZn3zwExIf!{XYx0Q=my%eu?rTDk!H!noeL-s0N2 z0QZ*gs2fPG^;XFX?etzLlr z!`NhPvbc6Hz`iv$TbnJe__7- z)?X~H0}QaAj6K#vC^2E|XXAi%z~VZ=K<*dg1?vTi>jwkuS7U>$nwfT{iv@Cx%=7K@?GA{;k2ggeXLiJjx3eUyF$a1Gk|NrfSJ_wD?z(O2%Egk+E9@)m_!?~& z>twFA*Ve$gnOE9Z+N-3r^f2$Y@3)gM2j$<(6w%XsTs$r`V1Z71xmbG%>uv56`^1?N z*2jEZye_gOtgrcsct!M-uzu!?SZ}@!bFY4RP7(dhC1QzC*R4@iHvy>P86!%25w_eJE6{MF4UP#g*v&FQ0Fxf zYIR$o&gh71SU-s!O4P$A2z5aNxa~p5x@)Uvp}ufkCD;CP-7j6P^X1y#c0;lLc!0-q z?Qnn8nR>mjb{cdui1G*FE<^tlf%_EbQxRFEI|0Nn8^Hf=@blp^9ri*KkYf|w^SWgWi?(F-GA45F}yLG(x5KW9Ek{@x07-$9tZ%WEgVUsup6 zpd+0hhx^kFlnNRLqD)PU@v@F>9f&=jy5WApeFXF>=rhoNbp4^$*h3&jPljCjBk@|# z)W9VcMVVe}R-eFSxHp}Qy{R%i8K0-zN|cq2 zvGU^cl&{Gzh{Z`f%+v3GMgAb#xNl?aT$n!|?LhZfTM*{IZSBQFm+7W^5z6{IslPvG zdi?8Q-uLIb{O~_P$4MX-u-8qxsHQ$|$HjC$UXW$;r0r@WR zn#B9u8q^iUYc<@Uq8=;QzTFrB}oC2rIe6ydq4;1DZ|60V!yoGs& z=TkkDNAh$jvmEXvHFz86ynX^G%u_y0;k**(*edKEX*_f!jDDD=+fety?zd=*c}|xy zjBijE>_rHg3OW+Tdzk`x-=%*NWm)EYmv!&5eqJ5)-6bF`WO3AC6P@ z#m2TZd4_qUF%EUe`|G>hQ{_15sU;}P^E%7mf7bQu?DGiQ=O4%lcpu{!HYWr7Z-K)6 zEyJ;w6zG0Xm}mR~dVe;}ON-Bk?~7mOeb>Lnewe)Pj!#D3K}$euLDzw{gZ6=50#Wuq zBjbk`c7N`Uu_o$%b5QSCU&rf5!fV#Iqsbi&ACGo=Cg?1Xo8}tl#YhWr-z6U=e@yJV z8R#$lcE}&Y9SLKb)xWhDmd{T{`6~e(&1Jmb;`(o~avJ7q##!^6_tS4PYVya$?iX>N zXPeJ9b7idEta(n^2hgUx0Ajjoo>RUv$}F#i`E{rpw}Ku3JrCmbni$KeKQ0UNls!^C z{3D##NN1xRT@Bg&yA>(d3SXH^}nx?7O_LH>3q~JK=MtIklVj{2JytFU7g6sj1%l7w4lm zKXtS{Bk4B{{R3^W(9R0axyNI{NbJ)GqMa4mRiPaf+D-AVYomlXALkr*eKyETBkiT| zyxti20r`7G(q;so;Bg*VHxZL+Qe11PL?)yvZY7k|(=WqC>if*;WxznW7*(-zf23` z8$K3$jK$LVZk`Z7fGEQ~eCg+&HYlec?%(VCxoeOo!~J`G?E4`e#{GNUu@(IEX%Sp! znVAHd1>)Yl+^d)2Q{UX9mws*n{b%<*ttnq~ztd3&%irttnv-$Z-D=qn9pj9GJBznpx(bZUP>}dvLTpTRAV! z`^&mOKZlU_Et*%p9zou?A2hG|{CZg}aqnwC%xxqFB;*`^ZZ&=V$ zyZeWA@UciL1a<69-%1>s1UYSm_tFfz12)7lPr{DDzV^q84}8q^n}oga>x&N&uSvgd zy!C~Fqc`MC?kDPE4TOoKKjO^-O$3qWKAOkE_4nQ6Jy{NaYd{-7cY^kVDEA%Q?+{N0 z+}dBQ25L3%dkxgw|CjaO-TyaM54r!ZgTvkbSM}<;g16Pg+`WEXELA9|)pc;Vd;P|- zdhTAI5ww*`96J{8*pq_2ev|08vD`)!GqqrSJ-ZyammwlVR& zeqFyOqD^by?e!a%>x8upb^pV?emPg>w=Xmf!hR)u&b}#p9&V2)&wYKv*VojLXTK4? z&UvTsImi0p^WWdGTBKG3f1U=8RR7;O-QWM4bsg=%=N*xIn#J{ZtCCrMN?R zNjXjO+gglO&QcagSUWKrdr@?d^439&Rm;@77#_wpUVb}?4(dSl4JnSU;$D%fJT76~ zMPsbL?<>X83$~0}s12kv_Z44Y2h+p!8_&l{n5VL|Mwjx}1OC^k=!Y|gjS&$Br@$U(nkXuC`}J6Vt-{`B zwpb)#8tiY55?2w!oT}$nhds_5v0aigV4rie*hj35FK5DDXRdfxlCxmHbBy>&!fcU; z_l?Ax%9~10 zVr`0|o=zK!mz9^5du9NOkG+}-?(cYDCiahrEI8SdYbLng&Gp2Z`#LxtZQvcsiZg-5 z^V?i(SGFsoDF-pnZwqm!a;GxamGk?76JXnAhcb|I@pxN`yOg_>X_8z-+^yWLBunA7 z5<8Wh%35L_k|SOmC}-FYFOPl;OA0)!jkrg-N3kh4&zEZ}b}74*&6JC$ubto?J?n_I z^wZoPHfOggZxb7pmF0zZB5cpBQPdJ(Equ8SVvn*%d6{zM)l)sWWO1o-sq(6n=8obT zG1XB)FH}55!7}3q8M`#cpM{(u{G$_0mObQ?@A|Fub^)yNWH!7UeVg&CJdB z{B{!;D;F#2#NvKa!~@C$%JK9Y&s%rFJ(KE7ar6+kDz_??l#6zb>9nV~Lb*a|OS$+w zdM|OEa-H&}l$PFNy|P}}#dur!dg&uJC>xZ;l*=B`*-Kwv@sRS6@)NPR?)!;LluMK@ zj3bWq7n_t#%EOc!mznMPJxN@zT(8_iET_Xf4?9`hq}-%zWxVnGF+kj)+@Q1~7T3W* z@v!o+(oMon5!{bwij!J-3J2p=7ip zXW)39a=DrAJx_)eW7_+?b}BH~p`l)qVbwSl$Cs2FnU?Ee!(5v~v!(Ec!)EbmVoRtU zN`@6=+K_o&!bXZx91luZmY9VjnQdJwKOfmh%@DDgX_;D5?8Q3@c9>5U7cnid`;m+` zoa@0>NNE|3>5s`GgP7`vmkZm<6UFFI8=H(ad;|`QaZImF_TtFH>ZD%c31YE2n2a`j z5RNXy#^l9xFb=kr`-w3wHl~B;cRcJYpCle*yow+11lVrQ7dx0{K%U%0SfT1F7SL}T zn*_VZ14I??Z(4SSCwH1yg`qLVmM>P| zc#my%Jl+EFzVg13B;AjxB8uZ5l1>Xn5st-@T#+coQ7BRtjK4y58m9hNJ!K%fj;&Ec}`#Tpa z@s@~kDc*Tv5sp=^oFCqNaUPDFB9^z{=UlVoO07 zTYy!XT|^Vg<)&wP_iZ6;j$?h_-jjr?o-EX=E<$|<>-4r`EngF?;j6~lJlIfFtFVUe z)Bd1=Lj4450YBw>zV;xj*FzmvQ36yvfvKn)Dr_mLuqy7Z-$T7nty6_+q+o5}DTo8> z2a~Wa5N~=_)Ik-t7~QpiD%J&J9jLd)5b423sVdq%6>CjZv{)*vqCbRm&qKLc1KI}K z1Ns~2YfvJ}L@Uq$P%-EjU=dIU+@HFj%RzHNlR#;p)u>0^L4#uMBPh2#e+g|l*8_6R zAJ+>mL;IW!tP1W)aIXRJJB%i9xi*k%2>C75G3dAU;5(alfxm0uJ2bdlcgQt`{Pt=z z{I>_jwS(<#Z;c_>Aab4IrNH@37S|YZZ6ensy6X$!Cl$msj9kC?z3Qz$q%8U8ac>_$ zUO$9;8+3CB?joG;L|y#`^gO5+bg&-R*5TTfxRwJt4Ol&3FM|4krhr}nz8f;j!7qU> z%0Lr95zr~1Phxs%i!d$FI?#O3B+#j#O^~?+^fCMoMfktM{S09;&blbSoj}7t(?L6+ z|K~tog3xS;gTR)8wtyZ04Ts+<&`n5BTe!8qS`E}{;QuWRELPAy#`-&^oOA9A(ME>n z1h5^ixCmJAPC#+r!)+mkeo92>Q+40N-AgPUp61TipE)ax>F7N=iMbMHxZ}&E62_3b zh!>>rEcg9HvLt6C`iS^Ol5^0rogf-WatZF-<^%~#L{HdCJSzFEgC4JmcuK~o0rop2_A~4k*gw1l|NW7s-{7{4 zxl>a;8TLDrxeR#iuT}&99U7?l{-1I1{hIqOJ;E~uWxk&K4JFTNf3+H@)xiHh8mRgG zFLUO8{~P}{S3~{p=zZ&Z_;5Y1@3S!bUle@n8=tBN9zBtMtu#w!{HZzs@P2|UWZk; zUVlXl-voGVf@`)z)G5P=0hk(L`uGKZJ<& zA%C=Y*B?!xeC@AR1GO6XGc>RUbuIj?&oJ)>7SwguG^yA~EdFgCTLe|?C#J~t|3?Ya z-4@_=3FAs1L!4fYb^?CAc7k6RHWVWyED^KL14OBW9fMiy6mdH-j4?dF^~EW8Z?s0j z8e#{$KH^*nYm7FgwYUaYFg|I5Hy2q_yOW6Pe@A+c*8cpncx`+2XOz;~F#fwVaHRe} z`2L?y|Lp4{BL4k>H>t_g@^$#}!mOSo$SVr`Lv_gE*R1#s5{#N~S8ZTwIXUlZWQ+fSt8 zeWtr6ATBo$yIkVERfm6mO~8M&Uci5j@z)n{y+BQj>ji3JTrW@)<9dOb*pefJ$Mpg= z<+xs;CdTyw#A<)F8kjQs_x=BJU^V;yS;T7e|9>HdwYcH&|9cXqqhGhh0SWWg1l%TJ zraLAWhG&AHUw80S&``7|hB&;wzK-aLmSU15R}XDWXR&}7=G;BG1{gb>Ec!`)8= zE@n!8n_x^35iQW)2V;V!Vj#ZT@t;LF7We^aW46#dXYoYY9td5cmT*!p7KUcA({^|qHrBDSud7fG_))>j0q zwF&)#p-Bi!SJlNysST18$4*!ER(^~zcT`{giy`K{Na-tgpbr-yO#@~OT1G#y*FPQ6}_EWGLEHS4C9UGV0?!-o$l zm;N%g)BC60&@G|;w_pA8%g!eculse5_4iW`n-W+P2}zh}8}2}hD9mU^@ce;$4^f=Uu^JmIA) z70>W|cfj!kz6^K&|A+prrf%+f$V=BFNE6#trc1%>!yo-p|LEese$8!HM?dPN>ln;; za9-sYH{7QGdg%Y<5YQGpXo+62bp4lusrC3f4P1@pjCPS|pN#g+-pWJG7%BwqknI?N zEpBk_98d?4g0&5OK^s8df}RDP47>r{J)qYR#t59Z0bc@o7c>mC8l(Wf4em_13*nvy z`U3Kea8CPXtx{m~1@V7B3~7LyfZ{d{?pzR`O@2hM4Zcy_4eL9yCHOdVMopVcF#v2!hLnQhc5TB)??>3|yZCJwpAERb^t*a>D z55t{@^M#Oq1?A)#Tz?+&OCZbd#b{%W_FHMMbq4Z98?9@gJKAOC_bPlB&3Dgy*UbKb z?~?h=3f~`dPMUMjoO5Pd$T?-sA#xYHIpZLia=I&G%Y9y)EE(~kLj$0IEu+7_qX@OMBrgQqQT z+UceZZrazT?QGh`P6N@NHEmVX4mE8|(|$BM#qE-`HmH-bxB!L$QR8^5&Q+Xg)C?$V|%ZRoPU=e|MQCy4t3aUUS=`@?;H zxUUbtvFA7S{GOlR@AG?oexJ|p@%g<0zc1kT1pI!0-wW^?Bz|+mZ;bdpg6|*rzJc!- z_&$N}4`?Tl<1*UPJr6`%xwMTNL0)M4mbPxwj=?uYC>yk0OIx+yqioX_Ep5-z*6fA# zP?mAu9)>^KiluE>+I^*+*D1J0JFc|bIuv2iE-US@4uZceaA{YSc2sFMm3C5T7nOEU zY4?wQ@LaFJ?;U6xllBgGqpfd@GS9tN zx!3Bir(k{FIE0Dow2R4SDB8lL?MuD`<~v{R@y7SJd|%7=vwR=R_pf~4$}x-kJ{9j0 zxj!WLgXI2?-0zXkuiVd(`!_xh;{J?R!^JCM(E)kkx(U8_*@HAa58buIr9;oYq7qeyQ)@mD+db8+{jE@Y1mgH3rT-c>BJ@2x-ukZM#u{RGD6q_G{f- z?V}~)@S$IS`SO>E$3ORiby=f3_nmOwuZz6+mE;6rr_>Qs9I;%~t>2+-hLYMo5?Qn? zlA_j6JI`)jN3^w)nmG2*)QG)EZ@tJ_!R`VYq5wUY3c*mtDVUkSmoHRw$Q7}QGXl`9bAR^L#yv9BNYQg(&uk4b~R#mqh zCSMBj?P0D2&%T5BP!RiS^2Z`ctdrzTjNsh8HNo3J*xwUpve^zW-W0^ka!>p;#Kp2k z{ygw(Yh51a?1RXU2C;sSKOHh`TNq9%!eReFyb{E|fP8n*=2*P2Z0Xi(;u_M%xLd*nTnmXZwxU*hf$X#mKD#ESqq_(sUE&n1tl;r4Ch7lSy?Am0VVzJTGcIBC4bzK{44 z5c@##OF?We$S*{g?DNROo7*?g@5e|d`*Py5LG1I%p9$i4g*=)Dx9=s-YRf)_e#Ob- zHMTj#7bASOQRL47&-Rsk4tVxglqMVU?@_IV7yAHv@rlQ)5I3`3b>5Wj6B&u3${$>e7uZ5#`cp8{h4$#8}u zoCo6NL3PK$l(BJ@eG_>V;jk~Id=uPXjxC9E)ic{`@@FG_j)TZ|1F@|qUjf|x4hFn| zys*zBt{_bI=dP|0CdX04yV6h0Zy|V&Yl&lZw%dohd1o48;c!Pjj`b*W28iP{@@N9Q zZ)4ylAYS%2#H*1W_Os*-`t|jIFxgKLFNX}r#^k99j=RZY7hQL}O&;Bi+ZT~v3VDt- z$)hWA$1Y6g1cb?cow$y;I5s5T1H}H2{A~E;c%J+*2%qB{`ke>Av~NMY56JCr;MPH2 z_$)xY4kYfXg8X)-` z)EAEZDT5}=eGVa?h^rjmk$+iH-LW+JX&{cN==Yw!<28;oh>t;BlfjTjaPIh>JXGv` z=LFYAzW5A894q_g;1JCCv@?7=L@c{WY zAdXkaPlwDbFyxU$_ZfzKKM==JRn3c{q_YVxphj4m{$w-d)}?)RX;E!;7V=O{A*GJM7%KMBOO zs^q!Z8;do;o@?06p@iX~TAC*q7_N8)Wke7+=q8i->~@+;t%&#&ZBeBI}2@;ZFG z-{yi(KscONU>e@mo>bg#0KuEcFP{}DkEFQI3gqj;FYT9;ht+F$JWYNUc+MFxoPNfW z3diciCj;j*2Ki&)m(Q%^%RzjmCO-ni@hP z{CwcFV@@7c#N9a-@)$a}&j;j9+&wH-|Ds zAU?MfFUL56^9sZ-1aS_5d`l4LEXbocdf%SHO~gI@A{H-qUg2{-!rI6<{I{7-t4WIidpMo}x^HapLK%4_4kDX}T z`5E$yK%CE@{8tE{^CiR$gu}TU@(V$HwkAIXaq)X(oQiw8jn_DjNSwRSa2|r;tTUff zIOjs#L^z8963-bpUUO{}fLC#q^G%dl0OH&a`DP%_)sVN~mvfoqY5AUWGYn@6^2K=< z^7}46p!AFBe=Y_~yh>P=`CXRp^0qtAM7|j5q=8{cb? z=dM?rA0(d#nRjF1bH^*r+cKT|kWSw&5;X44!%==Y5rhTTa@a_JdQB=j)d|(aMfJ{4qkyyIJZfB2GYZKLged1hI75- zxkEhPQIH=6;(RLkaggWx9rD~AjPG8^V`nk%+idWzEvQ&J%OKCWRmv2C=NvTCnTm9B zZjv~^C+A#0`DGw?uL`&dYNY#)3VcKO;yf*7rXn2oyK?XrQqA`c#LoutoeB8~q*%PI z!SlTh@qr-Dg)zEaIdb9(M!S4ZL_QnD`D5~D zAuhi2AzuLEyf^t=;GFwsT#FDF-|-P|0L1-{9()4A=e#ZP1pIUEn|uNMJ{$`NMZtaV zz;KfAjLbQ0%2YyzbNA#`q>befpyNQl;o2e4@!*?- zT7XUf{R7yypu->}NW2L5B@l*#(1rKqKwIG6FA+7L_YdiX+YUJMq~rWD@Rx(ug02Ad z2b~1!3+e~*M(w&t1)m1`1#$cedJgnFh-<27Yw0KOKZ9Ney#e|N^fBm7&|9G1@Y@IU z3HVPzCxagV`V9Q%AW!4ypxlui3OeoyOHen+q<~i8>|)Ssko_CzYtT2KV{xq^s6MCx z=sjTXgFXNa#Q7;8#XU^yU5>FT=u6O7po5^dLERzK1Jo1L3-k`KcR?qD?*Qrq>I_N- zbp&+*bp^EowFX%r8&v!I@6`ayZ0)aB1GO6X_tF4+g4$oL25L3%@2P=9Ump6BegCcs z{H32XIiswwdRDZwsxnegS`--*t*R<6onARPvuJWgv~p%uS^4ByWkuB`(aD9CGYSf4 zPR@$X8Va|2*X};sbxvVWJIS{Pd{gTacR#Ue{R6J(UNFEWi%Fa;YpKoD$1r; z6wHbYE-r~yPR=SWtSGB2n^qMWS6o?LP!btaRb5nE7U`OunHTAilG1bXxWc}Zkw_%F zU^+aMS0JUuB~@KZ3#SSM_b;fRVAi~Oo_@L(mY0hGl~ol`U)LF@hykV1x%jWFDk`Y( z0I(&+Q{8J|i_6Hh4h1lywHOec2cZ)8N@dZ^{OYP=oB%JJ3I(`uS!GeQoLFw==)q&N z(?#*LNQVxJ8W|YrplHbz(b|;jaG;`W!T%h zu&lJQDpEM3pd!+78g7jnY;kE-q@=hsDqltFs*1}>MOk^YqM)j*A_8r>fkZlr%Hp%4 z`Bg}9d09nOv}g=YCC`;*)fI(N-h08oz0;A5!t*I+r129`E!UQTu83|AiM%g-4*W~g^1Jz7$dSC$(sC~+^QXCf_mqw;ez z(?-U<4lXV&%BhA)hr)OOgNJ2j=_jzwW&)+)s;maF_}}su^V!C_hDRaKpygE+cS~$l| zKTBoigv|7D@eD$9ZXNgURo1AC>@@ct#fwU)4oT`msq?GpEH9}&yP9;T zm4~Xx%N>?I#8-vug$;)*!m2QGRC-$8s9cui?C4z7*LYbL*_q>6$-@=695TLun?x_* z3{P$GfHOh?y9$ZlRY+FN_+9OWeBRJ8Xd0^u@<&%kE9MKYH7uSs2Q@=3CXtRE%UOop zf>)zP)~K(s`(J=&fQ>;s&uj+R93b(G($7$3zL%w}%)GQ9(_Rk!sxho|Ivai7xu9A= z!MuI`jVVIETNTAuICA-mwT`h=cm1E~fQM%BAl;Pem^Xa2CWoC`a zjWtG)NJ9p^%E(gB(#2XR_Y5LyaQ?`$>6sN3D25P=bS#)P&utK+6%|seG;LOu=-Ra_ zLWmVRuYHZ(rr#A$F*a}5NCusQ!9>-xSQ%meu?W%Yj#vXE-MT3oguz}>4(cl# zt6VpLL1TxF%*f9{ZDoT6Yb~x|JR)>2bE5_2=*em%D}8M4_{_8%6m%)isFX+O;!rca zE{;7`R>92Zm|)~mLxrcEULysWMa6|)0StA5nHj^Rq?vTukOpMZovEj@gJj}ln$b+BscvFm_ zY<__|i0UCH*BhuwgCch*%z>^q?DISHS?rX&&fXjKu~f31J8DB+qs8?V$gyU2K^4Xo zaW!(RnVpt5Y+S4`K|%5MX=F60MNqldkB@}WI5)hpr4_Mp&6u3<$YyMId~AaYvC)m| zBR4v`I$G%t{oF?gDihB_`Gd1_U`5Oo@k>rxiJ!=z?4W#wQt6Eov;D3xRM%ny8I;5L z-A=1Ow^8$Er{$vK@S=_7+8xMAK{DI!NG=GJrLejx8qPAy;@G^*_*f3X1vQRY#lSuG zWP?_iqq|;lz-x$OMWpW$20>mqaR(-8RqlgN&d9Mt^4TA7SRE-Xn=9n;LZoAjqF=KB zm1p@yi$e)KwgyiWw1BgYc-FS<3p1EO<<;H=a>lRD~yOJeAC16=)wnk$P(k zzPym!vJ|_i!FZIh$IG#oH}6rPlHDyHHU3X~ZvvlpRptNRq-mROw1u*7PZuCb*Cbui zQc991X`41l(!_gPjN-1KqT`05h#k>E zM#dclMeXnXIrqCgPg2IQ^{4;;)fQWCGNt;NbXTlb zXQ|s!2k!0LLl^XMj4LeFv*u`PA-@jFrtyd_ARpg$gqn4JplxI+!oINP_U@sKB%^6E zHlC{LT58owFFH+7w-09;+GS~JtLg6>PQ!t%ySsXMj|5V7G@Ew#-$U!un7Zv(2W`Z8)sGm;9upAbC9 zk5I0{#d|0t*4MXgwTxpCVW_YhC|4?E#CQ}}RZ|m;_;5`Y$*$^y(ZC-mzo@JUfN1VV zs@udLcT}LbGYpbT5wGh;${Dgf)tRdgk46IDy`f?jDk(XNS*WF$Vx|EYuB}50j!|Mn zON}5S+vtmgVt$73nh6AJ^V0)sBU74#WYO#+ri<5b2|YP6x92cKMCcJ55lh)%@WxB) zaPazdwTX_cGEbmF`ITCzYO``~bhwPulneW(AZx=exgoKpm+vPjT} z>`smLx^1o20DdLlqSAt@c*6At1?6PiR(+6#q^gqJs;#2+&<79S&{pO1tQeF3DdQ;b!Iwxh6XYnMa;;V1G1qOCyhRi2{3~tcusmw zD*ntEon=97^V+I(ZQIt`<`%8y4ZUfj|E*gqbTH##y=(B`2x~GQ1*5$!&6rjy<{)Z@ z)mw^-5J7F5s#?>E6_uHA1$n<&WxGJvJd$>ee+npCOfKA7(1w ziR#tXR#c=dflOy{v8CP8Qrq0Pr9l#k!4t|ap0bxlxrk-a5F*F+2r5T` z1(Q3^_-5zWfJaGJHCjSLhI6!EDDr8fJcO-{5GaDY4?hU3TM3L7k%`BIWjL9wXb6BM$L~k|f64Sitzvn=Did7h7HOHg~}p=tEhn z(2E0N*%l6JohxF>jkd>%+H85>*0!Lnt-h|Y)_~At+SXRQpsT%SC{vueG}XAJzCN|e zcEbYO+Mk(GR`GM@ELgH&&YWU$4ss1_?n9X8?CxPP9MmaJV@u@Ng{0kwsXC14pA;W+S%sYpHR>F?W>>I%n*wWzm$U$E-- zX+drq>>ke4lhk8G$!Wo*Cy-2O@!h)DTr-A1q_Mkto~@#?ZLDEXA<~zS!E|-H{QGqnn84&VCHS z?R}o5n=>65Y-NM~sU_3b2}~Z4&41m{egLI1)9F9<)$C$7BgFg7dmAXpj$4rOPZ8%( z!4T&eE_@m-h2P03Rz=c`Z_H&F(S3b#XrI-seVO5qS8BS42HJ-^c55)@e8NJkO3OR0%XTfwdq7-pC18$lykM zs!g(}iXkD4w@2h)U;2KJ#UWocHL!sm5_iDPJxCPTNFESmIU%3KU8GO5-VUdBPlyio zo+Y#f(f~>l)GW~(zJcA;*bBm7mA(hVld|mXY||3nXBQ*(S9ABb3etX)!c}kD zRG-B(14GxEQkmplaMItkeP}fpy0$rUHKUs8340c%8=u$~8fN`&t7}}lDOJ+LP*agM zV!i4eG&Ld9hOUidp;Rm{dg}UG26kr#NARjiAY0eBWZDNic2{+2&FPB|WJdqsu0Wa$ zwi{deAydbhoc6wsOs7l*I*2o*nn_cW>V=4J$he)X&NZElJh@|2%`Ud*_y&p9+J9O5 z{+NA}!`&Fncq?vAH6w~`Zw4AYJ7g>&z$zdK*D`#NJt^_(kU_oz3^kiggZgMDPmZRP zR)S8_E7ievZZ%7|5zLzG#04p~Uaev_A9*@QtinL3>hATz*dybChJ5g}HOUu>YRxpw zW-puAYd(SuN<}?Nj4z_i`ZL)><%6PN}$KD>`m=H!P zjxYHN9*D(5*5GWx4uE>mKbV-WD2zsLv+d2q9HN=mMz8ZbpKYDUICYsuo!4%BcL$Or zYEvjum@3w`4>wh{_?k!WeW!-h6PHqhs=jWHP9dpSi1nM4@D1teu_c&TB5X+9e}48& z??rj)?Y`DN_hoftp-hy3Q8`p<-C+OTfrj>>V7gY;y*wGu^xM=*A}?fv+-#5rqe{IU zNMN!v6{3#G@qkYXs(EjpuU9MuBM$0fy6P~olRZ@Tb!YasOGOw8$P!Hd2|^5YcVhKJ zdir|o^`bN)s_iPIFk=jBTgb+5cP~6L6b$CxAvQUE`_(C1TSg8M8|*eCq)Kdfv<`BD zYyDmfG+A0FCwx|`mDk;`|mm;OR_nIt3 zpX}f$qK*gjv9_>|u@^|^j?9+6-u}++uI^CxVlxyAUF&5{wJFmU0!Hoah7m#-WlaQT zoJ#<2>Vl$4DXez^%^8BQ;gHCe8BX#)N>qF2pr{Dc)`cj`5?suxp~;;2k&_ZbnYLhV z7BxA3lZ9+Ep-r(;#99X0_xCkv6V56^6{+Z2vn?kDw>q4e=UUp!8XmJ%0TM4TrlsdNQ>v z4q5n(TxfK5vkDerQyu+1>|KZOUa$JLm{w+{$*j&Dy0&4+#I)D7)BU}@91d5-7!Dp6 z&39^{mvJT+gJyVjnGbB4$5*zft3H^Jo%#^2?&%DqhH{5Fl8a(c#wM&YjABL_n1cM0 zS{2FGvh(UIwza>9^Xx{YE|5(bh7hf_(swlIBz1SxFwVnnPfjxZUd2~-Snu0=JSFw$^NgPn z1)1Qrat#G2S_o~@>6?hfvoyT8x=EESm;pFc#Zh{{0F@0;TR(w7i#6MX1~4={xVK|C zHQc@{YjI(72tCuZ``}P_$56x|en`i2g72m*ev=-b9QhIVXt5yX5exe^cn=>Iw(qyzW#n~wV?(eE%vOW^ysc4_jUU;Fh^h!G|CJ2L;ablYS4LQ?T|fve zc*2nrjBP*dDGyI0Ep!6Qyp3+l!;kaq`6X6gkspJ;HgT!p;x3xI;G6|1X~@1Rj4DuHNn)>`eQ3>1u<#+@BK(pR%xcItQEA$^@vopY*)aL zT8$?AmNiv?4n=#*!J#&P^dOmzGnD;IKmObWyiUUroK4*<=1mOrvSJF>+PNI&)mXlX zddu6#qN>#m)rcR_5~!m3$-lvRmvcB})heUSXfN9BZ22fB##gN(LpudO+Gm3qc)4@b z&wBcIF{acw>K&|s{pvibc$T{3v2AU8`&7x!wyuhmJ1aVNE@>;X?JSONupF&xZQD@S z>dKZzIBj#u#OTV(BV0{w^_F$6%x*^LxEvqW)NXfWOQIBYjayq8eQ4)2*dq> zs)iO@ZFg5$lM$B{@=3v0LYP58iNn6;a>G}gG%l@Tu711+tH zP}+!i(_M|5N9sK|gN zM@zqIRo3>VI4M*uvo%tQu$^dpwfmS~JR51U@yc-SXsYYm*S`m?K9Vke?STe^GNz?a zsPAORHGoTk8O=-UlI*n($FJIZOM{eM_T-lo-N75x#ls%IGlBQ8DM^0l2K$g|tkj2C z&}B&-8^*q6Hfb?5^@Ujk?BoFt2x|(mi$$gqcy zLJd__vOXsGZS$5|j<%DqX&*@wODo|LMiD)lk*CV9O?};hKGZ_kn@Q^W!d{MXs8#yf*o^JT z-pnZTOf0nT9@IbTX#o9+oW=$#@jIgTf?C}`&5zELx$Rd zQGZf-G_`P%?VB>x-aCLL%#(Vb*I@kv#}&}e%+}#&UcZg0j0VEFFllh}P4}hy{_`a; z?HUVajS7&F9%Wq@QQg+8I!GL~R%)185|WsJ#mNeGMW&;WhY8}z0LAItG5f+oWy0n#( zI(yk_vMmAA)s1*mBx_L>eFo#pdQ&YcLTr;kxtC3buXwLxxm@dwwh6%2vE=0fi1vn9 zq``!qUs%0@w-p70*$&o{xVE>OgWWr|on(ye%MK*OKtC-_=#^sXn5DB`+3*VoZLBEz z>_+e5#EQggD;ffp4?1FUJyINOkBk`Np-P>U8X?X%I(!-}g$x*NsMS_GZ!n7#*Qg6b zA8*BhSSCfi$P7&-RwtW)C@S8PNm}9jf-^MM`<&I(3>?8+o8+@lq70bA+pDFaPqZ)7 zQO=Hv$G4efCd!NjK8g8B`5i5HK;!SGb-bifnCbQq?n;6Z(3Nq>?U&E4teM9lg8RFU_8&hcG zk!HqbhhM%1KdV-0u^v5St5H7Xs#O}lQ4-DAyclw}6@I}LORvg$WobRDWW6&@ro$Fa z!B8MPxg)CUroNFz;RH8OF|l7L{Go!*R`{<~+g*0xKB#^oVQc?hmXa~6Wn`-c z<<+c~-TiyD#O>jVk~iG#W8oe05Nbwud^tQE1*9;nsxwNJ!6r<>He?zQzX`LX>`lQg zrCHp3BRnfJe{%tlJZMSX5H#tbL-kCZw7iwYPR;H1XCrLB7)1oyUYHj>0n>T&n+;p8 zD20j}8Jo2#(g==W2#eJuc+?MTZyHh6>Z47*s55iANvX8$OZQ;}A4VDkZ5EE%lpiGt z?6u4k)Q zT|M<&Ci0c+>RAsDsDYuKPH;Hi1RAwa^nB1d6VKKw5Gk0<<42N?RCkquZ$Ios-$`u| z&IUa!UDwABn6Gg>-u>*TWK})L@_@yBs;YX{?0%1>-KIiPq;)n+O9%zQD=C>X@s8PS@9U?;{Rgh6Po(OQ;898bo8sD?1gPq^PI(LOhwxf=<@0O zZBg598VE_D9`N)w%Id=${*B6z9F$t=5q?Gt_KEl^*_B&$L?B!@#{)h>p-Hv&dw!2_ z+3HAyrZQD_X+w@}{7_0fQ?4H#BhNAfs+q55Nh<7+sCy(PJV|XkDn5=R64*4W<8DUC z?8A3a)k4-!sL!fTQZ0(oCXSCN%VXUH(+O$&#futYE)LY#j z9|$nrI2{-flpFLsY+#f&?G9eFJSqZbq( z?!|bVde<9j?YNS19=YO-J{J@2uW#QaJ6EP}C~@k7@9a{$ZEY!+Y-5WsxeASNS(;T; zOqQrtGC!}xr$_DRj49hTy?Dqb7aOgfje;drz~S)%%lN@46fCL}b98{Q3fOTn;~Nt+ zQSC;ZTvf|Zya^73kxhlsm-Ly>xvqzO$q216X@_NuBG>AqkZD>zfreantecZZJl3Nu zLQV_}8v#Ch8_#i9l{3XnWdgVc!|7r{T*&7({uYDv+A3iiA%QhDD#SP3&j(6XGuS`C zfs0W0v^t|Y+PULUcKb6+Qf&Ri#aRH(fAx4d-08KQ1ZPKO#rkH18et@iYif0h66VZE zF+Mn>93I7rUcm8IL)v8h9Z)+@ZW6C-TqOybA=L6mg zi5wKL3n=@yUgj?{Laa?3RGdwVOpHORE}X zxQ-@ARW+nB&c3*d&$f|n<8zTsxeqn84`7?^j#c;sn?_|B&Q|vNC^=fZ$t6mdYr0Gl zg*8J$9KzFDL_}4q!HJMJ#`?lgf%MLI5#5>7MS3R+Jm1`D%j~FXbe-09d`E7ck!8LJ z=4gq+k^%V?@sK~K)WaNZHB4ykdJfpY+k8w#3k_*{YwRXT;Vt1{%-kHe&{RxqHSj8T zuOzCk<~$PWXus0=ZZUT`JR$3&#d-8abW8)SAnS}q)L=U}Zl(Iu)B=MEy_2m1p1e?{ z@(9x4P-ys@3eJX-D%dqn81>@=OO}0b(#*_8LWGlux-9t&3q;lTn_(s}lJZ1)oz1Jc zMq%aSSHyw&KgucS9$UN9c4_=(cZd>*AlXK7pP7l^C{?U=L@2M&M~8&sPKi_G+Lx4b zSRtRv3#njr;uT4biXI3KTSc8^+^Mg#HhjW$pEf1}YeIPLI9D~(xA6cUA*dt5+76-Z zrp2w0T_m(aKtFG9($L858mZ(a^6fvf_*iennW`GG@hB>ScE*dP2%BxB(WhRW3I?L@ zZ|+$IHjpGib88mYO9xM*y8Ed&M>$oB&6a*?Et9{jGiXA{*kF@r>DTH=*QoFvO6Z8L@6(N~Jxac;wRNGBPBJ%CUy_`S=h zAb26%s_?j62DL?8NvM!!b%x5#J>MB+>{}Jyo3N9z{+-WoguL)FFsMzGi)jX0lj&TW z%8OT@Mi(2+F)3+l;@s_VdVJ6UW1Q1<>|V6{ICJ8vtM?t^3wLieBtgWMcXn3_KRkEfC7e%P=IE_$+h8C^?!qG(Au=Y6?uHmwoNtWU; zyV}Ne&zoII>^OB1A15a0Vn^+8XhNqA%TViks$JJ+gGpC2Ze-lCWe!)Wl{^Pq!s%T@ z+l<@meUIR;nA2V|ShCLLcv@3;#~x{c3^5L+2ODGxv;rWx}_i8;_JW1XU+} zLdrxA+}hCD${cLai~(g7IRi;uI1qk#{CyjEq&N|5Lc2Saj}(=WWV6$O$LALtqM8my zA?A|B7~E6(c|5+P?5^g>FS2~R94is~K<0BR+ttglQkyRqf0FGOg=YDLIaW4ycFf3l zj9kK<@`$gFk}{rs5o70sA|Fyb>q6) zunMq#EyphP)7IuVDr;&2wRW5OsyH6(HRIzP%ifc|_xBXQi0NI(W3H<8bq;G5XWij# z6A6Xbyy*M zJQ#hIs08*u7lxNVwMD4Sxs{D`ZZw7>2j(ev}ul}Zj zCh2wfuijW%!Iag~>XsZRE3K*Gua$0T;iN=_NtdNvQ(0M7A`W)rbb1|QDo$6kJnd@h z@rjhcRhOsTT0CF2)NZXs7mV_(#@|&#c>sM2nb`4F-8mqQmmPnUgk#<`enwBn0;HoQV$;xDIHML9KI$Sl?CsWl>=c)#7l*aW< zFX1Hn#-%F~sG4euU0PL|K&96%buH;lTV(2v=(#fOTGlOFR+hlktRy$wV8*GcOTlbQ zwko}hnw7V#OXgp*l>Esn*@Eh7XjHazWg@e56`3_OY-%enuV|=RhjXd$Wo>!I5}ifY zyJag{>Y^&}f>zs$rOT?)QAKLYSC;FXJs&JvQWfT#qzT34=S)dT2?Ew(l6Cvb+W16lHS;|o zv->SARa@#?TefifAWU4g1b)FYam)H@1a6EjU9rNguU*$%+lcKmfv#QaS{gQO%zlHv zTwPy?la;5dTw~q3^{rd$$7A|o_> zl|_N_isjia!Y|6JmnC0hwSH{{mqZfTWz~?jS2(VPG`BWzhzwy8R8NjmoL8(I^=+7Q*{E-qiiOHnGHR2rgAP-%ddbC< zM4f||Dz&tHNmXf9m4lZmw6uI}x;*z~NM_5rwrm+&{V~XE zM+OEumQNneM6Mhmr8>uRmMcfnf$~$ED=+s6GzSKArYrZsXD0lXln7>?kf;!B?jyXRfXrx3K%G3`JNzw7iP>fuuZ;vTX4sAx?n`UK@ zX>kTglQbZhR9(4$ln&!RlG5WpLc8+ctXy)O$}elaz%a$%#yU8(Sm#{j!L<4^)K&f0 z;nOlH`|4Qkj;RQrmRruW2rBT0Ae?{q4 zS#PVWTIgq=BFEl`k5>+-4_#4qRdLoQ{*Pn?FUzlT!CI_M3q#rd+kcDQ7VWfJkWxjA8FWw~fewlAQH;lnm3alTe1PK z?Qx@Zwto{=CG1*RL9)A680)5FlB~W~imbjCBD=4J341g9FFnQ`&#CU{A(PUEfxD7F z&R&pm?v(i>|Bh$%wivf#t#h;aTlU3gIM>Y|zy0@x&NX#9_b`9c{$r;*cQ1d`e#WKF z-O}s7*?p07rxiK3?kfMhV@;fwpo@a?E*bCfh5BRggjdgY{Ec)Ezhjnjb5}aId5?cS zQt#ZCE1WwyD8pk%{{JezxiZhW{@o+r3G+SLps?l&|2x|M-_W0ZKSp@xROc$mqiVBr zw_fPnGU)Qlj8FWJl-<7Exyyp~jF!c37I^G->UZ-B4?j`j+^%)Tg0rM``DF(+|HTzMuY1h98$ZH*LFfk4|## z4BkH;^jDZ>#X9GnXm@TU{q~Dfo!bB})X#D50~a}WCwVtkI(IqoLHMOF<=j1|gkQ$L zZD%=`q6~#$_~NQ+4?hc?SarGr=>U(&Xv&K7g6@Bp!KH*{5NYh z_}@+N*#{>(_xid1S^w88a&Fl>%sqm`W>ck6>dk~gyFU=$e{C`+sb!e zqyE2!w+i5eLGVS;^={gr@U=h=)y{VATH5yC3G*0d&6}LNco}q~4^E>$^Z5N3xNX$^ zQ`A-AJ9GVS_-5{~=^YGCW8>e6Q7Gj!a{`%y;gO z{60=!?5AB@7>kECIQPwF_>Z=p%DXUB%?lyYFy_A=jN64%J^rIXowiS)4FO#WNf(BX z!6&Cup9dLRTj3XlZ^Q2jk8gDDL-1cA{Cz)lx&KV~hV*H8Y&<;jF!87G@Ehp2Gg8jY zhyUNa1Rk$+?uH)afE=e!7EGqy!L!GX{Qofd+(do~Z-L$lrzGmB=Y0C}4E5<%wDkqf zwNUQ8ls9cUyv*3YmvQq0_-IN%lNVCosf_iH!f#JQdxc2}p7oeN?fiJJp@jEAoj*3-6kfIFG;@@RKw3w%<5ZqVx7Ci>{3@Z%!hbCNzQRKjbgQIGOU z=bnSdJK*<6`<;6`<3!<8^z9|HJp4=`3qHYk3B%TzAw(S*7qjVuuTjoJwEy3!?;!PB z3=d3a>?nK)8a>n%O7f%rPZ!az^w0I=^%U*eh9D zWHQv#hVL{vcMkkG487OUA03o^J^Yh`-*2x=JtiqoV;IkA$g~qTT0vRYGc0N;oO^`;R8XN`NTb5=iG(lU5|XY5I#`26+TgT z9rb!YeDPuQgJhUh!`NqDKeL@ar(a)vs&l{L`RNpM3uXQS++67V_w>hR+P}ZofBhcn zrO-?J7uO@}7dZDe@(RNQXc>mPsn2Zs{iB7>;i<^N$hxo1a#tUH1x>zi4z#@zy@@()W1Rjc zG=3rc^=`g@mj3uG`OWL0-_W&ArMxfK!b{NUF53H5^4<~9>?@?jGpc)nzWiK)bAO=C z?}Qew-0a*Z;g=(PdmA+0oCnX*=hIfkEjo=cq;NaD6o#|O>k8^~AN{?ZI@clxuAr?o z4UDN)=O$3U&(PQ3pqzEclHMzjht!koM-6+SeL4O8dFXpLb$J^!{P}6fL+0%%(Bu3$ z&Rt5qrt|(O@?K9_x1NGday8?YIddj?|DJmO!(?<6(uU#CMT}SIpzsIMOoI=f;v0oC z0@?MJcIW_atnT!9{l5=de1viyrXLh`(DupHX#;frIQ3ANPoG_xLXMOFS+w)x(6VMO z`Wx>$<|99f8B6rnQ+zj#wAUkpFQ9Gx{I1!JoFV-s(6Nzt5_MB}FKtPNPmy261n0gq zHHn4h6Um#td~-d01}zjm8xZ$DFC-s$<`C^U^(^Q9qnmjq-~*-m-a7pcPfhZ_`agq= zd_}2quZ1SJLBn4|=T}hIS>tFY`JKLsd>EfkK;zYyI5%+`v_A=6-0t)EF@3FY66Jh! zCUUn1-H`tI*Q=PTxA=F%^yiZ)WC{5nf{wR9vr9KJC)1WNe2f11@~PpI|GkO+55pDo z6JpYx%h*t;;o(=b^L5a#3p&4r`u>vNAJhIy`nd)A9O0Xn0RM03JX&}q^yx34FByLu zq0KYU{9`HT1N<5K<2B@`Fnuk3T;kjvwBsrG;ZgYJ$S%@?zXzHWLnDRT$VZ_nr_Y3Y zJm{;JB;Iw>=G?FtI^O~96wZfMVYr;}umO4&Rx(D4ktxC04By|dK7{=52kFmqphYrV z9Mm(3>qZuwU5y-O+_yuso`5$#*8new;Dqljr@hcR8QLbJ`|;E~VM7d4cNXbZG?ATiE!^W8{3M+4seWsiS*_m1pTKVhuSLpJ9l8&Zt< zBI>byG+&+1d`JDhPJbwD zpv?2@krrXzpPLZ&gs zK0KFshxhmL{T;n9Frm(!Qk$jxMEgm-6-k1^L@%G!!DZijAzQz;*ratGtknn?Ej(^VzlCx#g7iYk2C*o1I&+0~yUcqc8=UCqqvY z{7N0>PN5AA*ul;u4RznPkTn2(`N4jl`X|t>h`v!c0RJhxnYO=$?~2-;D`o7jsrUFh zsB0MB2v2N*cKqE03%4=`^Cn}*xd<7RcJ5`=@l&&DUokR@d>%n|e2#X%pLnQ-u|QsL z<=X!rQChIqH2EZEo!IIQ{=gcq$BEf>sK7r1=7MeiM8-S~$$ybrhPt ztCaCq$=H~S-b7t;!w=w%cT(n67ck$G_sRM2J8~_v1iJBVkiMG5yZfl)($k%L@g{hP zzPgKXdlo$MouEFs`JPGHzodR|rLCWw!x(|LO2(m+&t$#4k$ej2E5=NkG5Op1=rD|{ zM=9qzc(Md~9ZaE{(e7gSQ{g?(?q_>QN7|nwKS}~V-_NtcRPx$c3C}a$ZrO-FNLo&e zS&&^h4AZFBCu!rC;KlnG4`Fz7f}i^6|N9E)Px@mnc`SeySJTd#GRE*q@}5S$`SwT9 z;(gTn4*K*Hr28)E{&6cZ4*VPWzJ3Mz0(3f`Z%^Ie&HZ8iQme8WF_^z zgI|RYK#v);@0+|UsCBN5Jbp(R8>q9wbmYK)mLOMl*rU5}mjCUjqaR800Cj($(c|?0 z9mtAb5f#2Ro_V~8?~7UglkXy87%qiIY5GQCA9*ChPlLLJxUxVN{AR7kR5Aw6IR#lx zIq!uItEuCUY4bZTX6;2kT@M|<%UFK-bYwsV*~Gh7ET;~ndp*D3q|FMa(uS8+LPKy% zfZxjRjnFR)SMNYC+sc?q;GTvr?}1L^8DFD??`$D2>Xq7!4o06R!)EyLC^G7n`K&#H zI^0A0J+qUkJUnyqNZhe7Z=*lIwL1Ilo8bRhjH{{(sOuc&hMkNZ>b#^cPS;(^*g{_Y zro!VsL_c0any2BpUyxqmKKNYWeA1i(9d^Qd+XH$myWGD^{y&}X-jqT{Rgwqe{L%G{ zYx?oWK-)09VKe(M(DE>R#cr;J$7+y+eDhP@ z{gC!IoCe>)FCW|iEvVb&0WXDlgujd7RfTPgvqu-9&%-O%@4zNM!MQKOS5MM+j(j#y zFNGoKtMKhJ7~Ak*Q7d{A@WEw_G5UQSJorW0{W$nrDR&`!cqcre@Fwb<47UcdrIYlN zkzY}u{tC;;SK%kffsbAaZK3=6wdga~P{thkG)4R9$2ahPsFeAX`6hEEy89mc%>LUo z19=wE{*Sb8TLbp6H1(v9E~G6x>EDh*=DUC|!!Nt$dFV;n@D|#jP|@yxbN|2dJjQ>} zSL4^jZ;!0<@P6{%Jtf9JMtc?3L*reGJ)Hc1B6LrN64E8Z7wL~M{Ah=V{z(759@@O2 zI(*}QKa=>j2_Cr$M4PxQz4U)s|qd9 z>}v8lypc5U;VSz3=Y7mK^x5Yr=Ma7V2>ozd%96Vy^w;mEBIl9Kw?nUFn9o?fgMLZD zvrq1d-|V4|`)KR$=-XwqZ6S5MmcE-$TfY|ciBhkZ%m~K8M*8%I7oaDR*Ax7H1iq|+ zckV2vUVMKgb$*z<)=|GV6Cb2+dXXW|=E&aH&_}S&Pnl5_P1Ucf$7v`ECdO z`Fd~)izcB%^6n7*!HI5nC4Ih!KKKDNEA3`2OFkEpz7zUh@)UjY5bax80sZI$h3&j+r(Ozg2+BHT4zeWZU*W%!4}It(2QB_c9>0VJ zzn~q5q4f)=C`BAz03TLWGM7+(Dee9~ZF|R7bj~%bQTRR#AEzJx8NN8>3g&e3dLXE; z-XClZQ~BQyk>}4y|I|i)q0QTA-($+3ycIr0|0(<$9vYYkEjKVu#-T3}zd>Iq+(6%l z;k60+7G4-){qN(Gv!8RH-b|fe4nNM<7|Nl)($*#V|I1Ct`AWtc?R%KIev0}e!#M$s zi>u%}+V<`Q4=7zPbl5$Yc>?|DUBus#&(Rk8<9x;{vh44tBIjnHH}L&y$@}VF>PGv2 zNFAo~TfGpyf;7+4=k@0?en@vSGGy6h^fmQA2O7?~h=Q1l{>a$*9=x0kzhyi;%6Ieo zJ+_&CUku-U7=D?JZ246UV{UEy#VxI@D^5mUF?QPMBZURD4 z>#4(ejGLo{w5yG@(CiEFSKXj5NB^IGI{E}<{f_z%Gvgg zDc-MJ&YFq(o_rePaSQxJ+RMA>JLrAY0OJxmeXBaoI|<#C&)mXyVR(>sDZC>Ooo70> z$^;*F!KXI_^g8WKY!}Twt^U84@%$5b>HY=iDD&x;4D!0izkhuvauRy{8?^iZvT^}@ z#Ic;L@LAe&2YEc57++z6XQ1aTyZqB*&?yY}($4eOAh%N?2L5Y8SAu7*q0QA3sRw;D zmo^qsrzOy8SCG&5sl&0t&**1`>*!O3Clb8rG4Ln!dbmExuNoW^gQbR4;PUKJlP2C6dnlV`rXJ21&;SxxCfesp`5-9!}rhe(0{o||gcjNe{wb6uv zLnx~HcAP8VpXQ@HaQTLt;3l}~rW53m!s8~nnQoTZ0ScmTC%eya^flrnFALhCp6FSQ1po;09Exz-W0LHzAGZmC=0w62KLrQF%>Jf|}OF>W49%_7rp<8O=HVpnGRb)0U2 zD{%{Lea>DJo6&{|XH31oBBIp5K6+Lu&1*%f4$lszE%ti7k?v(6+X zpLHfB`KEKW2b?a|Vvlwv~ z5>fQs@Bj5hP1E^RI2$dLg@?El2rh}NhuzC<7zMIT@7J9b3qj&dG9-ZKp6ItZB4^hr6eig`? zF@m+8_yQj2Oc|UFcOUgSNqBxSR=7gGV+Q^!h0(^p&O(+(V_kE7%4}JAfliPI{UTf* zGQr0G3|gHs+kKvJDUJVA-5f@z&V9yX?ku-}(W&#Tak}%NBG-zuaP!;-*I;{dd66tC zcBM!K*~8=f7P*Vv8aw|Qi=33=&b34V62DwzxEtrTmcevf}M4aapRGS0sg-Fm@w!anE^A)_sjwCQNjV zuG8*4#JFi#*ETxc;fVF?llXd^ol`70dUU#M0-Qp{PEcU``8wyWyWp~og=_9`t*X1@ zI`^&nnA&3%Ug;Fa!Wad{C~#sZkURc0UTypk^z96+urrfvG}M{euow$t6d0qx|1b(@=TY|xbszZ-Yy0;?3S6~i zyt@g*e0AZRrh=*&E6wH}X&{Ub4@!}gR zPcAIDsi5$tTM7#c=Dj+VDl8~?acV~4yqS5fa9*J+c-i_HHTFzJ00Hhgu-%V(c8@Qr&Oy8I3ASpUJZ+^sXK-%u~zr*C-YH}5#Sv;Sp}9XWdRNZzZT+cN)$SG;}kG z=!-`W|9;=ZpI&-&LeJ3~es}b_Z~bcj(IbC&^l1OTzVx4;`S?{I|1#OT%Eob4FZs;) zn+thU^L5r*I;D2W|C)Qdu$=UZ)rG9EY0!--l88UOpjo zpTpN{`SaGQ@_FAL_se(oGV1a_-MQ+0W&oCYj zncq9z3;&x6c{P{m&R=+L|8J&lc>{ZOKT3W#{b?A8nmShPj``wPAN+UmH$KCuoIBnm z{%UQLemk*vwp{)fWN*_cCE3;f--OhmQ5Oq0(r@qf z<5B(xbkEoCE$ZylsG)LH>^pPvD;;NuhB(x6^{em-Mg z=2GA;#F>0{$!C@BzspCbeA>v*rhFmmzLETD$lpsI_mp(cN&Xgfhf97`sltNWGm$tB-Ar}8X66SJ52dvx-jBfrMF^DEz6 z@{6aniF`^{0?Ti+e5%Q3jQk+#KD~TT=uW)+Z|ZK6d{WBilKh)|o@e>Ok-q}n36?dZ3jYQouoJX0uXSHxDcS`x*e96u7zV+nK zPj?S>PgDM;bbs@uMBS;>J<+!S%SV&$TIznU{6NVsw0tzl&x?Fu=uY|u-pPND{G`c; z+iafYr&ssHj0A58vn%=ZX&ls{ehF44Vi-Sw7V zBl**k-xK+Y)SdJK@bVQWAGh+0Dc`KRUoGEox>v0Gjhefb5VbateObPA3duu$;&hK! zzN>XVQF~9irz#(DR}+u$PCguTPh5Ub()%h{q*Ob2%-P@Kdl%FBp-ILER-Jz8~Na-x{ zGc8|9^0B9TlkyuPAGGrCDnHfoyQKSl^3fyzLb`LR`|0wZBcHSKaV-B0x|c2gS@O5> zLZa?e>i)2N?a3F5?%>Hcsr(x0UbK7%>5jg9;A6pMC)#* z?ySo1n*24%uZa9{$q%)BxX1^Kd=1DShWu2^x3lh)%O9ZpO2{{~{EErXlzbk@znOe^ z$ls*qd)?)g-$nWP&^=c9+R@#3`LUIcZuy0h?<@J`kv}f^Ki^K&c|)Bq)OkXkACzxY z-9gfwBi%8Q4^R2Wkk8j25ap}#y+rx8lwKxZiSp4PA8xvDouV!B%OD>Ux~nVS?z;1= z`?K<=DLSMmuUAKdcOEB`&Z+b>_O@~-u7>U&>#nnWQ|ZXPd_>6i;<^3I8`SA*(C&O* z{qcPd=RLi>`o`N|vc3J&WreMW-D&e)b<;-+?mqXNf!m5I-#6}kbG}ef`NMZtuK3V( zD{gq%!$)6x=@oabcy`C%t^UKsyZ5~Iji0^dwkubEo5pKl}Z2KYQk~v%mVQaj!Y`0}r0};@{us%g?Ku>UKUR-$2R5x$pj5B5yuCKhY@Wz5UZptS#T|hB5 z#9S(cBXV*Y=VnxLthC6vyIrNbu~6(-kh)PGW&XjX3Y$`H#<+qRg*O!xOr5pEP0hnV zk~hxAGF{^y{No{;10W0M-#zaNZp_a&IV`x3C|?SKZzF2%5WJqKxmxfktX4E81y4YO zvwJkagZq>jcdW19_Sw zgoll63kIiC7RPZ9o2 zq|ux!n4w{Fo8X&>(lZ1vBx){D{_FQWkf*s%_?wBE0|nngl)Mmp19@uB6U=8eH|X2c z-UsqDmkWOlQFFfFtBKNA1S1-3?iH+It2ssAKKa-Kd6GH8-$eeBQG%}nmV6c51g!Z= z>7OON=0@RDM9sZ|&m~F^5PU6Bx{F{$las$>!Q;rm?s@=EVwg$q5`I2WbDr|w-Sl9d z{*Ht26Ts*^yI`${rOycNCQ2p?-b3A_3klvq)cmP@4v>%j{)g}r!AK7lTnMbWNpL=S zYA#j!L!_5(DSRmy$!ozcB!B5af)^7d>je*jw|g+a<7tcLJmK@mQ}em%OA&O~Ka@ zrE?3eB5JK5csgmMD+pdsxzYs%Gwe-gQ@Kx4uKZdHeim4|ztSMWY#kza3U8&~3I1kY zzUk6}yNJ@M^ljnh2lJ$B2;V|k`g<;d$_@rK=53m^cBIoNFzV0f~lg@8b)vhQF@f% zI?_m&75sI|(i%tbN}_yV3PyC=T21gI%98#icmv-`{};TJDBVIZBF}VU!QUcJ`C}6N zdeYwnAiA9a-K3KXKan1jJ|}o1X|%=>d^u5ngF$c}y&+viZ~^qxT0`&wqSlatCzG?* zT!L$f(tQQbB~STbRJlcztM!NQ3~7H)g>69) zYJDmA3ZisQ!H4)(>sP^b#D5O*Dd20Zr-YwOKC&yQ4%?}N-2nuiKzp@TR2r&cYX!m6 z_*Q@0MDStqmp(1H7g#m}<+Gc7q^k>mC3vkd1fRsWTC)nKcw18o-bj?bEBF6q= zgVtxlUq(J!GYQ@gtTngNJV+X?|Ajw9l&>4X?;_2&gF2i`O07YKpG3J@>*(7@_*QFd z!A}CqMxr#GM6KI}e-^y#3c|mfC>w&{^NF%q2!qDt;>~95&6jeqBOiVd!67@ zd8@Us;Ck}W+E1`<@yq6*Z!7p#_AudR5VdX<+(&w?(FISXHCp#8{d&^NJ|%nu(f%e1 zzi0DS_8H-CB+8zl^xH`j;|tkll+QinBfE>> z4+F~=y3)LYD4U<)1;icKcvvd{*&&2~3-y;>NbopDq}JAg-veHD80GmOdCDd#{2VZ{ zYY0YzF}s`KJw(~E1m8-O9Y^0j!nd-U3SR_9c1FP$6J@ItO!LfUAozO9mF+}u9{I~& zCwMPWb|=jn+h6y&JlSf6Pm!nWHi8R~g0h_mZXh4o9|XS$ShfbiF9nwEO7IiRyu%B}Ccy1)s?mvO5cIAx&*Ms_81uPr3@P+VzY`m)fZt8zyrN?8f zussr`DdTN;20Ra%$hIl`Zt9~wA;B|ABU`WFd~($uh2Tv@*;55?CB61{1mk7F_Fe=p z1(qFMu$=`D>e)|v*;a+`0G16}^*lg5Wt$XUH^pV^7yJ^U-BsgP{%35D3V0S@$xf>@ zJIO~je8Cf`we}qZzmTXs6T#bwvP}w}%Kx(A3!X#N9**Ekh_Z{TK8L7}_Lzi!Bl&A@ zK(IVpX+KQxS)`QBS@0&($Sy4SYGCcP2;NPUy;Sgc{+GR7`5z{K?H37ONz|U2;PZH^ zy$8WlDN8nT!Fg!A+9wj+NR<6p@U@hsJs-jCMA^LsH-ne$UuE4xS=!?h{$w!P;}ATV z{AIWGaGu$|1-J99_O=AW3byZ{d_GJ*vS|xHL>k%d1?N*Y?fD75kSFcG2u95^o3!A! zlm4ar=JA_PJfD~%o=H55cslV6;&kE+;w0i^;w$;)Rm5MzyT2h$0XLO6jd&9A8F0@M z#{*9wjw2QjPbHp4`~&a)NIV<(9OAje^N7C!_cZY+kqWtQ@cS?kRSddFHlPoJ_hAYn zU;RgY`Mm(V+El>vYk*%%yp#Ak;!5Hw;tFB~(QEAmt`fM4_#9>Yp7>Sb*NF17Bp*t@ z1^ylJQQ~)rKO#O!e2n-#;xfKnPW%tx9}_PIUQK)o_&OeeJ!O zA@5UlxP5R}X4srDCLD~$&qKrggPHiTySr~_xHHogd_9=y$_!@uIx=~NCMzQHrb*5 zOLp(g#Ac%QDO!nJh_bzFpJqGpGUDY#onO#is_f&K)9uXC4u0E-JBb}c?Wgq-`-wfo z0V3NecCKoOU+r7$CGI0?&*lIT^Qg5^w3E$H``nm4vAB7QpVnN{iL%1YBx0hqvnI3n zJ(Y;r)%MawbJ-Lz)!O+z*-X`6bcgK`rudyroI{*ToJYKXcp>p3ViB>Mcr~$;xQp0D zTtw7<(O4Lxz;$CJ7^A=#1;!{aMu9O3j8R~W0%H^yqreyi#wajGfiVh + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/dlls/MemHack/MemMisc.cpp b/dlls/MemHack/MemMisc.cpp new file mode 100644 index 00000000..527c1b46 --- /dev/null +++ b/dlls/MemHack/MemMisc.cpp @@ -0,0 +1,101 @@ +#include "MemConst.h" + +// Game memory addresses +maddress gameDllAddress; +maddress gameEngAddress; + +bool GetBaseAddress(void *pAddr, maddress &pBaseAddr) +{ +#ifdef WIN32 + MEMORY_BASIC_INFORMATION mem; + if (!VirtualQuery(pAddr, &mem, sizeof(mem))) + return false; + + if (pBaseAddr) + pBaseAddr = (maddress)mem.AllocationBase; + + IMAGE_DOS_HEADER *dos = (IMAGE_DOS_HEADER *)(mem.AllocationBase); + IMAGE_NT_HEADERS *pe = reinterpret_cast((unsigned long)dos + (unsigned long)dos->e_lfanew); + if (pe->Signature != IMAGE_NT_SIGNATURE) + return false; + + return true; +#else + Dl_info info; + struct stat buf; + + if (!dladdr(pAddr, &info)) + return false; + + if (!info.dli_fbase || !info.dli_fname) + return false; + + if (stat(info.dli_fname, &buf) != 0) + return false; + + if (pBaseAddr) + pBaseAddr = (maddress)info.dli_fbase; + if (memLength) + *memLength = buf.st_size; + + return true; +#endif +} + +/* Wrapper for mprotect and VirtualProtect */ +int MemoryProtect(void *addr, size_t len, unsigned long newProt, unsigned long *oldProt, char memType) { + int retVal; + + #ifdef __linux__ + maddress alignAddr = (maddress)addr - ((maddress)addr % pageSize); + retVal = mprotect((void*)alignAddr, pageSize, newProt); + + // Linux's mprotect doesn't get the old protection flags, so we have to fake it + switch (memType) { + case MEMTYPE_CODE: + *oldProt = MPROT_CODE; + break; + case MEMTYPE_RODATA: + *oldProt = MPROT_RODATA; + break; + default: + *oldProt = MPROT_CODE; + break; + } + #else + retVal = VirtualProtect(addr, len, newProt, oldProt); + // This will match the Windows return value with the Linux ones, done for consistency + if (retVal == 0) { + retVal = -1; + } else { + retVal = 0; + } + #endif + + return retVal; +} + +/* Gets real memory address */ +maddress GetRealMemoryAddress(maddress baseaddress, maddress address, char memType) +{ + if(baseaddress == NULL) return address; + + maddress realAddress = address; + + switch (memType) + { + case MEMTYPE_CODE: case MEMTYPE_RODATA: + realAddress = baseaddress + address; + break; + case MEMTYPE_DATA: + // Linux's data segment is in a not so simple place in memory + #ifdef __linux__ + realAddress = dataSectionStart + (address - dataSectionOffset); + #else + realAddress = baseaddress + address; + #endif + break; + } + + return realAddress; +} \ No newline at end of file diff --git a/dlls/MemHack/MemMisc.h b/dlls/MemHack/MemMisc.h new file mode 100644 index 00000000..751a11c5 --- /dev/null +++ b/dlls/MemHack/MemMisc.h @@ -0,0 +1,38 @@ +#ifndef __MEMMISC_H__ +#define __MEMMISC_H__ + +#include "MemConst.h" + +#define SAMPLE_DLLFUNC reinterpret_cast(gpGamedllFuncs->dllapi_table->pfnThink) +#define SAMPLE_ENGFUNC reinterpret_cast(*g_engfuncs.pfnChangeLevel) + +extern maddress gameDllAddress; +extern maddress gameEngAddress; + +inline maddress PickBaseAddress(long num) +{ + if(num == 0) return gameDllAddress; + else if(num == 1) return gameEngAddress; + + return NULL; +} + +extern int MemoryProtect(void *addr, size_t len, unsigned long newProt, unsigned long *oldProt, char memType = MEMTYPE_CODE); +extern maddress GetRealMemoryAddress(maddress baseaddress,maddress address, char memType); + +extern bool GetBaseAddress(void *pAddr, maddress &pBaseAddr); + +inline bool GetBaseAddresses( void ) +{ + bool success = false; + + success = GetBaseAddress(SAMPLE_DLLFUNC, gameDllAddress ); + if(success == false) return false; + + success = GetBaseAddress(SAMPLE_ENGFUNC, gameEngAddress ); + if(success == false) return false; + + return true; +} + +#endif \ No newline at end of file diff --git a/dlls/MemHack/MemMiscNatives.cpp b/dlls/MemHack/MemMiscNatives.cpp new file mode 100644 index 00000000..982917b1 --- /dev/null +++ b/dlls/MemHack/MemMiscNatives.cpp @@ -0,0 +1,27 @@ +#include "MemMisc.h" + +#define NATIVE_MISC_ADDRESS params[1] +#define NATIVE_MISC_BASEADDRESS PickBaseAddress(params[2]) +#define NATIVE_MISC_FLAGS params[3] + +static cell AMX_NATIVE_CALL memhack_get_base(AMX *amx, cell *params) +{ + cell *success = MF_GetAmxAddr(amx, params[2]); + maddress BaseAddr = NULL; + + bool is_success = GetBaseAddress((void*)(params[1]), BaseAddr); + *success = is_success; + + return cell(BaseAddr); +} + +static cell AMX_NATIVE_CALL memhack_get_realaddr(AMX *amx, cell *params) +{ + return (cell)GetRealMemoryAddress(NATIVE_MISC_ADDRESS,NATIVE_MISC_BASEADDRESS,NATIVE_MISC_FLAGS); +} + +AMX_NATIVE_INFO misc_natives[] = { + { "memhack_get_base", memhack_get_base }, + { "memhack_get_realaddr", memhack_get_realaddr }, + { NULL, NULL } +}; diff --git a/dlls/MemHack/MemRead.cpp b/dlls/MemHack/MemRead.cpp new file mode 100644 index 00000000..5d9e72a5 --- /dev/null +++ b/dlls/MemHack/MemRead.cpp @@ -0,0 +1,56 @@ +#include "MemMisc.h" + +/* Functions that read different data types in memory */ + +template +Type UTIL_ReadMemory(maddress BaseAddress, maddress StartAddress, char MemType, Type returnType) +{ + maddress EndAddress = GetRealMemoryAddress(BaseAddress, StartAddress, MemType); + + return *(Type*)EndAddress; +} + +char UTIL_ReadMemory_Byte(maddress BaseAddress, maddress address, char memType) +{ + return UTIL_ReadMemory( BaseAddress, address, memType, char(NULL)); +} + +short UTIL_ReadMemory_Word(maddress BaseAddress, maddress address, char memType) +{ + return UTIL_ReadMemory( BaseAddress, address, memType, short(NULL)); +} + +int32_t UTIL_ReadMemory_Dword(maddress BaseAddress, maddress address, char memType) +{ + return UTIL_ReadMemory( BaseAddress, address, memType, int32_t(NULL)); +} + +long long UTIL_ReadMemory_Qword(maddress BaseAddress, maddress address, char memType) +{ + return UTIL_ReadMemory( BaseAddress, address, memType, (long long)(NULL)); +} + +float UTIL_ReadMemory_Float(maddress BaseAddress, maddress address, char memType) +{ + return UTIL_ReadMemory( BaseAddress, address, memType, float(NULL)); +} + + unsigned char UTIL_ReadMemory_UnsignedByte(maddress BaseAddress, maddress address, char memType) +{ + return UTIL_ReadMemory( BaseAddress, address, memType, (unsigned char)(NULL)); +} + + unsigned short UTIL_ReadMemory_UnsignedWord(maddress BaseAddress, maddress address, char memType) +{ + return UTIL_ReadMemory( BaseAddress, address, memType, (unsigned short)(NULL)); +} + + uint32_t UTIL_ReadMemory_UnsignedDword(maddress BaseAddress, maddress address, char memType) +{ + return UTIL_ReadMemory( BaseAddress, address, memType, uint32_t(NULL)); +} + + maddress UTIL_ReadMemory_Pointer(maddress BaseAddress, maddress address, char memType) +{ + return UTIL_ReadMemory( BaseAddress, address, memType, maddress(NULL)); +} diff --git a/dlls/MemHack/MemRead.h b/dlls/MemHack/MemRead.h new file mode 100644 index 00000000..93656987 --- /dev/null +++ b/dlls/MemHack/MemRead.h @@ -0,0 +1,23 @@ +#ifndef __MEMREAD_H__ +#define __MEMREAD_H__ + +#include "MemMisc.h" + +// Functions that read different data types in memory + +// Base function +template +extern Type UTIL_ReadMemory(maddress BaseAddress, maddress StartAddress, char MemType, Type returnType); + +// Inline stocks +inline char UTIL_ReadMemory_Byte (maddress baseaddress, maddress address, char memType = MEMTYPE_DATA); +inline short UTIL_ReadMemory_Word (maddress baseaddress, maddress address, char memType = MEMTYPE_DATA); +inline int32_t UTIL_ReadMemory_Dword (maddress baseaddress, maddress address, char memType = MEMTYPE_DATA); +inline long long UTIL_ReadMemory_Qword (maddress baseaddress, maddress address, char memType = MEMTYPE_DATA); +inline float UTIL_ReadMemory_Float (maddress baseaddress, maddress address, char memType = MEMTYPE_DATA); +inline unsigned char UTIL_ReadMemory_UnsignedByte (maddress baseaddress, maddress address, char memType = MEMTYPE_DATA); +inline unsigned short UTIL_ReadMemory_UnsignedWord (maddress baseaddress, maddress address, char memType = MEMTYPE_DATA); +inline uint32_t UTIL_ReadMemory_UnsignedDword (maddress baseaddress, maddress address, char memType = MEMTYPE_DATA); +inline maddress UTIL_ReadMemory_Pointer (maddress baseaddress, maddress address, char memType = MEMTYPE_DATA); + +#endif \ No newline at end of file diff --git a/dlls/MemHack/MemReadNatives.cpp b/dlls/MemHack/MemReadNatives.cpp new file mode 100644 index 00000000..92fcdfe1 --- /dev/null +++ b/dlls/MemHack/MemReadNatives.cpp @@ -0,0 +1,78 @@ +#include "MemRead.h" + +#define NATIVE_HACK_BASEADDRESS PickBaseAddress(params[2]) +#define NATIVE_HACK_ADDRESS params[1] +#define NATIVE_HACK_FLAGS params[3] +#define NATIVE_HACK_SIGNED params[4] +#define NATIVE_HACK_MEMORY NATIVE_HACK_BASEADDRESS, NATIVE_HACK_ADDRESS, NATIVE_HACK_FLAGS + +static cell AMX_NATIVE_CALL memhack_get_char(AMX *amx, cell *params) +{ + if(NATIVE_HACK_SIGNED) + { + char HackedMemory = UTIL_ReadMemory_Byte(NATIVE_HACK_MEMORY); + return (cell)(HackedMemory); + } + else + { + unsigned char HackedMemory = UTIL_ReadMemory_UnsignedByte(NATIVE_HACK_MEMORY); + return (cell)(HackedMemory); + } +} + +static cell AMX_NATIVE_CALL memhack_get_short(AMX *amx, cell *params) +{ + if(NATIVE_HACK_SIGNED) + { + short HackedMemory = UTIL_ReadMemory_Word(NATIVE_HACK_MEMORY); + return (cell)(HackedMemory); + } + else + { + unsigned short HackedMemory = UTIL_ReadMemory_UnsignedWord(NATIVE_HACK_MEMORY); + return (cell)(HackedMemory); + } +} + +static cell AMX_NATIVE_CALL memhack_get_long(AMX *amx, cell *params) +{ + if(NATIVE_HACK_SIGNED) + { + long HackedMemory = UTIL_ReadMemory_Dword(NATIVE_HACK_MEMORY); + return (cell)(HackedMemory); + } + else + { + unsigned long HackedMemory = UTIL_ReadMemory_UnsignedDword(NATIVE_HACK_MEMORY); + return (cell)(HackedMemory); + } +} + +static cell AMX_NATIVE_CALL memhack_get_quad(AMX *amx, cell *params) +{ + long long HackedMemory = UTIL_ReadMemory_Qword(NATIVE_HACK_MEMORY); + return amx_ftoc(float(HackedMemory)); +} + +static cell AMX_NATIVE_CALL memhack_get_float(AMX *amx, cell *params) +{ + float HackedMemory = UTIL_ReadMemory_Float(NATIVE_HACK_MEMORY); + return amx_ftoc(HackedMemory); +} + +static cell AMX_NATIVE_CALL memhack_get_pointer(AMX *amx, cell *params) +{ + maddress HackedMemory = UTIL_ReadMemory_Pointer(NATIVE_HACK_MEMORY); + return (cell)(HackedMemory); +} + +AMX_NATIVE_INFO read_natives[] = { + { "memhack_get_char", memhack_get_char }, + { "memhack_get_short", memhack_get_short }, + { "memhack_get_long", memhack_get_long }, + + { "memhack_get_float", memhack_get_float }, + { "memhack_get_quad", memhack_get_quad }, + { "memhack_get_pointer", memhack_get_pointer }, + { NULL, NULL } +}; \ No newline at end of file diff --git a/dlls/MemHack/MemWrite.cpp b/dlls/MemHack/MemWrite.cpp new file mode 100644 index 00000000..4bdc6f97 --- /dev/null +++ b/dlls/MemHack/MemWrite.cpp @@ -0,0 +1,78 @@ +#include "MemMisc.h" + +/* Functions that patch different data types in memory */ +template +int UTIL_PatchMemory(maddress baseaddress, maddress address, Type patch, char memType, size_t byteType, bool extraProtect) +{ + unsigned long oldProtect = 0; + maddress realAddress = GetRealMemoryAddress(baseaddress, address, memType); + + switch (memType) + { + case MEMTYPE_CODE: + if (MemoryProtect((void*)realAddress, byteType, MPROT_CODE_EDIT, &oldProtect, memType) == MP_FAIL) return MP_FAIL; + break; + + case MEMTYPE_RODATA: + if (MemoryProtect((void*)realAddress, byteType, MPROT_RODATA_EDIT, &oldProtect, memType) == MP_FAIL) return MP_FAIL; + break; + } + + *(Type*)realAddress = patch; + + if (memType == MEMTYPE_CODE) + { + MemoryProtect((void*)realAddress, byteType, oldProtect, &oldProtect); + } + else if(extraProtect == true) + { + if(memType == MEMTYPE_RODATA) MemoryProtect((void*)realAddress, byteType, oldProtect, &oldProtect); + } + + return MP_OK; +} + + int UTIL_PatchMemory_Byte(maddress baseaddress, maddress address, char patch, char memType) +{ + return UTIL_PatchMemory(baseaddress, address, (char)(NULL), memType, BYTE_BYTES, true); +} + + int UTIL_PatchMemory_Word(maddress baseaddress, maddress address, short patch, char memType) +{ + return UTIL_PatchMemory(baseaddress, address, (short)(NULL), memType, WORD_BYTES, true); +} + + int UTIL_PatchMemory_Dword(maddress baseaddress, maddress address, int32_t patch, char memType) +{ + return UTIL_PatchMemory(baseaddress, address, (int32_t)(NULL), memType, DWORD_BYTES, true); +} + + int UTIL_PatchMemory_Qword(maddress baseaddress, maddress address, long long patch, char memType) +{ + return UTIL_PatchMemory(baseaddress, address, (long long)(NULL), memType, QWORD_BYTES, false); +} + + int UTIL_PatchMemory_Float(maddress baseaddress, maddress address, float patch, char memType) +{ + return UTIL_PatchMemory(baseaddress, address, (float)(NULL), memType, FLOAT_BYTES, false); +} + + int UTIL_PatchMemory_UnsignedByte(maddress baseaddress, maddress address, unsigned char patch, char memType) +{ + return UTIL_PatchMemory(baseaddress, address, (unsigned char)(NULL), memType, BYTE_BYTES, false); +} + + int UTIL_PatchMemory_UnsignedWord(maddress baseaddress, maddress address, unsigned short patch, char memType) +{ + return UTIL_PatchMemory(baseaddress, address, (unsigned short)(NULL), memType, WORD_BYTES, false); +} + + int UTIL_PatchMemory_UnsignedDword(maddress baseaddress, maddress address, uint32_t patch, char memType) +{ + return UTIL_PatchMemory(baseaddress, address, (uint32_t)(NULL), memType, DWORD_BYTES, false); +} + + int UTIL_PatchMemory_Pointer(maddress baseaddress, maddress address, maddress patch, char memType) +{ + return UTIL_PatchMemory(baseaddress, address, (maddress)(NULL), memType, DWORD_BYTES, true); +} diff --git a/dlls/MemHack/MemWrite.h b/dlls/MemHack/MemWrite.h new file mode 100644 index 00000000..8b0c7159 --- /dev/null +++ b/dlls/MemHack/MemWrite.h @@ -0,0 +1,23 @@ +#ifndef __MEMWRITE_H__ +#define __MEMWRITE_H__ + +#include "MemMisc.h" + +// Functions that patch different data types in memory + +// Base function +template +inline int UTIL_PatchMemory(maddress baseaddress, maddress address, Type patch, char memType, size_t byteType, bool extraProtect); + +// Inline stocks +extern inline int UTIL_PatchMemory_Byte (maddress baseaddress, maddress address, char patch, char memType = MEMTYPE_DATA); +extern inline int UTIL_PatchMemory_Word (maddress baseaddress, maddress address, short patch, char memType = MEMTYPE_DATA); +extern inline int UTIL_PatchMemory_Dword (maddress baseaddress, maddress address, int32_t patch, char memType = MEMTYPE_DATA); +extern inline int UTIL_PatchMemory_Qword (maddress baseaddress, maddress address, long long patch, char memType = MEMTYPE_DATA); +extern inline int UTIL_PatchMemory_Float (maddress baseaddress, maddress address, float patch, char memType = MEMTYPE_DATA); +extern inline int UTIL_PatchMemory_UnsignedByte (maddress baseaddress, maddress address, unsigned char patch, char memType = MEMTYPE_DATA); +extern inline int UTIL_PatchMemory_UnsignedWord (maddress baseaddress, maddress address, unsigned short patch, char memType = MEMTYPE_DATA); +extern inline int UTIL_PatchMemory_UnsignedDword (maddress baseaddress, maddress address, uint32_t patch, char memType = MEMTYPE_DATA); +extern inline int UTIL_PatchMemory_Pointer (maddress baseaddress, maddress address, maddress patch, char memType = MEMTYPE_DATA); + +#endif \ No newline at end of file diff --git a/dlls/MemHack/MemWriteNatives.cpp b/dlls/MemHack/MemWriteNatives.cpp new file mode 100644 index 00000000..9e57480c --- /dev/null +++ b/dlls/MemHack/MemWriteNatives.cpp @@ -0,0 +1,72 @@ +#include "MemWrite.h" + +#define NATIVE_PATCH_BASEADDRESS PickBaseAddress(params[2]) +#define NATIVE_PATCH_ADDRESS params[1] +#define NATIVE_PATCH_FLAGS params[4] +#define NATIVE_PATCH_SIGNED params[5] +#define NATIVE_PATCH_PARAMETER params[3] + +#define NATIVE_PATCH_MEMORY NATIVE_PATCH_BASEADDRESS, NATIVE_PATCH_ADDRESS + +static cell AMX_NATIVE_CALL memhack_set_char(AMX *amx, cell *params) +{ + if(NATIVE_PATCH_SIGNED) + { + return (cell)UTIL_PatchMemory_Byte(NATIVE_PATCH_MEMORY, (char)(NATIVE_PATCH_PARAMETER), NATIVE_PATCH_FLAGS); + } + else + { + return (cell)UTIL_PatchMemory_UnsignedByte(NATIVE_PATCH_MEMORY, (unsigned char)(NATIVE_PATCH_PARAMETER), NATIVE_PATCH_FLAGS); + } +} + +static cell AMX_NATIVE_CALL memhack_set_short(AMX *amx, cell *params) +{ + if(NATIVE_PATCH_SIGNED) + { + return (cell)UTIL_PatchMemory_Word(NATIVE_PATCH_MEMORY, (short)(NATIVE_PATCH_PARAMETER), NATIVE_PATCH_FLAGS); + } + else + { + return (cell)UTIL_PatchMemory_UnsignedWord(NATIVE_PATCH_MEMORY, (unsigned short)(NATIVE_PATCH_PARAMETER), NATIVE_PATCH_FLAGS); + } +} + +static cell AMX_NATIVE_CALL memhack_set_long(AMX *amx, cell *params) +{ + if(NATIVE_PATCH_SIGNED) + { + return (cell)UTIL_PatchMemory_Byte(NATIVE_PATCH_MEMORY, (long)(NATIVE_PATCH_PARAMETER), NATIVE_PATCH_FLAGS); + } + else + { + return (cell)UTIL_PatchMemory_UnsignedByte(NATIVE_PATCH_MEMORY, (unsigned long)(NATIVE_PATCH_PARAMETER), NATIVE_PATCH_FLAGS); + } +} + +static cell AMX_NATIVE_CALL memhack_set_quad(AMX *amx, cell *params) +{ + return (cell)UTIL_PatchMemory_Qword(NATIVE_PATCH_MEMORY, (long long)(NATIVE_PATCH_PARAMETER), NATIVE_PATCH_FLAGS); +} + +static cell AMX_NATIVE_CALL memhack_set_float(AMX *amx, cell *params) +{ + return (cell)UTIL_PatchMemory_Float(NATIVE_PATCH_MEMORY, amx_ctof(NATIVE_PATCH_PARAMETER), NATIVE_PATCH_FLAGS); +} + +static cell AMX_NATIVE_CALL memhack_set_pointer(AMX *amx, cell *params) +{ + return (cell)UTIL_PatchMemory_Pointer(NATIVE_PATCH_MEMORY, (maddress)(NATIVE_PATCH_PARAMETER), NATIVE_PATCH_FLAGS); +} + +AMX_NATIVE_INFO write_natives[] = { + { "memhack_set_char", memhack_set_char }, + { "memhack_set_short", memhack_set_short }, + { "memhack_set_long", memhack_set_long }, + + { "memhack_set_float", memhack_set_float }, + { "memhack_set_quad", memhack_set_quad }, + { "memhack_set_pointer", memhack_set_pointer }, + { NULL, NULL } +}; + diff --git a/dlls/MemHack/amxxmodule.cpp b/dlls/MemHack/amxxmodule.cpp new file mode 100644 index 00000000..e374e441 --- /dev/null +++ b/dlls/MemHack/amxxmodule.cpp @@ -0,0 +1,3078 @@ +/* AMX Mod X +* +* by the AMX Mod X Development Team +* originally developed by OLO +* +* Parts Copyright (C) 2001-2003 Will Day +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation; either version 2 of the License, or (at +* your option) any later version. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software Foundation, +* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +* +* In addition, as a special exception, the author gives permission to +* link the code of this program with the Half-Life Game Engine ("HL +* Engine") and Modified Game Libraries ("MODs") developed by Valve, +* L.L.C ("Valve"). You must obey the GNU General Public License in all +* respects for all of the code used other than the HL Engine and MODs +* from Valve. If you modify this file, you may extend this exception +* to your version of the file, but you are not obligated to do so. If +* you do not wish to do so, delete this exception statement from your +* version. +* +* Description: AMX Mod X Module Interface Functions +*/ + +#include +#include +#include +#include +#include +#include "amxxmodule.h" + +/************* METAMOD SUPPORT *************/ +#ifdef USE_METAMOD + +enginefuncs_t g_engfuncs; +globalvars_t *gpGlobals; + +DLL_FUNCTIONS *g_pFunctionTable; +DLL_FUNCTIONS *g_pFunctionTable_Post; +enginefuncs_t *g_pengfuncsTable; +enginefuncs_t *g_pengfuncsTable_Post; +NEW_DLL_FUNCTIONS *g_pNewFunctionsTable; +NEW_DLL_FUNCTIONS *g_pNewFunctionsTable_Post; + +// GetEntityAPI2 functions +static DLL_FUNCTIONS g_EntityAPI_Table = +{ +#ifdef FN_GameDLLInit + FN_GameDLLInit, +#else + NULL, +#endif +#ifdef FN_DispatchSpawn + FN_DispatchSpawn, +#else + NULL, +#endif +#ifdef FN_DispatchThink + FN_DispatchThink, +#else + NULL, +#endif +#ifdef FN_DispatchUse + FN_DispatchUse, +#else + NULL, +#endif +#ifdef FN_DispatchTouch + FN_DispatchTouch, +#else + NULL, +#endif +#ifdef FN_DispatchBlocked + FN_DispatchBlocked, +#else + NULL, +#endif +#ifdef FN_DispatchKeyValue + FN_DispatchKeyValue, +#else + NULL, +#endif +#ifdef FN_DispatchSave + FN_DispatchSave, +#else + NULL, +#endif +#ifdef FN_DispatchRestore + FN_DispatchRestore, +#else + NULL, +#endif +#ifdef FN_DispatchObjectCollsionBox + FN_DispatchObjectCollsionBox, +#else + NULL, +#endif +#ifdef FN_SaveWriteFields + FN_SaveWriteFields, +#else + NULL, +#endif +#ifdef FN_SaveReadFields + FN_SaveReadFields, +#else + NULL, +#endif +#ifdef FN_SaveGlobalState + FN_SaveGlobalState, +#else + NULL, +#endif +#ifdef FN_RestoreGlobalState + FN_RestoreGlobalState, +#else + NULL, +#endif +#ifdef FN_ResetGlobalState + FN_ResetGlobalState, +#else + NULL, +#endif +#ifdef FN_ClientConnect + FN_ClientConnect, +#else + NULL, +#endif +#ifdef FN_ClientDisconnect + FN_ClientDisconnect, +#else + NULL, +#endif +#ifdef FN_ClientKill + FN_ClientKill, +#else + NULL, +#endif +#ifdef FN_ClientPutInServer + FN_ClientPutInServer, +#else + NULL, +#endif +#ifdef FN_ClientCommand + FN_ClientCommand, +#else + NULL, +#endif +#ifdef FN_ClientUserInfoChanged + FN_ClientUserInfoChanged, +#else + NULL, +#endif +#ifdef FN_ServerActivate + FN_ServerActivate, +#else + NULL, +#endif +#ifdef FN_ServerDeactivate + FN_ServerDeactivate, +#else + NULL, +#endif +#ifdef FN_PlayerPreThink + FN_PlayerPreThink, +#else + NULL, +#endif +#ifdef FN_PlayerPostThink + FN_PlayerPostThink, +#else + NULL, +#endif +#ifdef FN_StartFrame + FN_StartFrame, +#else + NULL, +#endif +#ifdef FN_ParmsNewLevel + FN_ParmsNewLevel, +#else + NULL, +#endif +#ifdef FN_ParmsChangeLevel + FN_ParmsChangeLevel, +#else + NULL, +#endif +#ifdef FN_GetGameDescription + FN_GetGameDescription, +#else + NULL, +#endif +#ifdef FN_PlayerCustomization + FN_PlayerCustomization, +#else + NULL, +#endif +#ifdef FN_SpectatorConnect + FN_SpectatorConnect, +#else + NULL, +#endif +#ifdef FN_SpectatorDisconnect + FN_SpectatorDisconnect, +#else + NULL, +#endif +#ifdef FN_SpectatorThink + FN_SpectatorThink, +#else + NULL, +#endif +#ifdef FN_Sys_Error + FN_Sys_Error, +#else + NULL, +#endif +#ifdef FN_PM_Move + FN_PM_Move, +#else + NULL, +#endif +#ifdef FN_PM_Init + FN_PM_Init, +#else + NULL, +#endif +#ifdef FN_PM_FindTextureType + FN_PM_FindTextureType, +#else + NULL, +#endif +#ifdef FN_SetupVisibility + FN_SetupVisibility, +#else + NULL, +#endif +#ifdef FN_UpdateClientData + FN_UpdateClientData, +#else + NULL, +#endif +#ifdef FN_AddToFullPack + FN_AddToFullPack, +#else + NULL, +#endif +#ifdef FN_CreateBaseline + FN_CreateBaseline, +#else + NULL, +#endif +#ifdef FN_RegisterEncoders + FN_RegisterEncoders, +#else + NULL, +#endif +#ifdef FN_GetWeaponData + FN_GetWeaponData, +#else + NULL, +#endif +#ifdef FN_CmdStart + FN_CmdStart, +#else + NULL, +#endif +#ifdef FN_CmdEnd + FN_CmdEnd, +#else + NULL, +#endif +#ifdef FN_ConnectionlessPacket + FN_ConnectionlessPacket, +#else + NULL, +#endif +#ifdef FN_GetHullBounds + FN_GetHullBounds, +#else + NULL, +#endif +#ifdef FN_CreateInstancedBaselines + FN_CreateInstancedBaselines, +#else + NULL, +#endif +#ifdef FN_InconsistentFile + FN_InconsistentFile, +#else + NULL, +#endif +#ifdef FN_AllowLagCompensation + FN_AllowLagCompensation +#else + NULL +#endif +}; // g_EntityAPI2_Table + +// GetEntityAPI2_Post functions +static DLL_FUNCTIONS g_EntityAPI_Post_Table = +{ +#ifdef FN_GameDLLInit_Post + FN_GameDLLInit_Post, +#else + NULL, +#endif +#ifdef FN_DispatchSpawn_Post + FN_DispatchSpawn_Post, +#else + NULL, +#endif +#ifdef FN_DispatchThink_Post + FN_DispatchThink_Post, +#else + NULL, +#endif +#ifdef FN_DispatchUse_Post + FN_DispatchUse_Post, +#else + NULL, +#endif +#ifdef FN_DispatchTouch_Post + FN_DispatchTouch_Post, +#else + NULL, +#endif +#ifdef FN_DispatchBlocked_Post + FN_DispatchBlocked_Post, +#else + NULL, +#endif +#ifdef FN_DispatchKeyValue_Post + FN_DispatchKeyValue_Post, +#else + NULL, +#endif +#ifdef FN_DispatchSave_Post + FN_DispatchSave_Post, +#else + NULL, +#endif +#ifdef FN_DispatchRestore_Post + FN_DispatchRestore_Post, +#else + NULL, +#endif +#ifdef FN_DispatchObjectCollsionBox_Post + FN_DispatchObjectCollsionBox_Post, +#else + NULL, +#endif +#ifdef FN_SaveWriteFields_Post + FN_SaveWriteFields_Post, +#else + NULL, +#endif +#ifdef FN_SaveReadFields_Post + FN_SaveReadFields_Post, +#else + NULL, +#endif +#ifdef FN_SaveGlobalState_Post + FN_SaveGlobalState_Post, +#else + NULL, +#endif +#ifdef FN_RestoreGlobalState_Post + FN_RestoreGlobalState_Post, +#else + NULL, +#endif +#ifdef FN_ResetGlobalState_Post + FN_ResetGlobalState_Post, +#else + NULL, +#endif +#ifdef FN_ClientConnect_Post + FN_ClientConnect_Post, +#else + NULL, +#endif +#ifdef FN_ClientDisconnect_Post + FN_ClientDisconnect_Post, +#else + NULL, +#endif +#ifdef FN_ClientKill_Post + FN_ClientKill_Post, +#else + NULL, +#endif +#ifdef FN_ClientPutInServer_Post + FN_ClientPutInServer_Post, +#else + NULL, +#endif +#ifdef FN_ClientCommand_Post + FN_ClientCommand_Post, +#else + NULL, +#endif +#ifdef FN_ClientUserInfoChanged_Post + FN_ClientUserInfoChanged_Post, +#else + NULL, +#endif +#ifdef FN_ServerActivate_Post + FN_ServerActivate_Post, +#else + NULL, +#endif +#ifdef FN_ServerDeactivate_Post + FN_ServerDeactivate_Post, +#else + NULL, +#endif +#ifdef FN_PlayerPreThink_Post + FN_PlayerPreThink_Post, +#else + NULL, +#endif +#ifdef FN_PlayerPostThink_Post + FN_PlayerPostThink_Post, +#else + NULL, +#endif +#ifdef FN_StartFrame_Post + FN_StartFrame_Post, +#else + NULL, +#endif +#ifdef FN_ParmsNewLevel_Post + FN_ParmsNewLevel_Post, +#else + NULL, +#endif +#ifdef FN_ParmsChangeLevel_Post + FN_ParmsChangeLevel_Post, +#else + NULL, +#endif +#ifdef FN_GetGameDescription_Post + FN_GetGameDescription_Post, +#else + NULL, +#endif +#ifdef FN_PlayerCustomization_Post + FN_PlayerCustomization_Post, +#else + NULL, +#endif +#ifdef FN_SpectatorConnect_Post + FN_SpectatorConnect_Post, +#else + NULL, +#endif +#ifdef FN_SpectatorDisconnect_Post + FN_SpectatorDisconnect_Post, +#else + NULL, +#endif +#ifdef FN_SpectatorThink_Post + FN_SpectatorThink_Post, +#else + NULL, +#endif +#ifdef FN_Sys_Error_Post + FN_Sys_Error_Post, +#else + NULL, +#endif +#ifdef FN_PM_Move_Post + FN_PM_Move_Post, +#else + NULL, +#endif +#ifdef FN_PM_Init_Post + FN_PM_Init_Post, +#else + NULL, +#endif +#ifdef FN_PM_FindTextureType_Post + FN_PM_FindTextureType_Post, +#else + NULL, +#endif +#ifdef FN_SetupVisibility_Post + FN_SetupVisibility_Post, +#else + NULL, +#endif +#ifdef FN_UpdateClientData_Post + FN_UpdateClientData_Post, +#else + NULL, +#endif +#ifdef FN_AddToFullPack_Post + FN_AddToFullPack_Post, +#else + NULL, +#endif +#ifdef FN_CreateBaseline_Post + FN_CreateBaseline_Post, +#else + NULL, +#endif +#ifdef FN_RegisterEncoders_Post + FN_RegisterEncoders_Post, +#else + NULL, +#endif +#ifdef FN_GetWeaponData_Post + FN_GetWeaponData_Post, +#else + NULL, +#endif +#ifdef FN_CmdStart_Post + FN_CmdStart_Post, +#else + NULL, +#endif +#ifdef FN_CmdEnd_Post + FN_CmdEnd_Post, +#else + NULL, +#endif +#ifdef FN_ConnectionlessPacket_Post + FN_ConnectionlessPacket_Post, +#else + NULL, +#endif +#ifdef FN_GetHullBounds_Post + FN_GetHullBounds_Post, +#else + NULL, +#endif +#ifdef FN_CreateInstancedBaselines_Post + FN_CreateInstancedBaselines_Post, +#else + NULL, +#endif +#ifdef FN_InconsistentFile_Post + FN_InconsistentFile_Post, +#else + NULL, +#endif +#ifdef FN_AllowLagCompensation + FN_AllowLagCompensation, +#else + NULL, +#endif +}; // g_EntityAPI2_Table + +static enginefuncs_t g_EngineFuncs_Table = +{ +#ifdef FN_PrecacheModel + FN_PrecacheModel, +#else + NULL, +#endif +#ifdef FN_PrecacheSound + FN_PrecacheSound, +#else + NULL, +#endif +#ifdef FN_SetModel + FN_SetModel, +#else + NULL, +#endif +#ifdef FN_ModelIndex + FN_ModelIndex, +#else + NULL, +#endif +#ifdef FN_ModelFrames + FN_ModelFrames, +#else + NULL, +#endif +#ifdef FN_SetSize + FN_SetSize, +#else + NULL, +#endif +#ifdef FN_ChangeLevel + FN_ChangeLevel, +#else + NULL, +#endif +#ifdef FN_GetSpawnParms + FN_GetSpawnParms, +#else + NULL, +#endif +#ifdef FN_SaveSpawnParms + FN_SaveSpawnParms, +#else + NULL, +#endif +#ifdef FN_VecToYaw + FN_VecToYaw, +#else + NULL, +#endif +#ifdef FN_VecToAngles + FN_VecToAngles, +#else + NULL, +#endif +#ifdef FN_MoveToOrigin + FN_MoveToOrigin, +#else + NULL, +#endif +#ifdef FN_ChangeYaw + FN_ChangeYaw, +#else + NULL, +#endif +#ifdef FN_ChangePitch + FN_ChangePitch, +#else + NULL, +#endif +#ifdef FN_FindEntityByString + FN_FindEntityByString, +#else + NULL, +#endif +#ifdef FN_GetEntityIllum + FN_GetEntityIllum, +#else + NULL, +#endif +#ifdef FN_FindEntityInSphere + FN_FindEntityInSphere, +#else + NULL, +#endif +#ifdef FN_FindClientInPVS + FN_FindClientInPVS, +#else + NULL, +#endif +#ifdef FN_EntitiesInPVS + FN_EntitiesInPVS, +#else + NULL, +#endif +#ifdef FN_MakeVectors + FN_MakeVectors, +#else + NULL, +#endif +#ifdef FN_AngleVectors + FN_AngleVectors, +#else + NULL, +#endif +#ifdef FN_CreateEntity + FN_CreateEntity, +#else + NULL, +#endif +#ifdef FN_RemoveEntity + FN_RemoveEntity, +#else + NULL, +#endif +#ifdef FN_CreateNamedEntity + FN_CreateNamedEntity, +#else + NULL, +#endif +#ifdef FN_MakeStatic + FN_MakeStatic, +#else + NULL, +#endif +#ifdef FN_EntIsOnFloor + FN_EntIsOnFloor, +#else + NULL, +#endif +#ifdef FN_DropToFloor + FN_DropToFloor, +#else + NULL, +#endif +#ifdef FN_WalkMove + FN_WalkMove, +#else + NULL, +#endif +#ifdef FN_SetOrigin + FN_SetOrigin, +#else + NULL, +#endif +#ifdef FN_EmitSound + FN_EmitSound, +#else + NULL, +#endif +#ifdef FN_EmitAmbientSound + FN_EmitAmbientSound, +#else + NULL, +#endif +#ifdef FN_TraceLine + FN_TraceLine, +#else + NULL, +#endif +#ifdef FN_TraceToss + FN_TraceToss, +#else + NULL, +#endif +#ifdef FN_TraceMonsterHull + FN_TraceMonsterHull, +#else + NULL, +#endif +#ifdef FN_TraceHull + FN_TraceHull, +#else + NULL, +#endif +#ifdef FN_TraceModel + FN_TraceModel, +#else + NULL, +#endif +#ifdef FN_TraceTexture + FN_TraceTexture, +#else + NULL, +#endif +#ifdef FN_TraceSphere + FN_TraceSphere, +#else + NULL, +#endif +#ifdef FN_GetAimVector + FN_GetAimVector, +#else + NULL, +#endif +#ifdef FN_ServerCommand + FN_ServerCommand, +#else + NULL, +#endif +#ifdef FN_ServerExecute + FN_ServerExecute, +#else + NULL, +#endif +#ifdef FN_engClientCommand + FN_engClientCommand, +#else + NULL, +#endif +#ifdef FN_ParticleEffect + FN_ParticleEffect, +#else + NULL, +#endif +#ifdef FN_LightStyle + FN_LightStyle, +#else + NULL, +#endif +#ifdef FN_DecalIndex + FN_DecalIndex, +#else + NULL, +#endif +#ifdef FN_PointContents + FN_PointContents, +#else + NULL, +#endif +#ifdef FN_MessageBegin + FN_MessageBegin, +#else + NULL, +#endif +#ifdef FN_MessageEnd + FN_MessageEnd, +#else + NULL, +#endif +#ifdef FN_WriteByte + FN_WriteByte, +#else + NULL, +#endif +#ifdef FN_WriteChar + FN_WriteChar, +#else + NULL, +#endif +#ifdef FN_WriteShort + FN_WriteShort, +#else + NULL, +#endif +#ifdef FN_WriteLong + FN_WriteLong, +#else + NULL, +#endif +#ifdef FN_WriteAngle + FN_WriteAngle, +#else + NULL, +#endif +#ifdef FN_WriteCoord + FN_WriteCoord, +#else + NULL, +#endif +#ifdef FN_WriteString + FN_WriteString, +#else + NULL, +#endif +#ifdef FN_WriteEntity + FN_WriteEntity, +#else + NULL, +#endif +#ifdef FN_CVarRegister + FN_CVarRegister, +#else + NULL, +#endif +#ifdef FN_CVarGetFloat + FN_CVarGetFloat, +#else + NULL, +#endif +#ifdef FN_CVarGetString + FN_CVarGetString, +#else + NULL, +#endif +#ifdef FN_CVarSetFloat + FN_CVarSetFloat, +#else + NULL, +#endif +#ifdef FN_CVarSetString + FN_CVarSetString, +#else + NULL, +#endif +#ifdef FN_AlertMessage + FN_AlertMessage, +#else + NULL, +#endif +#ifdef FN_EngineFprintf + FN_EngineFprintf, +#else + NULL, +#endif +#ifdef FN_PvAllocEntPrivateData + FN_PvAllocEntPrivateData, +#else + NULL, +#endif +#ifdef FN_PvEntPrivateData + FN_PvEntPrivateData, +#else + NULL, +#endif +#ifdef FN_FreeEntPrivateData + FN_FreeEntPrivateData, +#else + NULL, +#endif +#ifdef FN_SzFromIndex + FN_SzFromIndex, +#else + NULL, +#endif +#ifdef FN_AllocString + FN_AllocString, +#else + NULL, +#endif +#ifdef FN_GetVarsOfEnt + FN_GetVarsOfEnt, +#else + NULL, +#endif +#ifdef FN_PEntityOfEntOffset + FN_PEntityOfEntOffset, +#else + NULL, +#endif +#ifdef FN_EntOffsetOfPEntity + FN_EntOffsetOfPEntity, +#else + NULL, +#endif +#ifdef FN_IndexOfEdict + FN_IndexOfEdict, +#else + NULL, +#endif +#ifdef FN_PEntityOfEntIndex + FN_PEntityOfEntIndex, +#else + NULL, +#endif +#ifdef FN_FindEntityByVars + FN_FindEntityByVars, +#else + NULL, +#endif +#ifdef FN_GetModelPtr + FN_GetModelPtr, +#else + NULL, +#endif +#ifdef FN_RegUserMsg + FN_RegUserMsg, +#else + NULL, +#endif +#ifdef FN_AnimationAutomove + FN_AnimationAutomove, +#else + NULL, +#endif +#ifdef FN_GetBonePosition + FN_GetBonePosition, +#else + NULL, +#endif +#ifdef FN_FunctionFromName + FN_FunctionFromName, +#else + NULL, +#endif +#ifdef FN_NameForFunction + FN_NameForFunction, +#else + NULL, +#endif +#ifdef FN_ClientPrintf + FN_ClientPrintf, +#else + NULL, +#endif +#ifdef FN_ServerPrint + FN_ServerPrint, +#else + NULL, +#endif +#ifdef FN_Cmd_Args + FN_Cmd_Args, +#else + NULL, +#endif +#ifdef FN_Cmd_Argv + FN_Cmd_Argv, +#else + NULL, +#endif +#ifdef FN_Cmd_Argc + FN_Cmd_Argc, +#else + NULL, +#endif +#ifdef FN_GetAttachment + FN_GetAttachment, +#else + NULL, +#endif +#ifdef FN_CRC32_Init + FN_CRC32_Init, +#else + NULL, +#endif +#ifdef FN_CRC32_ProcessBuffer + FN_CRC32_ProcessBuffer, +#else + NULL, +#endif +#ifdef FN_CRC32_ProcessByte + FN_CRC32_ProcessByte, +#else + NULL, +#endif +#ifdef FN_CRC32_Final + FN_CRC32_Final, +#else + NULL, +#endif +#ifdef FN_RandomLong + FN_RandomLong, +#else + NULL, +#endif +#ifdef FN_RandomFloat + FN_RandomFloat, +#else + NULL, +#endif +#ifdef FN_SetView + FN_SetView, +#else + NULL, +#endif +#ifdef FN_Time + FN_Time, +#else + NULL, +#endif +#ifdef FN_CrosshairAngle + FN_CrosshairAngle, +#else + NULL, +#endif +#ifdef FN_LoadFileForMe + FN_LoadFileForMe, +#else + NULL, +#endif +#ifdef FN_FreeFile + FN_FreeFile, +#else + NULL, +#endif +#ifdef FN_EndSection + FN_EndSection, +#else + NULL, +#endif +#ifdef FN_CompareFileTime + FN_CompareFileTime, +#else + NULL, +#endif +#ifdef FN_GetGameDir + FN_GetGameDir, +#else + NULL, +#endif +#ifdef FN_Cvar_RegisterVariable + FN_Cvar_RegisterVariable, +#else + NULL, +#endif +#ifdef FN_FadeClientVolume + FN_FadeClientVolume, +#else + NULL, +#endif +#ifdef FN_SetClientMaxspeed + FN_SetClientMaxspeed, +#else + NULL, +#endif +#ifdef FN_CreateFakeClient + FN_CreateFakeClient, +#else + NULL, +#endif +#ifdef FN_RunPlayerMove + FN_RunPlayerMove, +#else + NULL, +#endif +#ifdef FN_NumberOfEntities + FN_NumberOfEntities, +#else + NULL, +#endif +#ifdef FN_GetInfoKeyBuffer + FN_GetInfoKeyBuffer, +#else + NULL, +#endif +#ifdef FN_InfoKeyValue + FN_InfoKeyValue, +#else + NULL, +#endif +#ifdef FN_SetKeyValue + FN_SetKeyValue, +#else + NULL, +#endif +#ifdef FN_SetClientKeyValue + FN_SetClientKeyValue, +#else + NULL, +#endif +#ifdef FN_IsMapValid + FN_IsMapValid, +#else + NULL, +#endif +#ifdef FN_StaticDecal + FN_StaticDecal, +#else + NULL, +#endif +#ifdef FN_PrecacheGeneric + FN_PrecacheGeneric, +#else + NULL, +#endif +#ifdef FN_GetPlayerUserId + FN_GetPlayerUserId, +#else + NULL, +#endif +#ifdef FN_BuildSoundMsg + FN_BuildSoundMsg, +#else + NULL, +#endif +#ifdef FN_IsDedicatedServer + FN_IsDedicatedServer, +#else + NULL, +#endif +#ifdef FN_CVarGetPointer + FN_CVarGetPointer, +#else + NULL, +#endif +#ifdef FN_GetPlayerWONId + FN_GetPlayerWONId, +#else + NULL, +#endif +#ifdef FN_Info_RemoveKey + FN_Info_RemoveKey, +#else + NULL, +#endif +#ifdef FN_GetPhysicsKeyValue + FN_GetPhysicsKeyValue, +#else + NULL, +#endif +#ifdef FN_SetPhysicsKeyValue + FN_SetPhysicsKeyValue, +#else + NULL, +#endif +#ifdef FN_GetPhysicsInfoString + FN_GetPhysicsInfoString, +#else + NULL, +#endif +#ifdef FN_PrecacheEvent + FN_PrecacheEvent, +#else + NULL, +#endif +#ifdef FN_PlaybackEvent + FN_PlaybackEvent, +#else + NULL, +#endif +#ifdef FN_SetFatPVS + FN_SetFatPVS, +#else + NULL, +#endif +#ifdef FN_SetFatPAS + FN_SetFatPAS, +#else + NULL, +#endif +#ifdef FN_CheckVisibility + FN_CheckVisibility, +#else + NULL, +#endif +#ifdef FN_DeltaSetField + FN_DeltaSetField, +#else + NULL, +#endif +#ifdef FN_DeltaUnsetField + FN_DeltaUnsetField, +#else + NULL, +#endif +#ifdef FN_DeltaAddEncoder + FN_DeltaAddEncoder, +#else + NULL, +#endif +#ifdef FN_GetCurrentPlayer + FN_GetCurrentPlayer, +#else + NULL, +#endif +#ifdef FN_CanSkipPlayer + FN_CanSkipPlayer, +#else + NULL, +#endif +#ifdef FN_DeltaFindField + FN_DeltaFindField, +#else + NULL, +#endif +#ifdef FN_DeltaSetFieldByIndex + FN_DeltaSetFieldByIndex, +#else + NULL, +#endif +#ifdef FN_DeltaUnsetFieldByIndex + FN_DeltaUnsetFieldByIndex, +#else + NULL, +#endif +#ifdef FN_SetGroupMask + FN_SetGroupMask, +#else + NULL, +#endif +#ifdef FN_engCreateInstancedBaseline + FN_engCreateInstancedBaseline, +#else + NULL, +#endif +#ifdef FN_Cvar_DirectSet + FN_Cvar_DirectSet, +#else + NULL, +#endif +#ifdef FN_ForceUnmodified + FN_ForceUnmodified, +#else + NULL, +#endif +#ifdef FN_GetPlayerStats + FN_GetPlayerStats, +#else + NULL, +#endif +#ifdef FN_AddServerCommand + FN_AddServerCommand, +#else + NULL, +#endif +#ifdef FN_Voice_GetClientListening + FN_Voice_GetClientListening, +#else + NULL, +#endif +#ifdef FN_Voice_SetClientListening + FN_Voice_SetClientListening, +#else + NULL, +#endif +#ifdef FN_GetPlayerAuthId + FN_GetPlayerAuthId +#else + NULL +#endif +}; // g_EngineFuncs_Table + + +static enginefuncs_t g_EngineFuncs_Post_Table = +{ +#ifdef FN_PrecacheModel_Post + FN_PrecacheModel_Post, +#else + NULL, +#endif +#ifdef FN_PrecacheSound_Post + FN_PrecacheSound_Post, +#else + NULL, +#endif +#ifdef FN_SetModel_Post + FN_SetModel_Post, +#else + NULL, +#endif +#ifdef FN_ModelIndex_Post + FN_ModelIndex_Post, +#else + NULL, +#endif +#ifdef FN_ModelFrames_Post + FN_ModelFrames_Post, +#else + NULL, +#endif +#ifdef FN_SetSize_Post + FN_SetSize_Post, +#else + NULL, +#endif +#ifdef FN_ChangeLevel_Post + FN_ChangeLevel_Post, +#else + NULL, +#endif +#ifdef FN_GetSpawnParms_Post + FN_GetSpawnParms_Post, +#else + NULL, +#endif +#ifdef FN_SaveSpawnParms_Post + FN_SaveSpawnParms_Post, +#else + NULL, +#endif +#ifdef FN_VecToYaw_Post + FN_VecToYaw_Post, +#else + NULL, +#endif +#ifdef FN_VecToAngles_Post + FN_VecToAngles_Post, +#else + NULL, +#endif +#ifdef FN_MoveToOrigin_Post + FN_MoveToOrigin_Post, +#else + NULL, +#endif +#ifdef FN_ChangeYaw_Post + FN_ChangeYaw_Post, +#else + NULL, +#endif +#ifdef FN_ChangePitch_Post + FN_ChangePitch_Post, +#else + NULL, +#endif +#ifdef FN_FindEntityByString_Post + FN_FindEntityByString_Post, +#else + NULL, +#endif +#ifdef FN_GetEntityIllum_Post + FN_GetEntityIllum_Post, +#else + NULL, +#endif +#ifdef FN_FindEntityInSphere_Post + FN_FindEntityInSphere_Post, +#else + NULL, +#endif +#ifdef FN_FindClientInPVS_Post + FN_FindClientInPVS_Post, +#else + NULL, +#endif +#ifdef FN_EntitiesInPVS_Post + FN_EntitiesInPVS_Post, +#else + NULL, +#endif +#ifdef FN_MakeVectors_Post + FN_MakeVectors_Post, +#else + NULL, +#endif +#ifdef FN_AngleVectors_Post + FN_AngleVectors_Post, +#else + NULL, +#endif +#ifdef FN_CreateEntity_Post + FN_CreateEntity_Post, +#else + NULL, +#endif +#ifdef FN_RemoveEntity_Post + FN_RemoveEntity_Post, +#else + NULL, +#endif +#ifdef FN_CreateNamedEntity_Post + FN_CreateNamedEntity_Post, +#else + NULL, +#endif +#ifdef FN_MakeStatic_Post + FN_MakeStatic_Post, +#else + NULL, +#endif +#ifdef FN_EntIsOnFloor_Post + FN_EntIsOnFloor_Post, +#else + NULL, +#endif +#ifdef FN_DropToFloor_Post + FN_DropToFloor_Post, +#else + NULL, +#endif +#ifdef FN_WalkMove_Post + FN_WalkMove_Post, +#else + NULL, +#endif +#ifdef FN_SetOrigin_Post + FN_SetOrigin_Post, +#else + NULL, +#endif +#ifdef FN_EmitSound_Post + FN_EmitSound_Post, +#else + NULL, +#endif +#ifdef FN_EmitAmbientSound_Post + FN_EmitAmbientSound_Post, +#else + NULL, +#endif +#ifdef FN_TraceLine_Post + FN_TraceLine_Post, +#else + NULL, +#endif +#ifdef FN_TraceToss_Post + FN_TraceToss_Post, +#else + NULL, +#endif +#ifdef FN_TraceMonsterHull_Post + FN_TraceMonsterHull_Post, +#else + NULL, +#endif +#ifdef FN_TraceHull_Post + FN_TraceHull_Post, +#else + NULL, +#endif +#ifdef FN_TraceModel_Post + FN_TraceModel_Post, +#else + NULL, +#endif +#ifdef FN_TraceTexture_Post + FN_TraceTexture_Post, +#else + NULL, +#endif +#ifdef FN_TraceSphere_Post + FN_TraceSphere_Post, +#else + NULL, +#endif +#ifdef FN_GetAimVector_Post + FN_GetAimVector_Post, +#else + NULL, +#endif +#ifdef FN_ServerCommand_Post + FN_ServerCommand_Post, +#else + NULL, +#endif +#ifdef FN_ServerExecute_Post + FN_ServerExecute_Post, +#else + NULL, +#endif +#ifdef FN_engClientCommand_Post + FN_engClientCommand_Post, +#else + NULL, +#endif +#ifdef FN_ParticleEffect_Post + FN_ParticleEffect_Post, +#else + NULL, +#endif +#ifdef FN_LightStyle_Post + FN_LightStyle_Post, +#else + NULL, +#endif +#ifdef FN_DecalIndex_Post + FN_DecalIndex_Post, +#else + NULL, +#endif +#ifdef FN_PointContents_Post + FN_PointContents_Post, +#else + NULL, +#endif +#ifdef FN_MessageBegin_Post + FN_MessageBegin_Post, +#else + NULL, +#endif +#ifdef FN_MessageEnd_Post + FN_MessageEnd_Post, +#else + NULL, +#endif +#ifdef FN_WriteByte_Post + FN_WriteByte_Post, +#else + NULL, +#endif +#ifdef FN_WriteChar_Post + FN_WriteChar_Post, +#else + NULL, +#endif +#ifdef FN_WriteShort_Post + FN_WriteShort_Post, +#else + NULL, +#endif +#ifdef FN_WriteLong_Post + FN_WriteLong_Post, +#else + NULL, +#endif +#ifdef FN_WriteAngle_Post + FN_WriteAngle_Post, +#else + NULL, +#endif +#ifdef FN_WriteCoord_Post + FN_WriteCoord_Post, +#else + NULL, +#endif +#ifdef FN_WriteString_Post + FN_WriteString_Post, +#else + NULL, +#endif +#ifdef FN_WriteEntity_Post + FN_WriteEntity_Post, +#else + NULL, +#endif +#ifdef FN_CVarRegister_Post + FN_CVarRegister_Post, +#else + NULL, +#endif +#ifdef FN_CVarGetFloat_Post + FN_CVarGetFloat_Post, +#else + NULL, +#endif +#ifdef FN_CVarGetString_Post + FN_CVarGetString_Post, +#else + NULL, +#endif +#ifdef FN_CVarSetFloat_Post + FN_CVarSetFloat_Post, +#else + NULL, +#endif +#ifdef FN_CVarSetString_Post + FN_CVarSetString_Post, +#else + NULL, +#endif +#ifdef FN_AlertMessage_Post + FN_AlertMessage_Post, +#else + NULL, +#endif +#ifdef FN_EngineFprintf_Post + FN_EngineFprintf_Post, +#else + NULL, +#endif +#ifdef FN_PvAllocEntPrivateData_Post + FN_PvAllocEntPrivateData_Post, +#else + NULL, +#endif +#ifdef FN_PvEntPrivateData_Post + FN_PvEntPrivateData_Post, +#else + NULL, +#endif +#ifdef FN_FreeEntPrivateData_Post + FN_FreeEntPrivateData_Post, +#else + NULL, +#endif +#ifdef FN_SzFromIndex_Post + FN_SzFromIndex_Post, +#else + NULL, +#endif +#ifdef FN_AllocString_Post + FN_AllocString_Post, +#else + NULL, +#endif +#ifdef FN_GetVarsOfEnt_Post + FN_GetVarsOfEnt_Post, +#else + NULL, +#endif +#ifdef FN_PEntityOfEntOffset_Post + FN_PEntityOfEntOffset_Post, +#else + NULL, +#endif +#ifdef FN_EntOffsetOfPEntity_Post + FN_EntOffsetOfPEntity_Post, +#else + NULL, +#endif +#ifdef FN_IndexOfEdict_Post + FN_IndexOfEdict_Post, +#else + NULL, +#endif +#ifdef FN_PEntityOfEntIndex_Post + FN_PEntityOfEntIndex_Post, +#else + NULL, +#endif +#ifdef FN_FindEntityByVars_Post + FN_FindEntityByVars_Post, +#else + NULL, +#endif +#ifdef FN_GetModelPtr_Post + FN_GetModelPtr_Post, +#else + NULL, +#endif +#ifdef FN_RegUserMsg_Post + FN_RegUserMsg_Post, +#else + NULL, +#endif +#ifdef FN_AnimationAutomove_Post + FN_AnimationAutomove_Post, +#else + NULL, +#endif +#ifdef FN_GetBonePosition_Post + FN_GetBonePosition_Post, +#else + NULL, +#endif +#ifdef FN_FunctionFromName_Post + FN_FunctionFromName_Post, +#else + NULL, +#endif +#ifdef FN_NameForFunction_Post + FN_NameForFunction_Post, +#else + NULL, +#endif +#ifdef FN_ClientPrintf_Post + FN_ClientPrintf_Post, +#else + NULL, +#endif +#ifdef FN_ServerPrint_Post + FN_ServerPrint_Post, +#else + NULL, +#endif +#ifdef FN_Cmd_Args_Post + FN_Cmd_Args_Post, +#else + NULL, +#endif +#ifdef FN_Cmd_Argv_Post + FN_Cmd_Argv_Post, +#else + NULL, +#endif +#ifdef FN_Cmd_Argc_Post + FN_Cmd_Argc_Post, +#else + NULL, +#endif +#ifdef FN_GetAttachment_Post + FN_GetAttachment_Post, +#else + NULL, +#endif +#ifdef FN_CRC32_Init_Post + FN_CRC32_Init_Post, +#else + NULL, +#endif +#ifdef FN_CRC32_ProcessBuffer_Post + FN_CRC32_ProcessBuffer_Post, +#else + NULL, +#endif +#ifdef FN_CRC32_ProcessByte_Post + FN_CRC32_ProcessByte_Post, +#else + NULL, +#endif +#ifdef FN_CRC32_Final_Post + FN_CRC32_Final_Post, +#else + NULL, +#endif +#ifdef FN_RandomLong_Post + FN_RandomLong_Post, +#else + NULL, +#endif +#ifdef FN_RandomFloat_Post + FN_RandomFloat_Post, +#else + NULL, +#endif +#ifdef FN_SetView_Post + FN_SetView_Post, +#else + NULL, +#endif +#ifdef FN_Time_Post + FN_Time_Post, +#else + NULL, +#endif +#ifdef FN_CrosshairAngle_Post + FN_CrosshairAngle_Post, +#else + NULL, +#endif +#ifdef FN_LoadFileForMe_Post + FN_LoadFileForMe_Post, +#else + NULL, +#endif +#ifdef FN_FreeFile_Post + FN_FreeFile_Post, +#else + NULL, +#endif +#ifdef FN_EndSection_Post + FN_EndSection_Post, +#else + NULL, +#endif +#ifdef FN_CompareFileTime_Post + FN_CompareFileTime_Post, +#else + NULL, +#endif +#ifdef FN_GetGameDir_Post + FN_GetGameDir_Post, +#else + NULL, +#endif +#ifdef FN_Cvar_RegisterVariable_Post + FN_Cvar_RegisterVariable_Post, +#else + NULL, +#endif +#ifdef FN_FadeClientVolume_Post + FN_FadeClientVolume_Post, +#else + NULL, +#endif +#ifdef FN_SetClientMaxspeed_Post + FN_SetClientMaxspeed_Post, +#else + NULL, +#endif +#ifdef FN_CreateFakeClient_Post + FN_CreateFakeClient_Post, +#else + NULL, +#endif +#ifdef FN_RunPlayerMove_Post + FN_RunPlayerMove_Post, +#else + NULL, +#endif +#ifdef FN_NumberOfEntities_Post + FN_NumberOfEntities_Post, +#else + NULL, +#endif +#ifdef FN_GetInfoKeyBuffer_Post + FN_GetInfoKeyBuffer_Post, +#else + NULL, +#endif +#ifdef FN_InfoKeyValue_Post + FN_InfoKeyValue_Post, +#else + NULL, +#endif +#ifdef FN_SetKeyValue_Post + FN_SetKeyValue_Post, +#else + NULL, +#endif +#ifdef FN_SetClientKeyValue_Post + FN_SetClientKeyValue_Post, +#else + NULL, +#endif +#ifdef FN_IsMapValid_Post + FN_IsMapValid_Post, +#else + NULL, +#endif +#ifdef FN_StaticDecal_Post + FN_StaticDecal_Post, +#else + NULL, +#endif +#ifdef FN_PrecacheGeneric_Post + FN_PrecacheGeneric_Post, +#else + NULL, +#endif +#ifdef FN_GetPlayerUserId_Post + FN_GetPlayerUserId_Post, +#else + NULL, +#endif +#ifdef FN_BuildSoundMsg_Post + FN_BuildSoundMsg_Post, +#else + NULL, +#endif +#ifdef FN_IsDedicatedServer_Post + FN_IsDedicatedServer_Post, +#else + NULL, +#endif +#ifdef FN_CVarGetPointer_Post + FN_CVarGetPointer_Post, +#else + NULL, +#endif +#ifdef FN_GetPlayerWONId_Post + FN_GetPlayerWONId_Post, +#else + NULL, +#endif +#ifdef FN_Info_RemoveKey_Post + FN_Info_RemoveKey_Post, +#else + NULL, +#endif +#ifdef FN_GetPhysicsKeyValue_Post + FN_GetPhysicsKeyValue_Post, +#else + NULL, +#endif +#ifdef FN_SetPhysicsKeyValue_Post + FN_SetPhysicsKeyValue_Post, +#else + NULL, +#endif +#ifdef FN_GetPhysicsInfoString_Post + FN_GetPhysicsInfoString_Post, +#else + NULL, +#endif +#ifdef FN_PrecacheEvent_Post + FN_PrecacheEvent_Post, +#else + NULL, +#endif +#ifdef FN_PlaybackEvent_Post + FN_PlaybackEvent_Post, +#else + NULL, +#endif +#ifdef FN_SetFatPVS_Post + FN_SetFatPVS_Post, +#else + NULL, +#endif +#ifdef FN_SetFatPAS_Post + FN_SetFatPAS_Post, +#else + NULL, +#endif +#ifdef FN_CheckVisibility_Post + FN_CheckVisibility_Post, +#else + NULL, +#endif +#ifdef FN_DeltaSetField_Post + FN_DeltaSetField_Post, +#else + NULL, +#endif +#ifdef FN_DeltaUnsetField_Post + FN_DeltaUnsetField_Post, +#else + NULL, +#endif +#ifdef FN_DeltaAddEncoder_Post + FN_DeltaAddEncoder_Post, +#else + NULL, +#endif +#ifdef FN_GetCurrentPlayer_Post + FN_GetCurrentPlayer_Post, +#else + NULL, +#endif +#ifdef FN_CanSkipPlayer_Post + FN_CanSkipPlayer_Post, +#else + NULL, +#endif +#ifdef FN_DeltaFindField_Post + FN_DeltaFindField_Post, +#else + NULL, +#endif +#ifdef FN_DeltaSetFieldByIndex_Post + FN_DeltaSetFieldByIndex_Post, +#else + NULL, +#endif +#ifdef FN_DeltaUnsetFieldByIndex_Post + FN_DeltaUnsetFieldByIndex_Post, +#else + NULL, +#endif +#ifdef FN_SetGroupMask_Post + FN_SetGroupMask_Post, +#else + NULL, +#endif +#ifdef FN_engCreateInstancedBaseline_Post + FN_engCreateInstancedBaseline_Post, +#else + NULL, +#endif +#ifdef FN_Cvar_DirectSet_Post + FN_Cvar_DirectSet_Post, +#else + NULL, +#endif +#ifdef FN_ForceUnmodified_Post + FN_ForceUnmodified_Post, +#else + NULL, +#endif +#ifdef FN_GetPlayerStats_Post + FN_GetPlayerStats_Post, +#else + NULL, +#endif +#ifdef FN_AddServerCommand_Post + FN_AddServerCommand_Post, +#else + NULL, +#endif +#ifdef FN_Voice_GetClientListening_Post + FN_Voice_GetClientListening_Post, +#else + NULL, +#endif +#ifdef FN_Voice_SetClientListening_Post + FN_Voice_SetClientListening_Post, +#else + NULL, +#endif +#ifdef FN_GetPlayerAuthId_Post + FN_GetPlayerAuthId_Post +#else + NULL +#endif +}; // g_EngineFuncs_Post_Table + + +static NEW_DLL_FUNCTIONS g_NewFuncs_Table = +{ +#ifdef FN_OnFreeEntPrivateData + FN_OnFreeEntPrivateData, +#else + NULL, +#endif +#ifdef FN_GameShutdown + FN_GameShutdown, +#else + NULL, +#endif +#ifdef FN_ShouldCollide + ShouldCollide, +#else + NULL, +#endif +}; + + +static NEW_DLL_FUNCTIONS g_NewFuncs_Post_Table = +{ +#ifdef FN_OnFreeEntPrivateData_Post + FN_OnFreeEntPrivateData_Post, +#else + NULL, +#endif +#ifdef FN_GameShutdown_Post + FN_GameShutdown_Post, +#else + NULL, +#endif +#ifdef FN_ShouldCollide_Post + ShouldCollide_Post, +#else + NULL, +#endif +}; + +// Global variables from metamod. These variable names are referenced by +// various macros. +meta_globals_t *gpMetaGlobals; // metamod globals +gamedll_funcs_t *gpGamedllFuncs; // gameDLL function tables +mutil_funcs_t *gpMetaUtilFuncs; // metamod utility functions + + +plugin_info_t Plugin_info = { + META_INTERFACE_VERSION, + MODULE_NAME, + MODULE_VERSION, + MODULE_DATE, + MODULE_AUTHOR, + MODULE_URL, + MODULE_LOGTAG, + PT_ANYTIME, + PT_ANYTIME +}; + +/* +C_DLLEXPORT int GetEntityAPI(DLL_FUNCTIONS *pFunctionTable, int interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetEntityAPI; version=%d", interfaceVersion); + if(!pFunctionTable) { + LOG_ERROR(PLID, "GetEntityAPI called with null pFunctionTable"); + return(FALSE); + } + else if(interfaceVersion != INTERFACE_VERSION) { + LOG_ERROR(PLID, "GetEntityAPI version mismatch; requested=%d ours=%d", interfaceVersion, INTERFACE_VERSION); + return(FALSE); + } + memcpy(pFunctionTable, &g_EntityAPI_Table, sizeof( DLL_FUNCTIONS ) ); + + return (TRUE); +} + +C_DLLEXPORT int GetEntityAPI_Post(DLL_FUNCTIONS *pFunctionTable, int interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetEntityAPI_Post; version=%d", interfaceVersion); + if(!pFunctionTable) { + LOG_ERROR(PLID, "GetEntityAPI_Post called with null pFunctionTable"); + return(FALSE); + } + else if(interfaceVersion != INTERFACE_VERSION) { + LOG_ERROR(PLID, "GetEntityAPI_Post version mismatch; requested=%d ours=%d", interfaceVersion, INTERFACE_VERSION); + return(FALSE); + } + memcpy(pFunctionTable, &g_EntityAPI_Post_Table, sizeof( DLL_FUNCTIONS ) ); + + return(TRUE); +} +*/ + +C_DLLEXPORT int GetEntityAPI2(DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetEntityAPI2; version=%d", *interfaceVersion); + if(!pFunctionTable) { + LOG_ERROR(PLID, "GetEntityAPI2 called with null pFunctionTable"); + return(FALSE); + } + else if(*interfaceVersion != INTERFACE_VERSION) { + LOG_ERROR(PLID, + "GetEntityAPI2 version mismatch; requested=%d ours=%d", + *interfaceVersion, INTERFACE_VERSION); + //! Tell engine what version we had, so it can figure out who is + //! out of date. + *interfaceVersion = INTERFACE_VERSION; + return(FALSE); + } + memcpy(pFunctionTable, &g_EntityAPI_Table, sizeof(DLL_FUNCTIONS)); + g_pFunctionTable=pFunctionTable; + return(TRUE); +} + +C_DLLEXPORT int GetEntityAPI2_Post(DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetEntityAPI2_Post; version=%d", *interfaceVersion); + if(!pFunctionTable) { + LOG_ERROR(PLID, "GetEntityAPI2_Post called with null pFunctionTable"); + return(FALSE); + } + else if(*interfaceVersion != INTERFACE_VERSION) { + LOG_ERROR(PLID, "GetEntityAPI2_Post version mismatch; requested=%d ours=%d", *interfaceVersion, INTERFACE_VERSION); + //! Tell engine what version we had, so it can figure out who is out of date. + *interfaceVersion = INTERFACE_VERSION; + return(FALSE); + } + memcpy( pFunctionTable, &g_EntityAPI_Post_Table, sizeof( DLL_FUNCTIONS ) ); + g_pFunctionTable_Post=pFunctionTable; + return(TRUE); +} + +C_DLLEXPORT int GetEngineFunctions(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetEngineFunctions; version=%d", + *interfaceVersion); + if(!pengfuncsFromEngine) { + LOG_ERROR(PLID, + "GetEngineFunctions called with null pengfuncsFromEngine"); + return(FALSE); + } + else if(*interfaceVersion != ENGINE_INTERFACE_VERSION) { + LOG_ERROR(PLID, + "GetEngineFunctions version mismatch; requested=%d ours=%d", + *interfaceVersion, ENGINE_INTERFACE_VERSION); + // Tell metamod what version we had, so it can figure out who is + // out of date. + *interfaceVersion = ENGINE_INTERFACE_VERSION; + return(FALSE); + } + memcpy(pengfuncsFromEngine, &g_EngineFuncs_Table, sizeof(enginefuncs_t)); + g_pengfuncsTable=pengfuncsFromEngine; + return TRUE; +} + +C_DLLEXPORT int GetEngineFunctions_Post(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetEngineFunctions_Post; version=%d", *interfaceVersion); + if(!pengfuncsFromEngine) { + LOG_ERROR(PLID, "GetEngineFunctions_Post called with null pengfuncsFromEngine"); + return(FALSE); + } + else if(*interfaceVersion != ENGINE_INTERFACE_VERSION) { + LOG_ERROR(PLID, "GetEngineFunctions_Post version mismatch; requested=%d ours=%d", *interfaceVersion, ENGINE_INTERFACE_VERSION); + // Tell metamod what version we had, so it can figure out who is out of date. + *interfaceVersion = ENGINE_INTERFACE_VERSION; + return(FALSE); + } + memcpy(pengfuncsFromEngine, &g_EngineFuncs_Post_Table, sizeof(enginefuncs_t)); + g_pengfuncsTable_Post=pengfuncsFromEngine; + return TRUE; + +} + +C_DLLEXPORT int GetNewDLLFunctions(NEW_DLL_FUNCTIONS *pNewFunctionTable, + int *interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetNewDLLFunctions; version=%d", + *interfaceVersion); + if(!pNewFunctionTable) { + LOG_ERROR(PLID, + "GetNewDLLFunctions called with null pNewFunctionTable"); + return(FALSE); + } + else if(*interfaceVersion != NEW_DLL_FUNCTIONS_VERSION) { + LOG_ERROR(PLID, + "GetNewDLLFunctions version mismatch; requested=%d ours=%d", + *interfaceVersion, NEW_DLL_FUNCTIONS_VERSION); + //! Tell engine what version we had, so it can figure out who is + //! out of date. + *interfaceVersion = NEW_DLL_FUNCTIONS_VERSION; + return(FALSE); + } + memcpy(pNewFunctionTable, &g_NewFuncs_Table, sizeof(NEW_DLL_FUNCTIONS)); + g_pNewFunctionsTable=pNewFunctionTable; + return TRUE; +} + +C_DLLEXPORT int GetNewDLLFunctions_Post( NEW_DLL_FUNCTIONS *pNewFunctionTable, int *interfaceVersion ) +{ + LOG_DEVELOPER(PLID, "called: GetNewDLLFunctions_Post; version=%d", *interfaceVersion); + if(!pNewFunctionTable) { + LOG_ERROR(PLID, "GetNewDLLFunctions_Post called with null pNewFunctionTable"); + return(FALSE); + } + else if(*interfaceVersion != NEW_DLL_FUNCTIONS_VERSION) { + LOG_ERROR(PLID, "GetNewDLLFunctions_Post version mismatch; requested=%d ours=%d", *interfaceVersion, NEW_DLL_FUNCTIONS_VERSION); + //! Tell engine what version we had, so it can figure out who is out of date. + *interfaceVersion = NEW_DLL_FUNCTIONS_VERSION; + return(FALSE); + } + memcpy(pNewFunctionTable, &g_NewFuncs_Post_Table, sizeof(NEW_DLL_FUNCTIONS)); + g_pNewFunctionsTable_Post=pNewFunctionTable; + return TRUE; +} + + +static META_FUNCTIONS g_MetaFunctions_Table = +{ + NULL, + NULL, + GetEntityAPI2, + GetEntityAPI2_Post, + GetNewDLLFunctions, + GetNewDLLFunctions_Post, + GetEngineFunctions, + GetEngineFunctions_Post +}; + +C_DLLEXPORT int Meta_Query(char *ifvers, plugin_info_t **pPlugInfo, mutil_funcs_t *pMetaUtilFuncs) +{ + if ((int) CVAR_GET_FLOAT("developer") != 0) + UTIL_LogPrintf("[%s] dev: called: Meta_Query; version=%s, ours=%s\n", + Plugin_info.logtag, ifvers, Plugin_info.ifvers); + + // Check for valid pMetaUtilFuncs before we continue. + if(!pMetaUtilFuncs) { + UTIL_LogPrintf("[%s] ERROR: Meta_Query called with null pMetaUtilFuncs\n", Plugin_info.logtag); + return(FALSE); + } + + gpMetaUtilFuncs = pMetaUtilFuncs; + + *pPlugInfo = &Plugin_info; + + // Check for interface version compatibility. + if(!FStrEq(ifvers, Plugin_info.ifvers)) { + int mmajor=0, mminor=0, pmajor=0, pminor=0; + LOG_MESSAGE(PLID, "WARNING: meta-interface version mismatch; requested=%s ours=%s", + Plugin_info.logtag, ifvers); + // If plugin has later interface version, it's incompatible (update + // metamod). + sscanf(ifvers, "%d:%d", &mmajor, &mminor); + sscanf(META_INTERFACE_VERSION, "%d:%d", &pmajor, &pminor); + if(pmajor > mmajor || (pmajor==mmajor && pminor > mminor)) { + LOG_ERROR(PLID, "metamod version is too old for this module; update metamod"); + return(FALSE); + } + // If plugin has older major interface version, it's incompatible + // (update plugin). + else if(pmajor < mmajor) { + LOG_ERROR(PLID, "metamod version is incompatible with this module; please find a newer version of this module"); + return(FALSE); + } + // Minor interface is older, but this is guaranteed to be backwards + // compatible, so we warn, but we still accept it. + else if(pmajor==mmajor && pminor < mminor) + LOG_MESSAGE(PLID, "WARNING: metamod version is newer than expected; consider finding a newer version of this module"); + else + LOG_ERROR(PLID, "unexpected version comparison; metavers=%s, mmajor=%d, mminor=%d; plugvers=%s, pmajor=%d, pminor=%d", ifvers, mmajor, mminor, META_INTERFACE_VERSION, pmajor, pminor); + } + +#ifdef FN_META_QUERY + return FN_META_QUERY(); +#endif // FN_META_QUERY + + return 1; +} + + +C_DLLEXPORT int Meta_Attach(PLUG_LOADTIME now, META_FUNCTIONS *pFunctionTable, meta_globals_t *pMGlobals, gamedll_funcs_t *pGamedllFuncs) +{ + if(now > Plugin_info.loadable) { + LOG_ERROR(PLID, "Can't load module right now"); + return(FALSE); + } + if(!pMGlobals) { + LOG_ERROR(PLID, "Meta_Attach called with null pMGlobals"); + return(FALSE); + } + gpMetaGlobals=pMGlobals; + if(!pFunctionTable) { + LOG_ERROR(PLID, "Meta_Attach called with null pFunctionTable"); + return(FALSE); + } + + memcpy(pFunctionTable, &g_MetaFunctions_Table, sizeof(META_FUNCTIONS)); + gpGamedllFuncs=pGamedllFuncs; + + // Let's go. + +#ifdef FN_META_ATTACH + FN_META_ATTACH(); +#endif // FN_META_ATTACH + + return TRUE; +} + +C_DLLEXPORT int Meta_Detach(PLUG_LOADTIME now, PL_UNLOAD_REASON reason) +{ + if(now > Plugin_info.unloadable && reason != PNL_CMD_FORCED) { + LOG_ERROR(PLID, "Can't unload plugin right now"); + return(FALSE); + } + +#ifdef FN_META_DETACH + return FN_META_DETACH(); +#endif // FN_META_DETACH + return TRUE; +} + + + +#ifdef __linux__ +// linux prototype +C_DLLEXPORT void GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals ) { + +#else +#ifdef _MSC_VER +// MSVC: Simulate __stdcall calling convention +C_DLLEXPORT __declspec(naked) void GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals ) +{ + __asm // Prolog + { + // Save ebp + push ebp + // Set stack frame pointer + mov ebp, esp + // Allocate space for local variables + // The MSVC compiler gives us the needed size in __LOCAL_SIZE. + sub esp, __LOCAL_SIZE + // Push registers + push ebx + push esi + push edi + } +#else // _MSC_VER +#ifdef __GNUC__ +// GCC can also work with this +C_DLLEXPORT void __stdcall GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals ) +{ +#else // __GNUC__ +// compiler not known +#error There is no support (yet) for your compiler. Please use MSVC or GCC compilers or contact the AMX Mod X dev team. +#endif // __GNUC__ +#endif // _MSC_VER +#endif // __linux__ + + // ** Function core <-- + memcpy(&g_engfuncs, pengfuncsFromEngine, sizeof(enginefuncs_t)); + gpGlobals = pGlobals; + // NOTE! Have to call logging function _after_ copying into g_engfuncs, so + // that g_engfuncs.pfnAlertMessage() can be resolved properly, heh. :) + UTIL_LogPrintf("[%s] dev: called: GiveFnptrsToDll\n", Plugin_info.logtag); + // --> ** Function core + +#ifdef _MSC_VER + // Epilog + if (sizeof(int*) == 8) + { // 64 bit + __asm + { + // Pop registers + pop edi + pop esi + pop ebx + // Restore stack frame pointer + mov esp, ebp + // Restore ebp + pop ebp + // 2 * sizeof(int*) = 16 on 64 bit + ret 16 + } + } + else + { // 32 bit + __asm + { + // Pop registers + pop edi + pop esi + pop ebx + // Restore stack frame pointer + mov esp, ebp + // Restore ebp + pop ebp + // 2 * sizeof(int*) = 8 on 32 bit + ret 8 + } + } +#endif // #ifdef _MSC_VER +} + +#endif // #ifdef USE_METAMOD + +/************* AMXX Stuff *************/ + +// *** Globals *** +// Module info +static amxx_module_info_s g_ModuleInfo = +{ + MODULE_NAME, + MODULE_AUTHOR, + MODULE_VERSION, +#ifdef MODULE_RELOAD_ON_MAPCHANGE + 1, +#else // MODULE_RELOAD_ON_MAPCHANGE + 0, +#endif // MODULE_RELOAD_ON_MAPCHANGE + MODULE_LOGTAG +}; + +// Storage for the requested functions +PFN_ADD_NATIVES g_fn_AddNatives; +PFN_BUILD_PATHNAME g_fn_BuildPathname; +PFN_BUILD_PATHNAME_R g_fn_BuildPathnameR; +PFN_GET_AMXADDR g_fn_GetAmxAddr; +PFN_PRINT_SRVCONSOLE g_fn_PrintSrvConsole; +PFN_GET_MODNAME g_fn_GetModname; +PFN_GET_AMXSCRIPTNAME g_fn_GetAmxScriptName; +PFN_GET_AMXSCRIPT g_fn_GetAmxScript; +PFN_FIND_AMXSCRIPT_BYAMX g_fn_FindAmxScriptByAmx; +PFN_FIND_AMXSCRIPT_BYNAME g_fn_FindAmxScriptByName; +PFN_SET_AMXSTRING g_fn_SetAmxString; +PFN_GET_AMXSTRING g_fn_GetAmxString; +PFN_GET_AMXSTRINGLEN g_fn_GetAmxStringLen; +PFN_FORMAT_AMXSTRING g_fn_FormatAmxString; +PFN_COPY_AMXMEMORY g_fn_CopyAmxMemory; +PFN_LOG g_fn_Log; +PFN_LOG_ERROR g_fn_LogErrorFunc; +PFN_RAISE_AMXERROR g_fn_RaiseAmxError; +PFN_REGISTER_FORWARD g_fn_RegisterForward; +PFN_EXECUTE_FORWARD g_fn_ExecuteForward; +PFN_PREPARE_CELLARRAY g_fn_PrepareCellArray; +PFN_PREPARE_CHARARRAY g_fn_PrepareCharArray; +PFN_PREPARE_CELLARRAY_A g_fn_PrepareCellArrayA; +PFN_PREPARE_CHARARRAY_A g_fn_PrepareCharArrayA; +PFN_IS_PLAYER_VALID g_fn_IsPlayerValid; +PFN_GET_PLAYER_NAME g_fn_GetPlayerName; +PFN_GET_PLAYER_IP g_fn_GetPlayerIP; +PFN_IS_PLAYER_INGAME g_fn_IsPlayerIngame; +PFN_IS_PLAYER_BOT g_fn_IsPlayerBot; +PFN_IS_PLAYER_AUTHORIZED g_fn_IsPlayerAuthorized; +PFN_GET_PLAYER_TIME g_fn_GetPlayerTime; +PFN_GET_PLAYER_PLAYTIME g_fn_GetPlayerPlayTime; +PFN_GET_PLAYER_CURWEAPON g_fn_GetPlayerCurweapon; +PFN_GET_PLAYER_TEAM g_fn_GetPlayerTeam; +PFN_GET_PLAYER_TEAMID g_fn_GetPlayerTeamID; +PFN_GET_PLAYER_DEATHS g_fn_GetPlayerDeaths; +PFN_GET_PLAYER_MENU g_fn_GetPlayerMenu; +PFN_GET_PLAYER_KEYS g_fn_GetPlayerKeys; +PFN_IS_PLAYER_ALIVE g_fn_IsPlayerAlive; +PFN_GET_PLAYER_FRAGS g_fn_GetPlayerFrags; +PFN_IS_PLAYER_CONNECTING g_fn_IsPlayerConnecting; +PFN_IS_PLAYER_HLTV g_fn_IsPlayerHLTV; +PFN_GET_PLAYER_ARMOR g_fn_GetPlayerArmor; +PFN_GET_PLAYER_HEALTH g_fn_GetPlayerHealth; +#ifdef MEMORY_TEST +PFN_ALLOCATOR g_fn_Allocator; +PFN_REALLOCATOR g_fn_Reallocator; +PFN_DEALLOCATOR g_fn_Deallocator; +#endif +PFN_AMX_EXEC g_fn_AmxExec; +PFN_AMX_EXECV g_fn_AmxExecv; +PFN_AMX_ALLOT g_fn_AmxAllot; +PFN_AMX_FINDPUBLIC g_fn_AmxFindPublic; +PFN_LOAD_AMXSCRIPT g_fn_LoadAmxScript; +PFN_UNLOAD_AMXSCRIPT g_fn_UnloadAmxScript; +PFN_REAL_TO_CELL g_fn_RealToCell; +PFN_CELL_TO_REAL g_fn_CellToReal; +PFN_REGISTER_SPFORWARD g_fn_RegisterSPForward; +PFN_REGISTER_SPFORWARD_BYNAME g_fn_RegisterSPForwardByName; +PFN_UNREGISTER_SPFORWARD g_fn_UnregisterSPForward; +PFN_MERGEDEFINITION_FILE g_fn_MergeDefinition_File; +PFN_AMX_FINDNATIVE g_fn_AmxFindNative; +PFN_GETPLAYERFLAGS g_fn_GetPlayerFlags; +PFN_GET_PLAYER_EDICT g_fn_GetPlayerEdict; +PFN_FORMAT g_fn_Format; +PFN_REGISTERFUNCTION g_fn_RegisterFunction; +PFN_REQ_FNPTR g_fn_RequestFunction; +PFN_AMX_PUSH g_fn_AmxPush; + +// *** Exports *** +C_DLLEXPORT int AMXX_Query(int *interfaceVersion, amxx_module_info_s *moduleInfo) +{ + // check parameters + if (!interfaceVersion || !moduleInfo) + return AMXX_PARAM; + + // check interface version + if (*interfaceVersion != AMXX_INTERFACE_VERSION) + { + // Tell amxx core our interface version + *interfaceVersion = AMXX_INTERFACE_VERSION; + return AMXX_IFVERS; + } + + // copy module info + memcpy(moduleInfo, &g_ModuleInfo, sizeof(amxx_module_info_s)); + +#ifdef FN_AMXX_QUERY + FN_AMXX_QUERY(); +#endif // FN_AMXX_QUERY + // Everything ok :) + return AMXX_OK; +} + +// request function +#define REQFUNC(name, fptr, type) if ((fptr = (type)reqFnptrFunc(name)) == 0) return AMXX_FUNC_NOT_PRESENT +// request optional function +#define REQFUNC_OPT(name, fptr, type) fptr = (type)reqFnptrFunc(name) + +C_DLLEXPORT int AMXX_Attach(PFN_REQ_FNPTR reqFnptrFunc) +{ + // Check pointer + if (!reqFnptrFunc) + return AMXX_PARAM; + + g_fn_RequestFunction = reqFnptrFunc; + + // Req all known functions + // Misc + REQFUNC("BuildPathname", g_fn_BuildPathname, PFN_BUILD_PATHNAME); + REQFUNC("BuildPathnameR", g_fn_BuildPathnameR, PFN_BUILD_PATHNAME_R); + REQFUNC("PrintSrvConsole", g_fn_PrintSrvConsole, PFN_PRINT_SRVCONSOLE); + REQFUNC("GetModname", g_fn_GetModname, PFN_GET_MODNAME); + REQFUNC("Log", g_fn_Log, PFN_LOG); + REQFUNC("LogError", g_fn_LogErrorFunc, PFN_LOG_ERROR); + REQFUNC("MergeDefinitionFile", g_fn_MergeDefinition_File, PFN_MERGEDEFINITION_FILE); + REQFUNC("Format", g_fn_Format, PFN_FORMAT); + REQFUNC("RegisterFunction", g_fn_RegisterFunction, PFN_REGISTERFUNCTION); + + // Amx scripts + REQFUNC("GetAmxScript", g_fn_GetAmxScript, PFN_GET_AMXSCRIPT); + REQFUNC("FindAmxScriptByAmx", g_fn_FindAmxScriptByAmx, PFN_FIND_AMXSCRIPT_BYAMX); + REQFUNC("FindAmxScriptByName", g_fn_FindAmxScriptByName, PFN_FIND_AMXSCRIPT_BYNAME); + REQFUNC("LoadAmxScript", g_fn_LoadAmxScript, PFN_LOAD_AMXSCRIPT); + REQFUNC("UnloadAmxScript", g_fn_UnloadAmxScript, PFN_UNLOAD_AMXSCRIPT); + REQFUNC("GetAmxScriptName", g_fn_GetAmxScriptName, PFN_GET_AMXSCRIPTNAME); + + // String / mem in amx scripts support + REQFUNC("SetAmxString", g_fn_SetAmxString, PFN_SET_AMXSTRING); + REQFUNC("GetAmxString", g_fn_GetAmxString, PFN_GET_AMXSTRING); + REQFUNC("GetAmxStringLen", g_fn_GetAmxStringLen, PFN_GET_AMXSTRINGLEN); + REQFUNC("FormatAmxString", g_fn_FormatAmxString, PFN_FORMAT_AMXSTRING); + REQFUNC("CopyAmxMemory", g_fn_CopyAmxMemory, PFN_COPY_AMXMEMORY); + REQFUNC("GetAmxAddr", g_fn_GetAmxAddr, PFN_GET_AMXADDR); + + REQFUNC("amx_Exec", g_fn_AmxExec, PFN_AMX_EXEC); + REQFUNC("amx_Execv", g_fn_AmxExecv, PFN_AMX_EXECV); + REQFUNC("amx_FindPublic", g_fn_AmxFindPublic, PFN_AMX_FINDPUBLIC); + REQFUNC("amx_Allot", g_fn_AmxAllot, PFN_AMX_ALLOT); + REQFUNC("amx_FindNative", g_fn_AmxFindNative, PFN_AMX_FINDNATIVE); + + // Natives / Forwards + REQFUNC("AddNatives", g_fn_AddNatives, PFN_ADD_NATIVES); + REQFUNC("RaiseAmxError", g_fn_RaiseAmxError, PFN_RAISE_AMXERROR); + REQFUNC("RegisterForward", g_fn_RegisterForward, PFN_REGISTER_FORWARD); + REQFUNC("RegisterSPForward", g_fn_RegisterSPForward, PFN_REGISTER_SPFORWARD); + REQFUNC("RegisterSPForwardByName", g_fn_RegisterSPForwardByName, PFN_REGISTER_SPFORWARD_BYNAME); + REQFUNC("UnregisterSPForward", g_fn_UnregisterSPForward, PFN_UNREGISTER_SPFORWARD); + REQFUNC("ExecuteForward", g_fn_ExecuteForward, PFN_EXECUTE_FORWARD); + REQFUNC("PrepareCellArray", g_fn_PrepareCellArray, PFN_PREPARE_CELLARRAY); + REQFUNC("PrepareCharArray", g_fn_PrepareCharArray, PFN_PREPARE_CHARARRAY); + REQFUNC("PrepareCellArrayA", g_fn_PrepareCellArrayA, PFN_PREPARE_CELLARRAY_A); + REQFUNC("PrepareCharArrayA", g_fn_PrepareCharArrayA, PFN_PREPARE_CHARARRAY_A); + // Player + REQFUNC("IsPlayerValid", g_fn_IsPlayerValid, PFN_IS_PLAYER_VALID); + REQFUNC("GetPlayerName", g_fn_GetPlayerName, PFN_GET_PLAYER_NAME); + REQFUNC("GetPlayerIP", g_fn_GetPlayerIP, PFN_GET_PLAYER_IP); + REQFUNC("IsPlayerInGame", g_fn_IsPlayerIngame, PFN_IS_PLAYER_INGAME); + REQFUNC("IsPlayerBot", g_fn_IsPlayerBot, PFN_IS_PLAYER_BOT); + REQFUNC("IsPlayerAuthorized", g_fn_IsPlayerAuthorized, PFN_IS_PLAYER_AUTHORIZED); + REQFUNC("GetPlayerTime", g_fn_GetPlayerTime, PFN_GET_PLAYER_TIME); + REQFUNC("GetPlayerPlayTime", g_fn_GetPlayerPlayTime, PFN_GET_PLAYER_PLAYTIME); + REQFUNC("GetPlayerCurweapon", g_fn_GetPlayerCurweapon, PFN_GET_PLAYER_CURWEAPON); + REQFUNC("GetPlayerTeamID", g_fn_GetPlayerTeamID, PFN_GET_PLAYER_TEAMID); + REQFUNC("GetPlayerTeam",g_fn_GetPlayerTeam, PFN_GET_PLAYER_TEAM); + REQFUNC("GetPlayerDeaths", g_fn_GetPlayerDeaths, PFN_GET_PLAYER_DEATHS); + REQFUNC("GetPlayerMenu", g_fn_GetPlayerMenu, PFN_GET_PLAYER_MENU); + REQFUNC("GetPlayerKeys", g_fn_GetPlayerKeys, PFN_GET_PLAYER_KEYS); + REQFUNC("IsPlayerAlive", g_fn_IsPlayerAlive, PFN_IS_PLAYER_ALIVE); + REQFUNC("GetPlayerFrags", g_fn_GetPlayerFrags, PFN_GET_PLAYER_FRAGS); + REQFUNC("IsPlayerConnecting", g_fn_IsPlayerConnecting, PFN_IS_PLAYER_CONNECTING); + REQFUNC("IsPlayerHLTV", g_fn_IsPlayerHLTV, PFN_IS_PLAYER_HLTV); + REQFUNC("GetPlayerArmor", g_fn_GetPlayerArmor, PFN_GET_PLAYER_ARMOR); + REQFUNC("GetPlayerHealth", g_fn_GetPlayerHealth, PFN_GET_PLAYER_HEALTH); + REQFUNC("GetPlayerFlags", g_fn_GetPlayerFlags, PFN_GETPLAYERFLAGS); + REQFUNC("GetPlayerEdict", g_fn_GetPlayerEdict, PFN_GET_PLAYER_EDICT); + REQFUNC("amx_Push", g_fn_AmxPush, PFN_AMX_PUSH); + +#ifdef MEMORY_TEST + // Memory + REQFUNC_OPT("Allocator", g_fn_Allocator, PFN_ALLOCATOR); + REQFUNC_OPT("Reallocator", g_fn_Reallocator, PFN_REALLOCATOR); + REQFUNC_OPT("Deallocator", g_fn_Deallocator, PFN_DEALLOCATOR); +#endif + + REQFUNC("CellToReal", g_fn_CellToReal, PFN_CELL_TO_REAL); + REQFUNC("RealToCell", g_fn_RealToCell, PFN_REAL_TO_CELL); + +#ifdef FN_AMXX_ATTACH + FN_AMXX_ATTACH(); +#endif // FN_AMXX_ATACH + + return AMXX_OK; +} + +C_DLLEXPORT int AMXX_Detach() +{ +#ifdef FN_AMXX_DETACH + FN_AMXX_DETACH(); +#endif // FN_AMXX_DETACH + + return AMXX_OK; +} + +C_DLLEXPORT int AMXX_PluginsLoaded() +{ +#ifdef FN_AMXX_PLUGINSLOADED + FN_AMXX_PLUGINSLOADED(); +#endif // FN_AMXX_PLUGINSLOADED + return AMXX_OK; +} + +// Advanced MF functions +void MF_Log(const char *fmt, ...) +{ + // :TODO: Overflow possible here + char msg[3072]; + va_list arglst; + va_start(arglst, fmt); + vsprintf(msg, fmt, arglst); + va_end(arglst); + + g_fn_Log("[%s] %s", MODULE_LOGTAG, msg); +} + +void MF_LogError(AMX *amx, int err, const char *fmt, ...) +{ + // :TODO: Overflow possible here + char msg[3072]; + va_list arglst; + va_start(arglst, fmt); + vsprintf(msg, fmt, arglst); + va_end(arglst); + + g_fn_LogErrorFunc(amx, err, "[%s] %s", MODULE_LOGTAG, msg); +} + + +#ifdef _DEBUG +// validate macros +// Makes sure compiler reports errors when macros are invalid +void ValidateMacros_DontCallThis_Smiley() +{ + MF_BuildPathname("str", "str", 0); + MF_BuildPathnameR(NULL, 0, "%d", 0); + MF_FormatAmxString(NULL, 0, 0, NULL); + MF_GetAmxAddr(NULL, 0); + MF_PrintSrvConsole("str", "str", 0); + MF_GetModname(); + MF_GetScriptName(0); + MF_GetScriptAmx(0); + MF_FindScriptByAmx(NULL); + MF_FindScriptByName("str"); + MF_SetAmxString(NULL, 0, "str", 0); + MF_GetAmxString(NULL, 0, 0, 0); + MF_GetAmxStringLen(NULL); + MF_CopyAmxMemory(NULL, NULL, 0); + MF_Log("str", "str", 0); + MF_LogError(NULL, 0, NULL); + MF_RaiseAmxError(NULL, 0); + MF_RegisterForward("str", (ForwardExecType)0, 0, 0, 0); + MF_ExecuteForward(0, 0, 0); + MF_PrepareCellArray(NULL, 0); + MF_PrepareCharArray(NULL, 0); + MF_PrepareCellArrayA(NULL, 0, true); + MF_PrepareCharArrayA(NULL, 0, true); + MF_IsPlayerValid(0); + MF_GetPlayerName(0); + MF_GetPlayerIP(0); + MF_IsPlayerIngame(0); + MF_IsPlayerBot(0); + MF_IsPlayerAuthorized(0); + MF_GetPlayerTime(0); + MF_GetPlayerPlayTime(0); + MF_GetPlayerCurweapon(0); + MF_GetPlayerTeamID(0); + MF_GetPlayerTeam(0); + MF_GetPlayerDeaths(0); + MF_GetPlayerMenu(0); + MF_GetPlayerKeys(0); + MF_IsPlayerAlive(0); + MF_GetPlayerFrags(0); + MF_IsPlayerConnecting(0); + MF_IsPlayerHLTV(0); + MF_GetPlayerArmor(0); + MF_GetPlayerHealth(0); + MF_AmxExec(0, 0, 0); + MF_AmxExecv(0, 0, 0, 0, 0); + MF_AmxFindPublic(0, 0, 0); + MF_AmxAllot(0, 0, 0, 0); + MF_LoadAmxScript(0, 0, 0, 0, 0); + MF_UnloadAmxScript(0, 0); + MF_RegisterSPForward(0, 0, 0, 0, 0, 0); + MF_RegisterSPForwardByName(0, 0, 0, 0, 0, 0); + MF_UnregisterSPForward(0); + MF_GetPlayerFrags(0); + MF_GetPlayerEdict(0); + MF_Format("", 4, "str"); + MF_RegisterFunction(NULL, ""); +} +#endif + +#ifdef MEMORY_TEST + +/************* MEMORY *************/ +// undef all defined macros +#undef new +#undef delete +#undef malloc +#undef calloc +#undef realloc +#undef free + +const unsigned int m_alloc_unknown = 0; +const unsigned int m_alloc_new = 1; +const unsigned int m_alloc_new_array = 2; +const unsigned int m_alloc_malloc = 3; +const unsigned int m_alloc_calloc = 4; +const unsigned int m_alloc_realloc = 5; +const unsigned int m_alloc_delete = 6; +const unsigned int m_alloc_delete_array = 7; +const unsigned int m_alloc_free = 8; + +const char *g_Mem_CurrentFilename = "??"; +int g_Mem_CurrentLine = 0; +const char *g_Mem_CurrentFunc = "??"; + +const char *Mem_MakeSourceFile(const char *sourceFile) +{ + static char buffer[512]; + static size_t pos = 0; + if (!pos) + { + // init + buffer[0] = '['; + strcpy(buffer + 1, MODULE_NAME); + pos = strlen(MODULE_NAME) + 1; + buffer[pos++] = ']'; + } + + // convert from absolute path to [modulename]filename + const char *ptr = strrchr(sourceFile, '\\'); + if (ptr) + ptr++; + else + { + ptr = strrchr(sourceFile, '/'); + if (ptr) + ptr++; + else + ptr = sourceFile; + } + strcpy(buffer + pos, ptr); + return buffer; +} + +void Mem_SetOwner(const char *filename, int line, const char *function) +{ + g_Mem_CurrentFilename = filename; + g_Mem_CurrentLine = line; + g_Mem_CurrentFunc = function; +} + +void Mem_ResetGlobals() +{ + Mem_SetOwner("??", 0, "??"); +} + +// raw (re/de)allocators +void * Mem_Allocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, + const unsigned int allocationType, const size_t reportedSize) +{ + if (g_fn_Allocator) + return g_fn_Allocator(Mem_MakeSourceFile(sourceFile), sourceLine, sourceFunc, allocationType, reportedSize); + else + return malloc(reportedSize); +} + +void * Mem_Reallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, + const unsigned int reallocationType, const size_t reportedSize, void *reportedAddress) +{ + if (g_fn_Reallocator) + return g_fn_Reallocator(Mem_MakeSourceFile(sourceFile), sourceLine, sourceFunc, reallocationType, reportedSize, reportedAddress); + else + return realloc(reportedAddress, reportedSize); +} + +void Mem_Deallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, + const unsigned int deallocationType, void *reportedAddress) +{ + // If you you get user breakpoint here, something failed :) + // - invalid pointer + // - alloc type mismatch ( for example + // char *a = new char[5]; delete char; + // ) + // - The allocation unit is damaged (for example + // char *a = new char[5]; a[6] = 8; + // ) + // - break on dealloc flag set (somehow) + + if (g_fn_Deallocator) + g_fn_Deallocator(Mem_MakeSourceFile(sourceFile), sourceLine, sourceFunc, deallocationType, reportedAddress); + else + free(reportedAddress); +} + +// new and delete operators +void *operator new(size_t reportedSize) +{ + if (reportedSize == 0) + reportedSize = 1; + void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new, reportedSize); + // :TODO: Handler support ? + if (ptr) + return ptr; + + // allocation failed + return NULL; +} + +void *operator new[](size_t reportedSize) +{ + if (reportedSize == 0) + reportedSize = 1; + void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new_array, reportedSize); + // :TODO: Handler support ? + if (ptr) + return ptr; + + // allocation failed + return NULL; +} + +// Microsoft memory tracking operators +void *operator new(size_t reportedSize, const char *sourceFile, int sourceLine) +{ + if (reportedSize == 0) + reportedSize = 1; + void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new, reportedSize); + // :TODO: Handler support ? + if (ptr) + return ptr; + + // allocation failed + return NULL; +} +void *operator new[](size_t reportedSize, const char *sourceFile, int sourceLine) +{ + if (reportedSize == 0) + reportedSize = 1; + void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new_array, reportedSize); + // :TODO: Handler support ? + if (ptr) + return ptr; + + // allocation failed + return NULL; +} + +void operator delete(void *reportedAddress) +{ + if (!reportedAddress) + return; + + Mem_Deallocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_delete, reportedAddress); +} + +void operator delete[](void *reportedAddress) +{ + if (!reportedAddress) + return; + + Mem_Deallocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_delete_array, reportedAddress); +} + +#else + +#if !defined NO_ALLOC_OVERRIDES && !defined MEMORY_TEST && !defined WIN32 +void * ::operator new(size_t size) { + return(calloc(1, size)); +} + +void * ::operator new[](size_t size) { + return(calloc(1, size)); +} + +void ::operator delete(void * ptr) { + if(ptr) + free(ptr); +} + +void ::operator delete[](void * ptr) { + if(ptr) + free(ptr); +} +#endif + +#endif //MEMORY_TEST + +/************* stuff from dlls/util.cpp *************/ +// must come here because cbase.h declares it's own operator new + +#ifdef USE_METAMOD + +// Selected portions of dlls/util.cpp from SDK 2.1. +// Functions copied from there as needed... +// And modified to avoid buffer overflows (argh). + +/*** +* +* Copyright (c) 1999, 2000 Valve LLC. All rights reserved. +* +* This product contains software technology licensed from Id +* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc. +* All Rights Reserved. +* +* Use, distribution, and modification of this source code and/or resulting +* object code is restricted to non-commercial enhancements to products from +* Valve LLC. All other use, distribution, or modification is prohibited +* without written permission from Valve LLC. +* +****/ +/* + +===== util.cpp ======================================================== + + Utility code. Really not optional after all. + +*/ + +#include +#include "sdk_util.h" +#include + +#include // for strncpy(), etc + +#include "osdep.h" // win32 vsnprintf, etc + +char* UTIL_VarArgs( char *format, ... ) +{ + va_list argptr; + static char string[1024]; + + va_start (argptr, format); + vsnprintf (string, sizeof(string), format, argptr); + va_end (argptr); + + return string; +} + + +//========================================================= +// UTIL_LogPrintf - Prints a logged message to console. +// Preceded by LOG: ( timestamp ) < message > +//========================================================= +void UTIL_LogPrintf( char *fmt, ... ) +{ + va_list argptr; + static char string[1024]; + + va_start ( argptr, fmt ); + vsnprintf ( string, sizeof(string), fmt, argptr ); + va_end ( argptr ); + + // Print to server console + ALERT( at_logged, "%s", string ); +} + + +void UTIL_HudMessage(CBaseEntity *pEntity, const hudtextparms_t &textparms, + const char *pMessage) +{ + if ( !pEntity ) + return; + + MESSAGE_BEGIN( MSG_ONE, SVC_TEMPENTITY, NULL, ENT(pEntity->pev) ); + WRITE_BYTE( TE_TEXTMESSAGE ); + WRITE_BYTE( textparms.channel & 0xFF ); + + WRITE_SHORT( FixedSigned16( textparms.x, 1<<13 ) ); + WRITE_SHORT( FixedSigned16( textparms.y, 1<<13 ) ); + WRITE_BYTE( textparms.effect ); + + WRITE_BYTE( textparms.r1 ); + WRITE_BYTE( textparms.g1 ); + WRITE_BYTE( textparms.b1 ); + WRITE_BYTE( textparms.a1 ); + + WRITE_BYTE( textparms.r2 ); + WRITE_BYTE( textparms.g2 ); + WRITE_BYTE( textparms.b2 ); + WRITE_BYTE( textparms.a2 ); + + WRITE_SHORT( FixedUnsigned16( textparms.fadeinTime, 1<<8 ) ); + WRITE_SHORT( FixedUnsigned16( textparms.fadeoutTime, 1<<8 ) ); + WRITE_SHORT( FixedUnsigned16( textparms.holdTime, 1<<8 ) ); + + if ( textparms.effect == 2 ) + WRITE_SHORT( FixedUnsigned16( textparms.fxTime, 1<<8 ) ); + + if ( strlen( pMessage ) < 512 ) + { + WRITE_STRING( pMessage ); + } + else + { + char tmp[512]; + strncpy( tmp, pMessage, 511 ); + tmp[511] = 0; + WRITE_STRING( tmp ); + } + MESSAGE_END(); +} + +short FixedSigned16( float value, float scale ) +{ + int output; + + output = (int) (value * scale); + + if ( output > 32767 ) + output = 32767; + + if ( output < -32768 ) + output = -32768; + + return (short)output; +} + +unsigned short FixedUnsigned16( float value, float scale ) +{ + int output; + + output = (int) (value * scale); + if ( output < 0 ) + output = 0; + if ( output > 0xFFFF ) + output = 0xFFFF; + + return (unsigned short)output; +} +#endif // USE_METAMOD diff --git a/dlls/MemHack/amxxmodule.h b/dlls/MemHack/amxxmodule.h new file mode 100644 index 00000000..0a000d20 --- /dev/null +++ b/dlls/MemHack/amxxmodule.h @@ -0,0 +1,2241 @@ +/* + * AMX Mod X Module Interface Functions + * This file may be freely used +*/ + +// prevent double include +#ifndef __AMXXMODULE_H__ +#define __AMXXMODULE_H__ + +// config +#include "moduleconfig.h" + +// metamod include files +#ifdef USE_METAMOD +#include +#include +#include "osdep.h" +#endif // #ifdef USE_METAMOD + +// DLL Export +#undef DLLEXPORT +#ifndef __linux__ +#define DLLEXPORT __declspec(dllexport) +#else +#define DLLEXPORT +#define LINUX +#endif + +#undef C_DLLEXPORT +#define C_DLLEXPORT extern "C" DLLEXPORT + +// ***** AMXX stuff ***** + +// module interface version was 1 +// 2 - added logtag to struct (amxx1.1-rc1) +// 3 - added new tagAMX structure (amxx1.5) +#define AMXX_INTERFACE_VERSION 3 + +// amxx module info +struct amxx_module_info_s +{ + const char *name; + const char *author; + const char *version; + int reload; // reload on mapchange when nonzero + const char *logtag; // added in version 2 +}; + +// return values from functions called by amxx +#define AMXX_OK 0 /* no error */ +#define AMXX_IFVERS 1 /* interface version */ +#define AMXX_PARAM 2 /* Invalid parameter */ +#define AMXX_FUNC_NOT_PRESENT 3 /* Function not present */ + +// *** Small stuff *** +// The next section is copied from the amx.h file +// Copyright (c) ITB CompuPhase, 1997-2005 + +#if defined HAVE_STDINT_H + #include +#else + #if defined __LCC__ || defined __DMC__ || defined LINUX + #if defined HAVE_INTTYPES_H + #include + #else + #include + #endif + #elif !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L + /* The ISO C99 defines the int16_t and int_32t types. If the compiler got + * here, these types are probably undefined. + */ + #if defined __MACH__ + #include + typedef unsigned short int uint16_t; + typedef unsigned long int uint32_t; + #elif defined __FreeBSD__ + #include + #else + typedef short int int16_t; + typedef unsigned short int uint16_t; + #if defined SN_TARGET_PS2 + typedef int int32_t; + typedef unsigned int uint32_t; + #else + typedef long int int32_t; + typedef unsigned long int uint32_t; + #endif + #if defined __WIN32__ || defined _WIN32 || defined WIN32 + typedef __int64 int64_t; + typedef unsigned __int64 uint64_t; + #define HAVE_I64 + #elif defined __GNUC__ + typedef long long int64_t; + typedef unsigned long long uint64_t; + #define HAVE_I64 + #endif + #endif + #endif + #define HAVE_STDINT_H +#endif +#if defined _LP64 || defined WIN64 || defined _WIN64 + #if !defined __64BIT__ + #define __64BIT__ + #endif +#endif + +/* calling convention for native functions */ +#if !defined AMX_NATIVE_CALL + #define AMX_NATIVE_CALL +#endif +/* calling convention for all interface functions and callback functions */ +#if !defined AMXAPI + #if defined STDECL + #define AMXAPI __stdcall + #elif defined CDECL + #define AMXAPI __cdecl + #else + #define AMXAPI + #endif +#endif +#if !defined AMXEXPORT + #define AMXEXPORT +#endif + +#if !defined PAWN_CELL_SIZE + #define PAWN_CELL_SIZE 32 /* by default, use 32-bit cells */ +#endif +#if PAWN_CELL_SIZE==16 + typedef uint16_t ucell; + typedef int16_t cell; +#elif PAWN_CELL_SIZE==32 + typedef uint32_t ucell; + typedef int32_t cell; +#define REAL float +#elif PAWN_CELL_SIZE==64 + typedef uint64_t ucell; + typedef int64_t cell; +#define REAL double +#else + #error Unsupported cell size (PAWN_CELL_SIZE) +#endif + +#define UNPACKEDMAX ((1 << (sizeof(cell)-1)*8) - 1) +#define UNLIMITED (~1u >> 1) + +struct tagAMX; +typedef cell (AMX_NATIVE_CALL *AMX_NATIVE)(struct tagAMX *amx, cell *params); +typedef int (AMXAPI *AMX_CALLBACK)(struct tagAMX *amx, cell index, + cell *result, cell *params); +typedef int (AMXAPI *AMX_DEBUG)(struct tagAMX *amx); +#if !defined _FAR + #define _FAR +#endif + +#if defined _MSC_VER + #pragma warning(disable:4103) /* disable warning message 4103 that complains + * about pragma pack in a header file */ + #pragma warning(disable:4100) /* "'%$S' : unreferenced formal parameter" */ +#endif + + +/* Some compilers do not support the #pragma align, which should be fine. Some + * compilers give a warning on unknown #pragmas, which is not so fine... + */ +#if (defined SN_TARGET_PS2 || defined __GNUC__) && !defined AMX_NO_ALIGN + #define AMX_NO_ALIGN +#endif + +#if defined __GNUC__ + #define PACKED __attribute__((packed)) +#else + #define PACKED +#endif + +#if !defined AMX_NO_ALIGN + #if defined LINUX || defined __FreeBSD__ + #pragma pack(1) /* structures must be packed (byte-aligned) */ + #elif defined MACOS && defined __MWERKS__ + #pragma options align=mac68k + #else + #pragma pack(push) + #pragma pack(1) /* structures must be packed (byte-aligned) */ + #if defined __TURBOC__ + #pragma option -a- /* "pack" pragma for older Borland compilers */ + #endif + #endif +#endif + +typedef struct { + const char _FAR *name PACKED; + AMX_NATIVE func PACKED; +} AMX_NATIVE_INFO; + +#define AMX_USERNUM 4 + +/* The AMX structure is the internal structure for many functions. Not all + * fields are valid at all times; many fields are cached in local variables. + */ +typedef struct tagAMX { + unsigned char _FAR *base PACKED; /* points to the AMX header plus the code, optionally also the data */ + unsigned char _FAR *data PACKED; /* points to separate data+stack+heap, may be NULL */ + AMX_CALLBACK callback PACKED; + AMX_DEBUG debug PACKED; /* debug callback */ + /* for external functions a few registers must be accessible from the outside */ + cell cip PACKED; /* instruction pointer: relative to base + amxhdr->cod */ + cell frm PACKED; /* stack frame base: relative to base + amxhdr->dat */ + cell hea PACKED; /* top of the heap: relative to base + amxhdr->dat */ + cell hlw PACKED; /* bottom of the heap: relative to base + amxhdr->dat */ + cell stk PACKED; /* stack pointer: relative to base + amxhdr->dat */ + cell stp PACKED; /* top of the stack: relative to base + amxhdr->dat */ + int flags PACKED; /* current status, see amx_Flags() */ + /* user data */ + long usertags[AMX_USERNUM] PACKED; + //okay userdata[3] in AMX Mod X is for the CPlugin * pointer + //we're also gonna set userdata[2] to a special debug structure + void _FAR *userdata[AMX_USERNUM] PACKED; + /* native functions can raise an error */ + int error PACKED; + /* passing parameters requires a "count" field */ + int paramcount; + /* the sleep opcode needs to store the full AMX status */ + cell pri PACKED; + cell alt PACKED; + cell reset_stk PACKED; + cell reset_hea PACKED; + cell sysreq_d PACKED; /* relocated address/value for the SYSREQ.D opcode */ + /* support variables for the JIT */ + int reloc_size PACKED; /* required temporary buffer for relocations */ + long code_size PACKED; /* estimated memory footprint of the native code */ +} PACKED AMX; + +enum { + AMX_ERR_NONE, + /* reserve the first 15 error codes for exit codes of the abstract machine */ + AMX_ERR_EXIT, /* forced exit */ + AMX_ERR_ASSERT, /* assertion failed */ + AMX_ERR_STACKERR, /* stack/heap collision */ + AMX_ERR_BOUNDS, /* index out of bounds */ + AMX_ERR_MEMACCESS, /* invalid memory access */ + AMX_ERR_INVINSTR, /* invalid instruction */ + AMX_ERR_STACKLOW, /* stack underflow */ + AMX_ERR_HEAPLOW, /* heap underflow */ + AMX_ERR_CALLBACK, /* no callback, or invalid callback */ + AMX_ERR_NATIVE, /* native function failed */ + AMX_ERR_DIVIDE, /* divide by zero */ + AMX_ERR_SLEEP, /* go into sleepmode - code can be restarted */ + AMX_ERR_INVSTATE, /* invalid state for this access */ + + AMX_ERR_MEMORY = 16, /* out of memory */ + AMX_ERR_FORMAT, /* invalid file format */ + AMX_ERR_VERSION, /* file is for a newer version of the AMX */ + AMX_ERR_NOTFOUND, /* function not found */ + AMX_ERR_INDEX, /* invalid index parameter (bad entry point) */ + AMX_ERR_DEBUG, /* debugger cannot run */ + AMX_ERR_INIT, /* AMX not initialized (or doubly initialized) */ + AMX_ERR_USERDATA, /* unable to set user data field (table full) */ + AMX_ERR_INIT_JIT, /* cannot initialize the JIT */ + AMX_ERR_PARAMS, /* parameter error */ + AMX_ERR_DOMAIN, /* domain error, expression result does not fit in range */ +}; + +#if !defined AMX_NO_ALIGN + #if defined __linux__ + #pragma pack() /* reset default packing */ + #else + #pragma pack(pop) /* reset previous packing */ + #endif +#endif + + +// ***** declare functions ***** + +#ifdef USE_METAMOD +void UTIL_LogPrintf( char *fmt, ... ); +void UTIL_HudMessage(CBaseEntity *pEntity, const hudtextparms_t &textparms, const char *pMessage); +short FixedSigned16( float value, float scale ); +unsigned short FixedUnsigned16( float value, float scale ); + +#ifdef FN_META_QUERY +void FN_META_QUERY(void); +#endif // FN_META_QUERY + +#ifdef FN_META_ATTACH +void FN_META_ATTACH(void); +#endif // FN_META_ATTACH + +#ifdef FN_META_DETACH +void FN_META_DETACH(void); +#endif // FN_META_DETACH + + + + + +#ifdef FN_GameDLLInit +void FN_GameDLLInit(void); +#endif // FN_GameDLLInit + +#ifdef FN_DispatchSpawn +int FN_DispatchSpawn(edict_t *pent); +#endif // FN_DispatchSpawn + +#ifdef FN_DispatchThink +void FN_DispatchThink(edict_t *pent); +#endif // FN_DispatchThink + +#ifdef FN_DispatchUse +void FN_DispatchUse(edict_t *pentUser, edict_t *pentOther); +#endif // FN_DispatchUse + +#ifdef FN_DispatchTouch +void FN_DispatchTouch(edict_t *pentTouched, edict_t *pentOther); +#endif // FN_DispatchTouch + +#ifdef FN_DispatchBlocked +void FN_DispatchBlocked(edict_t *pentBlocked, edict_t *pentOther); +#endif // FN_DispatchBlocked + +#ifdef FN_DispatchKeyValue +void FN_DispatchKeyValue(edict_t *pentKeyvalue, KeyValueData *pkvd); +#endif // FN_DispatchKeyValue + +#ifdef FN_DispatchSave +void FN_DispatchSave(edict_t *pent, SAVERESTOREDATA *pSaveData); +#endif // FN_DispatchSave + +#ifdef FN_DispatchRestore +int FN_DispatchRestore(edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity); +#endif // FN_DispatchRestore + +#ifdef FN_DispatchObjectCollsionBox +void FN_DispatchObjectCollsionBox(edict_t *pent); +#endif // FN_DispatchObjectCollsionBox + +#ifdef FN_SaveWriteFields +void FN_SaveWriteFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount); +#endif // FN_SaveWriteFields + +#ifdef FN_SaveReadFields +void FN_SaveReadFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount); +#endif // FN_SaveReadFields + +#ifdef FN_SaveGlobalState +void FN_SaveGlobalState(SAVERESTOREDATA *pSaveData); +#endif // FN_SaveGlobalState + +#ifdef FN_RestoreGlobalState +void FN_RestoreGlobalState(SAVERESTOREDATA *pSaveData); +#endif // FN_RestoreGlobalState + +#ifdef FN_ResetGlobalState +void FN_ResetGlobalState(void); +#endif // FN_ResetGlobalState + +#ifdef FN_ClientConnect +BOOL FN_ClientConnect(edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ]); +#endif // FN_ClientConnect + +#ifdef FN_ClientDisconnect +void FN_ClientDisconnect(edict_t *pEntity); +#endif // FN_ClientDisconnect + +#ifdef FN_ClientKill +void FN_ClientKill(edict_t *pEntity); +#endif // FN_ClientKill + +#ifdef FN_ClientPutInServer +void FN_ClientPutInServer(edict_t *pEntity); +#endif // FN_ClientPutInServer + +#ifdef FN_ClientCommand +void FN_ClientCommand(edict_t *pEntity); +#endif // FN_ClientCommand + +#ifdef FN_ClientUserInfoChanged +void FN_ClientUserInfoChanged(edict_t *pEntity, char *infobuffer); +#endif // FN_ClientUserInfoChanged + +#ifdef FN_ServerActivate +void FN_ServerActivate(edict_t *pEdictList, int edictCount, int clientMax); +#endif // FN_ServerActivate + +#ifdef FN_ServerDeactivate +void FN_ServerDeactivate(void); +#endif // FN_ServerDeactivate + +#ifdef FN_PlayerPreThink +void FN_PlayerPreThink(edict_t *pEntity); +#endif // FN_PlayerPreThink + +#ifdef FN_PlayerPostThink +void FN_PlayerPostThink(edict_t *pEntity); +#endif // FN_PlayerPostThink + +#ifdef FN_StartFrame +void FN_StartFrame(void); +#endif // FN_StartFrame + +#ifdef FN_ParmsNewLevel +void FN_ParmsNewLevel(void); +#endif // FN_ParmsNewLevel + +#ifdef FN_ParmsChangeLevel +void FN_ParmsChangeLevel(void); +#endif // FN_ParmsChangeLevel + +#ifdef FN_GetGameDescription +const char *FN_GetGameDescription(void); +#endif // FN_GetGameDescription + +#ifdef FN_PlayerCustomization +void FN_PlayerCustomization(edict_t *pEntity, customization_t *pCust); +#endif // FN_PlayerCustomization + +#ifdef FN_SpectatorConnect +void FN_SpectatorConnect(edict_t *pEntity); +#endif // FN_SpectatorConnect + +#ifdef FN_SpectatorDisconnect +void FN_SpectatorDisconnect(edict_t *pEntity); +#endif // FN_SpectatorDisconnect + +#ifdef FN_SpectatorThink +void FN_SpectatorThink(edict_t *pEntity); +#endif // FN_SpectatorThink + +#ifdef FN_Sys_Error +void FN_Sys_Error(const char *error_string); +#endif // FN_Sys_Error + +#ifdef FN_PM_Move +void FN_PM_Move(struct playermove_s *ppmove, int server); +#endif // FN_PM_Move + +#ifdef FN_PM_Init +void FN_PM_Init(struct playermove_s *ppmove); +#endif // FN_PM_Init + +#ifdef FN_PM_FindTextureType +char FN_PM_FindTextureType(char *name); +#endif // FN_PM_FindTextureType + +#ifdef FN_SetupVisibility +void FN_SetupVisibility(edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas); +#endif // FN_SetupVisibility + +#ifdef FN_UpdateClientData +void FN_UpdateClientData(const struct edict_s *ent, int sendweapons, struct clientdata_s *cd); +#endif // FN_UpdateClientData + +#ifdef FN_AddToFullPack +int FN_AddToFullPack(struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet); +#endif // FN_AddToFullPack + +#ifdef FN_CreateBaseline +void FN_CreateBaseline(int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs); +#endif // FN_CreateBaseline + +#ifdef FN_RegisterEncoders +void FN_RegisterEncoders(void); +#endif // FN_RegisterEncoders + +#ifdef FN_GetWeaponData +int FN_GetWeaponData(struct edict_s *player, struct weapon_data_s *info); +#endif // FN_GetWeaponData + +#ifdef FN_CmdStart +void FN_CmdStart(const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed); +#endif // FN_CmdStart + +#ifdef FN_CmdEnd +void FN_CmdEnd(const edict_t *player); +#endif // FN_CmdEnd + +#ifdef FN_ConnectionlessPacket +int FN_ConnectionlessPacket(const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size); +#endif // FN_ConnectionlessPacket + +#ifdef FN_GetHullBounds +int FN_GetHullBounds(int hullnumber, float *mins, float *maxs); +#endif // FN_GetHullBounds + +#ifdef FN_CreateInstancedBaselines +void FN_CreateInstancedBaselines(void); +#endif // FN_CreateInstancedBaselines + +#ifdef FN_InconsistentFile +int FN_InconsistentFile(const edict_t *player, const char *filename, char *disconnect_message); +#endif // FN_InconsistentFile + +#ifdef FN_AllowLagCompensation +int FN_AllowLagCompensation(void); +#endif // FN_AllowLagCompensation + + + + +#ifdef FN_GameDLLInit_Post +void FN_GameDLLInit_Post(void); +#endif // FN_GameDLLInit_Post + +#ifdef FN_DispatchSpawn_Post +int FN_DispatchSpawn_Post(edict_t *pent); +#endif // FN_DispatchSpawn_Post + +#ifdef FN_DispatchThink_Post +void FN_DispatchThink_Post(edict_t *pent); +#endif // FN_DispatchThink_Post + +#ifdef FN_DispatchUse_Post +void FN_DispatchUse_Post(edict_t *pentUser, edict_t *pentOther); +#endif // FN_DispatchUse_Post + +#ifdef FN_DispatchTouch_Post +void FN_DispatchTouch_Post(edict_t *pentTouched, edict_t *pentOther); +#endif // FN_DispatchTouch_Post + +#ifdef FN_DispatchBlocked_Post +void FN_DispatchBlocked_Post(edict_t *pentBlocked, edict_t *pentOther); +#endif // FN_DispatchBlocked_Post + +#ifdef FN_DispatchKeyValue_Post +void FN_DispatchKeyValue_Post(edict_t *pentKeyvalue, KeyValueData *pkvd); +#endif // FN_DispatchKeyValue_Post + +#ifdef FN_DispatchSave_Post +void FN_DispatchSave_Post(edict_t *pent, SAVERESTOREDATA *pSaveData); +#endif // FN_DispatchSave_Post + +#ifdef FN_DispatchRestore_Post +int FN_DispatchRestore_Post(edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity); +#endif // FN_DispatchRestore_Post + +#ifdef FN_DispatchObjectCollsionBox_Post +void FN_DispatchObjectCollsionBox_Post(edict_t *pent); +#endif // FN_DispatchObjectCollsionBox_Post + +#ifdef FN_SaveWriteFields_Post +void FN_SaveWriteFields_Post(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount); +#endif // FN_SaveWriteFields_Post + +#ifdef FN_SaveReadFields_Post +void FN_SaveReadFields_Post(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount); +#endif // FN_SaveReadFields_Post + +#ifdef FN_SaveGlobalState_Post +void FN_SaveGlobalState_Post(SAVERESTOREDATA *pSaveData); +#endif // FN_SaveGlobalState_Post + +#ifdef FN_RestoreGlobalState_Post +void FN_RestoreGlobalState_Post(SAVERESTOREDATA *pSaveData); +#endif // FN_RestoreGlobalState_Post + +#ifdef FN_ResetGlobalState_Post +void FN_ResetGlobalState_Post(void); +#endif // FN_ResetGlobalState_Post + +#ifdef FN_ClientConnect_Post +BOOL FN_ClientConnect_Post(edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ]); +#endif // FN_ClientConnect_Post + +#ifdef FN_ClientDisconnect_Post +void FN_ClientDisconnect_Post(edict_t *pEntity); +#endif // FN_ClientDisconnect_Post + +#ifdef FN_ClientKill_Post +void FN_ClientKill_Post(edict_t *pEntity); +#endif // FN_ClientKill_Post + +#ifdef FN_ClientPutInServer_Post +void FN_ClientPutInServer_Post(edict_t *pEntity); +#endif // FN_ClientPutInServer_Post + +#ifdef FN_ClientCommand_Post +void FN_ClientCommand_Post(edict_t *pEntity); +#endif // FN_ClientCommand_Post + +#ifdef FN_ClientUserInfoChanged_Post +void FN_ClientUserInfoChanged_Post(edict_t *pEntity, char *infobuffer); +#endif // FN_ClientUserInfoChanged_Post + +#ifdef FN_ServerActivate_Post +void FN_ServerActivate_Post(edict_t *pEdictList, int edictCount, int clientMax); +#endif // FN_ServerActivate_Post + +#ifdef FN_ServerDeactivate_Post +void FN_ServerDeactivate_Post(void); +#endif // FN_ServerDeactivate_Post + +#ifdef FN_PlayerPreThink_Post +void FN_PlayerPreThink_Post(edict_t *pEntity); +#endif // FN_PlayerPreThink_Post + +#ifdef FN_PlayerPostThink_Post +void FN_PlayerPostThink_Post(edict_t *pEntity); +#endif // FN_PlayerPostThink_Post + +#ifdef FN_StartFrame_Post +void FN_StartFrame_Post(void); +#endif // FN_StartFrame_Post + +#ifdef FN_ParmsNewLevel_Post +void FN_ParmsNewLevel_Post(void); +#endif // FN_ParmsNewLevel_Post + +#ifdef FN_ParmsChangeLevel_Post +void FN_ParmsChangeLevel_Post(void); +#endif // FN_ParmsChangeLevel_Post + +#ifdef FN_GetGameDescription_Post +const char *FN_GetGameDescription_Post(void); +#endif // FN_GetGameDescription_Post + +#ifdef FN_PlayerCustomization_Post +void FN_PlayerCustomization_Post(edict_t *pEntity, customization_t *pCust); +#endif // FN_PlayerCustomization_Post + +#ifdef FN_SpectatorConnect_Post +void FN_SpectatorConnect_Post(edict_t *pEntity); +#endif // FN_SpectatorConnect_Post + +#ifdef FN_SpectatorDisconnect_Post +void FN_SpectatorDisconnect_Post(edict_t *pEntity); +#endif // FN_SpectatorDisconnect_Post + +#ifdef FN_SpectatorThink_Post +void FN_SpectatorThink_Post(edict_t *pEntity); +#endif // FN_SpectatorThink_Post + +#ifdef FN_Sys_Error_Post +void FN_Sys_Error_Post(const char *error_string); +#endif // FN_Sys_Error_Post + +#ifdef FN_PM_Move_Post +void FN_PM_Move_Post(struct playermove_s *ppmove, int server); +#endif // FN_PM_Move_Post + +#ifdef FN_PM_Init_Post +void FN_PM_Init_Post(struct playermove_s *ppmove); +#endif // FN_PM_Init_Post + +#ifdef FN_PM_FindTextureType_Post +char FN_PM_FindTextureType_Post(char *name); +#endif // FN_PM_FindTextureType_Post + +#ifdef FN_SetupVisibility_Post +void FN_SetupVisibility_Post(edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas); +#endif // FN_SetupVisibility_Post + +#ifdef FN_UpdateClientData_Post +void FN_UpdateClientData_Post(const struct edict_s *ent, int sendweapons, struct clientdata_s *cd); +#endif // FN_UpdateClientData_Post + +#ifdef FN_AddToFullPack_Post +int FN_AddToFullPack_Post(struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet); +#endif // FN_AddToFullPack_Post + +#ifdef FN_CreateBaseline_Post +void FN_CreateBaseline_Post(int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs); +#endif // FN_CreateBaseline_Post + +#ifdef FN_RegisterEncoders_Post +void FN_RegisterEncoders_Post(void); +#endif // FN_RegisterEncoders_Post + +#ifdef FN_GetWeaponData_Post +int FN_GetWeaponData_Post(struct edict_s *player, struct weapon_data_s *info); +#endif // FN_GetWeaponData_Post + +#ifdef FN_CmdStart_Post +void FN_CmdStart_Post(const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed); +#endif // FN_CmdStart_Post + +#ifdef FN_CmdEnd_Post +void FN_CmdEnd_Post(const edict_t *player); +#endif // FN_CmdEnd_Post + +#ifdef FN_ConnectionlessPacket_Post +int FN_ConnectionlessPacket_Post(const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size); +#endif // FN_ConnectionlessPacket_Post + +#ifdef FN_GetHullBounds_Post +int FN_GetHullBounds_Post(int hullnumber, float *mins, float *maxs); +#endif // FN_GetHullBounds_Post + +#ifdef FN_CreateInstancedBaselines_Post +void FN_CreateInstancedBaselines_Post(void); +#endif // FN_CreateInstancedBaselines_Post + +#ifdef FN_InconsistentFile_Post +int FN_InconsistentFile_Post(const edict_t *player, const char *filename, char *disconnect_message); +#endif // FN_InconsistentFile_Post + +#ifdef FN_AllowLagCompensation_Post +int FN_AllowLagCompensation_Post(void); +#endif // FN_AllowLagCompensation_Post + + + +#ifdef FN_PrecacheModel +int FN_PrecacheModel(char *s); +#endif // FN_PrecacheModel + +#ifdef FN_PrecacheSound +int FN_PrecacheSound(char *s); +#endif // FN_PrecacheSound + +#ifdef FN_SetModel +void FN_SetModel(edict_t *e, const char *m); +#endif // FN_SetModel + +#ifdef FN_ModelIndex +int FN_ModelIndex(const char *m); +#endif // FN_ModelIndex + +#ifdef FN_ModelFrames +int FN_ModelFrames(int modelIndex); +#endif // FN_ModelFrames + +#ifdef FN_SetSize +void FN_SetSize(edict_t *e, const float *rgflMin, const float *rgflMax); +#endif // FN_SetSize + +#ifdef FN_ChangeLevel +void FN_ChangeLevel(char *s1, char *s2); +#endif // FN_ChangeLevel + +#ifdef FN_GetSpawnParms +void FN_GetSpawnParms(edict_t *ent); +#endif // FN_GetSpawnParms + +#ifdef FN_SaveSpawnParms +void FN_SaveSpawnParms(edict_t *ent); +#endif // FN_SaveSpawnParms + +#ifdef FN_VecToYaw +float FN_VecToYaw(const float *rgflVector); +#endif // FN_VecToYaw + +#ifdef FN_VecToAngles +void FN_VecToAngles(const float *rgflVectorIn, float *rgflVectorOut); +#endif // FN_VecToAngles + +#ifdef FN_MoveToOrigin +void FN_MoveToOrigin(edict_t *ent, const float *pflGoal, float dist, int iMoveType); +#endif // FN_MoveToOrigin + +#ifdef FN_ChangeYaw +void FN_ChangeYaw(edict_t *ent); +#endif // FN_ChangeYaw + +#ifdef FN_ChangePitch +void FN_ChangePitch(edict_t *ent); +#endif // FN_ChangePitch + +#ifdef FN_FindEntityByString +edict_t *FN_FindEntityByString(edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue); +#endif // FN_FindEntityByString + +#ifdef FN_GetEntityIllum +int FN_GetEntityIllum(edict_t *pEnt); +#endif // FN_GetEntityIllum + +#ifdef FN_FindEntityInSphere +edict_t *FN_FindEntityInSphere(edict_t *pEdictStartSearchAfter, const float *org, float rad); +#endif // FN_FindEntityInSphere + +#ifdef FN_FindClientInPVS +edict_t *FN_FindClientInPVS(edict_t *pEdict); +#endif // FN_FindClientInPVS + +#ifdef FN_EntitiesInPVS +edict_t *FN_EntitiesInPVS(edict_t *pplayer); +#endif // FN_EntitiesInPVS + +#ifdef FN_MakeVectors +void FN_MakeVectors(const float *rgflVector); +#endif // FN_MakeVectors + +#ifdef FN_AngleVectors +void FN_AngleVectors(const float *rgflVector, float *forward, float *right, float *up); +#endif // FN_AngleVectors + +#ifdef FN_CreateEntity +edict_t *FN_CreateEntity(void); +#endif // FN_CreateEntity + +#ifdef FN_RemoveEntity +void FN_RemoveEntity(edict_t *e); +#endif // FN_RemoveEntity + +#ifdef FN_CreateNamedEntity +edict_t *FN_CreateNamedEntity(int className); +#endif // FN_CreateNamedEntity + +#ifdef FN_MakeStatic +void FN_MakeStatic(edict_t *ent); +#endif // FN_MakeStatic + +#ifdef FN_EntIsOnFloor +int FN_EntIsOnFloor(edict_t *ent); +#endif // FN_EntIsOnFloor + +#ifdef FN_DropToFloor +int FN_DropToFloor(edict_t *ent); +#endif // FN_DropToFloor + +#ifdef FN_WalkMove +int FN_WalkMove(edict_t *ent, float yaw, float dist, int iMode); +#endif // FN_WalkMove + +#ifdef FN_SetOrigin +void FN_SetOrigin(edict_t *e, const float *rgflOrigin); +#endif // FN_SetOrigin + +#ifdef FN_EmitSound +void FN_EmitSound(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch); +#endif // FN_EmitSound + +#ifdef FN_EmitAmbientSound +void FN_EmitAmbientSound(edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch); +#endif // FN_EmitAmbientSound + +#ifdef FN_TraceLine +void FN_TraceLine(const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceLine + +#ifdef FN_TraceToss +void FN_TraceToss(edict_t *pent, edict_t *pentToIgnore, TraceResult *ptr); +#endif // FN_TraceToss + +#ifdef FN_TraceMonsterHull +int FN_TraceMonsterHull(edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceMonsterHull + +#ifdef FN_TraceHull +void FN_TraceHull(const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceHull + +#ifdef FN_TraceModel +void FN_TraceModel(const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr); +#endif // FN_TraceModel + +#ifdef FN_TraceTexture +const char *FN_TraceTexture(edict_t *pTextureEntity, const float *v1, const float *v2 ); +#endif // FN_TraceTexture + +#ifdef FN_TraceSphere +void FN_TraceSphere(const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceSphere + +#ifdef FN_GetAimVector +void FN_GetAimVector(edict_t *ent, float speed, float *rgflReturn); +#endif // FN_GetAimVector + +#ifdef FN_ServerCommand +void FN_ServerCommand(char *str); +#endif // FN_ServerCommand + +#ifdef FN_ServerExecute +void FN_ServerExecute(void); +#endif // FN_ServerExecute + +#ifdef FN_engClientCommand +void FN_engClientCommand(edict_t *pEdict, char *szFmt, ...); +#endif // FN_engClientCommand + +#ifdef FN_ParticleEffect +void FN_ParticleEffect(const float *org, const float *dir, float color, float count); +#endif // FN_ParticleEffect + +#ifdef FN_LightStyle +void FN_LightStyle(int style, char *val); +#endif // FN_LightStyle + +#ifdef FN_DecalIndex +int FN_DecalIndex(const char *name); +#endif // FN_DecalIndex + +#ifdef FN_PointContents +int FN_PointContents(const float *rgflVector); +#endif // FN_PointContents + +#ifdef FN_MessageBegin +void FN_MessageBegin(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed); +#endif // FN_MessageBegin + +#ifdef FN_MessageEnd +void FN_MessageEnd(void); +#endif // FN_MessageEnd + +#ifdef FN_WriteByte +void FN_WriteByte(int iValue); +#endif // FN_WriteByte + +#ifdef FN_WriteChar +void FN_WriteChar(int iValue); +#endif // FN_WriteChar + +#ifdef FN_WriteShort +void FN_WriteShort(int iValue); +#endif // FN_WriteShort + +#ifdef FN_WriteLong +void FN_WriteLong(int iValue); +#endif // FN_WriteLong + +#ifdef FN_WriteAngle +void FN_WriteAngle(float flValue); +#endif // FN_WriteAngle + +#ifdef FN_WriteCoord +void FN_WriteCoord(float flValue); +#endif // FN_WriteCoord + +#ifdef FN_WriteString +void FN_WriteString(const char *sz); +#endif // FN_WriteString + +#ifdef FN_WriteEntity +void FN_WriteEntity(int iValue); +#endif // FN_WriteEntity + +#ifdef FN_CVarRegister +void FN_CVarRegister(cvar_t *pCvar); +#endif // FN_CVarRegister + +#ifdef FN_CVarGetFloat +float FN_CVarGetFloat(const char *szVarName); +#endif // FN_CVarGetFloat + +#ifdef FN_CVarGetString +const char *FN_CVarGetString(const char *szVarName); +#endif // FN_CVarGetString + +#ifdef FN_CVarSetFloat +void FN_CVarSetFloat(const char *szVarName, float flValue); +#endif // FN_CVarSetFloat + +#ifdef FN_CVarSetString +void FN_CVarSetString(const char *szVarName, const char *szValue); +#endif // FN_CVarSetString + +#ifdef FN_AlertMessage +void FN_AlertMessage(ALERT_TYPE atype, char *szFmt, ...); +#endif // FN_AlertMessage + +#ifdef FN_EngineFprintf +void FN_EngineFprintf(FILE *pfile, char *szFmt, ...); +#endif // FN_EngineFprintf + +#ifdef FN_PvAllocEntPrivateData +void *FN_PvAllocEntPrivateData(edict_t *pEdict, int32 cb); +#endif // FN_PvAllocEntPrivateData + +#ifdef FN_PvEntPrivateData +void *FN_PvEntPrivateData(edict_t *pEdict); +#endif // FN_PvEntPrivateData + +#ifdef FN_FreeEntPrivateData +void FN_FreeEntPrivateData(edict_t *pEdict); +#endif // FN_FreeEntPrivateData + +#ifdef FN_SzFromIndex +const char *FN_SzFromIndex(int iString); +#endif // FN_SzFromIndex + +#ifdef FN_AllocString +int FN_AllocString(const char *szValue); +#endif // FN_AllocString + +#ifdef FN_GetVarsOfEnt +struct entvars_s *FN_GetVarsOfEnt(edict_t *pEdict); +#endif // FN_GetVarsOfEnt + +#ifdef FN_PEntityOfEntOffset +edict_t *FN_PEntityOfEntOffset(int iEntOffset); +#endif // FN_PEntityOfEntOffset + +#ifdef FN_EntOffsetOfPEntity +int FN_EntOffsetOfPEntity(const edict_t *pEdict); +#endif // FN_EntOffsetOfPEntity + +#ifdef FN_IndexOfEdict +int FN_IndexOfEdict(const edict_t *pEdict); +#endif // FN_IndexOfEdict + +#ifdef FN_PEntityOfEntIndex +edict_t *FN_PEntityOfEntIndex(int iEntIndex); +#endif // FN_PEntityOfEntIndex + +#ifdef FN_FindEntityByVars +edict_t *FN_FindEntityByVars(struct entvars_s *pvars); +#endif // FN_FindEntityByVars + +#ifdef FN_GetModelPtr +void *FN_GetModelPtr(edict_t *pEdict); +#endif // FN_GetModelPtr + +#ifdef FN_RegUserMsg +int FN_RegUserMsg(const char *pszName, int iSize); +#endif // FN_RegUserMsg + +#ifdef FN_AnimationAutomove +void FN_AnimationAutomove(const edict_t *pEdict, float flTime); +#endif // FN_AnimationAutomove + +#ifdef FN_GetBonePosition +void FN_GetBonePosition(const edict_t *pEdict, int iBone, float *rgflOrigin, float *rgflAngles); +#endif // FN_GetBonePosition + +#ifdef FN_FunctionFromName +unsigned long FN_FunctionFromName(const char *pName); +#endif // FN_FunctionFromName + +#ifdef FN_NameForFunction +const char *FN_NameForFunction(unsigned long function); +#endif // FN_NameForFunction + +#ifdef FN_ClientPrintf +void FN_ClientPrintf(edict_t *pEdict, PRINT_TYPE ptype, const char *szMsg); +#endif // FN_ClientPrintf + +#ifdef FN_ServerPrint +void FN_ServerPrint(const char *szMsg); +#endif // FN_ServerPrint + +#ifdef FN_Cmd_Args +const char *FN_Cmd_Args(void); +#endif // FN_Cmd_Args + +#ifdef FN_Cmd_Argv +const char *FN_Cmd_Argv(int argc); +#endif // FN_Cmd_Argv + +#ifdef FN_Cmd_Argc +int FN_Cmd_Argc(void); +#endif // FN_Cmd_Argc + +#ifdef FN_GetAttachment +void FN_GetAttachment(const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles ); +#endif // FN_GetAttachment + +#ifdef FN_CRC32_Init +void FN_CRC32_Init(CRC32_t *pulCRC); +#endif // FN_CRC32_Init + +#ifdef FN_CRC32_ProcessBuffer +void FN_CRC32_ProcessBuffer(CRC32_t *pulCRC, void *p, int len); +#endif // FN_CRC32_ProcessBuffer + +#ifdef FN_CRC32_ProcessByte +void FN_CRC32_ProcessByte(CRC32_t *pulCRC, unsigned char ch); +#endif // FN_CRC32_ProcessByte + +#ifdef FN_CRC32_Final +CRC32_t FN_CRC32_Final(CRC32_t pulCRC); +#endif // FN_CRC32_Final + +#ifdef FN_RandomLong +long FN_RandomLong(long lLow, long lHigh); +#endif // FN_RandomLong + +#ifdef FN_RandomFloat +float FN_RandomFloat(float flLow, float flHigh); +#endif // FN_RandomFloat + +#ifdef FN_SetView +void FN_SetView(const edict_t *pClient, const edict_t *pViewent); +#endif // FN_SetView + +#ifdef FN_Time +float FN_Time(void); +#endif // FN_Time + +#ifdef FN_CrosshairAngle +void FN_CrosshairAngle(const edict_t *pClient, float pitch, float yaw); +#endif // FN_CrosshairAngle + +#ifdef FN_LoadFileForMe +byte *FN_LoadFileForMe(char *filename, int *pLength); +#endif // FN_LoadFileForMe + +#ifdef FN_FreeFile +void FN_FreeFile(void *buffer); +#endif // FN_FreeFile + +#ifdef FN_EndSection +void FN_EndSection(const char *pszSectionName); +#endif // FN_EndSection + +#ifdef FN_CompareFileTime +int FN_CompareFileTime(char *filename1, char *filename2, int *iCompare); +#endif // FN_CompareFileTime + +#ifdef FN_GetGameDir +void FN_GetGameDir(char *szGetGameDir); +#endif // FN_GetGameDir + +#ifdef FN_Cvar_RegisterVariable +void FN_Cvar_RegisterVariable(cvar_t *variable); +#endif // FN_Cvar_RegisterVariable + +#ifdef FN_FadeClientVolume +void FN_FadeClientVolume(const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds); +#endif // FN_FadeClientVolume + +#ifdef FN_SetClientMaxspeed +void FN_SetClientMaxspeed(const edict_t *pEdict, float fNewMaxspeed); +#endif // FN_SetClientMaxspeed + +#ifdef FN_CreateFakeClient +edict_t *FN_CreateFakeClient(const char *netname); +#endif // FN_CreateFakeClient + +#ifdef FN_RunPlayerMove +void FN_RunPlayerMove(edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec); +#endif // FN_RunPlayerMove + +#ifdef FN_NumberOfEntities +int FN_NumberOfEntities(void); +#endif // FN_NumberOfEntities + +#ifdef FN_GetInfoKeyBuffer +char *FN_GetInfoKeyBuffer(edict_t *e); +#endif // FN_GetInfoKeyBuffer + +#ifdef FN_InfoKeyValue +char *FN_InfoKeyValue(char *infobuffer, char *key); +#endif // FN_InfoKeyValue + +#ifdef FN_SetKeyValue +void FN_SetKeyValue(char *infobuffer, char *key, char *value); +#endif // FN_SetKeyValue + +#ifdef FN_SetClientKeyValue +void FN_SetClientKeyValue(int clientIndex, char *infobuffer, char *key, char *value); +#endif // FN_SetClientKeyValue + +#ifdef FN_IsMapValid +int FN_IsMapValid(char *filename); +#endif // FN_IsMapValid + +#ifdef FN_StaticDecal +void FN_StaticDecal(const float *origin, int decalIndex, int entityIndex, int modelIndex); +#endif // FN_StaticDecal + +#ifdef FN_PrecacheGeneric +int FN_PrecacheGeneric(char *s); +#endif // FN_PrecacheGeneric + +#ifdef FN_GetPlayerUserId +int FN_GetPlayerUserId(edict_t *e ); +#endif // FN_GetPlayerUserId + +#ifdef FN_BuildSoundMsg +void FN_BuildSoundMsg(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch, int msg_dest, int msg_type, const float *pOrigin, edict_t *ed); +#endif // FN_BuildSoundMsg + +#ifdef FN_IsDedicatedServer +int FN_IsDedicatedServer(void); +#endif // FN_IsDedicatedServer + +#ifdef FN_CVarGetPointer +cvar_t *FN_CVarGetPointer(const char *szVarName); +#endif // FN_CVarGetPointer + +#ifdef FN_GetPlayerWONId +unsigned int FN_GetPlayerWONId(edict_t *e); +#endif // FN_GetPlayerWONId + +#ifdef FN_Info_RemoveKey +void FN_Info_RemoveKey( char *s, const char *key); +#endif // FN_Info_RemoveKey + +#ifdef FN_GetPhysicsKeyValue +const char *FN_GetPhysicsKeyValue(const edict_t *pClient, const char *key); +#endif // FN_GetPhysicsKeyValue + +#ifdef FN_SetPhysicsKeyValue +void FN_SetPhysicsKeyValue(const edict_t *pClient, const char *key, const char *value); +#endif // FN_SetPhysicsKeyValue + +#ifdef FN_GetPhysicsInfoString +const char *FN_GetPhysicsInfoString( const edict_t *pClient); +#endif // FN_GetPhysicsInfoString + +#ifdef FN_PrecacheEvent +unsigned short FN_PrecacheEvent(int type, const char *psz); +#endif // FN_PrecacheEvent + +#ifdef FN_PlaybackEvent +void FN_PlaybackEvent(int flags, const edict_t *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2); +#endif // FN_PlaybackEvent + +#ifdef FN_SetFatPVS +unsigned char *FN_SetFatPVS(float *org); +#endif // FN_SetFatPVS + +#ifdef FN_SetFatPAS +unsigned char *FN_SetFatPAS(float *org); +#endif // FN_SetFatPAS + +#ifdef FN_CheckVisibility +int FN_CheckVisibility(const edict_t *entity, unsigned char *pset); +#endif // FN_CheckVisibility + +#ifdef FN_DeltaSetField +void FN_DeltaSetField(struct delta_s *pFields, const char *fieldname); +#endif // FN_DeltaSetField + +#ifdef FN_DeltaUnsetField +void FN_DeltaUnsetField(struct delta_s *pFields, const char *fieldname); +#endif // FN_DeltaUnsetField + +#ifdef FN_DeltaAddEncoder +void FN_DeltaAddEncoder(char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) ); +#endif // FN_DeltaAddEncoder + +#ifdef FN_GetCurrentPlayer +int FN_GetCurrentPlayer(void); +#endif // FN_GetCurrentPlayer + +#ifdef FN_CanSkipPlayer +int FN_CanSkipPlayer(const edict_t *player); +#endif // FN_CanSkipPlayer + +#ifdef FN_DeltaFindField +int FN_DeltaFindField(struct delta_s *pFields, const char *fieldname); +#endif // FN_DeltaFindField + +#ifdef FN_DeltaSetFieldByIndex +void FN_DeltaSetFieldByIndex(struct delta_s *pFields, int fieldNumber); +#endif // FN_DeltaSetFieldByIndex + +#ifdef FN_DeltaUnsetFieldByIndex +void FN_DeltaUnsetFieldByIndex(struct delta_s *pFields, int fieldNumber); +#endif // FN_DeltaUnsetFieldByIndex + +#ifdef FN_SetGroupMask +void FN_SetGroupMask(int mask, int op); +#endif // FN_SetGroupMask + +#ifdef FN_engCreateInstancedBaseline +int FN_engCreateInstancedBaseline(int classname, struct entity_state_s *baseline); +#endif // FN_engCreateInstancedBaseline + +#ifdef FN_Cvar_DirectSet +void FN_Cvar_DirectSet(struct cvar_s *var, char *value); +#endif // FN_Cvar_DirectSet + +#ifdef FN_ForceUnmodified +void FN_ForceUnmodified(FORCE_TYPE type, float *mins, float *maxs, const char *filename); +#endif // FN_ForceUnmodified + +#ifdef FN_GetPlayerStats +void FN_GetPlayerStats(const edict_t *pClient, int *ping, int *packet_loss); +#endif // FN_GetPlayerStats + +#ifdef FN_AddServerCommand +void FN_AddServerCommand(char *cmd_name, void (*function) (void)); +#endif // FN_AddServerCommand + +#ifdef FN_Voice_GetClientListening +qboolean FN_Voice_GetClientListening(int iReceiver, int iSender); +#endif // FN_Voice_GetClientListening + +#ifdef FN_Voice_SetClientListening +qboolean FN_Voice_SetClientListening(int iReceiver, int iSender, qboolean bListen); +#endif // FN_Voice_SetClientListening + +#ifdef FN_GetPlayerAuthId +const char *FN_GetPlayerAuthId(edict_t *e); +#endif // FN_GetPlayerAuthId + + + + + + +#ifdef FN_PrecacheModel_Post +int FN_PrecacheModel_Post(char *s); +#endif // FN_PrecacheModel_Post + +#ifdef FN_PrecacheSound_Post +int FN_PrecacheSound_Post(char *s); +#endif // FN_PrecacheSound_Post + +#ifdef FN_SetModel_Post +void FN_SetModel_Post(edict_t *e, const char *m); +#endif // FN_SetModel_Post + +#ifdef FN_ModelIndex_Post +int FN_ModelIndex_Post(const char *m); +#endif // FN_ModelIndex_Post + +#ifdef FN_ModelFrames_Post +int FN_ModelFrames_Post(int modelIndex); +#endif // FN_ModelFrames_Post + +#ifdef FN_SetSize_Post +void FN_SetSize_Post(edict_t *e, const float *rgflMin, const float *rgflMax); +#endif // FN_SetSize_Post + +#ifdef FN_ChangeLevel_Post +void FN_ChangeLevel_Post(char *s1, char *s2); +#endif // FN_ChangeLevel_Post + +#ifdef FN_GetSpawnParms_Post +void FN_GetSpawnParms_Post(edict_t *ent); +#endif // FN_GetSpawnParms_Post + +#ifdef FN_SaveSpawnParms_Post +void FN_SaveSpawnParms_Post(edict_t *ent); +#endif // FN_SaveSpawnParms_Post + +#ifdef FN_VecToYaw_Post +float FN_VecToYaw_Post(const float *rgflVector); +#endif // FN_VecToYaw_Post + +#ifdef FN_VecToAngles_Post +void FN_VecToAngles_Post(const float *rgflVectorIn, float *rgflVectorOut); +#endif // FN_VecToAngles_Post + +#ifdef FN_MoveToOrigin_Post +void FN_MoveToOrigin_Post(edict_t *ent, const float *pflGoal, float dist, int iMoveType); +#endif // FN_MoveToOrigin_Post + +#ifdef FN_ChangeYaw_Post +void FN_ChangeYaw_Post(edict_t *ent); +#endif // FN_ChangeYaw_Post + +#ifdef FN_ChangePitch_Post +void FN_ChangePitch_Post(edict_t *ent); +#endif // FN_ChangePitch_Post + +#ifdef FN_FindEntityByString_Post +edict_t *FN_FindEntityByString_Post(edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue); +#endif // FN_FindEntityByString_Post + +#ifdef FN_GetEntityIllum_Post +int FN_GetEntityIllum_Post(edict_t *pEnt); +#endif // FN_GetEntityIllum_Post + +#ifdef FN_FindEntityInSphere_Post +edict_t *FN_FindEntityInSphere_Post(edict_t *pEdictStartSearchAfter, const float *org, float rad); +#endif // FN_FindEntityInSphere_Post + +#ifdef FN_FindClientInPVS_Post +edict_t *FN_FindClientInPVS_Post(edict_t *pEdict); +#endif // FN_FindClientInPVS_Post + +#ifdef FN_EntitiesInPVS_Post +edict_t *FN_EntitiesInPVS_Post(edict_t *pplayer); +#endif // FN_EntitiesInPVS_Post + +#ifdef FN_MakeVectors_Post +void FN_MakeVectors_Post(const float *rgflVector); +#endif // FN_MakeVectors_Post + +#ifdef FN_AngleVectors_Post +void FN_AngleVectors_Post(const float *rgflVector, float *forward, float *right, float *up); +#endif // FN_AngleVectors_Post + +#ifdef FN_CreateEntity_Post +edict_t *FN_CreateEntity_Post(void); +#endif // FN_CreateEntity_Post + +#ifdef FN_RemoveEntity_Post +void FN_RemoveEntity_Post(edict_t *e); +#endif // FN_RemoveEntity_Post + +#ifdef FN_CreateNamedEntity_Post +edict_t *FN_CreateNamedEntity_Post(int className); +#endif // FN_CreateNamedEntity_Post + +#ifdef FN_MakeStatic_Post +void FN_MakeStatic_Post(edict_t *ent); +#endif // FN_MakeStatic_Post + +#ifdef FN_EntIsOnFloor_Post +int FN_EntIsOnFloor_Post(edict_t *ent); +#endif // FN_EntIsOnFloor_Post + +#ifdef FN_DropToFloor_Post +int FN_DropToFloor_Post(edict_t *ent); +#endif // FN_DropToFloor_Post + +#ifdef FN_WalkMove_Post +int FN_WalkMove_Post(edict_t *ent, float yaw, float dist, int iMode); +#endif // FN_WalkMove_Post + +#ifdef FN_SetOrigin_Post +void FN_SetOrigin_Post(edict_t *e, const float *rgflOrigin); +#endif // FN_SetOrigin_Post + +#ifdef FN_EmitSound_Post +void FN_EmitSound_Post(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch); +#endif // FN_EmitSound_Post + +#ifdef FN_EmitAmbientSound_Post +void FN_EmitAmbientSound_Post(edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch); +#endif // FN_EmitAmbientSound_Post + +#ifdef FN_TraceLine_Post +void FN_TraceLine_Post(const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceLine_Post + +#ifdef FN_TraceToss_Post +void FN_TraceToss_Post(edict_t *pent, edict_t *pentToIgnore, TraceResult *ptr); +#endif // FN_TraceToss_Post + +#ifdef FN_TraceMonsterHull_Post +int FN_TraceMonsterHull_Post(edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceMonsterHull_Post + +#ifdef FN_TraceHull_Post +void FN_TraceHull_Post(const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceHull_Post + +#ifdef FN_TraceModel_Post +void FN_TraceModel_Post(const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr); +#endif // FN_TraceModel_Post + +#ifdef FN_TraceTexture_Post +const char *FN_TraceTexture_Post(edict_t *pTextureEntity, const float *v1, const float *v2 ); +#endif // FN_TraceTexture_Post + +#ifdef FN_TraceSphere_Post +void FN_TraceSphere_Post(const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceSphere_Post + +#ifdef FN_GetAimVector_Post +void FN_GetAimVector_Post(edict_t *ent, float speed, float *rgflReturn); +#endif // FN_GetAimVector_Post + +#ifdef FN_ServerCommand_Post +void FN_ServerCommand_Post(char *str); +#endif // FN_ServerCommand_Post + +#ifdef FN_ServerExecute_Post +void FN_ServerExecute_Post(void); +#endif // FN_ServerExecute_Post + +#ifdef FN_engClientCommand_Post +void FN_engClientCommand_Post(edict_t *pEdict, char *szFmt, ...); +#endif // FN_engClientCommand_Post + +#ifdef FN_ParticleEffect_Post +void FN_ParticleEffect_Post(const float *org, const float *dir, float color, float count); +#endif // FN_ParticleEffect_Post + +#ifdef FN_LightStyle_Post +void FN_LightStyle_Post(int style, char *val); +#endif // FN_LightStyle_Post + +#ifdef FN_DecalIndex_Post +int FN_DecalIndex_Post(const char *name); +#endif // FN_DecalIndex_Post + +#ifdef FN_PointContents_Post +int FN_PointContents_Post(const float *rgflVector); +#endif // FN_PointContents_Post + +#ifdef FN_MessageBegin_Post +void FN_MessageBegin_Post(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed); +#endif // FN_MessageBegin_Post + +#ifdef FN_MessageEnd_Post +void FN_MessageEnd_Post(void); +#endif // FN_MessageEnd_Post + +#ifdef FN_WriteByte_Post +void FN_WriteByte_Post(int iValue); +#endif // FN_WriteByte_Post + +#ifdef FN_WriteChar_Post +void FN_WriteChar_Post(int iValue); +#endif // FN_WriteChar_Post + +#ifdef FN_WriteShort_Post +void FN_WriteShort_Post(int iValue); +#endif // FN_WriteShort_Post + +#ifdef FN_WriteLong_Post +void FN_WriteLong_Post(int iValue); +#endif // FN_WriteLong_Post + +#ifdef FN_WriteAngle_Post +void FN_WriteAngle_Post(float flValue); +#endif // FN_WriteAngle_Post + +#ifdef FN_WriteCoord_Post +void FN_WriteCoord_Post(float flValue); +#endif // FN_WriteCoord_Post + +#ifdef FN_WriteString_Post +void FN_WriteString_Post(const char *sz); +#endif // FN_WriteString_Post + +#ifdef FN_WriteEntity_Post +void FN_WriteEntity_Post(int iValue); +#endif // FN_WriteEntity_Post + +#ifdef FN_CVarRegister_Post +void FN_CVarRegister_Post(cvar_t *pCvar); +#endif // FN_CVarRegister_Post + +#ifdef FN_CVarGetFloat_Post +float FN_CVarGetFloat_Post(const char *szVarName); +#endif // FN_CVarGetFloat_Post + +#ifdef FN_CVarGetString_Post +const char *FN_CVarGetString_Post(const char *szVarName); +#endif // FN_CVarGetString_Post + +#ifdef FN_CVarSetFloat_Post +void FN_CVarSetFloat_Post(const char *szVarName, float flValue); +#endif // FN_CVarSetFloat_Post + +#ifdef FN_CVarSetString_Post +void FN_CVarSetString_Post(const char *szVarName, const char *szValue); +#endif // FN_CVarSetString_Post + +#ifdef FN_AlertMessage_Post +void FN_AlertMessage_Post(ALERT_TYPE atype, char *szFmt, ...); +#endif // FN_AlertMessage_Post + +#ifdef FN_EngineFprintf_Post +void FN_EngineFprintf_Post(FILE *pfile, char *szFmt, ...); +#endif // FN_EngineFprintf_Post + +#ifdef FN_PvAllocEntPrivateData_Post +void *FN_PvAllocEntPrivateData_Post(edict_t *pEdict, long cb); +#endif // FN_PvAllocEntPrivateData_Post + +#ifdef FN_PvEntPrivateData_Post +void *FN_PvEntPrivateData_Post(edict_t *pEdict); +#endif // FN_PvEntPrivateData_Post + +#ifdef FN_FreeEntPrivateData_Post +void FN_FreeEntPrivateData_Post(edict_t *pEdict); +#endif // FN_FreeEntPrivateData_Post + +#ifdef FN_SzFromIndex_Post +const char *FN_SzFromIndex_Post(int iString); +#endif // FN_SzFromIndex_Post + +#ifdef FN_AllocString_Post +int FN_AllocString_Post(const char *szValue); +#endif // FN_AllocString_Post + +#ifdef FN_GetVarsOfEnt_Post +struct entvars_s *FN_GetVarsOfEnt_Post(edict_t *pEdict); +#endif // FN_GetVarsOfEnt_Post + +#ifdef FN_PEntityOfEntOffset_Post +edict_t *FN_PEntityOfEntOffset_Post(int iEntOffset); +#endif // FN_PEntityOfEntOffset_Post + +#ifdef FN_EntOffsetOfPEntity_Post +int FN_EntOffsetOfPEntity_Post(const edict_t *pEdict); +#endif // FN_EntOffsetOfPEntity_Post + +#ifdef FN_IndexOfEdict_Post +int FN_IndexOfEdict_Post(const edict_t *pEdict); +#endif // FN_IndexOfEdict_Post + +#ifdef FN_PEntityOfEntIndex_Post +edict_t *FN_PEntityOfEntIndex_Post(int iEntIndex); +#endif // FN_PEntityOfEntIndex_Post + +#ifdef FN_FindEntityByVars_Post +edict_t *FN_FindEntityByVars_Post(struct entvars_s *pvars); +#endif // FN_FindEntityByVars_Post + +#ifdef FN_GetModelPtr_Post +void *FN_GetModelPtr_Post(edict_t *pEdict); +#endif // FN_GetModelPtr_Post + +#ifdef FN_RegUserMsg_Post +int FN_RegUserMsg_Post(const char *pszName, int iSize); +#endif // FN_RegUserMsg_Post + +#ifdef FN_AnimationAutomove_Post +void FN_AnimationAutomove_Post(const edict_t *pEdict, float flTime); +#endif // FN_AnimationAutomove_Post + +#ifdef FN_GetBonePosition_Post +void FN_GetBonePosition_Post(const edict_t *pEdict, int iBone, float *rgflOrigin, float *rgflAngles); +#endif // FN_GetBonePosition_Post + +#ifdef FN_FunctionFromName_Post +unsigned long FN_FunctionFromName_Post(const char *pName); +#endif // FN_FunctionFromName_Post + +#ifdef FN_NameForFunction_Post +const char *FN_NameForFunction_Post(unsigned long function); +#endif // FN_NameForFunction_Post + +#ifdef FN_ClientPrintf_Post +void FN_ClientPrintf_Post(edict_t *pEdict, PRINT_TYPE ptype, const char *szMsg); +#endif // FN_ClientPrintf_Post + +#ifdef FN_ServerPrint_Post +void FN_ServerPrint_Post(const char *szMsg); +#endif // FN_ServerPrint_Post + +#ifdef FN_Cmd_Args_Post +const char *FN_Cmd_Args_Post(void); +#endif // FN_Cmd_Args_Post + +#ifdef FN_Cmd_Argv_Post +const char *FN_Cmd_Argv_Post(int argc); +#endif // FN_Cmd_Argv_Post + +#ifdef FN_Cmd_Argc_Post +int FN_Cmd_Argc_Post(void); +#endif // FN_Cmd_Argc_Post + +#ifdef FN_GetAttachment_Post +void FN_GetAttachment_Post(const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles ); +#endif // FN_GetAttachment_Post + +#ifdef FN_CRC32_Init_Post +void FN_CRC32_Init_Post(CRC32_t *pulCRC); +#endif // FN_CRC32_Init_Post + +#ifdef FN_CRC32_ProcessBuffer_Post +void FN_CRC32_ProcessBuffer_Post(CRC32_t *pulCRC, void *p, int len); +#endif // FN_CRC32_ProcessBuffer_Post + +#ifdef FN_CRC32_ProcessByte_Post +void FN_CRC32_ProcessByte_Post(CRC32_t *pulCRC, unsigned char ch); +#endif // FN_CRC32_ProcessByte_Post + +#ifdef FN_CRC32_Final_Post +CRC32_t FN_CRC32_Final_Post(CRC32_t pulCRC); +#endif // FN_CRC32_Final_Post + +#ifdef FN_RandomLong_Post +long FN_RandomLong_Post(long lLow, long lHigh); +#endif // FN_RandomLong_Post + +#ifdef FN_RandomFloat_Post +float FN_RandomFloat_Post(float flLow, float flHigh); +#endif // FN_RandomFloat_Post + +#ifdef FN_SetView_Post +void FN_SetView_Post(const edict_t *pClient, const edict_t *pViewent); +#endif // FN_SetView_Post + +#ifdef FN_Time_Post +float FN_Time_Post(void); +#endif // FN_Time_Post + +#ifdef FN_CrosshairAngle_Post +void FN_CrosshairAngle_Post(const edict_t *pClient, float pitch, float yaw); +#endif // FN_CrosshairAngle_Post + +#ifdef FN_LoadFileForMe_Post +byte *FN_LoadFileForMe_Post(char *filename, int *pLength); +#endif // FN_LoadFileForMe_Post + +#ifdef FN_FreeFile_Post +void FN_FreeFile_Post(void *buffer); +#endif // FN_FreeFile_Post + +#ifdef FN_EndSection_Post +void FN_EndSection_Post(const char *pszSectionName); +#endif // FN_EndSection_Post + +#ifdef FN_CompareFileTime_Post +int FN_CompareFileTime_Post(char *filename1, char *filename2, int *iCompare); +#endif // FN_CompareFileTime_Post + +#ifdef FN_GetGameDir_Post +void FN_GetGameDir_Post(char *szGetGameDir); +#endif // FN_GetGameDir_Post + +#ifdef FN_Cvar_RegisterVariable_Post +void FN_Cvar_RegisterVariable_Post(cvar_t *variable); +#endif // FN_Cvar_RegisterVariable_Post + +#ifdef FN_FadeClientVolume_Post +void FN_FadeClientVolume_Post(const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds); +#endif // FN_FadeClientVolume_Post + +#ifdef FN_SetClientMaxspeed_Post +void FN_SetClientMaxspeed_Post(const edict_t *pEdict, float fNewMaxspeed); +#endif // FN_SetClientMaxspeed_Post + +#ifdef FN_CreateFakeClient_Post +edict_t *FN_CreateFakeClient_Post(const char *netname); +#endif // FN_CreateFakeClient_Post + +#ifdef FN_RunPlayerMove_Post +void FN_RunPlayerMove_Post(edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec); +#endif // FN_RunPlayerMove_Post + +#ifdef FN_NumberOfEntities_Post +int FN_NumberOfEntities_Post(void); +#endif // FN_NumberOfEntities_Post + +#ifdef FN_GetInfoKeyBuffer_Post +char *FN_GetInfoKeyBuffer_Post(edict_t *e); +#endif // FN_GetInfoKeyBuffer_Post + +#ifdef FN_InfoKeyValue_Post +char *FN_InfoKeyValue_Post(char *infobuffer, char *key); +#endif // FN_InfoKeyValue_Post + +#ifdef FN_SetKeyValue_Post +void FN_SetKeyValue_Post(char *infobuffer, char *key, char *value); +#endif // FN_SetKeyValue_Post + +#ifdef FN_SetClientKeyValue_Post +void FN_SetClientKeyValue_Post(int clientIndex, char *infobuffer, char *key, char *value); +#endif // FN_SetClientKeyValue_Post + +#ifdef FN_IsMapValid_Post +int FN_IsMapValid_Post(char *filename); +#endif // FN_IsMapValid_Post + +#ifdef FN_StaticDecal_Post +void FN_StaticDecal_Post(const float *origin, int decalIndex, int entityIndex, int modelIndex); +#endif // FN_StaticDecal_Post + +#ifdef FN_PrecacheGeneric_Post +int FN_PrecacheGeneric_Post(char *s); +#endif // FN_PrecacheGeneric_Post + +#ifdef FN_GetPlayerUserId_Post +int FN_GetPlayerUserId_Post(edict_t *e ); +#endif // FN_GetPlayerUserId_Post + +#ifdef FN_BuildSoundMsg_Post +void FN_BuildSoundMsg_Post(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch, int msg_dest, int msg_type, const float *pOrigin, edict_t *ed); +#endif // FN_BuildSoundMsg_Post + +#ifdef FN_IsDedicatedServer_Post +int FN_IsDedicatedServer_Post(void); +#endif // FN_IsDedicatedServer_Post + +#ifdef FN_CVarGetPointer_Post +cvar_t *FN_CVarGetPointer_Post(const char *szVarName); +#endif // FN_CVarGetPointer_Post + +#ifdef FN_GetPlayerWONId_Post +unsigned int FN_GetPlayerWONId_Post(edict_t *e); +#endif // FN_GetPlayerWONId_Post + +#ifdef FN_Info_RemoveKey_Post +void FN_Info_RemoveKey_Post( char *s, const char *key); +#endif // FN_Info_RemoveKey_Post + +#ifdef FN_GetPhysicsKeyValue_Post +const char *FN_GetPhysicsKeyValue_Post(const edict_t *pClient, const char *key); +#endif // FN_GetPhysicsKeyValue_Post + +#ifdef FN_SetPhysicsKeyValue_Post +void FN_SetPhysicsKeyValue_Post(const edict_t *pClient, const char *key, const char *value); +#endif // FN_SetPhysicsKeyValue_Post + +#ifdef FN_GetPhysicsInfoString_Post +const char *FN_GetPhysicsInfoString_Post( const edict_t *pClient); +#endif // FN_GetPhysicsInfoString_Post + +#ifdef FN_PrecacheEvent_Post +unsigned short FN_PrecacheEvent_Post(int type, const char *psz); +#endif // FN_PrecacheEvent_Post + +#ifdef FN_PlaybackEvent_Post +void FN_PlaybackEvent_Post(int flags, const edict_t *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2); +#endif // FN_PlaybackEvent_Post + +#ifdef FN_SetFatPVS_Post +unsigned char *FN_SetFatPVS_Post(float *org); +#endif // FN_SetFatPVS_Post + +#ifdef FN_SetFatPAS_Post +unsigned char *FN_SetFatPAS_Post(float *org); +#endif // FN_SetFatPAS_Post + +#ifdef FN_CheckVisibility_Post +int FN_CheckVisibility_Post(const edict_t *entity, unsigned char *pset); +#endif // FN_CheckVisibility_Post + +#ifdef FN_DeltaSetField_Post +void FN_DeltaSetField_Post(struct delta_s *pFields, const char *fieldname); +#endif // FN_DeltaSetField_Post + +#ifdef FN_DeltaUnsetField_Post +void FN_DeltaUnsetField_Post(struct delta_s *pFields, const char *fieldname); +#endif // FN_DeltaUnsetField_Post + +#ifdef FN_DeltaAddEncoder_Post +void FN_DeltaAddEncoder_Post(char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) ); +#endif // FN_DeltaAddEncoder_Post + +#ifdef FN_GetCurrentPlayer_Post +int FN_GetCurrentPlayer_Post(void); +#endif // FN_GetCurrentPlayer_Post + +#ifdef FN_CanSkipPlayer_Post +int FN_CanSkipPlayer_Post(const edict_t *player); +#endif // FN_CanSkipPlayer_Post + +#ifdef FN_DeltaFindField_Post +int FN_DeltaFindField_Post(struct delta_s *pFields, const char *fieldname); +#endif // FN_DeltaFindField_Post + +#ifdef FN_DeltaSetFieldByIndex_Post +void FN_DeltaSetFieldByIndex_Post(struct delta_s *pFields, int fieldNumber); +#endif // FN_DeltaSetFieldByIndex_Post + +#ifdef FN_DeltaUnsetFieldByIndex_Post +void FN_DeltaUnsetFieldByIndex_Post(struct delta_s *pFields, int fieldNumber); +#endif // FN_DeltaUnsetFieldByIndex_Post + +#ifdef FN_SetGroupMask_Post +void FN_SetGroupMask_Post(int mask, int op); +#endif // FN_SetGroupMask_Post + +#ifdef FN_engCreateInstancedBaseline_Post +int FN_engCreateInstancedBaseline_Post(int classname, struct entity_state_s *baseline); +#endif // FN_engCreateInstancedBaseline_Post + +#ifdef FN_Cvar_DirectSet_Post +void FN_Cvar_DirectSet_Post(struct cvar_s *var, char *value); +#endif // FN_Cvar_DirectSet_Post + +#ifdef FN_ForceUnmodified_Post +void FN_ForceUnmodified_Post(FORCE_TYPE type, float *mins, float *maxs, const char *filename); +#endif // FN_ForceUnmodified_Post + +#ifdef FN_GetPlayerStats_Post +void FN_GetPlayerStats_Post(const edict_t *pClient, int *ping, int *packet_loss); +#endif // FN_GetPlayerStats_Post + +#ifdef FN_AddServerCommand_Post +void FN_AddServerCommand_Post(char *cmd_name, void (*function)(void)); +#endif // FN_AddServerCommand_Post + +#ifdef FN_Voice_GetClientListening_Post +qboolean FN_Voice_GetClientListening_Post(int iReceiver, int iSender); +#endif // FN_Voice_GetClientListening_Post + +#ifdef FN_Voice_SetClientListening_Post +qboolean FN_Voice_SetClientListening_Post(int iReceiver, int iSender, qboolean bListen); +#endif // FN_Voice_SetClientListening_Post + +#ifdef FN_GetPlayerAuthId_Post +const char *FN_GetPlayerAuthId_Post(edict_t *e); +#endif // FN_GetPlayerAuthId + + + + +#ifdef FN_OnFreeEntPrivateData +void FN_OnFreeEntPrivateData(edict_t *pEnt); +#endif // FN_OnFreeEntPrivateData + +#ifdef FN_GameShutdown +void FN_GameShutdown(void); +#endif // FN_GameShutdown + +#ifdef FN_ShouldCollide +int FN_ShouldCollide(edict_t *pentTouched, edict_t *pentOther); +#endif // FN_ShouldCollide + + + + + +#ifdef FN_OnFreeEntPrivateData_Post +void FN_OnFreeEntPrivateData_Post(edict_t *pEnt); +#endif // FN_OnFreeEntPrivateData_Post + +#ifdef FN_GameShutdown_Post +void FN_GameShutdown_Post(void); +#endif // FN_GameShutdown_Post + +#ifdef FN_ShouldCollide_Post +int FN_ShouldCollide_Post(edict_t *pentTouched, edict_t *pentOther); +#endif // FN_ShouldCollide_Post + +#endif // USE_METAMOD + + +#ifdef FN_AMXX_QUERY +void FN_AMXX_QUERY(void); +#endif // FN_AMXX_QUERY + +#ifdef FN_AMXX_ATTACH +void FN_AMXX_ATTACH(void); +#endif // FN_AMXX_ATTACH + +#ifdef FN_AMXX_DETACH +void FN_AMXX_DETACH(void); +#endif // FN_AMXX_DETACH + +#ifdef FN_AMXX_PLUGINSLOADED +void FN_AMXX_PLUGINSLOADED(void); +#endif // FN_AMXX_PLUGINSLOADED + +// *** Types *** +typedef void* (*PFN_REQ_FNPTR)(const char * /*name*/); + +// ***** Module funcs stuff ***** +enum ForwardExecType +{ + ET_IGNORE = 0, // Ignore return vaue + ET_STOP, // Stop on PLUGIN_HANDLED + ET_STOP2, // Stop on PLUGIN_HANDLED, continue on other values, return biggest return value + ET_CONTINUE, // Continue; return biggest return value +}; + +enum ForwardParam +{ + FP_DONE = -1, // specify this as the last argument + // only tells the function that there are no more arguments + FP_CELL, // normal cell + FP_FLOAT, // float; used as normal cell though + FP_STRING, // string + FP_STRINGEX, // string; will be updated to the last function's value + FP_ARRAY, // array; use the return value of prepareArray. +}; + + +typedef int (*PFN_ADD_NATIVES) (const AMX_NATIVE_INFO * /*list*/); +typedef char * (*PFN_BUILD_PATHNAME) (const char * /*format*/, ...); +typedef char * (*PFN_BUILD_PATHNAME_R) (char * /*buffer*/, size_t /* maxlen */, const char * /* format */, ...); +typedef cell * (*PFN_GET_AMXADDR) (AMX * /*amx*/, cell /*offset*/); +typedef void (*PFN_PRINT_SRVCONSOLE) (char * /*format*/, ...); +typedef const char * (*PFN_GET_MODNAME) (void); +typedef const char * (*PFN_GET_AMXSCRIPTNAME) (int /*id*/); +typedef AMX * (*PFN_GET_AMXSCRIPT) (int /*id*/); +typedef int (*PFN_FIND_AMXSCRIPT_BYAMX) (const AMX * /*amx*/); +typedef int (*PFN_FIND_AMXSCRIPT_BYNAME) (const char * /*name*/); +typedef int (*PFN_SET_AMXSTRING) (AMX * /*amx*/, cell /*amx_addr*/, const char * /* source */, int /* max */); +typedef char * (*PFN_GET_AMXSTRING) (AMX * /*amx*/, cell /*amx_addr*/, int /*bufferId*/, int * /*pLen*/); +typedef int (*PFN_GET_AMXSTRINGLEN) (const cell *ptr); +typedef char * (*PFN_FORMAT_AMXSTRING) (AMX * /*amx*/, cell * /*params*/, int /*startParam*/, int * /*pLen*/); +typedef void (*PFN_COPY_AMXMEMORY) (cell * /*dest*/, const cell * /*src*/, int /*len*/); +typedef void (*PFN_LOG) (const char * /*fmt*/, ...); +typedef void (*PFN_LOG_ERROR) (AMX * /*amx*/, int /*err*/, const char * /*fmt*/, ...); +typedef int (*PFN_RAISE_AMXERROR) (AMX * /*amx*/, int /*error*/); +typedef int (*PFN_REGISTER_FORWARD) (const char * /*funcname*/, ForwardExecType /*exectype*/, ... /*paramtypes terminated by PF_DONE*/); +typedef int (*PFN_EXECUTE_FORWARD) (int /*id*/, ... /*params*/); +typedef cell (*PFN_PREPARE_CELLARRAY) (cell * /*ptr*/, unsigned int /*size*/); +typedef cell (*PFN_PREPARE_CHARARRAY) (char * /*ptr*/, unsigned int /*size*/); +typedef cell (*PFN_PREPARE_CELLARRAY_A) (cell * /*ptr*/, unsigned int /*size*/, bool /*copyBack*/); +typedef cell (*PFN_PREPARE_CHARARRAY_A) (char * /*ptr*/, unsigned int /*size*/, bool /*copyBack*/); +typedef int (*PFN_IS_PLAYER_VALID) (int /*id*/); +typedef const char * (*PFN_GET_PLAYER_NAME) (int /*id*/); +typedef const char * (*PFN_GET_PLAYER_IP) (int /*id*/); +typedef int (*PFN_IS_PLAYER_INGAME) (int /*id*/); +typedef int (*PFN_IS_PLAYER_BOT) (int /*id*/); +typedef int (*PFN_IS_PLAYER_AUTHORIZED) (int /*id*/); +typedef float (*PFN_GET_PLAYER_TIME) (int /*id*/); +typedef float (*PFN_GET_PLAYER_PLAYTIME) (int /*id*/); +typedef int (*PFN_GETPLAYERFLAGS) (int /* id*/); +typedef int (*PFN_GET_PLAYER_CURWEAPON) (int /*id*/); +typedef const char * (*PFN_GET_PLAYER_TEAM) (int /*id*/); +typedef int (*PFN_GET_PLAYER_TEAMID) (int /*id*/); +typedef int (*PFN_GET_PLAYER_DEATHS) (int /*id*/); +typedef int (*PFN_GET_PLAYER_MENU) (int /*id*/); +typedef int (*PFN_GET_PLAYER_KEYS) (int /*id*/); +typedef int (*PFN_IS_PLAYER_ALIVE) (int /*id*/); +typedef int (*PFN_GET_PLAYER_FRAGS) (int /*id*/); +typedef int (*PFN_IS_PLAYER_CONNECTING) (int /*id*/); +typedef int (*PFN_IS_PLAYER_HLTV) (int /*id*/); +typedef int (*PFN_GET_PLAYER_ARMOR) (int /*id*/); +typedef int (*PFN_GET_PLAYER_HEALTH) (int /*id*/); +#ifdef USE_METAMOD +typedef edict_t * (*PFN_GET_PLAYER_EDICT) (int /*id*/); +#else +typedef void * (*PFN_GET_PLAYER_EDICT) (int /*id*/); +#endif + +#ifdef MEMORY_TEST +typedef void * (*PFN_ALLOCATOR) (const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/, + const unsigned int /*type*/, const size_t /*size*/); +typedef void * (*PFN_REALLOCATOR) (const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/, + const unsigned int /*type*/, const size_t /*size*/, void* /*addr*/ ); +typedef void (*PFN_DEALLOCATOR) (const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/, + const unsigned int /*type*/, const void* /*addr*/ ); +#endif +typedef int (*PFN_AMX_EXEC) (AMX* /*amx*/, cell* /*return val*/, int /*index*/); +typedef int (*PFN_AMX_EXECV) (AMX* /*amx*/, cell* /*return val*/, int /*index*/, int /*numparams*/, cell[] /*params*/); +typedef int (*PFN_AMX_ALLOT) (AMX* /*amx*/, int /*length*/, cell* /*amx_addr*/, cell** /*phys_addr*/); +typedef int (*PFN_AMX_FINDPUBLIC) (AMX* /*amx*/, char* /*func name*/, int* /*index*/); +typedef int (*PFN_AMX_FINDNATIVE) (AMX* /*amx*/, char* /*func name*/, int* /*index*/); +typedef int (*PFN_LOAD_AMXSCRIPT) (AMX* /*amx*/, void** /*code*/, const char* /*path*/, char[64] /*error info*/, int /* debug */); +typedef int (*PFN_UNLOAD_AMXSCRIPT) (AMX* /*amx*/,void** /*code*/); +typedef cell (*PFN_REAL_TO_CELL) (REAL /*x*/); +typedef REAL (*PFN_CELL_TO_REAL) (cell /*x*/); +typedef int (*PFN_REGISTER_SPFORWARD) (AMX * /*amx*/, int /*func*/, ... /*params*/); +typedef int (*PFN_REGISTER_SPFORWARD_BYNAME) (AMX * /*amx*/, const char * /*funcName*/, ... /*params*/); +typedef void (*PFN_UNREGISTER_SPFORWARD) (int /*id*/); +typedef void (*PFN_MERGEDEFINITION_FILE) (const char * /*filename*/); +typedef const char * (*PFN_FORMAT) (const char * /*fmt*/, ... /*params*/); +typedef void (*PFN_REGISTERFUNCTION) (void * /*pfn*/, const char * /*desc*/); +typedef int (*PFN_AMX_PUSH) (AMX * /*amx*/, cell /*value*/); + +extern PFN_ADD_NATIVES g_fn_AddNatives; +extern PFN_BUILD_PATHNAME g_fn_BuildPathname; +extern PFN_BUILD_PATHNAME_R g_fn_BuildPathnameR; +extern PFN_GET_AMXADDR g_fn_GetAmxAddr; +extern PFN_PRINT_SRVCONSOLE g_fn_PrintSrvConsole; +extern PFN_GET_MODNAME g_fn_GetModname; +extern PFN_GET_AMXSCRIPTNAME g_fn_GetAmxScriptName; +extern PFN_GET_AMXSCRIPT g_fn_GetAmxScript; +extern PFN_FIND_AMXSCRIPT_BYAMX g_fn_FindAmxScriptByAmx; +extern PFN_FIND_AMXSCRIPT_BYNAME g_fn_FindAmxScriptByName; +extern PFN_SET_AMXSTRING g_fn_SetAmxString; +extern PFN_GET_AMXSTRING g_fn_GetAmxString; +extern PFN_GET_AMXSTRINGLEN g_fn_GetAmxStringLen; +extern PFN_FORMAT_AMXSTRING g_fn_FormatAmxString; +extern PFN_COPY_AMXMEMORY g_fn_CopyAmxMemory; +extern PFN_LOG g_fn_Log; +extern PFN_LOG_ERROR g_fn_LogErrorFunc; +extern PFN_RAISE_AMXERROR g_fn_RaiseAmxError; +extern PFN_REGISTER_FORWARD g_fn_RegisterForward; +extern PFN_EXECUTE_FORWARD g_fn_ExecuteForward; +extern PFN_PREPARE_CELLARRAY g_fn_PrepareCellArray; +extern PFN_PREPARE_CHARARRAY g_fn_PrepareCharArray; +extern PFN_PREPARE_CELLARRAY_A g_fn_PrepareCellArrayA; +extern PFN_PREPARE_CHARARRAY_A g_fn_PrepareCharArrayA; +extern PFN_IS_PLAYER_VALID g_fn_IsPlayerValid; +extern PFN_GET_PLAYER_NAME g_fn_GetPlayerName; +extern PFN_GET_PLAYER_IP g_fn_GetPlayerIP; +extern PFN_IS_PLAYER_INGAME g_fn_IsPlayerIngame; +extern PFN_IS_PLAYER_BOT g_fn_IsPlayerBot; +extern PFN_IS_PLAYER_AUTHORIZED g_fn_IsPlayerAuthorized; +extern PFN_GET_PLAYER_TIME g_fn_GetPlayerTime; +extern PFN_GET_PLAYER_PLAYTIME g_fn_GetPlayerPlayTime; +extern PFN_GET_PLAYER_CURWEAPON g_fn_GetPlayerCurweapon; +extern PFN_GET_PLAYER_TEAMID g_fn_GetPlayerTeamID; +extern PFN_GET_PLAYER_DEATHS g_fn_GetPlayerDeaths; +extern PFN_GET_PLAYER_MENU g_fn_GetPlayerMenu; +extern PFN_GET_PLAYER_KEYS g_fn_GetPlayerKeys; +extern PFN_IS_PLAYER_ALIVE g_fn_IsPlayerAlive; +extern PFN_GET_PLAYER_FRAGS g_fn_GetPlayerFrags; +extern PFN_IS_PLAYER_CONNECTING g_fn_IsPlayerConnecting; +extern PFN_IS_PLAYER_HLTV g_fn_IsPlayerHLTV; +extern PFN_GET_PLAYER_ARMOR g_fn_GetPlayerArmor; +extern PFN_GET_PLAYER_HEALTH g_fn_GetPlayerHealth; +extern PFN_AMX_EXEC g_fn_AmxExec; +extern PFN_AMX_ALLOT g_fn_AmxAllot; +extern PFN_AMX_FINDPUBLIC g_fn_AmxFindPublic; +extern PFN_LOAD_AMXSCRIPT g_fn_LoadAmxScript; +extern PFN_UNLOAD_AMXSCRIPT g_fn_UnloadAmxScript; +extern PFN_REAL_TO_CELL g_fn_RealToCell; +extern PFN_CELL_TO_REAL g_fn_CellToReal; +extern PFN_REGISTER_SPFORWARD g_fn_RegisterSPForward; +extern PFN_REGISTER_SPFORWARD_BYNAME g_fn_RegisterSPForwardByName; +extern PFN_UNREGISTER_SPFORWARD g_fn_UnregisterSPForward; +extern PFN_MERGEDEFINITION_FILE g_fn_MergeDefinition_File; +extern PFN_AMX_FINDNATIVE g_fn_AmxFindNative; +extern PFN_GETPLAYERFLAGS g_fn_GetPlayerFlags; +extern PFN_GET_PLAYER_EDICT g_fn_GetPlayerEdict; +extern PFN_FORMAT g_fn_Format; +extern PFN_GET_PLAYER_TEAM g_fn_GetPlayerTeam; +extern PFN_REGISTERFUNCTION g_fn_RegisterFunction; +extern PFN_REQ_FNPTR g_fn_RequestFunction; +extern PFN_AMX_PUSH g_fn_AmxPush; + +#ifdef MAY_NEVER_BE_DEFINED +// Function prototypes for intellisense and similar systems +// They understand #if 0 so we use #ifdef MAY_NEVER_BE_DEFINED +int MF_AddNatives (const AMX_NATIVE_INFO *list) { } +char * MF_BuildPathname (const char * format, ...) { } +char * MF_BuildPathnameR (char *buffer, size_t maxlen, const char *fmt, ...) { } +cell * MF_GetAmxAddr (AMX * amx, cell offset) { } +void MF_PrintSrvConsole (char * format, ...) { } +const char * MF_GetModname (void) { } +const char * MF_GetScriptName (int id) { } +AMX * MF_GetScriptAmx (int id) { } +int MF_FindScriptByAmx (const AMX * amx) { } +int MF_FindScriptByAmx (const char * name) { } +int MF_SetAmxString (AMX * amx, cell amx_addr, const char * source , int max ) { } +char * MF_GetAmxString (AMX * amx, cell amx_addr, int bufferId, int * pLen) { } +int MF_GetAmxStringLen (const cell *ptr) { } +char * MF_FormatAmxString (AMX * amx, cell * params, int startParam, int * pLen) { } +void MF_CopyAmxMemory (cell * dest, const cell * src, int len) { } +void MF_Log (const char * fmt, ...) { } +void MF_LogError (AMX * amx, int err, const char *fmt, ...) { } +int MF_RaiseAmxError (AMX * amx, int error) { } +int MF_RegisterForward (const char * funcname, ForwardExecType exectype, ...) { } +int MF_ExecuteForward (int id, ...) { } +cell MF_PrepareCellArray (cell * ptr, unsigned int size) { } +cell MF_PrepareCharArray (char * ptr, unsigned int size) { } +cell MF_PrepareCellArrayA (cell * ptr, unsigned int size, bool copyBack) { } +cell MF_PrepareCharArrayA (char * ptr, unsigned int size, bool copyBack) { } +int MF_IsPlayerValid (int id) { } +const char * MF_GetPlayerName (int id) { } +const char * MF_GetPlayerIP (int id) { } +int MF_IsPlayerIngame (int id) { } +int MF_IsPlayerBot (int id) { } +int MF_IsPlayerAuthorized (int id) { } +float MF_GetPlayerTime (int id) { } +float MF_GetPlayerPlayTime (int id) { } +int MF_GetPlayerCurweapon (int id) { } +const char * MF_GetPlayerTeam (int id) { } +int MF_GetPlayerTeamID (int id) { } +int MF_GetPlayerDeaths (int id) { } +int MF_GetPlayerMenu (int id) { } +int MF_GetPlayerKeys (int id) { } +int MF_IsPlayerAlive (int id) { } +int MF_GetPlayerFrags (int id) { } +int MF_IsPlayerConnecting (int id) { } +int MF_IsPlayerHLTV (int id) { } +int MF_GetPlayerArmor (int id) { } +int MF_GetPlayerHealth (int id) { } +REAL amx_ctof (cell x) { } +cell amx_ftoc (float x) { } +int MF_RegisterSPForwardByName (AMX * amx, const char *str, ...) { } +int MF_RegisterSPForward (AMX * amx, int func, ...) { } +void MF_UnregisterSPForward (int id) { } +int MF_GetPlayerFlags (int id) { } +edict_t* MF_GetPlayerEdict (int id) { } +const char * MF_Format (const char *fmt, ...) { } +void MF_RegisterFunction (void *pfn, const char *description) { } +void * MF_RequestFunction (const char *description) { } +int MF_AmxPush (AMX *amx, cell *params) { } +int MF_AmxExec (AMX *amx, cell *retval, int idx) { } +#endif // MAY_NEVER_BE_DEFINED + +#define MF_AddNatives g_fn_AddNatives +#define MF_BuildPathname g_fn_BuildPathname +#define MF_BuildPathnameR g_fn_BuildPathnameR +#define MF_FormatAmxString g_fn_FormatAmxString +#define MF_GetAmxAddr g_fn_GetAmxAddr +#define MF_PrintSrvConsole g_fn_PrintSrvConsole +#define MF_GetModname g_fn_GetModname +#define MF_GetScriptName g_fn_GetAmxScriptName +#define MF_GetScriptAmx g_fn_GetAmxScript +#define MF_FindScriptByAmx g_fn_FindAmxScriptByAmx +#define MF_FindScriptByName g_fn_FindAmxScriptByName +#define MF_SetAmxString g_fn_SetAmxString +#define MF_GetAmxString g_fn_GetAmxString +#define MF_GetAmxStringLen g_fn_GetAmxStringLen +#define MF_CopyAmxMemory g_fn_CopyAmxMemory +void MF_Log(const char *fmt, ...); +void MF_LogError(AMX *amx, int err, const char *fmt, ...); +#define MF_RaiseAmxError g_fn_RaiseAmxError +#define MF_RegisterForward g_fn_RegisterForward +#define MF_ExecuteForward g_fn_ExecuteForward +#define MF_PrepareCellArray g_fn_PrepareCellArray +#define MF_PrepareCharArray g_fn_PrepareCharArray +#define MF_PrepareCellArrayA g_fn_PrepareCellArrayA +#define MF_PrepareCharArrayA g_fn_PrepareCharArrayA +#define MF_IsPlayerValid g_fn_IsPlayerValid +#define MF_GetPlayerName g_fn_GetPlayerName +#define MF_GetPlayerIP g_fn_GetPlayerIP +#define MF_IsPlayerIngame g_fn_IsPlayerIngame +#define MF_IsPlayerBot g_fn_IsPlayerBot +#define MF_IsPlayerAuthorized g_fn_IsPlayerAuthorized +#define MF_GetPlayerTime g_fn_GetPlayerTime +#define MF_GetPlayerPlayTime g_fn_GetPlayerPlayTime +#define MF_GetPlayerCurweapon g_fn_GetPlayerCurweapon +#define MF_GetPlayerTeam g_fn_GetPlayerTeam +#define MF_GetPlayerTeamID g_fn_GetPlayerTeamID +#define MF_GetPlayerDeaths g_fn_GetPlayerDeaths +#define MF_GetPlayerMenu g_fn_GetPlayerMenu +#define MF_GetPlayerKeys g_fn_GetPlayerKeys +#define MF_IsPlayerAlive g_fn_IsPlayerAlive +#define MF_GetPlayerFrags g_fn_GetPlayerFrags +#define MF_IsPlayerConnecting g_fn_IsPlayerConnecting +#define MF_IsPlayerHLTV g_fn_IsPlayerHLTV +#define MF_GetPlayerArmor g_fn_GetPlayerArmor +#define MF_GetPlayerHealth g_fn_GetPlayerHealth +#define MF_AmxExec g_fn_AmxExec +#define MF_AmxExecv g_fn_AmxExecv +#define MF_AmxFindPublic g_fn_AmxFindPublic +#define MF_AmxAllot g_fn_AmxAllot +#define MF_AmxFindNative g_fn_AmxFindNative +#define MF_LoadAmxScript g_fn_LoadAmxScript +#define MF_UnloadAmxScript g_fn_UnloadAmxScript +#define MF_MergeDefinitionFile g_fn_MergeDefinition_File +#define amx_ctof g_fn_CellToReal +#define amx_ftoc g_fn_RealToCell +#define MF_RegisterSPForwardByName g_fn_RegisterSPForwardByName +#define MF_RegisterSPForward g_fn_RegisterSPForward +#define MF_UnregisterSPForward g_fn_UnregisterSPForward +#define MF_GetPlayerFlags g_fn_GetPlayerFlags +#define MF_GetPlayerEdict g_fn_GetPlayerEdict +#define MF_Format g_fn_Format +#define MF_RegisterFunction g_fn_RegisterFunction +#define MF_RequestFunction g_fn_RequestFunction; +#define MF_AmxPush g_fn_AmxPush + +#ifdef MEMORY_TEST +/*** Memory ***/ +void *operator new(size_t reportedSize); +void *operator new[](size_t reportedSize); +void *operator new(size_t reportedSize, const char *sourceFile, int sourceLine); +void *operator new[](size_t reportedSize, const char *sourceFile, int sourceLine); +void operator delete(void *reportedAddress); +void operator delete[](void *reportedAddress); + +// Allocation types +extern const unsigned int m_alloc_unknown; +extern const unsigned int m_alloc_new; +extern const unsigned int m_alloc_new_array; +extern const unsigned int m_alloc_malloc; +extern const unsigned int m_alloc_calloc; +extern const unsigned int m_alloc_realloc; +extern const unsigned int m_alloc_delete; +extern const unsigned int m_alloc_delete_array; +extern const unsigned int m_alloc_free; + +// To be called before new / delete +void Mem_SetOwner(const char *filename, int line, const char *function); +// Actual allocator +void * Mem_Allocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, + const unsigned int allocationType, const size_t reportedSize); +void * Mem_Reallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, + const unsigned int reallocationType, const size_t reportedSize, void *reportedAddress); +void Mem_Deallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, + const unsigned int deallocationType, void *reportedAddress); + +// memory macros +#ifndef __FUNCTION__ +#define __FUNCTION__ "??" +#endif + +// call Mem_SetOwner, followed by the actual new operator +#define new (Mem_SetOwner(__FILE__,__LINE__,__FUNCTION__),false) ? NULL : new +// call Mem_SetOwner, followed by the actual delete operator +#define delete (Mem_SetOwner(__FILE__,__LINE__,__FUNCTION__),false) ? Mem_SetOwner("",0,"") : delete +#define malloc(sz) Mem_Allocator (__FILE__,__LINE__,__FUNCTION__,m_alloc_malloc,sz) +#define calloc(sz) Mem_Allocator (__FILE__,__LINE__,__FUNCTION__,m_alloc_calloc,sz) +#define realloc(ptr,sz) Mem_Reallocator(__FILE__,__LINE__,__FUNCTION__,m_alloc_realloc,sz,ptr) +#define free(ptr) Mem_Deallocator(__FILE__,__LINE__,__FUNCTION__,m_alloc_free,ptr) + +#endif //MEMORY_TEST + +#endif // #ifndef __AMXXMODULE_H__ diff --git a/dlls/MemHack/memhack.inc b/dlls/MemHack/memhack.inc new file mode 100644 index 00000000..97762de6 --- /dev/null +++ b/dlls/MemHack/memhack.inc @@ -0,0 +1,20 @@ +#include + +native memhack_get_char(address,baseaddress = DLLBASE, memtype = MEMTYPE_DATA, signtype = MEM_SIGNED); +native memhack_get_short(address,baseaddress = DLLBASE, memtype = MEMTYPE_DATA, signtype = MEM_SIGNED); +native memhack_get_long(address,baseaddress = DLLBASE, memtype = MEMTYPE_DATA, signtype = MEM_SIGNED); + +native Float:memhack_get_float(address,baseaddress = DLLBASE, memtype = MEMTYPE_DATA); +native Float:memhack_get_quad(address,baseaddress = DLLBASE, memtype = MEMTYPE_DATA); +native memhack_get_pointer(address,baseaddress = DLLBASE, memtype = MEMTYPE_DATA); + +native memhack_set_char(address,baseaddress = DLLBASE, new_val, memtype = MEMTYPE_DATA, signtype = MEM_SIGNED); +native memhack_set_short(address,baseaddress = DLLBASE, new_val, memtype = MEMTYPE_DATA, signtype = MEM_SIGNED); +native memhack_set_long(address,baseaddress = DLLBASE, new_val, memtype = MEMTYPE_DATA, signtype = MEM_SIGNED); + +native memhack_set_float(address,baseaddress = DLLBASE, Float:new_val, memtype = MEMTYPE_DATA); +native memhack_set_quad(address,baseaddress = DLLBASE,Float:new_val, memtype = MEMTYPE_DATA); +native memhack_set_pointer(address,baseaddress = DLLBASE, new_val, memtype = MEMTYPE_DATA); + +native memhack_get_base(func_addr,&success); +native memhack_get_realaddr(address,baseaddress,memtype = MEMTYPE_DATA); \ No newline at end of file diff --git a/dlls/MemHack/memhack_const.inc b/dlls/MemHack/memhack_const.inc new file mode 100644 index 00000000..bd30a7d9 --- /dev/null +++ b/dlls/MemHack/memhack_const.inc @@ -0,0 +1,23 @@ +#if defined _memhack_const_included + #endinput +#endif +#define _memhack_const_included + +// Different Address Bases +#define MEM_DLLBASE 0 +#define MEM_ENGBASE 1 +#define MEM_NULLBASE 2 + +// Signed or unsigned +#define MEM_SIGNED 0 +#define MEM_UNSIGNED 1 + +// Memory area types +#define MEMTYPE_CODE 0 // Code (usually .text segment, requires mprotect or VirtualProtect) +#define MEMTYPE_DATA 1 // Data (usually .data segment, writable by default) +#define MEMTYPE_RODATA 2 // Read-Only Data (usually .rodata on Linux, .rdata on Windows) + +// Return codes for patching (set natives) +#define MP_FAIL -1 +#define MP_OK 0 + diff --git a/dlls/MemHack/moduleconfig.h b/dlls/MemHack/moduleconfig.h new file mode 100644 index 00000000..73d774a6 --- /dev/null +++ b/dlls/MemHack/moduleconfig.h @@ -0,0 +1,463 @@ +// Configuration + +#ifndef __MODULECONFIG_H__ +#define __MODULECONFIG_H__ + +// Module info +#define MODULE_NAME "MemHack" +#define MODULE_VERSION "1.65" +#define MODULE_AUTHOR "SD and Rukia" +#define MODULE_URL "www.amxmodx.org" +#define MODULE_LOGTAG "MEMHACK" +// If you want the module not to be reloaded on mapchange, remove / comment out the next line +#define MODULE_RELOAD_ON_MAPCHANGE + +#ifdef __DATE__ +#define MODULE_DATE __DATE__ +#else // __DATE__ +#define MODULE_DATE "Unknown" +#endif // __DATE__ + +// metamod plugin? +#define USE_METAMOD + +// - AMXX Init functions +// Also consider using FN_META_* +// AMXX query +//#define FN_AMXX_QUERY OnAmxxQuery +// AMXX attach +// Do native functions init here (MF_AddNatives) +#define FN_AMXX_ATTACH OnAmxxAttach +// AMXX dettach +//#define FN_AMXX_DETTACH OnAmxxDettach +// All plugins loaded +// Do forward functions init here (MF_RegisterForward) +// #define FN_AMXX_PLUGINSLOADED OnPluginsLoaded + +/**** METAMOD ****/ +// If your module doesn't use metamod, you may close the file now :) +#ifdef USE_METAMOD +// ---- +// Hook Functions +// Uncomment these to be called +// You can also change the function name + +// - Metamod init functions +// Also consider using FN_AMXX_* +// Meta query +//#define FN_META_QUERY OnMetaQuery +// Meta attach +//#define FN_META_ATTACH OnMetaAttach +// Meta dettach +//#define FN_META_DETTACH OnMetaDettach + +// (wd) are Will Day's notes +// - GetEntityAPI2 functions +// #define FN_GameDLLInit GameDLLInit /* pfnGameInit() */ +// #define FN_DispatchSpawn DispatchSpawn /* pfnSpawn() */ +// #define FN_DispatchThink DispatchThink /* pfnThink() */ +// #define FN_DispatchUse DispatchUse /* pfnUse() */ +// #define FN_DispatchTouch DispatchTouch /* pfnTouch() */ +// #define FN_DispatchBlocked DispatchBlocked /* pfnBlocked() */ +// #define FN_DispatchKeyValue DispatchKeyValue /* pfnKeyValue() */ +// #define FN_DispatchSave DispatchSave /* pfnSave() */ +// #define FN_DispatchRestore DispatchRestore /* pfnRestore() */ +// #define FN_DispatchObjectCollsionBox DispatchObjectCollsionBox /* pfnSetAbsBox() */ +// #define FN_SaveWriteFields SaveWriteFields /* pfnSaveWriteFields() */ +// #define FN_SaveReadFields SaveReadFields /* pfnSaveReadFields() */ +// #define FN_SaveGlobalState SaveGlobalState /* pfnSaveGlobalState() */ +// #define FN_RestoreGlobalState RestoreGlobalState /* pfnRestoreGlobalState() */ +// #define FN_ResetGlobalState ResetGlobalState /* pfnResetGlobalState() */ +// #define FN_ClientConnect ClientConnect /* pfnClientConnect() (wd) Client has connected */ +// #define FN_ClientDisconnect ClientDisconnect /* pfnClientDisconnect() (wd) Player has left the game */ +// #define FN_ClientKill ClientKill /* pfnClientKill() (wd) Player has typed "kill" */ +// #define FN_ClientPutInServer ClientPutInServer /* pfnClientPutInServer() (wd) Client is entering the game */ +// #define FN_ClientCommand ClientCommand /* pfnClientCommand() (wd) Player has sent a command (typed or from a bind) */ +// #define FN_ClientUserInfoChanged ClientUserInfoChanged /* pfnClientUserInfoChanged() (wd) Client has updated their setinfo structure */ +// #define FN_ServerActivate ServerActivate /* pfnServerActivate() (wd) Server is starting a new map */ +// #define FN_ServerDeactivate ServerDeactivate /* pfnServerDeactivate() (wd) Server is leaving the map (shutdown or changelevel); SDK2 */ +// #define FN_PlayerPreThink PlayerPreThink /* pfnPlayerPreThink() */ +// #define FN_PlayerPostThink PlayerPostThink /* pfnPlayerPostThink() */ +// #define FN_StartFrame StartFrame /* pfnStartFrame() */ +// #define FN_ParmsNewLevel ParmsNewLevel /* pfnParmsNewLevel() */ +// #define FN_ParmsChangeLevel ParmsChangeLevel /* pfnParmsChangeLevel() */ +// #define FN_GetGameDescription GetGameDescription /* pfnGetGameDescription() Returns string describing current .dll. E.g. "TeamFotrress 2" "Half-Life" */ +// #define FN_PlayerCustomization PlayerCustomization /* pfnPlayerCustomization() Notifies .dll of new customization for player. */ +// #define FN_SpectatorConnect SpectatorConnect /* pfnSpectatorConnect() Called when spectator joins server */ +// #define FN_SpectatorDisconnect SpectatorDisconnect /* pfnSpectatorDisconnect() Called when spectator leaves the server */ +// #define FN_SpectatorThink SpectatorThink /* pfnSpectatorThink() Called when spectator sends a command packet (usercmd_t) */ +// #define FN_Sys_Error Sys_Error /* pfnSys_Error() Notify game .dll that engine is going to shut down. Allows mod authors to set a breakpoint. SDK2 */ +// #define FN_PM_Move PM_Move /* pfnPM_Move() (wd) SDK2 */ +// #define FN_PM_Init PM_Init /* pfnPM_Init() Server version of player movement initialization; (wd) SDK2 */ +// #define FN_PM_FindTextureType PM_FindTextureType /* pfnPM_FindTextureType() (wd) SDK2 */ +// #define FN_SetupVisibility SetupVisibility /* pfnSetupVisibility() Set up PVS and PAS for networking for this client; (wd) SDK2 */ +// #define FN_UpdateClientData UpdateClientData /* pfnUpdateClientData() Set up data sent only to specific client; (wd) SDK2 */ +// #define FN_AddToFullPack AddToFullPack /* pfnAddToFullPack() (wd) SDK2 */ +// #define FN_CreateBaseline CreateBaseline /* pfnCreateBaseline() Tweak entity baseline for network encoding allows setup of player baselines too.; (wd) SDK2 */ +// #define FN_RegisterEncoders RegisterEncoders /* pfnRegisterEncoders() Callbacks for network encoding; (wd) SDK2 */ +// #define FN_GetWeaponData GetWeaponData /* pfnGetWeaponData() (wd) SDK2 */ +// #define FN_CmdStart CmdStart /* pfnCmdStart() (wd) SDK2 */ +// #define FN_CmdEnd CmdEnd /* pfnCmdEnd() (wd) SDK2 */ +// #define FN_ConnectionlessPacket ConnectionlessPacket /* pfnConnectionlessPacket() (wd) SDK2 */ +// #define FN_GetHullBounds GetHullBounds /* pfnGetHullBounds() (wd) SDK2 */ +// #define FN_CreateInstancedBaselines CreateInstancedBaselines /* pfnCreateInstancedBaselines() (wd) SDK2 */ +// #define FN_InconsistentFile InconsistentFile /* pfnInconsistentFile() (wd) SDK2 */ +// #define FN_AllowLagCompensation AllowLagCompensation /* pfnAllowLagCompensation() (wd) SDK2 */ + +// - GetEntityAPI2_Post functions +// #define FN_GameDLLInit_Post GameDLLInit_Post +// #define FN_DispatchSpawn_Post DispatchSpawn_Post +// #define FN_DispatchThink_Post DispatchThink_Post +// #define FN_DispatchUse_Post DispatchUse_Post +// #define FN_DispatchTouch_Post DispatchTouch_Post +// #define FN_DispatchBlocked_Post DispatchBlocked_Post +// #define FN_DispatchKeyValue_Post DispatchKeyValue_Post +// #define FN_DispatchSave_Post DispatchSave_Post +// #define FN_DispatchRestore_Post DispatchRestore_Post +// #define FN_DispatchObjectCollsionBox_Post DispatchObjectCollsionBox_Post +// #define FN_SaveWriteFields_Post SaveWriteFields_Post +// #define FN_SaveReadFields_Post SaveReadFields_Post +// #define FN_SaveGlobalState_Post SaveGlobalState_Post +// #define FN_RestoreGlobalState_Post RestoreGlobalState_Post +// #define FN_ResetGlobalState_Post ResetGlobalState_Post +// #define FN_ClientConnect_Post ClientConnect_Post +// #define FN_ClientDisconnect_Post ClientDisconnect_Post +// #define FN_ClientKill_Post ClientKill_Post +// #define FN_ClientPutInServer_Post ClientPutInServer_Post +// #define FN_ClientCommand_Post ClientCommand_Post +// #define FN_ClientUserInfoChanged_Post ClientUserInfoChanged_Post +// #define FN_ServerActivate_Post ServerActivate_Post +// #define FN_ServerDeactivate_Post ServerDeactivate_Post +// #define FN_PlayerPreThink_Post PlayerPreThink_Post +// #define FN_PlayerPostThink_Post PlayerPostThink_Post +// #define FN_StartFrame_Post StartFrame_Post +// #define FN_ParmsNewLevel_Post ParmsNewLevel_Post +// #define FN_ParmsChangeLevel_Post ParmsChangeLevel_Post +// #define FN_GetGameDescription_Post GetGameDescription_Post +// #define FN_PlayerCustomization_Post PlayerCustomization_Post +// #define FN_SpectatorConnect_Post SpectatorConnect_Post +// #define FN_SpectatorDisconnect_Post SpectatorDisconnect_Post +// #define FN_SpectatorThink_Post SpectatorThink_Post +// #define FN_Sys_Error_Post Sys_Error_Post +// #define FN_PM_Move_Post PM_Move_Post +// #define FN_PM_Init_Post PM_Init_Post +// #define FN_PM_FindTextureType_Post PM_FindTextureType_Post +// #define FN_SetupVisibility_Post SetupVisibility_Post +// #define FN_UpdateClientData_Post UpdateClientData_Post +// #define FN_AddToFullPack_Post AddToFullPack_Post +// #define FN_CreateBaseline_Post CreateBaseline_Post +// #define FN_RegisterEncoders_Post RegisterEncoders_Post +// #define FN_GetWeaponData_Post GetWeaponData_Post +// #define FN_CmdStart_Post CmdStart_Post +// #define FN_CmdEnd_Post CmdEnd_Post +// #define FN_ConnectionlessPacket_Post ConnectionlessPacket_Post +// #define FN_GetHullBounds_Post GetHullBounds_Post +// #define FN_CreateInstancedBaselines_Post CreateInstancedBaselines_Post +// #define FN_InconsistentFile_Post InconsistentFile_Post +// #define FN_AllowLagCompensation_Post AllowLagCompensation_Post + +// - GetEngineAPI functions +// #define FN_PrecacheModel PrecacheModel +// #define FN_PrecacheSound PrecacheSound +// #define FN_SetModel SetModel +// #define FN_ModelIndex ModelIndex +// #define FN_ModelFrames ModelFrames +// #define FN_SetSize SetSize +// #define FN_ChangeLevel ChangeLevel +// #define FN_GetSpawnParms GetSpawnParms +// #define FN_SaveSpawnParms SaveSpawnParms +// #define FN_VecToYaw VecToYaw +// #define FN_VecToAngles VecToAngles +// #define FN_MoveToOrigin MoveToOrigin +// #define FN_ChangeYaw ChangeYaw +// #define FN_ChangePitch ChangePitch +// #define FN_FindEntityByString FindEntityByString +// #define FN_GetEntityIllum GetEntityIllum +// #define FN_FindEntityInSphere FindEntityInSphere +// #define FN_FindClientInPVS FindClientInPVS +// #define FN_EntitiesInPVS EntitiesInPVS +// #define FN_MakeVectors MakeVectors +// #define FN_AngleVectors AngleVectors +// #define FN_CreateEntity CreateEntity +// #define FN_RemoveEntity RemoveEntity +// #define FN_CreateNamedEntity CreateNamedEntity +// #define FN_MakeStatic MakeStatic +// #define FN_EntIsOnFloor EntIsOnFloor +// #define FN_DropToFloor DropToFloor +// #define FN_WalkMove WalkMove +// #define FN_SetOrigin SetOrigin +// #define FN_EmitSound EmitSound +// #define FN_EmitAmbientSound EmitAmbientSound +// #define FN_TraceLine TraceLine +// #define FN_TraceToss TraceToss +// #define FN_TraceMonsterHull TraceMonsterHull +// #define FN_TraceHull TraceHull +// #define FN_TraceModel TraceModel +// #define FN_TraceTexture TraceTexture +// #define FN_TraceSphere TraceSphere +// #define FN_GetAimVector GetAimVector +// #define FN_ServerCommand ServerCommand +// #define FN_ServerExecute ServerExecute +// #define FN_engClientCommand engClientCommand +// #define FN_ParticleEffect ParticleEffect +// #define FN_LightStyle LightStyle +// #define FN_DecalIndex DecalIndex +// #define FN_PointContents PointContents +// #define FN_MessageBegin MessageBegin +// #define FN_MessageEnd MessageEnd +// #define FN_WriteByte WriteByte +// #define FN_WriteChar WriteChar +// #define FN_WriteShort WriteShort +// #define FN_WriteLong WriteLong +// #define FN_WriteAngle WriteAngle +// #define FN_WriteCoord WriteCoord +// #define FN_WriteString WriteString +// #define FN_WriteEntity WriteEntity +// #define FN_CVarRegister CVarRegister +// #define FN_CVarGetFloat CVarGetFloat +// #define FN_CVarGetString CVarGetString +// #define FN_CVarSetFloat CVarSetFloat +// #define FN_CVarSetString CVarSetString +// #define FN_AlertMessage AlertMessage +// #define FN_EngineFprintf EngineFprintf +// #define FN_PvAllocEntPrivateData PvAllocEntPrivateData +// #define FN_PvEntPrivateData PvEntPrivateData +// #define FN_FreeEntPrivateData FreeEntPrivateData +// #define FN_SzFromIndex SzFromIndex +// #define FN_AllocString AllocString +// #define FN_GetVarsOfEnt GetVarsOfEnt +// #define FN_PEntityOfEntOffset PEntityOfEntOffset +// #define FN_EntOffsetOfPEntity EntOffsetOfPEntity +// #define FN_IndexOfEdict IndexOfEdict +// #define FN_PEntityOfEntIndex PEntityOfEntIndex +// #define FN_FindEntityByVars FindEntityByVars +// #define FN_GetModelPtr GetModelPtr +// #define FN_RegUserMsg RegUserMsg +// #define FN_AnimationAutomove AnimationAutomove +// #define FN_GetBonePosition GetBonePosition +// #define FN_FunctionFromName FunctionFromName +// #define FN_NameForFunction NameForFunction +// #define FN_ClientPrintf ClientPrintf +// #define FN_ServerPrint ServerPrint +// #define FN_Cmd_Args Cmd_Args +// #define FN_Cmd_Argv Cmd_Argv +// #define FN_Cmd_Argc Cmd_Argc +// #define FN_GetAttachment GetAttachment +// #define FN_CRC32_Init CRC32_Init +// #define FN_CRC32_ProcessBuffer CRC32_ProcessBuffer +// #define FN_CRC32_ProcessByte CRC32_ProcessByte +// #define FN_CRC32_Final CRC32_Final +// #define FN_RandomLong RandomLong +// #define FN_RandomFloat RandomFloat +// #define FN_SetView SetView +// #define FN_Time Time +// #define FN_CrosshairAngle CrosshairAngle +// #define FN_LoadFileForMe LoadFileForMe +// #define FN_FreeFile FreeFile +// #define FN_EndSection EndSection +// #define FN_CompareFileTime CompareFileTime +// #define FN_GetGameDir GetGameDir +// #define FN_Cvar_RegisterVariable Cvar_RegisterVariable +// #define FN_FadeClientVolume FadeClientVolume +// #define FN_SetClientMaxspeed SetClientMaxspeed +// #define FN_CreateFakeClient CreateFakeClient +// #define FN_RunPlayerMove RunPlayerMove +// #define FN_NumberOfEntities NumberOfEntities +// #define FN_GetInfoKeyBuffer GetInfoKeyBuffer +// #define FN_InfoKeyValue InfoKeyValue +// #define FN_SetKeyValue SetKeyValue +// #define FN_SetClientKeyValue SetClientKeyValue +// #define FN_IsMapValid IsMapValid +// #define FN_StaticDecal StaticDecal +// #define FN_PrecacheGeneric PrecacheGeneric +// #define FN_GetPlayerUserId GetPlayerUserId +// #define FN_BuildSoundMsg BuildSoundMsg +// #define FN_IsDedicatedServer IsDedicatedServer +// #define FN_CVarGetPointer CVarGetPointer +// #define FN_GetPlayerWONId GetPlayerWONId +// #define FN_Info_RemoveKey Info_RemoveKey +// #define FN_GetPhysicsKeyValue GetPhysicsKeyValue +// #define FN_SetPhysicsKeyValue SetPhysicsKeyValue +// #define FN_GetPhysicsInfoString GetPhysicsInfoString +// #define FN_PrecacheEvent PrecacheEvent +// #define FN_PlaybackEvent PlaybackEvent +// #define FN_SetFatPVS SetFatPVS +// #define FN_SetFatPAS SetFatPAS +// #define FN_CheckVisibility CheckVisibility +// #define FN_DeltaSetField DeltaSetField +// #define FN_DeltaUnsetField DeltaUnsetField +// #define FN_DeltaAddEncoder DeltaAddEncoder +// #define FN_GetCurrentPlayer GetCurrentPlayer +// #define FN_CanSkipPlayer CanSkipPlayer +// #define FN_DeltaFindField DeltaFindField +// #define FN_DeltaSetFieldByIndex DeltaSetFieldByIndex +// #define FN_DeltaUnsetFieldByIndex DeltaUnsetFieldByIndex +// #define FN_SetGroupMask SetGroupMask +// #define FN_engCreateInstancedBaseline engCreateInstancedBaseline +// #define FN_Cvar_DirectSet Cvar_DirectSet +// #define FN_ForceUnmodified ForceUnmodified +// #define FN_GetPlayerStats GetPlayerStats +// #define FN_AddServerCommand AddServerCommand +// #define FN_Voice_GetClientListening Voice_GetClientListening +// #define FN_Voice_SetClientListening Voice_SetClientListening +// #define FN_GetPlayerAuthId GetPlayerAuthId + +// - GetEngineAPI_Post functions +// #define FN_PrecacheModel_Post PrecacheModel_Post +// #define FN_PrecacheSound_Post PrecacheSound_Post +// #define FN_SetModel_Post SetModel_Post +// #define FN_ModelIndex_Post ModelIndex_Post +// #define FN_ModelFrames_Post ModelFrames_Post +// #define FN_SetSize_Post SetSize_Post +// #define FN_ChangeLevel_Post ChangeLevel_Post +// #define FN_GetSpawnParms_Post GetSpawnParms_Post +// #define FN_SaveSpawnParms_Post SaveSpawnParms_Post +// #define FN_VecToYaw_Post VecToYaw_Post +// #define FN_VecToAngles_Post VecToAngles_Post +// #define FN_MoveToOrigin_Post MoveToOrigin_Post +// #define FN_ChangeYaw_Post ChangeYaw_Post +// #define FN_ChangePitch_Post ChangePitch_Post +// #define FN_FindEntityByString_Post FindEntityByString_Post +// #define FN_GetEntityIllum_Post GetEntityIllum_Post +// #define FN_FindEntityInSphere_Post FindEntityInSphere_Post +// #define FN_FindClientInPVS_Post FindClientInPVS_Post +// #define FN_EntitiesInPVS_Post EntitiesInPVS_Post +// #define FN_MakeVectors_Post MakeVectors_Post +// #define FN_AngleVectors_Post AngleVectors_Post +// #define FN_CreateEntity_Post CreateEntity_Post +// #define FN_RemoveEntity_Post RemoveEntity_Post +// #define FN_CreateNamedEntity_Post CreateNamedEntity_Post +// #define FN_MakeStatic_Post MakeStatic_Post +// #define FN_EntIsOnFloor_Post EntIsOnFloor_Post +// #define FN_DropToFloor_Post DropToFloor_Post +// #define FN_WalkMove_Post WalkMove_Post +// #define FN_SetOrigin_Post SetOrigin_Post +// #define FN_EmitSound_Post EmitSound_Post +// #define FN_EmitAmbientSound_Post EmitAmbientSound_Post +// #define FN_TraceLine_Post TraceLine_Post +// #define FN_TraceToss_Post TraceToss_Post +// #define FN_TraceMonsterHull_Post TraceMonsterHull_Post +// #define FN_TraceHull_Post TraceHull_Post +// #define FN_TraceModel_Post TraceModel_Post +// #define FN_TraceTexture_Post TraceTexture_Post +// #define FN_TraceSphere_Post TraceSphere_Post +// #define FN_GetAimVector_Post GetAimVector_Post +// #define FN_ServerCommand_Post ServerCommand_Post +// #define FN_ServerExecute_Post ServerExecute_Post +// #define FN_engClientCommand_Post engClientCommand_Post +// #define FN_ParticleEffect_Post ParticleEffect_Post +// #define FN_LightStyle_Post LightStyle_Post +// #define FN_DecalIndex_Post DecalIndex_Post +// #define FN_PointContents_Post PointContents_Post +// #define FN_MessageBegin_Post MessageBegin_Post +// #define FN_MessageEnd_Post MessageEnd_Post +// #define FN_WriteByte_Post WriteByte_Post +// #define FN_WriteChar_Post WriteChar_Post +// #define FN_WriteShort_Post WriteShort_Post +// #define FN_WriteLong_Post WriteLong_Post +// #define FN_WriteAngle_Post WriteAngle_Post +// #define FN_WriteCoord_Post WriteCoord_Post +// #define FN_WriteString_Post WriteString_Post +// #define FN_WriteEntity_Post WriteEntity_Post +// #define FN_CVarRegister_Post CVarRegister_Post +// #define FN_CVarGetFloat_Post CVarGetFloat_Post +// #define FN_CVarGetString_Post CVarGetString_Post +// #define FN_CVarSetFloat_Post CVarSetFloat_Post +// #define FN_CVarSetString_Post CVarSetString_Post +// #define FN_AlertMessage_Post AlertMessage_Post +// #define FN_EngineFprintf_Post EngineFprintf_Post +// #define FN_PvAllocEntPrivateData_Post PvAllocEntPrivateData_Post +// #define FN_PvEntPrivateData_Post PvEntPrivateData_Post +// #define FN_FreeEntPrivateData_Post FreeEntPrivateData_Post +// #define FN_SzFromIndex_Post SzFromIndex_Post +// #define FN_AllocString_Post AllocString_Post +// #define FN_GetVarsOfEnt_Post GetVarsOfEnt_Post +// #define FN_PEntityOfEntOffset_Post PEntityOfEntOffset_Post +// #define FN_EntOffsetOfPEntity_Post EntOffsetOfPEntity_Post +// #define FN_IndexOfEdict_Post IndexOfEdict_Post +// #define FN_PEntityOfEntIndex_Post PEntityOfEntIndex_Post +// #define FN_FindEntityByVars_Post FindEntityByVars_Post +// #define FN_GetModelPtr_Post GetModelPtr_Post +// #define FN_RegUserMsg_Post RegUserMsg_Post +// #define FN_AnimationAutomove_Post AnimationAutomove_Post +// #define FN_GetBonePosition_Post GetBonePosition_Post +// #define FN_FunctionFromName_Post FunctionFromName_Post +// #define FN_NameForFunction_Post NameForFunction_Post +// #define FN_ClientPrintf_Post ClientPrintf_Post +// #define FN_ServerPrint_Post ServerPrint_Post +// #define FN_Cmd_Args_Post Cmd_Args_Post +// #define FN_Cmd_Argv_Post Cmd_Argv_Post +// #define FN_Cmd_Argc_Post Cmd_Argc_Post +// #define FN_GetAttachment_Post GetAttachment_Post +// #define FN_CRC32_Init_Post CRC32_Init_Post +// #define FN_CRC32_ProcessBuffer_Post CRC32_ProcessBuffer_Post +// #define FN_CRC32_ProcessByte_Post CRC32_ProcessByte_Post +// #define FN_CRC32_Final_Post CRC32_Final_Post +// #define FN_RandomLong_Post RandomLong_Post +// #define FN_RandomFloat_Post RandomFloat_Post +// #define FN_SetView_Post SetView_Post +// #define FN_Time_Post Time_Post +// #define FN_CrosshairAngle_Post CrosshairAngle_Post +// #define FN_LoadFileForMe_Post LoadFileForMe_Post +// #define FN_FreeFile_Post FreeFile_Post +// #define FN_EndSection_Post EndSection_Post +// #define FN_CompareFileTime_Post CompareFileTime_Post +// #define FN_GetGameDir_Post GetGameDir_Post +// #define FN_Cvar_RegisterVariable_Post Cvar_RegisterVariable_Post +// #define FN_FadeClientVolume_Post FadeClientVolume_Post +// #define FN_SetClientMaxspeed_Post SetClientMaxspeed_Post +// #define FN_CreateFakeClient_Post CreateFakeClient_Post +// #define FN_RunPlayerMove_Post RunPlayerMove_Post +// #define FN_NumberOfEntities_Post NumberOfEntities_Post +// #define FN_GetInfoKeyBuffer_Post GetInfoKeyBuffer_Post +// #define FN_InfoKeyValue_Post InfoKeyValue_Post +// #define FN_SetKeyValue_Post SetKeyValue_Post +// #define FN_SetClientKeyValue_Post SetClientKeyValue_Post +// #define FN_IsMapValid_Post IsMapValid_Post +// #define FN_StaticDecal_Post StaticDecal_Post +// #define FN_PrecacheGeneric_Post PrecacheGeneric_Post +// #define FN_GetPlayerUserId_Post GetPlayerUserId_Post +// #define FN_BuildSoundMsg_Post BuildSoundMsg_Post +// #define FN_IsDedicatedServer_Post IsDedicatedServer_Post +// #define FN_CVarGetPointer_Post CVarGetPointer_Post +// #define FN_GetPlayerWONId_Post GetPlayerWONId_Post +// #define FN_Info_RemoveKey_Post Info_RemoveKey_Post +// #define FN_GetPhysicsKeyValue_Post GetPhysicsKeyValue_Post +// #define FN_SetPhysicsKeyValue_Post SetPhysicsKeyValue_Post +// #define FN_GetPhysicsInfoString_Post GetPhysicsInfoString_Post +// #define FN_PrecacheEvent_Post PrecacheEvent_Post +// #define FN_PlaybackEvent_Post PlaybackEvent_Post +// #define FN_SetFatPVS_Post SetFatPVS_Post +// #define FN_SetFatPAS_Post SetFatPAS_Post +// #define FN_CheckVisibility_Post CheckVisibility_Post +// #define FN_DeltaSetField_Post DeltaSetField_Post +// #define FN_DeltaUnsetField_Post DeltaUnsetField_Post +// #define FN_DeltaAddEncoder_Post DeltaAddEncoder_Post +// #define FN_GetCurrentPlayer_Post GetCurrentPlayer_Post +// #define FN_CanSkipPlayer_Post CanSkipPlayer_Post +// #define FN_DeltaFindField_Post DeltaFindField_Post +// #define FN_DeltaSetFieldByIndex_Post DeltaSetFieldByIndex_Post +// #define FN_DeltaUnsetFieldByIndex_Post DeltaUnsetFieldByIndex_Post +// #define FN_SetGroupMask_Post SetGroupMask_Post +// #define FN_engCreateInstancedBaseline_Post engCreateInstancedBaseline_Post +// #define FN_Cvar_DirectSet_Post Cvar_DirectSet_Post +// #define FN_ForceUnmodified_Post ForceUnmodified_Post +// #define FN_GetPlayerStats_Post GetPlayerStats_Post +// #define FN_AddServerCommand_Post AddServerCommand_Post +// #define FN_Voice_GetClientListening_Post Voice_GetClientListening_Post +// #define FN_Voice_SetClientListening_Post Voice_SetClientListening_Post +// #define FN_GetPlayerAuthId_Post GetPlayerAuthId_Post + +// #define FN_OnFreeEntPrivateData OnFreeEntPrivateData +// #define FN_GameShutdown GameShutdown +// #define FN_ShouldCollide ShouldCollide + +// #define FN_OnFreeEntPrivateData_Post OnFreeEntPrivateData_Post +// #define FN_GameShutdown_Post GameShutdown_Post +// #define FN_ShouldCollide_Post ShouldCollide_Post + + +#endif // USE_METAMOD + +#endif // __MODULECONFIG_H__ +