From 0d8940899cf857c84511474316f5b23cc15b0297 Mon Sep 17 00:00:00 2001 From: LexManos Date: Sat, 4 Aug 2012 22:45:31 -0700 Subject: [PATCH] Moved logo to new client folder Added blank Access Transformer config for Forge Implemented version storage Added basic dummy FML mod container to remove the need for mod metadata file Added beggining work on Forge event system Updated and moved EnumHelper --- client/forge_logo.png | Bin 0 -> 24332 bytes .../client/EnumHelperClient.java | 44 +++ common/forge_at.cfg | 20 + .../classloading/FMLForgePlugin.java | 40 ++ .../net/minecraftforge/common/EnumHelper.java | 239 ++++++++++++ .../common/ForgeDummyContainer.java | 39 ++ .../minecraftforge/common/ForgeVersion.java | 44 +++ .../minecraftforge/common/MinecraftForge.java | 8 + .../minecraftforge/event/ASMEventHandler.java | 119 ++++++ common/net/minecraftforge/event/Event.java | 70 ++++ common/net/minecraftforge/event/EventBus.java | 103 +++++ .../minecraftforge/event/EventPriority.java | 16 + .../minecraftforge/event/ForgeSubscribe.java | 15 + .../minecraftforge/event/IEventListener.java | 8 + .../minecraftforge/event/ListenerList.java | 211 ++++++++++ .../transformers/EventTransformer.java | 132 +++++++ .../transformers/ForgeAccessTransformer.java | 13 + .../minecraft/src/forge/EnumHelperClient.java | 106 ----- .../net/minecraft/src/forge/EnumHelper.java | 366 ------------------ 19 files changed, 1121 insertions(+), 472 deletions(-) create mode 100644 client/forge_logo.png create mode 100644 client/net/minecraftforge/client/EnumHelperClient.java create mode 100644 common/forge_at.cfg create mode 100644 common/net/minecraftforge/classloading/FMLForgePlugin.java create mode 100644 common/net/minecraftforge/common/EnumHelper.java create mode 100644 common/net/minecraftforge/common/ForgeDummyContainer.java create mode 100644 common/net/minecraftforge/common/ForgeVersion.java create mode 100644 common/net/minecraftforge/common/MinecraftForge.java create mode 100644 common/net/minecraftforge/event/ASMEventHandler.java create mode 100644 common/net/minecraftforge/event/Event.java create mode 100644 common/net/minecraftforge/event/EventBus.java create mode 100644 common/net/minecraftforge/event/EventPriority.java create mode 100644 common/net/minecraftforge/event/ForgeSubscribe.java create mode 100644 common/net/minecraftforge/event/IEventListener.java create mode 100644 common/net/minecraftforge/event/ListenerList.java create mode 100644 common/net/minecraftforge/transformers/EventTransformer.java create mode 100644 common/net/minecraftforge/transformers/ForgeAccessTransformer.java delete mode 100644 forge_client/src/net/minecraft/src/forge/EnumHelperClient.java delete mode 100644 forge_common/net/minecraft/src/forge/EnumHelper.java diff --git a/client/forge_logo.png b/client/forge_logo.png new file mode 100644 index 0000000000000000000000000000000000000000..19a02ca4b7816334103afe5327b3cee5dfbaa96a GIT binary patch literal 24332 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�=u1;YqF|JMyMw>y({(_5HMeoHU|1x??;*H@viXsO=?z* zCbZ}FFl)bsSOWf2hM_FA(3}Pn+eMu+UEr?l?tWt4n<5Ch7nVOHh>gvn^oPz{lp}TdbkK8f_1^ zxe2m=`z>2TAXw|I2}V$Vzn7-c2GF0=CcI@_N)f93E^cuI^yA`+;PXDv@4~~a9ZbRA zD;32wg&%{SPHJgOhJZk*XUg3h*s3SMO(T#DDuL)z(|Cnu4^y0#|4jmE{2?+c00`mG zy!_l$ejtoHBSpu7I6n3Ic+nZ~luv#=oO`SjJUzblQ*Czu0N13wO#;s@f33Tu9eB1e zw=7+^z(7rraeQS39(rMCK!*o-cmj1#8^_+H(7I}(fSPZjB3kZa|h_19rd`R#r5x?u(h)_QOf*KT}>;(}} zzC_linGXSg))y0s0f^f>TedYv1F#&gRwxMo5AuhoTfx-`d1#oJZJtk_dJ&q>9S8(s zBRsws%CFoPwK%wZf^_P5<;MI^fgql@HMar)?T&3&wsSKOV0W!;4MZZl*4Eys{Q!U} zzhodEBAvQpF(aY<22^;ms8?c_g`)mpAOc0q^$3X6QbQAk6Mz7+ zmZXlPKm@i!Cu2hzL?)qw79Csc5b{sbPEx-PQe4Mu4cI3{Q(tQx=pSunT&M#?l=jx{ znz=mr=#SVI^3fwTzf`o9gWh#tCSH$%NG`k6y}MTr|KX>jzLYT6e zz^0ENqEpotQs%;pJqeRpMO>1ABRFFWdv$wBgnipnZ$$?}dA8+m%E`$GkLq{U9S1uc z$dpV1pfCI=fSbGn-u{{XTy0IT<6V)X+!JF@B6`-D@TTDi+bnd_w4RX&$3L$$EjR_l z!PQgJhC}GHulD7)H<70nTd+I#AvChCy{H)o=`eo(g?-?l?9DFNmn8r|{XG1!e+Ssp zOpRCBX_DZSTP2)?Wr+Bp?fKuQLZou=n;rAgq2G0U)*8D92)N_(*5o}&#%qI+iDB|ZjNLyAyB)Qynp#>1An~Y(XE|jxeQ{<%3MMeaY zIZ7oE>PA8#lUcx;mH$ZssSOC3;{^lbz|Jg@co@jX1`fFmr2}!e49`2J03PYegI^4i z5bCOE*J<;B0g8|Fj{u@b=(5Q&J&jO+gGr%2cxq<7nn%@TCP-#;*F9Tv1!S#OfrjS< z$*4!8K`my2q+h?PP|16Ov`JN2Qf^{`WITWEOLZRj``tAftFBFuwBuIsDnSIYN=;0U z`}WwA{#=*0l4+wj1!2*4{yrkU;Zb;suL%IXNQxnOYGmg(HTl)u0HB{$#a05KG?vt_ zuX6z+*^&1=0|=`;Ak^8H7Y4q+QHnkp_(BCYaoreuvU*HdZ_&xICuN^Us0R#9kVc|Q zNjXs8PKDMl_xubVXKI05zBzdIhf}c*q%rS4A{%->b8Qd5Q$;pOmcLA z5dClJ9bNYVfGtbws#*&|CZkHhGCdQdunn67*8||?e&zJS656MsC`~jTBCEYS_iSzf zqHOs#>s#_|MFl&3N?jHM5l3n9u2GyIDf99-ev~!#&I4q$idKy9^k#SD8HH^CD{l z02n@YtWPfmkM@+uajs$TX!{0w+`54Pc3rAVtlb3!7ZTeO4jz7yl)stVH2~@i({e)~ zs#OUBV_ZNStJQ_nxnGPu$>s9Za_yfW^?#OangE`E*Os=Q+V}vd4`q610CB{RL_)fJpF$Nq%%a%3xKic7xxr9Am-Es2}AKv zeoQDvI07P&!27=U`D?~Is>DdEGKu`^+c7M(1&@MH}!ZF}!7ysth;98E*b~Qcj4TjJj z83GLp1L+fpmw|bjQ5uPGBDeg5+=|H~K?+DYP1z7h15@(RNwf?c73`zCb~VgHW> zvFW$p)SMIBi7SJ4J9A_wt{jNCb5G%CIRN}6`+{1$Akx`5rqm_(5bPG6%+rL%_>&MJebNxIvkL6-q+{n^h?wfk6NVy>l8;K+ zdW*a^=YCbMczyk38gJPARpm=;aD?#SHLX0a|FEHOp_VJ}I7sT64(+hXcN+@3bcD$g z^LnEUKR^7=Qd5(6F^*9d7WFJFZR%l)0<(+gv+}=5AiL}%9{YjkyEirdRai0kNQjaT zidQ0(^=(=~YR}|AZ8dLt-Xw%jjZ}hqBn-?rRlD)6mIx^+N{dUBlL(l&^$mPcIKt1m z*+EK{SnSW{*(FM@SnTuWw0;GUq!sa@vYuG%Px_G$WhAlK@i&p`E3Se*(Xp77q zs^nIAaV+*le5R}-JV#3dUCq7xx_B26KdfK!c{UKl1#HWYbpjA6Sq=R%1Risn`R?bt zL9aTI%1JCz!MF%-EB!9KB*Bi_hK(=T~p%sl~lp zyP%aH%Ai2eevba{`&6hKAfLykX(=c}|4ol-mkFM{;A+ZICRWs=OwP_8Wil)OCkW(7 zMDd4NOCZwtDI+HKEkZjkcXw}3#@ z>@Bu}Cn)bM(IciwdUq5BZNSk8fp$R5IjIPJqSFvi4nRLpv43MP`EWw}2GpQ_lQOR`XTO38(qX>>LK;L;U6Ji#Z8|`t7xu)q z?1aeXx1R3q3kaRl$Nq=~`<&Kk^K1M9A`pp0$w+>LHf>lXs?_pV0x7QXQY9Y?p7v~8 zj4`xQ%mYkq1bD`tQGEB8 zloRoL4{C=l&4CE)mYBStH4)#PoVqaT8u|3#*tsDdXbzX%`n(?iI2j>$s(7Kr4sgw(mNj6LZIGLsil9L4o~ zYOW{L2$K4_JKi`@aQ-N+YuV;3{_s&8%`PR~UJD&YfjE9mP!E?ysJ%J=(@ZG8a$eYL zzr(+$8J}0>0RkD3AL9mlD)ou;3&|4kRnY-+T*+z8UOt7};knE+so^Q*2@Kjz%ZV3RNQN+^-0LrAEIEUB-`1{v+xw+txmjy*t zhJeQy(`tLt0suf(R4h>V8R^~GN6*buhvi@X;m8Ntj@@4zt_#2V!yVVuBOqv3>C%Yg z>H3({D^0N2{x@#HQoN%$HST3^#rlZ&p%wW9sVN8ze_j3od0#+3zPD)KegHhLHm+9i zn45pz)z0_4 z4Iyo76;*|yzaC|hf6CR##uGgEaa)WD*vYMLyR#GMZ8vP~YgGUQ;%>3f90aiOvp;d~a{xQ&UsFp_ z&LX{w3_RwTY8!4M5zb3AG?zpD&X%3tcnS#lh|=I!1HX{Z7~7d$1w=B?o%>@lM071n z;x>hLAfz$0{HTQF1H9}rp&{N-B7XU4zS_lxM7*rJ;P}$rMEuHn!8tr9iFlbnerxi+ z549^|Eds-jJi@#5bJocqRK6;BK6#37Ut8&=f_0$hg~&5OU?0Q9Yp$t@PDUWgY2pur zUJ~(jB_ZOTMDjf(LFYW4LjOBfrisY$M zxz{3R`5K@;al*d5f>57oVLM)k09Ql_)h-<&;>BZl!xy;{@jb`Pd4&o`adZ~ZPf{1r zZ_X~F&&q!hfv|p@1Jn}LI0517yd}ADV&O7XL zP!4$dMJPf!uofZAZL0~BP=r?a3J(eD0fA&`_wXOa5ol9VfAP?$_mWVr)?Gq5J7@?` zBNW=*(@&0vWh}P<0@>)IDk(dPQ@J5^OC$vVv@UODG62X>$d0P?(+Hi~GW^ppA9&77 zM~)x=767DspKVVpLI=g#RyBhseeAok=Xs9soJi$I`2zrugu1Uvz+?UN+lIDsU4+gY zulc+PBAO!ujb*hyAe#;v4+a5oMD~j9gYORu3}E}eL+HxJ3*TP=AU(y`sqSbSUMJA8{YO8C2=9Ar#py!`omV=lI|KmzF?MHN836Rr zN5x#3BM6lQd5$_1Bb0h;o3AktVNsQbjNN1M6jDk?6c9tl%EW{S4RW%D|9w}`Gr_>@ zwO&0q98o6Lo1mUGt21R&TEG!l)?{7_?`i0a+a2x%1k$S!rFIkuIYx0}5e7$q$O|Lr zOvLYO3sWaganbIlX)>?>xn2Ya1lOJ3wFlb$#J->&sDHCul|*?o5QkNefoCB?c_rJc ztqc&#J-B_oB+4d7OLiflQNlYZyoZn0kNk5L53a7AN$89yHi_PSyEHz3K8G5H&Vm@EdZrl zyiHgd0KmGs@9H3O*yqv7)d3O7$9qm~JsAPA`$XA@F%X2`p^pa11k>5=*G7QPpSG>p z^&3JX*)91EasXh--9dY+;Pdt&pFtp);kAeE9QptNDQF*G&${1txQCHFVW&HIx_q4;dmZlB}Wd_<3O=A!WO7fE>XOBgk3&8|e z0x=(r@{P=c$l$wx^Ii~9#9Lc0H?!`3415)&3W3QT+Sx_^L!RU*JY^ex(^AlPj(o37 zKM+WdYSv=V*Y$<5x`8^0aQZ@(dBIlztP*=aYyT0Ua~@~7uwc)#Cr<7;0quRPd*5*~ zP#=BNm|O!rF7GQ(Zby0Y*!xs4H0imsoEDnU;S?v{O<_mVn zNb|OF!5|cM&!@#x69_o9;zT(R+>z}KnN{$Na(np(nVL0f6lVX&8!|4~=?UF({7_b?!uh652d{pSP0WC!%Q-2fu`BxXDW zhEZqX zugU3?slIVA@M@PujRXUMM2*@sm;)dz^A;TAk0TKx9%#+s9mNr7YaO)3Maos5{U<2I z;U-MIscr7qa|2hNO3SRfO~&fHr42i1kqB+dYyTeGO0fmtfj^U!CKE`*t_XGVK9GhJ z5%T1XbmfGY^Wgx%4Li~>2><{?B6Yu20K$z}wXE5B0in~__Px6yk~r1Wmfi#&>!I&= zUa0Z|&()@p(2xB0Y;rNclUU+^YKc z%0=*fWZp-q07%7|!6x3p2x+-16wAu|^+Kt*`xYq%5FsTmu&g%({VVz*3AOqPap{>4>0I=NKPg;X#8`N%^U?7N)v<=_G#e+or{>?TSqP3&AmCAy> zJTHj&qP?D*91KCfd5IYEJs%aH#r8!2F;(Wq1!Kq;P|3w}V>$rPSA;AeA2OKc>io>+ z8bZ;^miNi`jA$jv<*e8Zgm-iGOCD<+!Fj&nY2Di-!ii<&2l5huF!xp!l|Y0!BGCLR zIceh9mL`Q-h;R=4SoK8-*rQ9gct!3B0PqZVUq|Q<0cqx*HYBlT!U^!Dp}xZ@3YF0N(RrhAvf9~7(B?LAAE;h0Pw1gg%;0Cz z6CQIV;0k!m-^TQl@6gUxaG9_H0Lkz4OmIv9U@HsuCPxVM$07^K$C+2jMI;57kT*hl zWjI3wuvSp+vdo#kUTGWRyybxo=o#i}q^tt~=HIKErU?-f=B8)B0uadLMD(ypLy&+P} zSMhl30QJaQ;yz|S2IcvJG}d9%d@oCnU#@6K1fVaz7%YwanoKmd7lP}!o zlj01rX795+tB4j|#|_Bb0L#*IBHNs3yeclXH1nh3w<(e*|XVg}{K6Ubx}b zYKTmHOteMU!0!VN>*cJ2kR?LHWWFxgGa+r8wFwYJ>MMtfTOra;EVOYpb%k=vt-Ot( z{t?eC3=MgKfI^K=>H`rfwl3qAyfHh4H7oy<1j2oj3eXOB>^Da(o$G_4L;wd=Xp7bl zB0Vol$V?JQnz~mXd9g8fSwOI7EdcXZev;%1rqc7gE<1yVnYGL}(2e}}oxWr405pk} z?q*I4U?7@U6V1;;NM9-1C43zQRGixNB{y&c;?LVhL{+iadp~TwFJMiZy2?I9UEIGp z7NK|j|Ju9um?*O=u0WaRH!p!12A7vEi@4(O5Lwg_5k(%3fPjej)>(?KrOL9FWyz+s zgc|BnLabHSMOV?)kr-lZOQ=%1wG-l6A%?od!3~%xOASTBT1t@V8SXhB&RDalU{aI$ z>*Rjl{mwo2ckeyto_o*zE;sn*Exa#b1{%5&eklw0OwNC|y4$PH+#Yz?t3$ruYS})N z*r|sByk5VkBD~T5oA%`uu~%$14vH=$S-aBTX3Mz{pRy#>X7kf2LnVz? z3q=71mHFrtMOKUPUUKtFsm*36(OsVh3VW+*#qbhnx1GmUb=$9&-Tov|zpN0R*R6QC z1Pn%=zy4lqjm@@kOZ?$DP@v%n!3P6cAM@uNV(Y_Jhm1V#Ej8vhWOsoA?c6eZ1GM`G zU*?I|15Q6VyQx3henHc%&8i&0_dredy>-y;1=mwO5_Q1;!qR~lE#P)@NFvWv90EaB-93c&Z@7A?Ns^&xgNGh85yWk#>J0-mOEoj%Q z#+VTu^sC%saoy2?O=M`ZNKMd ziY@pv#rv+GDZ1$EVL$}SE^@`fW~QKn#~w)HPsvP%26U;vCWTI(h$>Wg#@*VpM;ojV zO5V0w{5+I_l0l%?l;hHRt7Uez%E}!A+A}MTyKA+);WNu96T*A5O3!&%Et-D$De*O{ z#XCisE*P*{>fcW&Rdtx#DQp;*u0CfM>=fK&o>BCU?v47RT&I5p8oD}M+N%5Jt5vNE z^QV5aXVdv^W}VMatGht&-s&dq?N$GjD-o7jEk2JpAHjVnzed(00{Jw6#-3F?W?GuUNeH#}j zXa;JK)(hf+mP@+?V7S!9+-)Izr&TG=N(@$uZ@uD(BnzHf<$+?rq2XNKuG#hGc2%u7 z(xa$nk8iNNQXC8U%N2Jdp!j_&_C&q!^`;i;pY9Rn7Sh|Rk;w{0DyUzNG}aT^LtVvLh2W`ZYGnhW zN}yx%91*mGrcO30ssU=1mx+UcmdOobPsm>j^)3Lzv@$>X4Wqf;w@r~Jf#-fpm90ys)7DfryAvIfyz_`+zfc0uDocE+VZ`p*eCIU{Dbn_;ws?NB6}!m z0z5JLPEg}fB{GnsS*emV0PR;MNTB_-a~0+G?|o(R0x|Ga@8X(-IUt8v zy3KPO(ji=#5Xx5@xn^N5Ja6SRf~$aEx#X@Vw2RMuE>ZyPuMXx)gE;-c+opKa16 zK_=vTB#rm%2AU&j^8`G-9!hFFp?q(ZR3(6Rs$aEYP<0&oJ1)Jl{%-mg>+kP=$@+T~ z{>nt@TEcSC*TH~zmNA#vcLd|mORz&f#OS9~TC1h-!}GgW#mpKsw|{Xiwao_<;iaVX zBbt-uc2m%Lp)Ys`*uvmzhC^sP^xY*w_o`AnnT`c=5~G{p@&1B1bQC7WlL9U zJD6b$v7$?FVumDe2Xplkr7V8FxRDLS##{H6ozN3?Fw$cH$XzRk|mRzLIHshofQd%rYz z4CEv}BoF1s?=MH?glYSq!DFg;B0pYEl;64jbkNlDw}PyIZm732jwmO!&vdst)t}^= za(`z_%dWriy6Ed*Ks;*k2DEfG!=D$;I&`ugPsr|PhUDy@Xw8;xRHO44w1+__ZHdz6 zHig@gCqpwZejrVFJimxS&!QNYs(P5=@WU%Uhe(>aoV{M{Jl5A}I8-#Fl3_`g$%0;6C6;?LuN<@VjkAJ%40;?eg}ex%mz znS+vumotvf;fmqaJYVGV9AA7-`RQB_FCWpbclylk{4a7lmBaHPd7QrI@kBhP9Z!`1 zx%wlnFT|1B8~IIlyHov1t||BTiE$}%{f*Z}|Gy0gqi$nt#v>VL9auYx3VMJUl9WE? zk?gsP2MzziuHyXtWm@9u{i~tM%LoGnm!f!z1BW~q{#-}Y>V9Ry`O~EMAIyn=C^K(t zV{5=my4Xx?4qmLI9KyYtVvHIaV4g@o0ULOWx_Co^9tkaN(SRkxM;;2z1j!JRp?PVF z(PIyvW{i8^ndHyofaMZSga;Wq9zQxT>5StGaOL?DA1A(ieVq;Pv zk0;_WRXmB`_sPZM`XU@(Bu;i`lZksB z`M4KDH?j@zhJ(qc!9AO6yvIa_1U(XdX$$vAXtSN7w$K2cM+5Vec~<8humOH?38R<% zUXGqWflGc{k^ej%4_5AFMt}JM;_(j7M4vk1SNmfOQ~rv_k=W^6I@~&K~Jd%({p)4LLLb%ZP6YHZnjg@7KQ&}oP7s|2ghO1z!0MuLZk;@ zj;_0fYuN_$-0tvrP<%fN)6C_g%h*52Ch=o*ik z1CCVRwEM57-P1~Wxu&JR&phi=ST6cH7!W4%Xi&y+<{yI!`w4FD#o!6{{pbnk z(9jg&KYXsR0pdM?>9_IcaQI#^hz4rdamFPmaWWWVIFQOwzAjA1;rnBlzZB)Xiv#fr z@>gMb;V9>Aex}C^P8A;5GU0$;gVgwPRNap>9Qp6%@t|@Ujda9gR)Z6Mh?n;r9!Ez! zamMP6dqZ9qkk2Eeg^p=@5BZr~lk!n;0;6q?&-wBS9pxuJBp1&I6{C8uBOX)6)8Hhh z%t^->F8O}qOzwab+IdznjNxu}b}sEfMjOVR%TsM+_1<`re}00000 LNkvXXu0mjf%&PsO literal 0 HcmV?d00001 diff --git a/client/net/minecraftforge/client/EnumHelperClient.java b/client/net/minecraftforge/client/EnumHelperClient.java new file mode 100644 index 0000000000..dcb4719832 --- /dev/null +++ b/client/net/minecraftforge/client/EnumHelperClient.java @@ -0,0 +1,44 @@ +package net.minecraftforge.client; + +import net.minecraft.src.EnumGameType; +import net.minecraft.src.EnumOS; +import net.minecraft.src.EnumOptions; +import net.minecraft.src.EnumRarity; +import net.minecraftforge.common.EnumHelper; + +public class EnumHelperClient extends EnumHelper +{ + + private static Class[][] clentTypes = + { + {EnumGameType.class, int.class, String.class}, + {EnumOptions.class, String.class, boolean.class, boolean.class}, + {EnumOS.class}, + {EnumRarity.class, int.class, String.class} + }; + + public static EnumGameType addGameType(String name, int id, String displayName) + { + return addEnum(EnumGameType.class, name, id, displayName); + } + + public static EnumOptions addOptions(String name, String langName, boolean isSlider, boolean isToggle) + { + return addEnum(EnumOptions.class, name, langName, isSlider, isToggle); + } + + public static EnumOS addOS2(String name) + { + return addEnum(EnumOS.class, name); + } + + public static EnumRarity addRarity(String name, int color, String displayName) + { + return addEnum(EnumRarity.class, name, color, displayName); + } + + public static > T addEnum(Class enumType, String enumName, Object... paramValues) + { + return addEnum(clentTypes, enumType, enumName, paramValues); + } +} diff --git a/common/forge_at.cfg b/common/forge_at.cfg new file mode 100644 index 0000000000..07d03a580d --- /dev/null +++ b/common/forge_at.cfg @@ -0,0 +1,20 @@ +[ +{ + "modid" : "mod_MinecraftForge", + "name" : "Minecraft Forge", + "version" : "{version}", + "url" : "http://MinecraftForge.net", + "credits" : "Lots of people have contributed to MinecraftForge", + "authors": [ + "LexManos", + "Eloraam", + "Spacetoad" + ], + "description": "Minecraft Forge is a common open source API allowing a broad range of mods to work cooperatively together.\nIt allows many mods to be created without them editing the main Minecraft code.", + "logoFile" : "/forge_logo.png", + "updateUrl" : "http://minecraftforge.net/forum/index.php/topic,5.0.html", + "parent" : "", + "screenshots": [ + ] +} +] \ No newline at end of file diff --git a/common/net/minecraftforge/classloading/FMLForgePlugin.java b/common/net/minecraftforge/classloading/FMLForgePlugin.java new file mode 100644 index 0000000000..add70921ba --- /dev/null +++ b/common/net/minecraftforge/classloading/FMLForgePlugin.java @@ -0,0 +1,40 @@ +package net.minecraftforge.classloading; + +import java.util.Map; + +import cpw.mods.fml.relauncher.IFMLLoadingPlugin; + +public class FMLForgePlugin implements IFMLLoadingPlugin +{ + @Override + public String[] getLibraryRequestClass() + { + return null; + } + + @Override + public String[] getASMTransformerClass() + { + return new String[]{ + "net.minecraftforge.transformers.ForgeAccessTransformer", + "net.minecraftforge.transformers.EventTransformer" + }; + } + + @Override + public String getModContainerClass() + { + return "net.minecraftforge.common.ForgeDummyContainer"; + } + + @Override + public String getSetupClass() + { + return null; + } + + @Override + public void injectData(Map data) + { + } +} diff --git a/common/net/minecraftforge/common/EnumHelper.java b/common/net/minecraftforge/common/EnumHelper.java new file mode 100644 index 0000000000..b810c46303 --- /dev/null +++ b/common/net/minecraftforge/common/EnumHelper.java @@ -0,0 +1,239 @@ +package net.minecraftforge.common; + +import net.minecraft.src.*; +import java.lang.reflect.*; +import java.util.*; + +public class EnumHelper +{ + private static Object reflectionFactory = null; + private static Method newConstructorAccessor = null; + private static Method newInstance = null; + private static Method newFieldAccessor = null; + private static Method fieldAccessorSet = null; + private static boolean isSetup = false; + + //Some enums are decompiled with extra arguments, so lets check for that + private static Class[][] commonTypes = + { + {EnumAction.class}, + {EnumArmorMaterial.class, int.class, int[].class, int.class}, + {EnumArt.class, String.class, int.class, int.class, int.class, int.class}, + {EnumCreatureAttribute.class}, + {EnumCreatureType.class, Class.class, int.class, Material.class, boolean.class}, + {EnumDoor.class}, + {EnumEnchantmentType.class}, + {EnumEntitySize.class}, + {EnumMobType.class}, + {EnumMovingObjectType.class}, + {EnumSkyBlock.class, int.class}, + {EnumStatus.class}, + {EnumToolMaterial.class, int.class, int.class, float.class, int.class, int.class} + }; + + public static EnumAction addAction(String name) + { + return addEnum(EnumAction.class, name); + } + public static EnumArmorMaterial addArmorMaterial(String name, int durability, int[] reductionAmounts, int enchantability) + { + return addEnum(EnumArmorMaterial.class, name, durability, reductionAmounts, enchantability); + } + public static EnumArt addArt(String name, String tile, int sizeX, int sizeY, int offsetX, int offsetY) + { + return addEnum(EnumArt.class, name, tile, sizeX, sizeY, offsetX, offsetY); + } + public static EnumCreatureAttribute addCreatureAttribute(String name) + { + return addEnum(EnumCreatureAttribute.class, name); + } + public static EnumCreatureType addCreatureType(String name, Class typeClass, int maxNumber, Material material, boolean peaceful) + { + return addEnum(EnumCreatureType.class, name, typeClass, maxNumber, material, peaceful); + } + public static EnumDoor addDoor(String name) + { + return addEnum(EnumDoor.class, name); + } + public static EnumEnchantmentType addEnchantmentType(String name) + { + return addEnum(EnumEnchantmentType.class, name); + } + public static EnumEntitySize addEntitySize(String name) + { + return addEnum(EnumEntitySize.class, name); + } + public static EnumMobType addMobType(String name) + { + return addEnum(EnumMobType.class, name); + } + public static EnumMovingObjectType addMovingObjectType(String name) + { + if (!isSetup) + { + setup(); + } + + return addEnum(EnumMovingObjectType.class, name); + } + public static EnumSkyBlock addSkyBlock(String name, int lightValue) + { + return addEnum(EnumSkyBlock.class, name, lightValue); + } + public static EnumStatus addStatus(String name) + { + return addEnum(EnumStatus.class, name); + } + public static EnumToolMaterial addToolMaterial(String name, int harvestLevel, int maxUses, float efficiency, int damage, int enchantability) + { + return addEnum(EnumToolMaterial.class, name, harvestLevel, maxUses, efficiency, damage, enchantability); + } + + private static void setup() + { + if (isSetup) + { + return; + } + + try + { + Method getReflectionFactory = Class.forName("sun.reflect.ReflectionFactory").getDeclaredMethod("getReflectionFactory"); + reflectionFactory = getReflectionFactory.invoke(null); + newConstructorAccessor = Class.forName("sun.reflect.ReflectionFactory").getDeclaredMethod("newConstructorAccessor", Constructor.class); + newInstance = Class.forName("sun.reflect.ConstructorAccessor").getDeclaredMethod("newInstance", Object[].class); + newFieldAccessor = Class.forName("sun.reflect.ReflectionFactory").getDeclaredMethod("newFieldAccessor", Field.class, boolean.class); + fieldAccessorSet = Class.forName("sun.reflect.FieldAccessor").getDeclaredMethod("set", Object.class, Object.class); + } + catch (Exception e) + { + e.printStackTrace(); + } + + isSetup = true; + } + + /* + * Everything below this is found at the site below, and updated to be able to compile in Eclipse/Java 1.6+ + * Also modified for use in decompiled code. + * Found at: http://niceideas.ch/roller2/badtrash/entry/java_create_enum_instances_dynamically + */ + private static Object getConstructorAccessor(Class enumClass, Class[] additionalParameterTypes) throws Exception + { + Class[] parameterTypes = new Class[additionalParameterTypes.length + 2]; + parameterTypes[0] = String.class; + parameterTypes[1] = int.class; + System.arraycopy(additionalParameterTypes, 0, parameterTypes, 2, additionalParameterTypes.length); + return newConstructorAccessor.invoke(reflectionFactory, enumClass.getDeclaredConstructor(parameterTypes)); + } + + private static < T extends Enum> T makeEnum(Class enumClass, String value, int ordinal, Class[] additionalTypes, Object[] additionalValues) throws Exception + { + Object[] parms = new Object[additionalValues.length + 2]; + parms[0] = value; + parms[1] = Integer.valueOf(ordinal); + System.arraycopy(additionalValues, 0, parms, 2, additionalValues.length); + return enumClass.cast(newInstance.invoke(getConstructorAccessor(enumClass, additionalTypes), new Object[] {parms})); + } + + public static void setFailsafeFieldValue(Field field, Object target, Object value) throws Exception + { + field.setAccessible(true); + Field modifiersField = Field.class.getDeclaredField("modifiers"); + modifiersField.setAccessible(true); + modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL); + Object fieldAccessor = newFieldAccessor.invoke(reflectionFactory, field, false); + fieldAccessorSet.invoke(fieldAccessor, target, value); + } + + private static void blankField(Class enumClass, String fieldName) throws Exception + { + for (Field field : Class.class.getDeclaredFields()) + { + if (field.getName().contains(fieldName)) + { + field.setAccessible(true); + setFailsafeFieldValue(field, enumClass, null); + break; + } + } + } + + private static void cleanEnumCache(Class enumClass) throws Exception + { + blankField(enumClass, "enumConstantDirectory"); + blankField(enumClass, "enumConstants"); + } + + public static > T addEnum(Class enumType, String enumName, Object... paramValues) + { + return addEnum(commonTypes, enumType, enumName, paramValues); + } + + public static > T addEnum(Class[][] map, Class enumType, String enumName, Object... paramValues) + { + for (Class[] lookup : map) + { + if (lookup[0] == enumType) + { + Class[] paramTypes = new Class[lookup.length - 1]; + if (paramTypes.length > 0) + { + System.arraycopy(lookup, 1, paramTypes, 0, paramTypes.length); + } + return addEnum(enumType, enumName, paramTypes, paramValues); + } + } + return null; + } + + @SuppressWarnings("unchecked") + public static > T addEnum(Class enumType, String enumName, Class[] paramTypes, Object[] paramValues) + { + if (!isSetup) + { + setup(); + } + + Field valuesField = null; + Field[] fields = enumType.getDeclaredFields(); + int flags = Modifier.PRIVATE | Modifier.STATIC | Modifier.FINAL | 0x1000 /*SYNTHETIC*/; + String valueType = String.format("[L%s;", enumType.getName().replace('.', '/')); + + for (Field field : fields) + { + if ((field.getModifiers() & flags) == flags && + field.getType().getName().replace('.', '/').equals(valueType)) //Apparently some JVMs return .'s and some don't.. + { + valuesField = field; + break; + } + } + valuesField.setAccessible(true); + + try + { + T[] previousValues = (T[])valuesField.get(enumType); + List values = new ArrayList(Arrays.asList(previousValues)); + T newValue = (T)makeEnum(enumType, enumName, values.size(), paramTypes, paramValues); + values.add(newValue); + setFailsafeFieldValue(valuesField, null, values.toArray((T[]) Array.newInstance(enumType, 0))); + cleanEnumCache(enumType); + + return newValue; + } + catch (Exception e) + { + e.printStackTrace(); + throw new RuntimeException(e.getMessage(), e); + } + } + + static + { + if (!isSetup) + { + setup(); + } + } +} \ No newline at end of file diff --git a/common/net/minecraftforge/common/ForgeDummyContainer.java b/common/net/minecraftforge/common/ForgeDummyContainer.java new file mode 100644 index 0000000000..22be4b0d9f --- /dev/null +++ b/common/net/minecraftforge/common/ForgeDummyContainer.java @@ -0,0 +1,39 @@ +package net.minecraftforge.common; + +import java.util.Arrays; + +import com.google.common.eventbus.EventBus; + +import cpw.mods.fml.common.DummyModContainer; +import cpw.mods.fml.common.LoadController; +import cpw.mods.fml.common.Loader; +import cpw.mods.fml.common.ModMetadata; + +import static net.minecraftforge.common.ForgeVersion.*; + +public class ForgeDummyContainer extends DummyModContainer +{ + public ForgeDummyContainer() + { + super(new ModMetadata()); + ModMetadata meta = getMetadata(); + meta.modId = "Forge"; + meta.name = "Minecraft Forge"; + meta.version = String.format("%d.%d.%d.%d", majorVersion, minorVersion, revisionVersion, buildVersion); + meta.credits = "Made possible with help from many people"; + meta.authorList = Arrays.asList("LexManos", "Eloraam", "Spacetoad"); + meta.description = "Minecraft Forge is a common open source API allowing a broad range of mods " + + "to work cooperatively together. It allows many mods to be created without " + + "them editing the main Minecraft code."; + meta.url = "http://MinecraftForge.net"; + meta.updateUrl = "http://MinecraftForge.net/forum/index.php/topic,5.0.html"; + meta.screenshots = new String[0]; + meta.logoFile = "/forge_logo.png"; + } + + @Override + public boolean registerBus(EventBus bus, LoadController controller) + { + return true; + } +} diff --git a/common/net/minecraftforge/common/ForgeVersion.java b/common/net/minecraftforge/common/ForgeVersion.java new file mode 100644 index 0000000000..caf1574ece --- /dev/null +++ b/common/net/minecraftforge/common/ForgeVersion.java @@ -0,0 +1,44 @@ +/** + * This software is provided under the terms of the Minecraft Forge Public + * License v1.0. + */ + +package net.minecraftforge.common; + +public class ForgeVersion +{ + //This number is incremented every Minecraft version, and never reset + public static final int majorVersion = 4; + //This number is incremented every official release, and reset every Minecraft version + public static final int minorVersion = 0; + //This number is incremented every time a interface changes, and reset every Minecraft version + public static final int revisionVersion = 0; + //This number is incremented every time Jenkins builds Forge, and never reset. Should always be 0 in the repo code. + public static final int buildVersion = 0; + + public static int getMajorVersion() + { + return majorVersion; + } + + public static int getMinorVersion() + { + return minorVersion; + } + + public static int getRevisionVersion() + { + return revisionVersion; + } + + public static int getBuildVersion() + { + return buildVersion; + } + + public static String getVersion() + { + return String.format("%d.%d.%d.%d", majorVersion, minorVersion, revisionVersion, buildVersion); + } +} + diff --git a/common/net/minecraftforge/common/MinecraftForge.java b/common/net/minecraftforge/common/MinecraftForge.java new file mode 100644 index 0000000000..f576a29486 --- /dev/null +++ b/common/net/minecraftforge/common/MinecraftForge.java @@ -0,0 +1,8 @@ +package net.minecraftforge.common; + +import net.minecraftforge.event.EventBus; + +public class MinecraftForge +{ + public static final EventBus eventBus = new EventBus(); +} diff --git a/common/net/minecraftforge/event/ASMEventHandler.java b/common/net/minecraftforge/event/ASMEventHandler.java new file mode 100644 index 0000000000..fdddb3993e --- /dev/null +++ b/common/net/minecraftforge/event/ASMEventHandler.java @@ -0,0 +1,119 @@ +package net.minecraftforge.event; + +import static org.objectweb.asm.Opcodes.*; + +import java.lang.reflect.Method; + + +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Type; + + +public class ASMEventHandler implements IEventListener +{ + private static int IDs = 0; + private static final String HANDLER_DESC = Type.getInternalName(IEventListener.class); + private static final String HANDLER_FUNC_DESC = Type.getMethodDescriptor(IEventListener.class.getDeclaredMethods()[0]); + private static final ASMClassLoader LOADER = new ASMClassLoader(); + + private final IEventListener handler; + private final ForgeSubscribe subInfo; + public ASMEventHandler(Object target, Method method) throws Exception + { + handler = (IEventListener)createWrapper(method).getConstructor(Object.class).newInstance(target); + subInfo = method.getAnnotation(ForgeSubscribe.class); + } + + @Override + public void invoke(Event event) + { + if (handler != null) + { + if (!event.isCancelable() || !event.isCanceled() || subInfo.receiveCanceled()) + { + handler.invoke(event); + } + } + } + + public EventPriority getPriority() + { + return subInfo.priority(); + } + + public Class createWrapper(Method callback) + { + ClassWriter cw = new ClassWriter(0); + MethodVisitor mv; + + String name = getUniqueName(callback); + String desc = name.replace('.', '/'); + String instType = Type.getInternalName(callback.getDeclaringClass()); + String eventType = Type.getInternalName(callback.getParameterTypes()[0]); + + /* + System.out.println("Name: " + name); + System.out.println("Desc: " + desc); + System.out.println("InstType: " + instType); + System.out.println("Callback: " + callback.getName() + Type.getMethodDescriptor(callback)); + System.out.println("Event: " + eventType); + */ + + cw.visit(V1_6, ACC_PUBLIC | ACC_SUPER, desc, null, "java/lang/Object", new String[]{ HANDLER_DESC }); + + cw.visitSource(".dynamic", null); + { + cw.visitField(ACC_PUBLIC, "instance", "Ljava/lang/Object;", null, null).visitEnd(); + } + { + mv = cw.visitMethod(ACC_PUBLIC, "", "(Ljava/lang/Object;)V", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "", "()V"); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 1); + mv.visitFieldInsn(PUTFIELD, desc, "instance", "Ljava/lang/Object;"); + mv.visitInsn(RETURN); + mv.visitMaxs(2, 2); + mv.visitEnd(); + } + { + mv = cw.visitMethod(ACC_PUBLIC, "invoke", HANDLER_FUNC_DESC, null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, desc, "instance", "Ljava/lang/Object;"); + mv.visitTypeInsn(CHECKCAST, instType); + mv.visitVarInsn(ALOAD, 1); + mv.visitTypeInsn(CHECKCAST, eventType); + mv.visitMethodInsn(INVOKEVIRTUAL, instType, callback.getName(), Type.getMethodDescriptor(callback)); + mv.visitInsn(RETURN); + mv.visitMaxs(2, 2); + mv.visitEnd(); + } + cw.visitEnd(); + return LOADER.define(name, cw.toByteArray()); + } + + private String getUniqueName(Method callback) + { + return String.format("%s_%d_%s_%s_%s", getClass().getName(), IDs++, + callback.getDeclaringClass().getSimpleName(), + callback.getName(), + callback.getParameterTypes()[0].getSimpleName()); + } + + private static class ASMClassLoader extends ClassLoader + { + private ASMClassLoader() + { + super(ASMClassLoader.class.getClassLoader()); + } + + public Class define(String name, byte[] data) + { + return defineClass(name, data, 0, data.length); + } + } + +} diff --git a/common/net/minecraftforge/event/Event.java b/common/net/minecraftforge/event/Event.java new file mode 100644 index 0000000000..ca41c22fad --- /dev/null +++ b/common/net/minecraftforge/event/Event.java @@ -0,0 +1,70 @@ +package net.minecraftforge.event; + + +/** + * Base Event class that all other events are derived from + */ +public class Event +{ + private boolean isCanceled = false; + private static ListenerList listeners = new ListenerList(); + + public Event() + { + setup(); + } + + /** + * Determine if this function is cancelable at all. + * @return If access to setCanceled should be allowed + */ + public boolean isCancelable() + { + return false; + } + + /** + * Determine if this event is canceled and should stop executing. + * @return The current canceled state + */ + public boolean isCanceled() + { + return isCanceled; + } + + /** + * Sets the state of this event, not all events are cancelable, and any attempt to + * cancel a event that can't be will result in a IllegalArgumentException. + * + * The functionality of setting the canceled state is defined on a per-event bases. + * + * @param cancel The new canceled value + */ + public void setCanceled(boolean cancel) + { + if (!isCancelable()) + { + throw new IllegalArgumentException("Attempted to cancel a uncancelable event"); + } + isCanceled = cancel; + } + + /** + * Called by the base constructor, this is used by ASM generated + * event classes to setup various functionality such as the listener's list. + */ + protected void setup() + { + } + + /** + * Returns a ListenerList object that contains all listeners + * that are registered to this event. + * + * @return Listener List + */ + public ListenerList getListenerList() + { + return listeners; + } +} diff --git a/common/net/minecraftforge/event/EventBus.java b/common/net/minecraftforge/event/EventBus.java new file mode 100644 index 0000000000..2855a8372f --- /dev/null +++ b/common/net/minecraftforge/event/EventBus.java @@ -0,0 +1,103 @@ +package net.minecraftforge.event; + +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; + + + +import com.google.common.reflect.TypeToken; + +public class EventBus +{ + private static int maxID = 0; + + private ConcurrentHashMap> listeners = new ConcurrentHashMap>(); + private final int busID = maxID++; + + public EventBus() + { + ListenerList.resize(busID + 1); + } + + public void register(Object target) + { + Set> supers = TypeToken.of(target.getClass()).getTypes().rawTypes(); + for (Method method : target.getClass().getMethods()) + { + for (Class cls : supers) + { + try + { + Method real = cls.getDeclaredMethod(method.getName(), method.getParameterTypes()); + if (real.isAnnotationPresent(ForgeSubscribe.class)) + { + Class[] parameterTypes = method.getParameterTypes(); + if (parameterTypes.length != 1) + { + throw new IllegalArgumentException( + "Method " + method + " has @ForgeSubscribe annotation, but requires " + parameterTypes.length + + " arguments. Event handler methods must require a single argument." + ); + } + + Class eventType = parameterTypes[0]; + + if (!Event.class.isAssignableFrom(eventType)) + { + throw new IllegalArgumentException("Method " + method + " has @ForgeSubscribe annotation, but takes a argument that is not a Event " + eventType); + } + + register(eventType, target, method); + break; + } + } + catch (NoSuchMethodException e) + { + ; + } + } + } + } + + private void register(Class eventType, Object target, Method method) + { + try + { + Event event = (Event)eventType.newInstance(); + ASMEventHandler listener = new ASMEventHandler(target, method); + event.getListenerList().register(busID, listener.getPriority(), listener); + + ArrayList others = listeners.get(target); + if (others == null) + { + others = new ArrayList(); + listeners.put(target, others); + } + others.add(listener); + } + catch (Exception e) + { + e.printStackTrace(); + } + } + + public void unregister(Object object) + { + ArrayList list = listeners.remove(object); + for (IEventListener listener : list) + { + ListenerList.unregiterAll(busID, listener); + } + } + + public void post(Event event) + { + IEventListener[] listeners = event.getListenerList().getListeners(busID); + for (IEventListener listener : listeners) + { + listener.invoke(event); + } + } +} diff --git a/common/net/minecraftforge/event/EventPriority.java b/common/net/minecraftforge/event/EventPriority.java new file mode 100644 index 0000000000..74302900c6 --- /dev/null +++ b/common/net/minecraftforge/event/EventPriority.java @@ -0,0 +1,16 @@ +package net.minecraftforge.event; + +public enum EventPriority +{ + /*Priority of event listeners, listeners will be sorted with respect to this priority level. + * + * Note: + * Due to using a ArrayList in the ListenerList, + * these need to stay in a contiguous index starting at 0. {Default ordinal} + */ + HIGHEST, //First to execute + HIGH, + NORMAL, + LOW, + LOWEST //Last to execute +} diff --git a/common/net/minecraftforge/event/ForgeSubscribe.java b/common/net/minecraftforge/event/ForgeSubscribe.java new file mode 100644 index 0000000000..0a5ffd8c55 --- /dev/null +++ b/common/net/minecraftforge/event/ForgeSubscribe.java @@ -0,0 +1,15 @@ +package net.minecraftforge.event; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +import static java.lang.annotation.RetentionPolicy.*; +import static java.lang.annotation.ElementType.*; + +@Retention(value = RUNTIME) +@Target(value = METHOD) +public @interface ForgeSubscribe +{ + public EventPriority priority() default EventPriority.NORMAL; + public boolean receiveCanceled() default false; +} diff --git a/common/net/minecraftforge/event/IEventListener.java b/common/net/minecraftforge/event/IEventListener.java new file mode 100644 index 0000000000..9fdd7f481f --- /dev/null +++ b/common/net/minecraftforge/event/IEventListener.java @@ -0,0 +1,8 @@ +package net.minecraftforge.event; + + + +public interface IEventListener +{ + public void invoke(Event event); +} diff --git a/common/net/minecraftforge/event/ListenerList.java b/common/net/minecraftforge/event/ListenerList.java new file mode 100644 index 0000000000..b88a4c86e7 --- /dev/null +++ b/common/net/minecraftforge/event/ListenerList.java @@ -0,0 +1,211 @@ +package net.minecraftforge.event; + +import java.util.*; + + +public class ListenerList +{ + private static ArrayList allLists = new ArrayList(); + private static int maxSize = 0; + + private ListenerList parent; + private ListenerListInst[] lists = new ListenerListInst[0]; + + public ListenerList() + { + allLists.add(this); + resizeLists(maxSize); + } + + public ListenerList(ListenerList parent) + { + allLists.add(this); + this.parent = parent; + resizeLists(maxSize); + } + + public static void resize(int max) + { + if (max <= maxSize) + { + return; + } + for (ListenerList list : allLists) + { + list.resizeLists(max); + } + maxSize = max; + } + + public void resizeLists(int max) + { + if (parent != null) + { + parent.resizeLists(max); + } + + if (lists.length >= max) + { + return; + } + + ListenerListInst[] newList = new ListenerListInst[max]; + int x = 0; + for (; x < lists.length; x++) + { + newList[x] = lists[x]; + } + for(; x < max; x++) + { + if (parent != null) + { + newList[x] = new ListenerListInst(parent.getInstance(x)); + } + else + { + newList[x] = new ListenerListInst(); + } + } + lists = newList; + } + + public static void clearBusID(int id) + { + for (ListenerList list : allLists) + { + list.lists[id].dispose(); + } + } + + protected ListenerListInst getInstance(int id) + { + return lists[id]; + } + + public IEventListener[] getListeners(int id) + { + return lists[id].getListeners(); + } + + public void register(int id, EventPriority priority, IEventListener listener) + { + lists[id].register(priority, listener); + } + + public void unregister(int id, IEventListener listener) + { + lists[id].unregister(listener); + } + + public static void unregiterAll(int id, IEventListener listener) + { + for (ListenerList list : allLists) + { + list.unregister(id, listener); + } + } + + private class ListenerListInst + { + private boolean rebuild = true; + private IEventListener[] listeners; + private ArrayList> priorities; + private ListenerListInst parent; + + private ListenerListInst() + { + int count = EventPriority.values().length; + priorities = new ArrayList>(count); + + for (int x = 0; x < count; x++) + { + priorities.add(new ArrayList()); + } + } + + public void dispose() + { + for (ArrayList listeners : priorities) + { + listeners.clear(); + } + priorities.clear(); + parent = null; + listeners = null; + } + + private ListenerListInst(ListenerListInst parent) + { + this(); + this.parent = parent; + } + + /** + * Returns a ArrayList containing all listeners for this event, + * and all parent events for the specified priority. + * + * The list is returned with the listeners for the children events first. + * + * @param priority The Priority to get + * @return ArrayList containing listeners + */ + public ArrayList getListeners(EventPriority priority) + { + ArrayList ret = new ArrayList(priorities.get(priority.ordinal())); + if (parent != null) + { + ret.addAll(parent.getListeners(priority)); + } + return ret; + } + + /** + * Returns a full list of all listeners for all priority levels. + * Including all parent listeners. + * + * List is returned in proper priority order. + * + * Automatically rebuilds the internal Array cache if its information is out of date. + * + * @return Array containing listeners + */ + public IEventListener[] getListeners() + { + if (shouldRebuild()) buildCache(); + return listeners; + } + + protected boolean shouldRebuild() + { + return rebuild || (parent != null && parent.shouldRebuild()); + } + + /** + * Rebuild the local Array of listeners, returns early if there is no work to do. + */ + private void buildCache() + { + ArrayList ret = new ArrayList(); + for (EventPriority value : EventPriority.values()) + { + ret.addAll(getListeners(value)); + } + listeners = ret.toArray(new IEventListener[0]); + rebuild = false; + } + + public void register(EventPriority priority, IEventListener listener) + { + priorities.get(priority.ordinal()).add(listener); + rebuild = true; + } + + public void unregister(IEventListener listener) + { + for(ArrayList list : priorities) + { + list.remove(listener); + } + } + } +} diff --git a/common/net/minecraftforge/transformers/EventTransformer.java b/common/net/minecraftforge/transformers/EventTransformer.java new file mode 100644 index 0000000000..07b5cf8f92 --- /dev/null +++ b/common/net/minecraftforge/transformers/EventTransformer.java @@ -0,0 +1,132 @@ +package net.minecraftforge.transformers; + +import java.util.List; + +import net.minecraftforge.event.Event; +import net.minecraftforge.event.ListenerList; + +import org.objectweb.asm.*; +import org.objectweb.asm.tree.*; +import static org.objectweb.asm.Opcodes.*; +import static org.objectweb.asm.Type.*; +import static org.objectweb.asm.ClassWriter.*; + +import cpw.mods.fml.relauncher.IClassTransformer; + +public class EventTransformer implements IClassTransformer +{ + public EventTransformer() + { + } + + @Override + public byte[] transform(String name, byte[] bytes) + { + ClassReader cr = new ClassReader(bytes); + ClassNode classNode = new ClassNode(); + cr.accept(classNode, 0); + + try + { + buildEvents(classNode); + } + catch (Exception e) + { + e.printStackTrace(); + } + + ClassWriter cw = new ClassWriter(COMPUTE_MAXS | COMPUTE_FRAMES); + classNode.accept(cw); + + return cw.toByteArray(); + } + + @SuppressWarnings("unchecked") + private void buildEvents(ClassNode classNode) throws Exception + { + Class parent = Class.forName(classNode.superName.replace('/', '.')); + if (!Event.class.isAssignableFrom(parent)) + { + return; + } + + boolean hasSetup = false; + boolean hasGetListenerList = false; + + Type tList = Type.getType(ListenerList.class); + + for (MethodNode method : (List)classNode.methods) + { + if (method.name.equals("setup") && + method.desc.equals(Type.getMethodDescriptor(VOID_TYPE)) && + (method.access & ACC_PROTECTED) == ACC_PROTECTED) + { + hasSetup = true; + } + if (method.name.equals("getListenerList") && + method.desc.equals(Type.getMethodDescriptor(tList)) && + (method.access & ACC_PUBLIC) == ACC_PUBLIC) + { + hasGetListenerList = true; + } + } + + if (hasSetup) + { + if (!hasGetListenerList) + { + throw new RuntimeException("Event class defines setup() but does not define getListenerList! " + classNode.name); + } + else + { + return; + } + } + + Type tSuper = Type.getType(classNode.superName); + + //Add private static ListenerList LISTENER_LIST + classNode.fields.add(new FieldNode(ACC_PRIVATE | ACC_STATIC, "LISTENER_LIST", tList.getDescriptor(), null, null)); + + /*Add: + * protected void setup() + * { + * super.setup(); + * if (LISTENER_LIST != NULL) + * { + * return; + * } + * LISTENER_LIST = new ListenerList(super.getListenerList()); + * } + */ + MethodNode method = new MethodNode(ASM4, ACC_PROTECTED, "setup", getMethodDescriptor(VOID_TYPE), null, null); + method.instructions.add(new VarInsnNode(ALOAD, 0)); + method.instructions.add(new MethodInsnNode(INVOKESPECIAL, tSuper.getInternalName(), "setup", getMethodDescriptor(VOID_TYPE))); + method.instructions.add(new FieldInsnNode(GETSTATIC, classNode.name, "LISTENER_LIST", tList.getDescriptor())); + LabelNode initLisitener = new LabelNode(); + method.instructions.add(new JumpInsnNode(IFNULL, initLisitener)); + method.instructions.add(new InsnNode(RETURN)); + method.instructions.add(initLisitener); + method.instructions.add(new FrameNode(F_SAME, 0, null, 0, null)); + method.instructions.add(new TypeInsnNode(NEW, tList.getInternalName())); + method.instructions.add(new InsnNode(DUP)); + method.instructions.add(new VarInsnNode(ALOAD, 0)); + method.instructions.add(new MethodInsnNode(INVOKESPECIAL, tSuper.getInternalName(), "getListenerList", getMethodDescriptor(tList))); + method.instructions.add(new MethodInsnNode(INVOKESPECIAL, tList.getInternalName(), "", getMethodDescriptor(VOID_TYPE, tList))); + method.instructions.add(new FieldInsnNode(PUTSTATIC, classNode.name, "LISTENER_LIST", tList.getDescriptor())); + method.instructions.add(new InsnNode(RETURN)); + classNode.methods.add(method); + + /*Add: + * public ListenerList getListenerList() + * { + * return this.LISTENER_LIST; + * } + */ + method = new MethodNode(ASM4, ACC_PUBLIC, "getListenerList", getMethodDescriptor(tList), null, null); + method.instructions.add(new FieldInsnNode(GETSTATIC, classNode.name, "LISTENER_LIST", tList.getDescriptor())); + method.instructions.add(new InsnNode(ARETURN)); + classNode.methods.add(method); + } + +} diff --git a/common/net/minecraftforge/transformers/ForgeAccessTransformer.java b/common/net/minecraftforge/transformers/ForgeAccessTransformer.java new file mode 100644 index 0000000000..810d950069 --- /dev/null +++ b/common/net/minecraftforge/transformers/ForgeAccessTransformer.java @@ -0,0 +1,13 @@ +package net.minecraftforge.transformers; + +import java.io.IOException; + +import cpw.mods.fml.common.asm.transformers.AccessTransformer; + +public class ForgeAccessTransformer extends AccessTransformer +{ + public ForgeAccessTransformer() throws IOException + { + super("forge_at.cfg"); + } +} diff --git a/forge_client/src/net/minecraft/src/forge/EnumHelperClient.java b/forge_client/src/net/minecraft/src/forge/EnumHelperClient.java deleted file mode 100644 index e552428461..0000000000 --- a/forge_client/src/net/minecraft/src/forge/EnumHelperClient.java +++ /dev/null @@ -1,106 +0,0 @@ -package net.minecraft.src.forge; - -import argo.jdom.JsonNodeType; -import net.minecraft.src.EnumOS2; -import net.minecraft.src.EnumOptions; -import net.minecraft.src.EnumRarity; - -public class EnumHelperClient extends EnumHelper -{ - - private static Class[][] ctrs = - { - {JsonNodeType.class}, - {EnumOptions.class, String.class, boolean.class, boolean.class}, - {EnumOS2.class}, - {EnumRarity.class, int.class, String.class} - }; - - private static boolean[] decompiled = new boolean[ctrs.length]; - private static boolean isSetup = false; - - public static JsonNodeType addJsonNodeType(String name) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiled[0], JsonNodeType.class, name, - new Class[] {}, - new Object[] {}); - } - public static EnumOptions addOptions(String name, String langName, boolean isSlider, boolean isToggle) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiled[1], EnumOptions.class, name, - new Class[] {String.class, boolean.class, boolean.class}, - new Object[]{langName, isSlider, isToggle }); - } - public static EnumOS2 addOS2(String name) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiled[2], EnumOS2.class, name, - new Class[] {}, - new Object[]{}); - } - public static EnumRarity addRarity(String name, int color, String displayName) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiled[3], EnumRarity.class, name, - new Class[] {int.class, String.class}, - new Object[]{color, displayName }); - } - - private static void setup() - { - //System.out.println("Enum Helper Initalizing: "); - for (int x = 0; x < ctrs.length; x++) - { - try - { - Class[] enumHeaders = new Class[ctrs[x].length + 3]; - enumHeaders[0] = String.class; - enumHeaders[1] = int.class; - enumHeaders[2] = String.class; - enumHeaders[3] = int.class; - - for (int y = 1; y < ctrs[x].length; y++) - { - enumHeaders[3 + y] = ctrs[x][y]; - } - - ctrs[x][0].getDeclaredConstructor(enumHeaders); - decompiled[x] = true; - - } - catch (Exception e) - { - //Nom Nom Nom - } - //System.out.format("\t%-25s %s\r\n", ctrs[x][0].getName().replace("net.minecraft.src.", ""), decompiled[x]); - } - isSetup = true; - } - - static - { - if (!isSetup) - { - setup(); - } - } - -} diff --git a/forge_common/net/minecraft/src/forge/EnumHelper.java b/forge_common/net/minecraft/src/forge/EnumHelper.java deleted file mode 100644 index 1b1e341fed..0000000000 --- a/forge_common/net/minecraft/src/forge/EnumHelper.java +++ /dev/null @@ -1,366 +0,0 @@ -package net.minecraft.src.forge; - -import net.minecraft.src.*; -import java.lang.reflect.*; -import java.util.*; - -public class EnumHelper -{ - private static Object reflectionFactory = null; - private static Method newConstructorAccessor = null; - private static Method newInstance = null; - private static Method newFieldAccessor = null; - private static Method fieldAccessorSet = null; - private static boolean isSetup = false; - - //Some enums are decompiled with extra arguments, so lets check for that - private static Class[][] ctrs = - { - {EnumAction.class}, - {EnumArmorMaterial.class, int.class, int[].class, int.class}, - {EnumArt.class, String.class, int.class, int.class, int.class, int.class}, - {EnumCreatureAttribute.class}, - {EnumCreatureType.class, Class.class, int.class, Material.class, boolean.class}, - {EnumDoor.class}, - {EnumEnchantmentType.class}, - {EnumMobType.class}, - {EnumMovingObjectType.class}, - {EnumSkyBlock.class, int.class}, - {EnumStatus.class}, - {EnumToolMaterial.class, int.class, int.class, float.class, int.class, int.class} - }; - - private static boolean[] decompiledFlags = new boolean[ctrs.length]; - - public static EnumAction addAction(String name) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[0], EnumAction.class, name, - new Class[] {}, - new Object[]{}); - } - public static EnumArmorMaterial addArmorMaterial(String name, int durability, int[] reductionAmounts, int enchantability) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[1], EnumArmorMaterial.class, name, - new Class[] { int.class, int[].class, int.class }, - new Object[]{ durability, reductionAmounts, enchantability }); - } - public static EnumArt addArt(String name, String tile, int sizeX, int sizeY, int offsetX, int offsetY) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[2], EnumArt.class, name, - new Class[] {String.class, int.class, int.class, int.class, int.class}, - new Object[]{tile, sizeX, sizeY, offsetX, offsetY}); - } - public static EnumCreatureAttribute addCreatureAttribute(String name) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[3], EnumCreatureAttribute.class, name, - new Class[] {}, - new Object[]{}); - } - public static EnumCreatureType addCreatureType(String name, Class typeClass, int maxNumber, Material material, boolean peaceful) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[4], EnumCreatureType.class, name, - new Class[] {Class.class, int.class, Material.class, boolean.class}, - new Object[]{typeClass, maxNumber, material, peaceful}); - } - public static EnumDoor addDoor(String name) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[5], EnumDoor.class, name, - new Class[] {}, - new Object[]{}); - } - public static EnumEnchantmentType addEnchantmentType(String name) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[6], EnumEnchantmentType.class, name, - new Class[] {}, - new Object[]{}); - } - public static EnumMobType addMobType(String name) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[7], EnumMobType.class, name, - new Class[] {}, - new Object[]{}); - } - public static EnumMovingObjectType addMovingObjectType(String name) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[8], EnumMovingObjectType.class, name, - new Class[] {}, - new Object[]{}); - } - public static EnumSkyBlock addSkyBlock(String name, int lightValue) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[9], EnumSkyBlock.class, name, - new Class[] {int.class }, - new Object[]{lightValue}); - } - public static EnumStatus addStatus(String name) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[10], EnumStatus.class, name, - new Class[] {}, - new Object[]{}); - } - public static EnumToolMaterial addToolMaterial(String name, int harvestLevel, int maxUses, float efficiency, int damage, int enchantability) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[11], EnumToolMaterial.class, name, - new Class[] { int.class, int.class, float.class, int.class, int.class }, - new Object[]{ harvestLevel, maxUses, efficiency, damage, enchantability }); - } - - private static void setup() - { - if (isSetup) - { - return; - } - - //System.out.println("Enum Helper Initalizing: "); - for (int x = 0; x < ctrs.length; x++) - { - try - { - Class[] enumHeaders = new Class[ctrs[x].length + 3]; - enumHeaders[0] = String.class; - enumHeaders[1] = int.class; - enumHeaders[2] = String.class; - enumHeaders[3] = int.class; - - for (int y = 1; y < ctrs[x].length; y++) - { - enumHeaders[3 + y] = ctrs[x][y]; - } - - ctrs[x][0].getDeclaredConstructor(enumHeaders); - decompiledFlags[x] = true; - - } - catch (Exception e) - { - //Nom Nom Nom - } - //System.out.format("\t%-25s %s\r\n", ctrs[x][0].getName().replace("net.minecraft.src.", ""), decompiled[x]); - } - - - - try - { - Method getReflectionFactory = Class.forName("sun.reflect.ReflectionFactory").getDeclaredMethod("getReflectionFactory"); - reflectionFactory = getReflectionFactory.invoke(null); - newConstructorAccessor = Class.forName("sun.reflect.ReflectionFactory").getDeclaredMethod("newConstructorAccessor", Constructor.class); - newInstance = Class.forName("sun.reflect.ConstructorAccessor").getDeclaredMethod("newInstance", Object[].class); - newFieldAccessor = Class.forName("sun.reflect.ReflectionFactory").getDeclaredMethod("newFieldAccessor", Field.class, boolean.class); - fieldAccessorSet = Class.forName("sun.reflect.FieldAccessor").getDeclaredMethod("set", Object.class, Object.class); - } - catch (Exception e) - { - e.printStackTrace(); - } - - isSetup = true; - } - - - /* - * Everything below this is found at the site below, and updated to be able to compile in Eclipse/Java 1.6+ - * Also modified for use in decompiled code. - * Found at: http://niceideas.ch/roller2/badtrash/entry/java_create_enum_instances_dynamically - */ - - private static Object getConstructorAccessor(boolean decompiled, Class enumClass, Class[] additionalParameterTypes) throws Exception - { - Class[] parameterTypes = null; - if (decompiled) - { - parameterTypes = new Class[additionalParameterTypes.length + 4]; - parameterTypes[0] = String.class; - parameterTypes[1] = int.class; - parameterTypes[2] = String.class; - parameterTypes[3] = int.class; - System.arraycopy(additionalParameterTypes, 0, parameterTypes, 4, additionalParameterTypes.length); - } - else - { - parameterTypes = new Class[additionalParameterTypes.length + 2]; - parameterTypes[0] = String.class; - parameterTypes[1] = int.class; - System.arraycopy(additionalParameterTypes, 0, parameterTypes, 2, additionalParameterTypes.length); - } - return newConstructorAccessor.invoke(reflectionFactory, enumClass.getDeclaredConstructor(parameterTypes)); - } - - private static < T extends Enum> T makeEnum(boolean decompiled, Class enumClass, String value, int ordinal, Class[] additionalTypes, Object[] additionalValues) throws Exception - { - Object[] parms = null; - if (decompiled) - { - parms = new Object[additionalValues.length + 4]; - parms[0] = value; - parms[1] = Integer.valueOf(ordinal); - parms[2] = value; - parms[3] = Integer.valueOf(ordinal); - System.arraycopy(additionalValues, 0, parms, 4, additionalValues.length); - } - else - { - parms = new Object[additionalValues.length + 2]; - parms[0] = value; - parms[1] = Integer.valueOf(ordinal); - System.arraycopy(additionalValues, 0, parms, 2, additionalValues.length); - } - return enumClass.cast(newInstance.invoke(getConstructorAccessor(decompiled, enumClass, additionalTypes), new Object[] {parms})); - } - - public static void setFailsafeFieldValue(Field field, Object target, Object value) throws Exception - { - field.setAccessible(true); - Field modifiersField = Field.class.getDeclaredField("modifiers"); - modifiersField.setAccessible(true); - modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL); - Object fieldAccessor = newFieldAccessor.invoke(reflectionFactory, field, false); - fieldAccessorSet.invoke(fieldAccessor, target, value); - } - - private static void blankField(Class enumClass, String fieldName) throws Exception - { - for (Field field : Class.class.getDeclaredFields()) - { - if (field.getName().contains(fieldName)) - { - field.setAccessible(true); - setFailsafeFieldValue(field, enumClass, null); - break; - } - } - } - - private static void cleanEnumCache(Class enumClass) throws Exception - { - blankField(enumClass, "enumConstantDirectory"); - blankField(enumClass, "enumConstants"); - } - - public static < T extends Enum> T addEnum(Class enumType, String enumName, boolean decompiled) - { - return addEnum(decompiled, enumType, enumName, new Class[] {}, new Object[] {}); - } - - @SuppressWarnings("unchecked") - public static > T addEnum(boolean decompiled, Class enumType, String enumName, Class[] paramTypes, Object[] paramValues) - { - if (!isSetup) - { - setup(); - } - - Field valuesField = null; - Field[] fields = enumType.getDeclaredFields(); - int flags = Modifier.PRIVATE | Modifier.STATIC | Modifier.FINAL | 0x1000 /*SYNTHETIC*/; - String valueType = String.format("[L%s;", enumType.getName().replace('.', '/')); - - for (Field field : fields) - { - if (decompiled) - { - if (field.getName().contains("$VALUES")) - { - valuesField = field; - break; - } - } - else - { - if ((field.getModifiers() & flags) == flags && - field.getType().getName().replace('.', '/').equals(valueType)) //Apparently some JVMs return .'s and some don't.. - { - valuesField = field; - break; - } - } - } - valuesField.setAccessible(true); - - try - { - T[] previousValues = (T[])valuesField.get(enumType); - List values = new ArrayList(Arrays.asList(previousValues)); - T newValue = (T)makeEnum(decompiled, enumType, enumName, values.size(), paramTypes, paramValues); - values.add(newValue); - setFailsafeFieldValue(valuesField, null, values.toArray((T[]) Array.newInstance(enumType, 0))); - cleanEnumCache(enumType); - - return newValue; - } - catch (Exception e) - { - e.printStackTrace(); - throw new RuntimeException(e.getMessage(), e); - } - } - - static - { - if (!isSetup) - { - setup(); - } - } -} \ No newline at end of file