From 251f99339b8d9930cd433ba0c994c7d01485a88b Mon Sep 17 00:00:00 2001
From: XProger <xproger@list.ru>
Date: Sun, 20 Nov 2016 23:27:42 +0300
Subject: [PATCH] code refactoring; animation, character and sprite classes,
 compiler warnings etc.; fixed #19; fixed #20

---
 bin/OpenLara.exe                  | Bin 109568 -> 112640 bytes
 src/animation.h                   | 253 +++++++++++
 src/camera.h                      |  27 +-
 src/character.h                   | 137 ++++++
 src/controller.h                  | 541 ++++-------------------
 src/debug.h                       |  20 +-
 src/enemy.h                       | 120 ++----
 src/format.h                      |  40 +-
 src/game.h                        |  11 +-
 src/lara.h                        | 685 +++++++++++++-----------------
 src/level.h                       |  24 +-
 src/libs/minimp3/minimp3.cpp      |  10 +-
 src/platform/web/index.html       |   4 +-
 src/platform/win/OpenLara.vcxproj |   3 +
 src/platform/win/main.cpp         |   6 +-
 src/sprite.h                      |  70 +++
 src/trigger.h                     |  19 +-
 src/utils.h                       |  13 +-
 18 files changed, 989 insertions(+), 994 deletions(-)
 create mode 100644 src/animation.h
 create mode 100644 src/character.h
 create mode 100644 src/sprite.h

diff --git a/bin/OpenLara.exe b/bin/OpenLara.exe
index de8cf3bab416e931e3617451bacb3f36f1175ce9..3d0e86e58169b64c9bdccad43488b5c825fb0814 100644
GIT binary patch
delta 47611
zcmafc4SW>U)%VVRBnxbq32ZQ62tgKz5Fr}G(10c+n?xYE0rIhs1lj_{1ud0Xpps+~
zCqdR>k-BK4#R@_!kJ@Sr6%-_2l!T851ELK=6_vIVH`O2rL8<%x&z;#2)c1Y){n-0`
z?z!ild+xdCo;#`Ph^Xq0*nDB!_=tOo4f?+e1`{`cvl$GJa|Xk7EpyXggaZC=4)o_n
za2EpOxCxd;jhta^Am2F8vY9i)a=#flEYQwbC)ck<JE}|V&072LZ-T+FXu@NQe=7de
zV0daWa?#R|im);;&^V%BJ5olZ-rO_U7;lU`n_&pWq;3u@Fpt;blQ!@1n?K^X&4CpW
z_u%)%h#^DUGYk(mJ~I1AhGj~!!LTz4>6FH$J0`RTPDaG`g7{Cw=-AB}hL(`%uqjy%
ztH*$t5K0ckByA3ii*x|kLy`C1#d@4X6$_Luxhrdj3*c%S#r~o8+D5P0^IdS5hg%kl
z%w<A*;LnkR$D(eb$FR&sSqA*5FJcVxVOuCB4n<0L?NzVkP{MBl!N_Uo<4)_Hk;rzb
zqgDpo*1N|co^rIdk>Ap^vk`qOO)Z5A@G43PrCk$Kl?b^fBu2VIF^QW4d#%d>AfaFE
zG&J(vuN+yhu&hNb0=3Y6LOZ&T!;d;b%SfaQ2W1RIhI}{{!!?IuVmAl8{U#1Z{*FcX
z3E6AY(XBjfQF~xtza3I?Lx$liUWj_*5DP8)S?F&5iZ5>Zice}pnWa(B+gWm&D%~t-
z3l}W<UO{`fVDa|~I>H6Zv;wKOlMCUJ72j*3h6`4Hub?|zAbzhPmW|2XymM`zf}Q0^
zw9rru+K|~$rLXw1CV6!1nG6GwVR*4t7Ne2FjrzqPMPD+MHSO$qkH~Oqp+*W6-uRJ1
zjT|U6pr2b>N+7RB6O@|2Uy4GFEGV@8NTEiWGK&DLciMiWf<_{}g7CcxJMCvO0`qLA
z@7M*xR9~lMSTV5ax`jVfy&qX}qot+kdViJ*<VFo2&GLBU*?Vi)shz=)K<$QVHJ^&Q
z-)Lyqb1Z7O+308pbVfTU;0KLLOmC#Y&u_fUN1G#;@{c-i@C%S|TO2_DGGFGrf*(uI
zp}_n>BX6g?v(AehQJXQ#tnh5{4ZZxiL1T@Z4+R<qJxHMY4<1RuU4us((;EZx20t)}
zCJ*pGSjs1Yz1$XSL!f@}I3t2ngC`i@IJAeeFSHsL9oqA=xM_oouEsq(CY-ZSSUKrM
zBeyFMf1k|l+Vj$V-*E_bOnIjt*B)4yd6jG5Q<yc6<K7Rv>YR#%>O6WIw>$8c()UN{
zNJi}i){66nQlR>$PQQ%ldyQf5wrpq!yi)eBgj?zrSQW4B)=GQcSh$2UX1*Nwa?u!W
zLEwu;W4XG({Xf0^zB2&KC${qwkFAcOCK}1ypcYZ5xVZ(HQIyFiHuDotJqEb$D3EgV
zPe%^b>XuyK6OSWzxYmS~9{cHn*hPTw;?=`hk6Zl}SL*BQgUJ9Dv-?nB+RsXi2!8jo
z=O{?|dEN{cCXg>W&lh#^(WUM6pzdY9<Zt!-M9WG5sjpwXiZ8;1&i`9}{#Te|hdOv?
zD0H?I(<V4?xZP^Te?uV+_?}}wZ;9X>flZ!apnKpIPXYIrXO`ba@uABXaMQH-o=wXS
zaMbzCM;6oc{P~fh2uk)BhecD5tLLlVbuo~`!4CI|sm7W^fnSPKqjfTOC{8Q-vmp1N
zxPn+_oHvE)EcD(%DcQ?fyyJZ&uz&R*sPmt$iK9STlS0AXHFJj3m;qzD9X~S!ux>#Q
zVsmVKQ4DH~T01X!KZL5+D$llte3fQjrA>WsQz+yy7P)*8>OT<;O;(R1C@Km~_GMeu
z(}6#%9mV}AaD469abNjEA^ETn9IRy9Oxfll7XYb^PgACitF$dFD{ZzK3jKfH-X4hi
z^+*Zpcjp`U*|Cdad+`%2-0?iccT?^*ioHg;={u%E3hkVSpB?EGE5=W7oR&MQH`hhE
zb}cunH#Zlt4MWOW<m+kDa?vecpIAOhzJ7P*1A&9T9xS0ynQq>>2w{t2+_@dyQJOHK
zG+{$&!iCa=2c-!MN-x&a%UHTeR__-_<cb4xy??pPCmDB&$PNwzfsLTFWhJF(g|O5L
zq%J2T0e&N<<?EU|_k9-%6)L|nw{lYtVAsAX+U5HVq7@_`0n)k))dPXb$K$zedtP{a
zFqcSmd~3|DIabm*KyzP?tu?Y3u#{}8{0oP{<;zJ>xs8F2b@7>>D4~#2l;Bn#it|PI
zoz_B^+I;~q-M$<_Y1OAjxunb%S|bRA`o_nY>(zF(9~y>M$ElnWm{Oi>%(xg>UOtZ7
z8F;SzVeZ$@R6JvJJ{8zfF(#T}Q*2f;ZN3a!D|h~#!10Q^_$nWpeL2&1!;`3<3Pe^e
z;LZeoUO98vHmq)vmQz_+d<t<aHX#ZNqOEdx|K~o_Rsxb=R$iiI@~Pw-yyD4FsMYK+
z<QfbqSCx*!x$5~qWmW9B4CE{A%6D#G!Hp^R9zK;}sLWbsa2O1QbJRZo1-Cooy`k9N
zX+ITcth$ps75KbrUD12BD446Bpg@VDMjk_1?a@l7GWD<RNL5LR25(AjNF1v0wMWGW
zh4XMBp-BDR%?66ue*!fh^qE<U**<^?9IPJKADIaiS)L?S4Rlv0Igs?(Y6)oiPU=W$
z3JwWRZ7G2(RIdlppSXW&Ip(y`!})Ton9NX2`DQ3VjWq^nksHt~H2KgcQ5aMxW)TVw
zaAORHxyuZR$WiWHu{rSe6Uh^hPt&=ev{^7f11wZ7`LoTf5d_x-^kZD8aMfw$#K=PR
zj+#KM?2ul|Ftj>*k`)7j^Uq`b`<xeABU6dH@-DVI)%`51%a_+3ia7`@QqK8u%u0(t
z@4U}>!<T0ZiM3atg`#9`$ZJ!&JtiR7h$Mn7?HLAt?RoIE3z$N&MBZjrv<AxD29y>e
zeEw9RL5>{;L<&QczY_V`@^|L)PL?b`6}TkFNXS&)Rp*1(eWf<P(?;W&^g;<*X|+%e
zMROaVE2Xwf)RDjC%Kv^S85R5sv50zW$w$mSlYfD^`a5b|{!d0Q<)0*-rbKlCjL3(6
zW%jXXC}tx7k}@qp{L1Ck){q#DVR{VcT|_EoJIYI&Z926>t3hp|9U1~snAB^YASOEk
z31~L(`?#fY&%E*o{4S`RhTlh7{8yECzg3OVElq1Gx5`Z>gq0&uS}G33Z`n|B@LNx7
z#bQ5XREnmQ#+H=E^p?PwS|;EZ)Fv4F{UcCOdqzq*j|JhhmT9A6M}efdg+<C)e_qG3
zE3aZ|ORuQkUV>ydFD#miOts`I2zCD|b0H-jLPD9G5`qXCpK??=^0onUckNStbJMl6
z1KRS{<Z2A3>0bis7P@?yRy7_Cf+pWOtH(Tljz3efxd==@<a&(7F8?ZlfxV6n`F#;7
zM?JIV_ks3V6`=Vt?J12O!B^2ee`#6-FZ)f9Y47?fx|B@2sR_{LxWI1ym4dp5p<V1^
zAYVp8ab85Z$LMpam|7I5(q`(ZVKVT)oACEo`}QYNe@fmBUq+mAvgs33K0~&YLAnu)
zfX3rn8|N|lR}RrTncfR+B7@eyFSIee&=QuP?61L+qHh6~K)_;kU{|~UAE<pOg;8_#
zL9GQ%fR&D#gP;x5q3veSB7Dvs9P;i0WzB?}6rLyr@D%S2jJBug6C*>;mz}7tLMuS?
z-tbi>$`u{hFa#w}^_w$%&WmCcZQLE|rAj8cY5wFRNi@^yRO)OWI#cz|68aKiL~mcJ
z)bxo(?`*0Xd9$;rj2kK^6cKlP`K87k@{wc){bQv0eM9(tk^JlJz5=!OG@HEUTPN>r
zprwsS4NsjfJ6(MVjZ;EF=%6=JLO!W7o%NJ`51ZQctS5KAKYJ2OuVy`EPXf8@eMhhm
zuzlHCDUEJlMbFZ->`ALcrSyicLRD5}5r=`dOxFt4`v@H3kgN>c*xt02rEmKZl+gMg
z$TA{(D+nxo?F)<{ug7CAHuYri`!Xl_@_N$R%73erUP+<Bd5nbXWLEb$>hk-tCx0K;
zy%mIOF2hv?u9H`dRz6m;a|zEulBva|K7*FjMMn;`PwOfFl)={!OJ%@+NmXcpX8(kx
z7ZPFx-AZ29bf6{3O|!5f3%b+VeR*B;`HgFD=mTFB%NAcURi{OECtDWAURp|!5ivl}
z?YB+#WyWcX!i3r+BjOnCRwXbHU;HNomC~Q-VEv!&hB1IByDE{Dw(F%ytn@~2X)-JQ
z3rhQR--j8ce6_9|-8cQqLaYT5HA$^SZR&oK)<G%*vGP_B5xpb80161g@{<w1%&FP{
zGIa=3H3;bp!h|pcCMb1Ym2^2dm_R5eeVJKdUR6U-@d=GA4M;8n@;Nf05BM`@iBX_N
zUWZFvfWZchzErK6ChS^Jjfgdmk>krR!^A3PK<f3<5|>}X^78c-FJi?{qF5o>dkf1y
zwhkEjG8co%r`%sTLb;}7E@mubI^t62p$RxB$JCv+Zc+I^Q#7t$wT!{LkKo;${65sr
zSEV=tdz1Pr)c&YV!(O3{XC(vib?_Dtw;=Z6<Ba-tU#6&0zYUcMf~Y}Q%OLEz6@sA8
zpTu^l=Ltm9zsx!dl&kA?5akTSo+|9749cSfrH@#<Ww)3^P#_({Gw73{j~UdT5UdE_
z0ZJ(Ef_8$!3YK0gX){Y1X#>l<{c<A;ncBl9tnCYZ!uD)HzD9x1bqXZ06%@vwq5t8p
z`=T#zL>u*Qs8798LL0>9FsN7hfReD~-2&_BTVZV>SdZ(lD51f6J`8JNA6Ni&%fw_6
zsO2Z^K6x9eYjZPE2SqsqO7id79)@MV71m85fhBf*Entz1kazXMy4a}=k#dwhgc1ad
zMjl(=<@pY^U4GK$lXv&F-L1Dxr7UesuOY@r?ME3FkNgHQ*mOMF6|S>4T<76H#nbW9
zOoHr_4<Z-(2c~w0(h9vq*+V&CCR4X(NTKQgyp%>?<*=o`>><i=?29h7nv|BjF66{!
zD9&#G9)c`4#zTDioZaAw1IoZOWj``2#w<S-udqJklc9{IzDY*^94$jK_{xnpv})!5
zpzZmPA;Dk}2YR?d+L&jr(N5G}P3wWQ+;bQZ3)O&1TLmr2AK|7oXmxWj$Zcq${tOL>
zn<&AyfjuV>lNh;j7_fo)ex)6G`53l35d=#)x}Vf|&n?p!2iSBh!#Nc7Tt4{>LAL;c
zHU}L@GN51mTW9wPKh(<pz8VNZR?5<OR1dE<wGmASN6OToT?j*~M-k2FMP#rUeL5Jf
zqlW8L>ve#-R_B$^F-2@)np)*nQ)7a$aS@0AMq_ozfaxp$G$p0ce*n_gK%{>a|HOVo
z_G@0?x3ElUS<tIg=g%!tu7}oG)ylyB-wglBBGd@2PEd<k=ullOOjL7OI8{w&VY-^i
z!YnnJg}G{?H^4s=C-tY~nmE<SLWlZ|Na-Z?D;7>tKWE`o^-~sRsUNa%mU^0n^VDN3
zEK!?TxLAFgg)7v*uuxQAVPU!Y5{3I}FhI4AMK@A(qlCD8I6btF<bhhrO14pS6^qhx
zRF|<REiSc`MQJgqb6AuXhnmBpjTD{AqKwb(W>MlJbqtF#{<xh*X<k(U(ZQj8G?A)>
zWz&4A-|U$hXy6j7y9mR%g^Jg%G!-coRyqjeS;3Q6@<U!hX~TJ}Nd513frMvsC6D5a
zn=;!jCQr$>i{qi?`)jeBLq#4ATCISZWYk!U9EIh-6#{4<bbd6774Mpo9V;fH3%!-r
zNO_kvi&gJp&9J9K^D+lbsK)OzEye9e&19?zrA^6+3!HnF=XwIcXR8MF82LkOSoz*5
zzS*|gb4uQoK*e)e+?7D{b7N4Y^SKemEB_7juX9Yr3DTc!b$R0E7J1BcN*7s<5Y91%
zb7GN$>l@BaeC{z(cED3NE~$zR>#GFcIy;WsXsaAoFJWBEE^dJ7z-#rJC%cvfC>~SQ
z9%!r^5{aW})wECA1OKRtpL6V&U~E^RFB1lbwJ2abUfOJjRpF9cX*0A&5O^^rv>LRF
z4aL-;4&v(NN70USU=QJk%rZJAGq8EjkAaa{e17soAQM_`UG@y?yap-UTg8w)goepN
zG-e@2<2V&K`+VF(02Pc>POA3rXj?Wlx|W$RV4SQyunlb7jNxTt@b0bGu7@lFKyem3
ze%aYtGkK_I(K3AW{w$ES^>yy_o-11$Ib-ySz?;8Iv7cWK)L~&!W+&3IXs%10^=RO~
zzl-Ny3B+w{=KdY{c-wI9=$`*>+sXAm+M-*cVDtWcesm4&RZD#ZRZ3omX0F;}dokVE
ze|S@$TB8H&cHCpvYCgM?m?m5~(6r+u8MA)#(j5#EEY5Ar@a(qKH0(M2(l<uis|Oh*
z%WiZOc;U67flaSl_XO)tbNp*>-z*_+df~O71R{3NA4VPdruQhdHsZ|bU`q3B9k<7K
z#~5uN?z`Ep7vjNJPILXw{WV+?c>cAmHvz@|0MN`o#v5&hJ>lvaYI`=l{vpS6f4-Tk
z<kg^ul)x*0-VjA-ZE!xPWAeaXeroK0^pD}Hfmimf)@yvA*SPDiE4V@JuZC-2n*FrY
z2;QEL-dxBHasZ(6EuVO5d1D;zPGS-p0uSvkHKsNM{<J@5OzLiG>9%Y}Em&X4m{?2g
z`F%a=ir%uo?Qhi>$IK4wc<asqC3)b2koSZ-H*e4TZxwOe*1%l{HW-Cjd-fe@GD~2z
zqGcWb0|x$JnTlX1Gr@hZtcT)c2t&U06~xKVgLo{(%eDMOmaoO9Qhc*kXBNfDREGK`
z6n|ceub?>D%#dGB@eS<~OKhYBS<z6io#JFYLwrBQ%eDMAij&<7`5i2-<*O7|wRjK3
zpV#6x*nf7C*$VX?6eoKd;^`EpwTO7htLT4cm6i~xfMgO1YA8-J2JtN{Uu(RJ;x#OP
zXBD!R?L`Lav{62Z6~r&FIxNm7S_Irh)Hd$Ci1hv{+-CC6T0TKs9(@>441D10rfBYT
zAhP+MDJaB38NQ!|Ld*#*9n+?zqt0vTs17Y{>C(~`Tu!t%k9Ytn|5`9i$?&~e1qQ(H
zRgo2QSj*~#aYjq`!noK6MiRkz<NGiKy{!;#6Vu45lti^_q2&U>h)<{9{cES<erxza
z9SHT#5D}un9baTc#rhzNb>PJS&VXp$--JMY`Pa^(B}Cn6z|bR6?EeB}SipQZx&N<T
zU<(cQ_C5FGdd4{7g}|)8Wz)UXmcM<+MGbj0-QW>Cw)rr*J|B3obrkn(prtiP<!`h}
zoYC}B;O=8tlw5NxkE83QBgfNWBDJNQ#<rp4S$zYsN5V{G<M*WtO&2Vtj7dSG(mb+I
z7+DxA&rZM=YHiJqGZ?BK@D)0Ig^9kx5?|pWv>4#w=FEZkFUJnXOr}<{t>))f{kquT
z{V7J85$Dgx-Id!C3r69KPGh9FMQOjxOVP$v{rQO*_EqMT#vsh2>8Sl6?z&2%=z>jN
za>KA8qnMvK2-h)rJ*zE#*wms>#prkT@DrQ(>}JK_Gpe1`@jpv74+@*S<O*8$u-0>x
zvlv=ok>7hoIi+MK_}9&<Z~D|?nrroCI+RSwT<@Eiu(UO^7&=9Pwcfuj9W`+aNi^X1
z&9IMe^UX|D@@%z7CG)kj!3ciebYXlOE_a*Q-Eo;^9ur>CnW#OTS_~TBrZ@%u%|_FY
z)v{9!4Mv7<<|IWru1+M}XC^6LIEeT&LcYvo7!_Rp%yd_NA+&;cXt=NjMJz1CcFz=9
zX1JESpjknynp+5Jqzj5Gfyhh9(CA#&A_&wT7=nCjlh7sbdCZJ%2aRvS`Dm+h^4fPk
zZ;!v2la$u2*S=GFV5{U`e^+r$0<>HK#09h{f;RqC+E>1UD>PszZ+u=8^fNZ{5*nTX
zQ6<9+(cXp$dN3ALGyBc8*!yuM(c{nIwqE;IX;okn{wjx}rQQ7N1w9I98my$3ocg@>
zs^mAjd>N_ymc|Vk?wUr?!S7o)MB(^-3+zpwSxm)~$f(7?InzA8hcLa4-j!~D#(Wp7
z`G%sosu2em!svBx&q9DrIrRkq`^_uMd>K=TSUN|53ksE02{3P%R#}OfQ=C?>`3){8
zl_M3Ka@3c1rKq;Caye4Nl)=k;B214@g;_HV)pGfLIYwe9lp`-&Fl8nwbFx5t6qx<C
zW`19hk#FFpIB%5q;~O%Jh*aLCID6zKYdWZq)?EGx_I_nB^^_sEMxZa44tLzsh)W-d
zP9|mpFuBZ3{&raWuPbX9rfYgJjeLXad>u5Md(Y{Vb197*3PQLHfCVv@m!Cy8Lz*|W
zEboXgxq+gI(0&+{Gya7m#Hqfs8|W7^^mCGwe4yWj3g$<Z(k=`E7DS97t)tvZ14!$D
zX{0ayp9SNPAHg>~2wm5u<bajZu?q4bX?}Af6nd&41Un_aZ+0y1aIU1C<u^iE3q92g
zZy{}XN`3-yWxlm;<bB-j(thw2n5T_zm_CqSa8z4JQIre0(1DUhmQ@U%5;B<B&=#2+
z*ZsvUG^GkBciEKmS#y<A0TinMrHbPHHdpOA@itohSi>}M<y#UUSk0)R6vV<jZ8~B!
zNGVrg1@Kyzrsc%(@>@i}22O4==8DU6#Z*}}iDkKb?Qf8e26HjV0^e}=cn~PVC^wl$
zhaNB(yw)_Y&1*^z8dDmva5or(OXLc>K^zT8gumjnvmr#Mo2l8YSrV>_%)xts>jb^J
zR@W4+swFe2skxUL(V1ul@sksm4cybZ`HeXsGFXU6Y$tguchRPDFS%FniAS)2?<MtX
zF3AO^hn<C}D7$xCg9I%}sj$5jBGX4E_+{RHnDE8@cBQ#VHOrs!qnesNjUZPSy72`9
z9m<g=wg0F~1KO3$RDQuZe&4M9Ly&*+5P?ACG{Jy8;uoAI2%qqyjx>D&2yQ6c?siPE
z?zZ42nb9sO&7(d5zyTyPNSd5RZnMAO3dW7tQ5Ymx6E}?ks;2uS>N&eHw#-<>O5vpw
zT>w=eI<JcgY^nq=50~HB=JLbsC2zm_OQcb|)TXqlzRl3(sV&eE${?wP*@5M&M@dzi
zSe@a!K`jiGJT(@ga0pePTG>`~{2u<3%L<%Z+-0^h^agH>&P922I?AJqHG#}_yXvkp
zW~@*Mnj&9mTh%(ZK^)*;m9G1=+_EPrGpF7O4)s@Dtj84F>M`gJL<ZJ_wk*FLITw&4
zC^J(7sqLdAq9O7c{mzRZ62^MPh3*SL38CO3VtJ6)#lTj`16_m#AXD)PWILJXOIJOT
zf1~=Ws)}T^v#VbHBS-)vOswjB4m6r;R!k}9lo{5vTvx>aC4HXXw!xQoIA~Fh`=rvt
z@NZ0;ZsuhV30$Y$pWoxLF7!FikH7A(P5u^#7;H7p3%-iR+H;l5aQD9W>hvB?6l4_?
zi1i3=g^DlNBiASj9zp5xdt==)w)=YIV`y`3U~CADKnTGMGuXm~u`*7OG}N8iq^ot$
z0$<#DR5YfQ+PwX%Dg*;xa~kJ)EXL#M?_E&x+G;ZviT#vcm6)!Xz6$bl{k3$abEz*v
zT4DdF0C9x7XzJ_x>Ix7P$oIBm4iGLm;jefDVMPZYnfMVR1!n?FJEsnFR`H2oh?2vg
z>Uo6C_)nxSJrii^yj{|~o1&dt*dZ~xU^kygJY0Y-i>c}<KJi_o2?b(o_xt$ICTBCB
zNc=_>qn$N~eFRr3G$5gOOsnMnUn<+cC$=JwaQGPMyzP47Kd4Z89>1l#Fcf*oYtVqU
z;r~X1-&y6tJb?zSPFQ`a9$@pn5^DpqgZqEMeYu`!89}u4rZHJIK&d#7Nn&M+vn>-8
zm!0R+<z~8HQXtr{*Qa$<3{spR_+d;&=RUYsNlJIngl1SzN)KzRizt^SqLQ&f{CO&b
z_PVLcs#MTzK`h@u-gxbN12z^W46rlgSap`?8?bW0>Y8vsrED_|8VnEi?ya63t}bD1
zXiMZgTOu0EP~~pbtKe+ekOLN@`CUMKMx93VLdogh+i5nr{1m7+dnGJ1fz#bvKRaCC
z@1&Yom+ew`VTMsu4d_)Vwfep1$@29rX2uT|TW6zf=`xh&fiI#w&!#}y2@#M%#T<Gf
zX+?TfF&i!YFo{&0L1KqwlaOhnsw9&rCS(doqJ@MsqC%#f(o{Rs-dAh1LE&fGkk?w&
zYMS>pS)t7256}?-b8Df0rcEuq911O;X^r=1#`-c>`qzoDu6nQd*mZ_a-i&?GCvU;8
zl4&+=05{PNz&5G}txI|7(R>?-2x_3~ydIDWAvsn?7u>*z`F$CJ|3DQQ^={KQsC}E#
z!d7}&)N4!)a5G;*Ft+Y~2~cRQvl3j=luMyE$;8+iK|@ealbvt%GWFP95)1@xX4Zo7
z(VEf-bt>g3R3-DOd!Q`fXj2%0Lx$<pdlzb3#2BbDN_vt!b+ZA|;z<JNvu}WsWX^zw
z_8#;X@-V^HTHSR5WlDh+9s9gjisWxX{H7_8_poa%KOJw{Ok_}I4D%OAd*>)z$VD?$
z(CDw71iTP+?pLtZg}j59l!CqZaURA`UK{e@IS4NpjFc8XZ8X?$n2%pH`3^?sb*o1N
zP^&8)a;ugMtt3oucnp{874H?8=Dcv+m~B&UzmBzx?l69r-%s__6Te}7FR}XbAX5Y{
zmW=R7H-50;3B|-DF7OrYvO+GpazmKWc3a$mkg!cpKm?+RGK6&Slbeukr-TEM;$*!T
zInkxmLwYO@bgUAcBbfS@o~TudE<i2HDb7uWpm)*8&Zs|oQlm~6oO0zZ0X~~>lLsK|
za`PKC56;!&$%B(+TGi*)Q+*IdKFo5|-fBNjqH0(OWrEWNPtQkCla68Ju`2NEpTVw0
z2%7nc&HNKJS}M=VPt3LQ>%DrRjSiGg`~oTFTS<C>JBDV5$>Hb%o7!4iXB^CpUpNB}
zV1x%PJenn#u$USF%+yMhp<62M;ESO7xZx-l4gH$(wAw7=ylQ4pgeBd6?*$ZLpGoXS
z_{jOXjf1&|xC?dX2Xpsu7wdRCch5K#K)hX81JGq-YeRg^*Wft6^FnyCe^y6Q#12q(
z%k11v3xtT<P$$H22@-%umtMqf(ME_6pgaZ$hmPS4m}vJuS4H6RE~rzV2b^x|ht4OO
zZn-?)8qXJ9WCuMVM%&;tXJ3u+an#HZebd2ANf~Q>(?O7=jB?*}&~rx(E~gBu6Zpgr
zfzMftt{OQYY;g-ek?>;4HUAD5==J!CEvtuXlnXZ~fmbnB$IS*|$q=qkhJDg)(WFOG
z<5J&rfgKbw%z=JqHr<zRUjCppUU`DnDc_LA#o{z%Ti#|@rZ1KoyG%{+%4)&*Sfwhx
zlGWG}*#5!D*vVtbBsuF_sQ!|{kk%yqN?C1I6UGM4evoL~KQ>_c`+bpgcu^nT5y<%a
z2)hU_jM1DWg|c!ahHq;Kh<|sG75TS+A0d(NC`29vUgL{|Gb!g3hI!};hPj@|1gB_T
z`Hay^SYO4$XlIX_2=^sa(UiL@>ccE4<lO)a%&<Ubcc|5BzLt*$*B}(A0SW}?l>w^C
z(n8GUhQPFr6p8R<sy^ne5r}E0FSnjWN(<>4(b;0~E&#};5&eIvLrz3zmt${x5c(E7
zq3Cl#oTO;<-IpZ@O)9)?ZqE?qCL8lS{^AO)S}UE1nb7SDJo8~?{{cF>Am6Za2}H%I
z=V}+^Ld1!WEu+gI*iHPT+u&-+=7KsBnyloS)nCKNt@zWCzn?0lwTXAYYM^OBzJch^
z=6{mzKdD7NHOQp~5sE)I5O@Agi2zpGmD((X(+GeV>5J%e)2$Jc>QH@b)z_(jugySi
z+6&Y|vZi(L{uHWJdIRuji}2e0eh12Y&NlxOl;bOCS3a2Qt2p7q;brMFG&uqs^kMEg
zj5Q=A;J+(y`215`Y~Z1PjGnO^ZaK($1bXX1wlsrxYn@dN?t>m*^H<>Fi%5Hc_MD1=
zI&L*DQtm+NVNpZi&_6PXex{EeN&Y=;;d~7pbCvaMJ6~%fxl%>h`y$7;i1TyBSu!s7
za%9!)T@iThqr0O;<)ll^#a81xL`{NQ1Mh!yrxf91z_i_&&9u|%tELKXa5R_LLn&A8
zipBO>g#8oPFb3y~ESh^em|1-ZUK_n!dPB`b61?EA1bYg%X;xCAOfkfZwqKDB=!OuH
z=$J{HTFEEKU|jwX=vYkWG`4r;ph@u=z$X2T@iLQwP7-t2M8T)+SJ~8`47p;%HVcgh
zu`A&g^HLFQu^(SVrLrWlOO@HHDy;CxyusIe3IRuI0Kac$JhM5Z&+^;g<h3*{6V`>l
z5j7j4VO{X$S><myzUB~kL;l9d*Zh%1OnlArEMn$sWJLVazm<EqH5JV6)i88C9Sn`k
z<^a<Q>;~kNP&So(-14lIMKHUhl}V{cO0(o|BKX<_fS}vWZ_%&ZWAaW`&%{Gz=)cu{
z?K&z{jsm9g(U4Mgh7jAAJ_9bR;y~O7`m@>G&b)>(=D}Ff0|erx`wDu}+WC!X;3#GG
z)G4!5#Q{o0erR>70#XT8m5aeaS22ErfA%c4*$Es!p~;iA;KiEH9w#^Y3^US{Afs)D
zRZFZRAOs-}ZTz!~QAExD-)*dVn*^mW3A3SO+hJ1jz*3kc8Hcz+t0$@Z;ed|0JPMf;
zTmhJj#W3NzfYoGb=O`LWwwcb4IuXn+`B-RaS~Fi0iL%a1><*LAb97$rjVE^g8*xlP
z=cg=;==_k%vQvH8X;XE*)NEi5=dL8;_Uf*SpbHGodD~PIRxrsML_2h89ZQL->cG*@
z969w`9t``q4)B+tE<|h;?I1X5V<2E{GJQecU}s7<dwqaB(%Pb(vBcPdT2&sHbTM_(
zGv&Yvl49Eqa*NguZ@GeeJ%ml(xsA-GT)yT3%_`th$Iuwqela!zwUHAzbTNUsZRc72
z8FuAChfD3k4PaOkz_{|6y$u%z@2an@gU$)Qc^7Up5|dHds>U--jD+6wtQ%idxfIUX
z7(})M7_+Gen%FBHVH53f3J$|1ZR%CMeHF4Kz7K!_XxfIp7V8yoD{c6(^6{V{d4;?6
z%|pJ}Q{A=KN=^tx{w#+}x#aSRjyRQASzhdjGx%pY;t)x|J-!X015WaD^O2eCld>GK
z`7j;D1OYP73S&kbAixhb%K@*(EJv|R9q>^oRD)&Kh2^%q5_{T7u#{;(DGt7JN4lDi
zBNSA2UzTIuegnqj-|L`r)6#x9c7Kh7x#N%)4}W;5@v|Jo$RxKZ4@?v>|Her1T+|MK
z8_^NFG%eS>>Ss!U&419*h$_k^I;8+7i(=avggr1f!gO4jZd1$~(3^nEn34Gk^Mfz)
z7}X=B6*}SX?+}z+hw69@$pU(eYR{Bg)3p;krOJ0JB@U!b@KTSEm~Z>-l|1|;#Qw<1
z<7+J#s50A3l+?Cd_-3rK@eP^A&?>V_?f3(me$kPL8gZDi6^<nQE_Nj2cb+2^zq1@u
zG1IVi2qlh5h@C*pvYn~TC9tj(i<Dcu0(B+6crjIWx98&rDh-qGx_ab>itJYL{{l3X
zOdK^E!T$3c4y5Ke<{^%m0%U#d;|&;$NT-1mZd7OvQDK&25-QKc=1>xog*AqS$&Q}U
zC4_CX=#U_gqE|Rd@VnTth_wJV=p<cz<=bA9D?1lrYfz_vO~RfFgNNeysXrQEJ05nA
zB6OgfrH55c_|?e@O>`*bsJwGKB8FDe%D3>EgL&pHrnG#R<SEE)kayCd6G6KckjTcN
zTY#S+&0HUM{Hf?x{`m@n|G-{U(JyNK-fmy!GMuYn`lxqftMeb&g;HdbcCU*pc9(>0
z_Ri{UDAU%C(1pb#cZu}+;5w)#1ca~eFrKfkyCaPoClwICOv$!Nvy>MPqmBHn*_(=U
z^zvh~lyv*mEbb?qHxUFzE#+PL4-9wAQtOjc*@FKdWzJgll`kNr`^n#0MDtQ#p;6Zz
z<Q;?t9%@xnZA~d(sTlA=`BKrf^=-(LNM#cvm57jQQ7}tc&rs;$yewx{@E*CxsKs5u
zF|+}){CUA)cuLKpxj|m;F)I;XOUP9mG=*I7y~W<X?qgceu+K!0;9t!0et|r^cg8%@
zW>3Trf2l}ygvHh72ywB0-*!Z`Z7+iMFA{imeq!5d%hhJ1m&b8(^#fO%&Eijx6o-N<
zqv-k*yqjl30wx}^?L|kR3SWb_JSY*^1u1IK(Xu!q_)D!1s;&OdN*qHbN|v=)GpkD}
z3y;F|r)aB3Ax&-EmPGwD!ERb7q7!CE5F&y&PzltrJE}vgqGJ<H=inwj2X=rGnw*HB
zNghME;P|ZRXS@!Eu3sf<kd#UEE$|cZKby=4)a*%;%nPYKj3zd+(9j$$^RZcjd_*GM
z$EHh5tRPaurO1_}(cDf!S!mHz(3?y*AU7aCNsfqW2mGCYIN80V=qH&ehMB}zsqabR
zF?C6}j{FDW35F7_7_#B8;{;oW*J&Nf|HAE*Q;`3#iz;q-l2#;k+SbU6Sc<+Uw<B5G
zxYp`>l9(}=EBAcoy-z7JFMr4yUl{nwe{PrFvXdckwiy?aWxhIA%Z6w3-bncmjDN8a
z>94sU!L+xsnkj$@F{~@>?`@t?zH$Z5h+aF*2_0NDZ#SI6nwG-9&1=O|xc2RIZny#9
zm3hiT_T?YUIusgl4>p~Sc;(51KyTS@{45<W_P=MTPc#iuKLKiP$ZdNFHrO`M*L$N#
z?ffn<^UI-GG$-q~qdqi5-#Z9_oX!Nrn}`;3<>MjX7R?fAEnWyhca-+rFX_7P5REPH
zr~iyjJwz14Ge^E*hB@te#Y76(^{nqXMvUoIdW|VGeEo_A?*;?LFS29sF!OS~KT~vJ
zvvsIX!H1Oej?yoN;*sB)FXAms6b9<PNXS^R>wD6cB<UrZ!7rie(G0%K$h~1bo5Adr
ztq~XBfzo8~u~8~V0{$=WSd_hTKL2d90$X6(rtLtxjDNOqeDk%A+wl$yyr%OR0qUby
zJibuHmIjd^7Rn7<P-gJvK}`Cdq<G=-HQ4ggbq0B+`;LJPj38x@OYf?_?!aB$qonl&
zQBw&>5KO@8(!3ugVn>T+rH>8O2Y_2WyV7>;R7%^ZV<~M*eGfs3Y@+t7Cxd{jF6pt_
zk|vq)|7)(Cl+@RtpF*TLl<buX8~7Bfci>X_0f*Ou*D6@#m$-Zqee=&kDG0B{g;;}~
zo&OGnX!oLBpq$-kky+UGA=~2v#3+851`OO3Vn07VaKR^bC_TuKUqgm+{Bj`oQe3Vk
z?ZPe+^BiRJMjb0PKv-;saT(zvtZQK|V&To6PIdIYRG7IIKbhr$KVFKLMggnvaX-tE
zpd80$o|IYcUnNo`!lgi%o0XZ+M)t!|20PF!M=Z5oOXlc_O=~8yO(_n05kE0=?V1F|
zq#Q>J7dcr}0ygH_c7*ww8#-UbAgT_$fnS{Ne~;hGe7s;;!Q`e8pdkYC?}!oz84UvN
zuW|+m#<wZYrB-|sc=fAMl64qJ0lb8pM`O9m0he$qnUQ<cJvge68o7_Ot8DY!<z?1*
z0AyNnk?Hw^fQ3^Z9R-1V+pPw2a8cL<#<mfd9<MK>8PW|yR`s_MOACb}pQr*Xu1gaC
ziB@-!sew;y16;V(xT9FI=$woCLAr$^xczW{hDo4yWbvV+wJ;mAQ4*zj>(PZGovD*B
zO-XIOf-VH#<j=vAQ>ckWF3(szPm$D>zXfmg$Za8C#f`Kce$$f}(K6Ce)VhHv>2Tu`
zysQX*qL_op*ly7Ydy>&=ii25Sn+;AKrH_l)M0?87^b1xOhZLsM$V)CjuQ`vg=h2Vz
zBKS=4_WT0wzPO=32huKoSGPO)O02_x4-U@2^X=_G1(qP(?L(3Ec7?pEOMSTqnBkOs
z*sdKA7cSuUZJ2-=LbIi?A`Q&PX?eDY1FZVyKSQB6xU#^}E92}*v~s?KTw)r7wsr!M
zUynD+zYR?KdaSW#YoPS&5mI#*?UQq#Dy6H0qMCDJe+-J5(}FZSi>mP$I~&nZx{<lQ
z3QZ`11s0umMV+=(n`dg^yrNdJq>zVX9|NFOU8?270BF-2^jx;H7XMwMk*~+k{4E2f
ztM^Y@wiUy6ZW!RK@lI4&c3O_r>%iU5Y+KDaIOxcYMwj~Odu*XZc?=l-<AGmYjgcT<
z<Wx=^p+soAIZHy5I;m!V3ey9JNCrd^BTID`$qQ_NWUAAY;vsl(>OVjVZ>y;XUdvd|
zDW~iG@)qQz9NiE&j|RTL75rxS0zC-o>mT$9{;JK0{`za>c(ghWL|3}$)<(OX3b_8)
zE-e^<eURKUQci0(S5pGiq7p7jvm+FCmt{KUvu&Q9#`4S6u+}Ww(J=@cRnE>P#q3lL
z+Mo9r^(shoxk=bX=iUI<f!FH&YXu8|_iHBl2ffk-aEt%I1?0Wz;pj=i{=`uR!${>K
za&V(As|bB^7yIqTubPP;oX{cGRC+_FU-*zQK)>*zD<4m!i$w9AAB1V<Uzx150D->h
zyxg@+kqWTikph1fvOevUvdWAZ^eH#cNxDYO<&AcjAWYed@%Ywr61@z?9lifR8;!mm
ziIBI4(y1)1{<0s)3DZG7j>=|;e;cx8Iy7G`EOcS<Isll8N8*z|et8>*Gt9_I4&^vX
z)qW_`@necuKD`SN@GbyPQlQ&R*-Vq`9h&x)c#r&@NldKlFMnsLw8-B@h>n!g!36m`
zPK-tAZ78k$g33Bk=Dp}K&4<U}>FIFpK^o(O(;W;PbNmk_snWw3QdLD9)bmD6W?rml
zffq6?5A0^9D0j-5L@}~8r#KXXgrC^vTa&mtl2(&F$kcW+SmdNb!jb(YI%g_@ya9;B
zwJ@#s8Br`*s&TW(mb0>n2%L7Dud&91K+5_nhQJ-ye<m=~+Pn*x)ng&~&<#Ui%k_jP
zmg%6(L#WntJ$CFt?8M7A5jE@(Kt-n9#Ux~2MlMysXR5>z@*&mm%s015m6Z9d(K`ec
zm6OX1>F6yTR~ass`g0Wdeou&i=%o9mG)}3e=Av~<^(3I>B{$0!GHa%soAP@q!48C9
z6>FPqN3S5kR<)I{q0LWD?a$YcqnVsKfUntzh$N>*!CuL-qQy!%b&&XLId!lo%BjP}
zU&^WRqDM|0Auf?qM~aK&)H}ola_T6kQmGCxUrrqjyK?Fn*p*YqiqqxPL~)v&dM7-u
zQpbrYa_V?-f}ENp-YKU}5FK*rL<~ALSsW&(-Yv$+sgvMSl6vnDae$mUS&WcV?-RMq
zvZq=Wv?#twTwvh0!z6)?0!Ouz`hdj6h+bsckjQwrH48j!sCvM^KFr3-$uNb-L5RIc
z#B-@HVRt5;zFB>n&h>O~2^#T;La#}$Y|H47s{S+-#{}d`borR3fGyEMQ*VI=AgDo4
zz7=|de|;b5#^Atkue8eWZba|t8yFz84W`RR%lmrDxuw3+9+-6f`xX;+mF=(s(_vDH
zz@;}|Q-vtbzO%1B*@jq^7^_I^yaTguWTkD&?A?`-N3w?ZaKXE#JWV>CzKnWD-QdsO
zO(-budSGpJsgDBz^d>hjhV+h>@9*zTplkH7MR`!KMLCCA2CtrnbdG>$vED?K24_|u
zAz|qWxxvEx#u=Efs)`;1d7oT2;5n`LI=$cNQ6o|5rsh=LMbaM&6BilUg&A2$3n4|6
zOSCzjnD2=wp7I>w<@28Bv)Ye1Lk7GoFF50?*k5~^-}F2@92Dmn2`_&2De*?r$)2yV
zpad>~&W_+P{!Li?Lj0SswL05sj`B7Cg3W>+6Lvh@$dDf323!ticzIW{0E!!GLrOF6
zY|=q0C;6;qpYw{pb{2-^QnR61LYDgr@tF-@!Crr@O+tRJNDtvMq~4_*Q@6egkzR3-
z<hgz?0Zm5OlAMSx5ZRXO&>}U-Nm^uMa<UdV7%tiyuKb!_$9)bO0mPphJ{WG?L>J={
zR@fzl8*b4f?2d$8#PCHud{H-Fq!N|2V_WfA?c@qIuMD?<Kt$`7+2ODUYPL8O)aYoC
zrJ8Pfqv@K5fexe0+&8x+OWKf1I#?qu!HU{hhBiFP5H{-LAfE$w6xo#f_M=<Di^GH{
z*`i~>91m)AVuX$5bomV&fqW65gmbk!(O%Sbkjz!0gfy=oK%q=nJfg{&qC^`QyR`?P
zz~a!zp%^o+=}|@%Nndj_-xqIJ;P;`415rv26?$RdTxh7&qn<ag(~5TMT4s5JF*jUh
z)RrGFXjflB0l-`IoA?TVh1VL62yjCB54u3NWp`<C!sb$KI^iRUs_bR~SfH996#!9&
zPbrOvO}q;jFn5(D2LY@JdI#^m?!r%}-?^K@OMd4;ghF1I0{ap>w6!Dbz<kp&ArCAk
zFb5a7t<iN`G4A(^;Zeez5SQ!*iSk~<kMoU?OTzaU;6H|2#ed;=sj!1Qj2--@Q&?H>
zN65#M!GrlONYhvFIY>Gy?MDG^tOi4_I4oBjlq(L%70u8S26-&O2#+0dnV%oDc={LP
z^FmPkH<46}pQGJ6E3>S_$UP?&7_#G>^tN`o6KMDt5Pp_)<EP*P4Gc#F8kdKRPsk{t
zBPlr{3V9ci!pO*q9ZhxV@ltdi`L!g0bEBOq#hP)nXj301tM6fZX9w^=Q`RjzCL&QP
ze81be5XTK&{KGy#;65FZ`zPy2>k?P=I4MwXtZ$VbWCMCZJNgBZ1(-*HeBMg5sp&?{
zdAP3J$i+$@Lj}TF5EYy!$W9T>oKd3l;QY9aoubY|WI<xl6q%sUGrg3a+4hPsPgJp|
z|K)l&pM|#pdtG6{=Q>7!Ey?uBwrJ-@kClnGj^#bJrVHlz)vZae16ejtI8EPet0#BR
zjR<jSJFisihm_8N(8h^z<N52fIfM-2GMe<dyG&eKB-5O}e!uRQCNAFi{`+-Ln>ZXp
z&KCJfU{E@11AiP>$r%@FPSv#6aIuA_kW*x088M1<Z`w!H<+$mrn)XL3#Y5^JsW5|8
z_!Da$>oFDo0K%QD!s`rzS^6;$R@6}TP<QOZJPE+-@voVF5JOgnCLDbbEWzco?*P@h
z#vXaoSqNXSI<C$}UFA6J5|L^K>I5z7J_IPZmjU5xA45&~0NaW0_3t6wj^C2y80^pP
zkW)ia!c_*YO6(^ecplJ0;z0R+i+4h6b^<hkh9LItx<)fMR98qEfK64oW3a(%%h5Jy
zIb<x~4uwC~;NK$vI8>52(wh!!#;oBs&F-I_sQ$Z=@frkyW}pHm=|?B#Zxq24aCg)!
z2o>-b_;Z#cVRZy7K(WC={6sokWs?DkuGkXzY_KLw-5(b)nDNTDSa_C$Xo?z%atr*q
z-s9Ov1Y@+DBX`vEY*%m(-*Bj|(Za<`xHGeB*b{=)-_q+Ve&bYdFdG}Lxo|20K^I{>
zASivQ6a?K1g6f(E)2cki1^#`rP^GFe3;MwwhygJ;nd)DDdxA_rO16rtdT|}D9K@f=
zjdX9%k9{(LlCZKhMbmlAUUtYQajhNlcOR--5y6cp%k~&<Dq2j@vjmg-<UPRh%)vP7
z{03Gnj@Z2o9sn)P__C0P^Jh2G9qhZ^SaC(LZe?3nF933NpGR;HNvvo&iZrUs<ZD}@
zmtwFj`TpOK{tMXCb9)Cy=hCXTYw&9j*DBK!F*x#Z0H5`kM3+9wCxghiTCHi6xYre?
zPX%(*(|?Fvgyb=H?nmuDqiWDb+W8`~QyN`22Q(75b*|2*kgZHFPMcoB*AN~+g7uJ#
zU2S@Lt~fT=yAtTq#6R{6R`SDcO|D=z>TEcaAsHUa{J&H(21kZRnjk-(Xz>o~gQQM+
zJZw{wzr@*Bb6~+2x$t>5r&@%Ac=hZRRq5EI%50D+-W%#?%~+e2%ar4C>q@v(4@5Or
zeZ5p)uO6e4QaoIOF>u|o>edSw6$v}_Uzir`X|<mqLpxLZi<9tV2*T2-k|kg>wX8r(
zPd_b3k(S9{R<Xt+mC<u3Pk-u4`8B$(ZY3R+6&Gm5@W)1pf9p2Pbam@?y;OdS2@S7F
zDedtLKy$eziH`9jdtu^pZM`tx2*Wh?7Dx3dZVVTHh8NY^IBAsaEF0smp1H#C09IRM
z_0Ly?AT2`d6Cvo0W?C0t%5m>1Ow;f)wAN)^*Nq|1IOc5cwrs?7W7BgFuR+A`>_8m5
zEU;kCneG_MrgB!%Gf?XTb)-^=6c}vqQ*cEcc9aP29Vjcr`6N+AQ{OX&+yxlDmvEL;
z^gkCFF@%-^rB)bDDB;{C9|rEQ%@XV$k^=o`q14ie7zp{DXTqq|Ju!eABr)tgkudyH
z1083}F5t|N)5jQ2cdJX=*e)?XY?LB+ny0WIJHFp}*aa{bwd-EhG6#EuJzQ100;W<Y
zloaSS5Dmlp&b==6qkK#cK5?@bNO~BPfE(-XvT-}{`P#bEHtrtdnTEQEC@#J~Q4=G8
z_iNpRDDJj!8otVP51~Bmog+*@m-bY*>;kl!M&&rh48-=jyaR5U$<C;YT<G&#@Su|(
zRn{wOm(}f#;zE;&pec>OZ?rbYaC+9r&L=X`>6CXz5#{ivhLG8KsO}#Fxrz92YTZDd
zyFI!}C*OtOIHGpdp}L<STMD~THu@{JP@fNX)0)tj%5(%P6=?3l|1GZkUQXO`nDIq|
zyfL0JhQDH0n4aDmkh+E;j}KDT#M3SdCkaiY(-|okC-+$B5>Kd!&*cn6xU!mf+C0LJ
zE~VYnWAzcuvIzUU=E!aOh?d;tJen2I$VndV^-Autx<LZ>b^k7$AF(=VilU>Ts1e1&
z^un8&EA_;18(+thi<?Jexoax3`Kc430Fq!y0~YAR3>B1g=OiR`r2vMk<0={VI)_mm
z=9K_1A%4?vN@kk<6&KLkOi{C+&0Q-&z(Y$cfzv3%V?p`yOSr3`QyiR4=?C)$zjf0a
z2SII$QVClirRSB^!{j3(MhB311;p;XH60o!1c99K=miZss*=Mrj;qDc6pEWw6Kn(U
z*~IdV$1HSX)-FIS605P>9>m&6OwKq~w|)qBuk`YRj4ku9<h6SW(rB#;yQ~Thghdt}
z2e^x1X?zR`BlR&$W?u@fB)hzi&TwJ7yXL5b(XgXjUXR+EOWkO;d05x2;a))_%>aJ|
zrFkdRZq)1J;@D23zoI^MYwL9^Ddd4i_ELK|>q7>Scl-+)TqcF^vT3#%)<e`_mj!Ul
zgXxqZF{PUJSANrFGP;5>lxmuR2E+ZB$Gj^`Ys;;6zUB>#mEUK#E+sF)jjteu*zNq&
z+iAA5a3!*T8yW%1)5!3z6!Ao=-tXLuXF`pnloK_aIO_;`G>8IBbxF2}A9f>DSWb9g
z5+$5~5T)}_w6hUEd50<4roOL@kqr>MA&_ULJ8wUx7%U~wQ#!Zvpq^q^<d`>JHUbsu
zlEfH+Cldzo2=RuHcR|Z2Zc_K;=tmeyaCU1tX5M*zJxOR(EEBO?AS_&~d1|oREQoTA
zlRXCT&<PxFkU`36=>?o|3F(V2I@?B<Qi3{<E_jV%II_}-bsHUr{-;&rw(W%9HUN+q
zZ!>%gb|FoS{Uc0m0lsKba9*JsIjjJUS20<{uD2;5G2RPchJyo9BiN4~57Q^T@t`<9
z9gl~>37GpdZQ3^qq|GVK<f>n{ekkYZ9|7>}qxlVW-wfsG^VW4khH+mQCphaOZs&gS
zVCOFQv1-@5)m?PfU<?m^95}77(ufwmeqzrtpt0N3+p-wX!>b3?vXD`jRrl)c+|Y$-
zD7eYw@D^g_R`tD1y@6G4(9AO64QBOg-fqZ`B2%8`;#&fLq1oo;h1Piek{45wlwDqz
z5Xb$(_>a|fzBulV#Wbht-qp-tlI2JQgxR>>1y7J{N@~hwj@tZ_Gzw<G9*IwIjigKN
z1o(F2AmyQ}JDWO4OO=2lU|Bc~wT0acYw+qKhI1(r={!q)S<yyRC~BZ<zMxTm5uvGq
zx-T<KAaw0qXvQ0I=Z)prR(v_EM|qo;psAHs;}f(xVJ@WS*Gj<+dViMI?9I5E6T^Aa
zl!7a;osOSw-kQ=pzIhtWhBS&Yr5xM%>9#((1L0ZlQ(W7@mOBg|q68#7C8xg9^191k
z4Pz$1T!r3X<?QjTPl8dCyffDf!woExzF5cdAtIrfuO)*&$hW?Rg;0>xqZw?%@Lh$X
zMpatDQUdd_ZeyDOo?xjjBlqTHv&%`eOxIg>QOgvqA-h#Z2TOYJL$|{MDPnH$wm_1@
z{R#flDuje!4`e7)$X<&am{p>)$0Md)Jd<sM)~r@YYczW;=H$pbG$);rP$%majDTMn
zInXdx2tOSw(;tI`Z^>_cXrayko~n}0mLhv>M(T(=iZmZw2=R4|bajGdQr)!+B+}pY
zUXTxLK?+U*W1%-L&$PzBjSD1vzQHWb!9MluBA{bp@^?;Xr7g4)Pq@=@Yx>t!Fq~A>
z;3Rp;NVBu)Et1Zo>GkyTo_OrGnso{cw6u0sq@91Z>6&vRF@tD@3A*+mHOgG62+CKu
zp~cmqX4cOYSLTYhll_aY-729@&Cy_yXIvRIc?!v(z2>MGB_E&}=kSL_?u2P9u}t6p
z`5JoYl=cB%vyh-4SMU2s(-B;hgt)=y@v<TXms-wlG5DHPf*7Mi<7@9kk~$iRkX{W+
z>SOQ|CM82400kT1;|`_x8xvnk-?hS+wc&Qta5W`?K1Lw#tU@VH0Srm3!mt^XrW5nQ
zTp=jbwK{hF&vdV-ji|wn(@|>?!`@4eUjB8z&ct9C%~hZVIZF00&C_HFE^MKFpWqYE
z11Ode>76d($KjfJx!3a~ml!Y|d{>Mr#o*HL%PGW|fnHvs!r$@)A-|-{;Fr9ryri47
zYSnfCJ%RxA9fAW>i5kute4Q3fSDQ|wI$RI@d7FHBH$WV(we}oeL-%d`zG&qu67KZW
zUcP{D(oayF8>|0CJc4`8rqBD!pN{Zpo%p@<Qkp1*&st%3#Oe)7nRsJ>hoyj<xm4lU
zN79y#YU1~?7d=qF$?s*KRcWgJgg|PY`0~!kOU^^iIk7JBUJZz*9IekyqX_Au_(Vvd
zz|T6Se1q}elV~_@Vj$ELy1_%2jXwduE7&vTsl<OinV7^cC$Ts!6bunQQODJTO}D72
zZ_#X<*{x}j@~!{R#Omlzggc6mX@(47uVH{vrdi!}j@ZikBSmmZZ($dlw3+4KbXLMr
zVK<hgfQqX~zGfbajNof#vdH9cWH4VdopKoSS-jD7M`^<t#7K{&b6lN&6nA^Sjkvz@
zm^&l6x<8NN#z^nL%TQ4WeR9s0uN%c-wMV_t#BFrm)y*htEb?{ETdw3-<wk4Tk@Cmj
zGn>GKIh1y3AX1KSs<II6M>7#{h5+nKhmMB7z%z*6WMqn@-P+zppX3V8KPnx;x@0cT
znQPTm`@^`PH_;3@MCviPoc0)lKT(><#cec^)|5j?JW90&14v&O69EHe(%{^%t<VBX
zXVB^4@K7L*Tn+ZU4AHgNVbgeBG9WH6hc86zkQ+2(SSrO9T7;zFM`y0BSI_Pvu)12U
zIrGvXITDVExO{HePoHgM+bDVIlWkJhK@w=!ez^)6?5?@C0TJ}Do|YLvXGu)`SWlFq
zq^7gfgi|*4Eifc2fa_|bx`3tNc`jgq>zf!7Y5@5+cQMUjom86f;nw)$8jb4kaBHM+
zkp{&@fNQ#Y9-+Y0eAbXX*=3$)bW2ryil6x5>VfjhgrPxxneZk}L`juH10W7VaeVF9
zSRGfHS8NquqauOb?CB0ocAiBNHNAEqz)xIHEVbI|8Bp9wUjYIR()uc7A#zhe12#-S
zTR9~>bQIHQUS}EM(X&jguApu~(GLk=SChgpVs#j|YcS?HV%ddIlti<PvJ$)}psOF+
z&NVV%FQ+>@+RKI65U3<J2`@?#e?UKD`#C))L_T4H>4WM7y=`_mQ~8v3a?yuI?qi<(
zN!jqRnr(K?QD?6Jqh~pw-PPI0axqKLxWuxBVUko%JdngXB7pki1V7#!%qe2cRSvDe
z^#DyGa3U(LjwWbYGo~?m+gOEU;K)!biQ3Xow`nYQn=}r~N7E8-152a)hZBGy(ty<V
z`)-*4yUM4s7CQT(EoOz)71S%J`@;#asT;#Ev<a|JP}i{>5Ij~>lcQE*+^~i_01rzM
zzqf(v9SnM0T|pu@Nz%rGkBKy5ITkZQ)kA(H&=f*>QZMfTIpHkJPDtP@T58@%Pyfyt
zFeYH-U-B#>CE5ED%t~cC^P0S4!KN>~Pi!jYD2#ov*>8wJ6Zt~!)Lid9o=KhkC?$m^
ziDQV}N6MjoVjOrLo;#tT;vhM6JJgZTFwx4y%N@br(t{nGTSyYXDTurojw)-2BNmFv
zdQES>fmG32D9?+PH%Y0+M|&Y3lgnq}_iibBN}<)8fos0;EnAfi{6UqJ564Tm<xVOp
zAK%PG?AujXQfVJbk<+R$m6eIr-%==<)0!*eSVs(ghI}MGE$>G8OT9viCjDLY+Fp=q
z^)TgWk}*E*!O}@}?_ZF6B>28|h$0_Z5?{L9x+-aFTZ~hGb%v2^FerE5Wfrx1#uj%@
z2SyqNM{fXF&#?JZH}JJT2U>Dv(g3kPet*H&&P5sx?_x0c8hT=iN&X@Gfdv@*jlEZA
zzy7r5a86T~-dk5TjvHDqla(M#P`f96k4Had86?}V_K4|9@VDx~C+^`Zz-MeVA<>R^
zO8W9G!`gPotZ1k^F%Gu2%w+^G2^u*>pi-GMz9|jQs>IQZ*yZuli1<<(7?Qr0=DCO1
zk?cnc86#rgX_ZN0wzj^Of-8wH*i*~*U&KSa%OK9QDln)-yB320LtnAwc|Zsr^bDI;
zCBZ{vK0o`L;C{eTeoyxiN{f6UmR>@6j0@$SSnq9M;3=u11ulwSe5MY6x9%C#3jPk+
z9$v8)`>=G=+PwG5pT&>=SR9N0Bjli294rT|Py^yR$3p$}4DC#yz|=Vufzli-_1xY$
z5Yf7p@m#F=eN0&0$K$yX(!1dQt1YBI4C!p4#T0Y3#azrg@$E8wFN7zhZ#|)TQZ=4t
zEU`{5ci6{x=OYjd;@l>Dr1s>s_vFtw`M5*f0w<xlSd17@th#GEYmlsLqJcJbnyNnG
z_&1N{6YbT9PT=t|*5+VL6jO-N!{_v%xg}Vu%w8!^8H1;rC)F$f#3mf+8Phom2rADJ
zsH@FZzBUG`+|_1*={{B(M{@*U<0SnKl(M@OLs}E`i>6L649bjH&OMRvW6n-a%T5yi
z?TK^;Kb6=^mO-dM2GVfZ2~R}uGg>NLYiXI#2_Iq|P))y~1udt>@-^?XNCIC&8>W8#
z_d7SZLXY8%*>q#*F?e;qj?=H=+_DuP?R9QWIX3<nTi^JLE5qc9&4$YUus;b=3B()p
z(uKKg1_#R(TUe2RzeR=;ygY;v>E>TAqf><^8|=vZO~RWh9wR?;4^D@Fx|<1b{Tc#>
z8to{_Oib{mULEOq7)^_tnPA098umAJ)}Q*YvAT`aUXpOyWm$qKC=agm3@!GU<SDW9
z;VFcV4$%9iUP%H9X`*2_aZ!BdHPB<X8PO4)T@-~!-lqsLh961-D<0g^maDcW>#H21
zlr|lezq_t%0xo*5umWUR)ve(=R=v&!t&GewSUt#`jcayV`??UIR!A~EkHmpHhI9cJ
z#@}~qPijO?QWK14WEH{gt*SrAv;pGyEXP3mG*bM^2Wje09XAnn?L)+YRrv26sP2H{
zD|pxfDOuJ64pG>xqet$EgDYXrP`DEI+zwa5o?&n$?CA$r!kz(eCG45xg(w#+nuT0D
zDtbnN7K}u}y;^SxqS+H2{Da&REz%#bW4aa8b!iz!vBvC)3i>^Rf<6*v<sR~OU}BB^
zioK(Gdn@pCseW8y!LtJEl5J!w)sKFw`~P|F1J+?9jI}teP4}C;J`(<n*OTGTc>Qh&
znCo}IpYi%c_%mKFq|afIw*46Gxz8~`ItN(A`*$aZ34Mn~)(KX7P4Dp9Y8rn%2rK&$
zX5+_cD|=;`VyMeX=91zV0Y{0GpnH4!=`83Sqv_*yHObr^(hj0NJ}iBlc`;b$d*iC6
z?WDMO@DBQ0Xlc#ZkD$3*aB%Ss@co9Wvx2H=`&qTvs%bB=2%gm$sji9Yn!PsJM|I75
z<<@ZJUE#`Rsw`Qkc0{<gpx6E@t8`n{v>hxm5LM`cEmFj`jYn1tvaxE~`&26SZ)F$J
zv1}Y4vj+XDrk&_pmc`0G3YVSiEyIdse{QyFT79_i16HVal2A2mcetRVZvh-j-eLuV
zs;2!<xW*Y)qklESuZs2gw{WFb!j=Bsx6<8oJd@vIws%P%hyi=1!iGd*0rCNEvffN3
z!(6!h&q)z=(UZ9$k$1@K2wgXRGM6OPk~(ryy#!4m{ML=Ve%=lY^mCQaD^wsR@!eUH
zlF^VWEX6LdNHP-drbhEMbOi>NUcSb}BJlK80Sdmne9gx!atB}Y0gFuJYyOvLm~u1&
zuZtdqKL?pn@SNjR5TBK0hnOb*x#k(P;I^Y)_<Ss+9Mw)ZEc3ah2h&dBHCfT=PBMiM
z!)v#KI84wHqs)>Egb{y^sw3Ur`2-?zs@)sKCrVU{$><>5k1gU{IW<xoC#Ob;qvceC
zm>{Q`z&xn}UmMbZv$}v1!#0bl=&m=1Z4%>d=D69{Zi2Xw3fFP7R@6FC!|4>BtH;o&
z>G>zG&{U!}dsgQ^q@7#CR#x{hNXsU^C`$k6#VnGj+Gh#yuwQ+DoG!LC1<tC9EJGMU
z?lFK_M56j362k1bLrOnUM-t$<UP9+DcD@kk+ZWgd63`b)@v0eZ>4h{Ibm$#8vjEE>
z*noY&RcDM?QMx%s?HYc!m3-!plg~Wxra#w-gU6;SZG7R^*uX(5W4o?~3>}Qo8J%-V
z*nYtX0aW_&6M<rMKe+y2BVlhyn-Ie{f|~j4COp~WprrtX@E*LWgOKAO@TF{seANO@
zLyoM%1N|_ISVTTo%#c+HpU~KYoLp}{+JDbrNOwii>j_pcMONd<UGT$P-E&>##mZcA
znfrbt=D5TVpbw&ajxCGdWHY1lkg0MYD2I(FWZ`SCqd=Z=hs4*sOzULIgvx&Ml)K?)
zj1&p;U>%%pDwD_|2uMI9hhsL1^mAY5uMr1fnC&_EG<3){SQ4zF;2lUvr85RYLqVPr
ztz|9l&ARzkQ3BV!%KG>boj^NqTGa`OI&b0Z%=Z6BScZ1o)vXy?UAsC5MSTyabSxk(
z;`6cJ<Il4!Ljn-uSl9&c+t)mThP_`jg8>X<!;8;O{p(xoHKTUu(Ef@no`YJo6$3vr
zNb{-(0B#|vFux$bE0R)(<FpG72g@)@(Tb>hCzTr|5p<Z<ItN2~BJ(Ek?3gR>bYw9u
zP~8k?EETdq=yoN&=!-ElJ}Q!5Cd&)pL^D%U=hv7jy4rz4qgnT%k0*i~_*xQ`1Y4@o
zW+2SIOj%;e*j5IWW)by>j2$fF7P}0Ffx3eFj#h-m>d(T>!qm^#%3z8i;|5?sKP#sz
zFs7kF2s7{)m9C;8t*K~pz+}YabcsUNmn3MwNsV;wanUg7LP|4~>~`y)N}7VNJcx5~
z=E||+XO<(C3@7vvSIz2z>ygLqCEX4;9$Aib7rrjxknlr)?|X6Zwy^q+?<L%F2{HrV
zfrd5>?~m4b2?Nlx9%EUc3;Tuy%!>*1jgD0MZbLGoPl5{pzQLj1p<RsQ#t@C^E?G#I
zKtcf&4u7sy6M)1K$a^m=h#{HcNSHzt2B~99k|x9T7pmIl$w4Ki9MbF)8}yneu&I)S
z(T@Y5q_!_%i_OoUM%wBS95S`{6SO~Qdlpb2d2DyMLUUH4^>YLgVVLzck)<#&;&6;~
z-hpK|(ISG+AEUpeVM76e2;A0&jU?4wuW7Bd#Zz01qZVurXNz!MA6C<UM|+N+UegNf
z!x73?hy^r@sW1b$xI17La$mrm6@qqh$za2W{C8hqiajfD2N_QIy&cLos4yMWEyn4B
z8Sj={!Fck{(`1x(;Kz9Z<OEA)mLn_4xO}cP-lh2<;6rOh+<s*hK|gtiaP_ZRs{}}T
zGXpSqtG0v=i{FrSK^piLX+C@w+2a0=k9H`n<5_VUo&5P1u;5FE;C~ys)IMT&5!YJ}
z$)DpkjIJGKXrES^f$(MYFhd+Y!+SU2vM>AsWGkScxf34*Y<X-5Kk@iu(SPRf+KUXW
z?W--kG_h^Xm-if1GSjz?Z$8zNhA$nz*o-e{(<RqJNP5lc@Asa-O_I`tA+vk9TJ)SN
zT61v)_at@*BIZT#6#LBJ1eCG62#&A41M!r`n$!4T(U!*lQ{K79S6y5Q{P!adA|&1$
zOfX{50Ktty6%8mcpb3PB0&*eb1>s?Z7z1n3CO|cClU`o&$Auu2A6;9EJgl#FY3mxa
zmLw2Kd{iT{Ew=6!5!+vybejs5fGKysXXbZF@X>bv-h4ij`<wU7nKLtI&YW|mj0dL1
z_}V1ib5mlKq~F%)r#Aue2dZd2zt&pyt3}tidcA9?nlbv$waa--c@Z07*Z_%FNw{Gw
z@?jm$t!$E;p+jQ3oXd1XUPrx422HE9lvP~80+RTpWW9Fqs}6Sz_(bqXtj{W87jA$v
zn=9g7#c3&)EL;)uQco}_<ID6I`MUhWG`J{Y-;<|UuPTm|aE#p*L@g$b&XYsbk`O1n
zCcnCMZG__}*Efc!gLy?AY#>i6k4-E`EidtehE&@;ST9J~Ig8xvnkikVifK=hn8|L;
zMsm;r#SoG5w>4@+lxCmeU!J4*IM%eB62Hbe%xy)3Ee-r)j8-nsfNmisVrBUg9Sen%
z1Yx;c@JV1F^?@|(rdEmvTh{&p?g>{05ImmsKap=LUjMZEc*33i0twl{qCM-k5FsXB
zgp6(ri02&Ff*kVN%NFr2w*ccx*imD@Ca;NcPV6tYGAAv`q%Rq?m6*1;Ft#NNv#Wo_
z4Q@PCwQER5o@Kw%b5q`#74fc38JS9Fged}n>-Pp^<?!5iNIk|LPruZoU~a&p*eas-
z6sdg)wM(?57o2%ZK{?*_>ukNlrJZV?O**sUGPmmXC`u54szP=5IB}J~Z3cVk#rx$f
zJUz1(c#UkSJ}0N8%ApD-Nb3gn$Wmg^BGt5^&fAZ{HS9~8>T^{@RL*cwsUN6Rkp)s!
zq@d0`Emlp#@2F{*>2r3H3#{;izhcN<0M1$AB?^!U%XAGijBneHm*%LY=%y$+KdnfY
zkr$H;`n80pT?CTk9fc}|v{=mFDv9@KtfWBUV$LOSuFAiV)`7s41*$5OV=xW7J5U6J
zvRCu;Dsh|7`K%_qdWKtPR1Ch@vJC0E(g}X=V!Df9i;w0$aKICG!36W#K9vXURTIqQ
znZhLru6~B`QKofyP(zG_F^bbAVtzvNqy$BK?Q?0a;0)3tv*?+8+?fLLgpm@0oO6&P
zR$@o1{m}&T7I~aXd6Fk0Is-_odr}LW!*jxyzWQZrbtv5gAYt`iRR3P|L$(FzJ-O)o
z@zY?nGIZ;j!_t;+dnrCgZy|+Nc+fiID3!1jd)78ktXquVxu0?bKSgJOz*tr!B;{q}
z_fb65<s8FEX$-DS-9;|Eg{<L+_$@Y!ffFz4wV(yvPeJza%_#CogWq&+XW*pdU4N%!
ze@ga0QFNRtdTdY8Cz$%0Nvur{YyI4UiNS*}GP8sA%K?4pHs=?O7edpDzV&A)gSWQ9
ziFF?af12Q;g;<`NH{Y-2R<KqgH!3fO4nw<QuSA<J5lu~HthmI=8JK{8fZB9R`Zrqd
zAni0T!MPSDvo$l4x7v?bTMq!Abw}4+ZPf^;wj|@`@_tzeq4A={X&(4fdZY`nf8a{W
z1Ugcr#>=dNk@DI@LBjw2wTCI3RrM<-{IWoL)y0cUC0Qv%GDvMX8>(oIc)FaY2FZxH
zHZRUNCzZFiF;u_g?sncFqUTT}yQOT3i{0E^;yvT!xw+9sIzh<%&gy2p#(DF)X^^b-
zlJini&7?%yT554X#op9nbq9O6Uu1`rybr*c7%AkDmi9r^rw@{u9jYttN-~Y@)@w<f
zL2d>3-X<FcIGn=w6S9tqu4_??OYAA~4gEBspTab3i%@s1KK=<E=QZhnVI$POZ~-Kp
zvMMf@u=0UPMi;K~;gWDBbFs&m%4f(Sv!duGObbif!RZn0+ZAz~LA=bY1iFqwkt=I-
zxz3<=NIwDr%$!fZ170bMD_GbJzs&L&mYh41lx!7j-(h7DNcyUIu~HVZM@y|vNzp7*
zd|zPNvY7Trtel-CX$ry-Zqn)Dq=DuXH(jJk_nEH8k1;BB`v6G7>-909^HswAGMZgl
zsX&>hL%~>~+9_8^e;4#Q5}>CL{-?wqVgBzCjz+ka@b7RF6S!FA?sQhy3elpT(5gQC
zA|okSLsuZHUCDkWK;MMO?I|Z2M8u4KSb|?fo)O@WCRB@xWB6P8ia0&8Ky=*xNt`+G
z8X@TCaTG5EB{jE5ET0yML`_j{to?DEnc^o}1&C&D{1VVsxJN}31q}%CstgfOC(5G|
zOH?a~=Q|QFWf89xA#{u`frw&~DUTG;LKY?Wr?N;JM2%v&&|`{d(oLgqc}@>}<T*Wc
z!oR3=;CKDXK)QmoTVnkDPLZKf;5r4aq8*P(sE=4mspB83B&<&YikGM)07G&P1JU>q
z0D5!z=l4#NPX!(U#QpM5_z?o$BE^jB0q;yA71(uerCTxx3iMMX?#saqpo*jr1#TIH
zB9&Ny`$~rbR063p4BCm2cEROlw%<kSG`TQRDy~X+e>MA(D80UW4Orx=yykcX#YD)>
z>k73gf#~9VLbL$)WI4HoUk4FLcQ{uKRM1>s1)`EM%+?57pgHJIxMbN4DR1v(mtt6T
z|3G-JRkxF(Saqx2%w6I=<2<Z0SA2l6T|(w#2mJ!Sc@q7vl10gSw|de()U)bufXOey
z??oR280IP)MUgUp4H}962>uF*$6tIxXA%tiFTAi{q2xvUwD>fsPbi+-+-8FQqRr2%
zfWqIO_RMY47U-wEd?6HQ^1d&+4AR_=E9jH|CT)jrfJ@i%&Mk&kJX0FQ<cvD5GcaZS
zg)87K#Dwlzb)BzldhwFjQ1|Lc#N*<S$meP*0o~<+2xulcef@Ho#3<$#Xd!-O2TIsa
z$nqy8R9uO?R;IsIge$qWJ<kA@#k76Gk97#n<{!i#u@IBZ<+qJ!E*~+qVx05G0~bPN
zQLM=#GFT{li~X$K(06kE>6yaqbek|xDOVZ33Y?p~x-XaAq8Z&wBRhaMa2|V&nZK@h
z#J{xR8Y?GBFe^*&NQv(XdMS+Z`YQPny?`$fe-Cj%3|z3pVtFY~3C}5`Ql6XM;K9(?
z_8X{R5XU`{6j&kW5T)_Jk($`(_E^zi$npQ0Yxsz=zJ&|tx#lp`%USA<+?oOjAA$G@
zmjS#6)q#L!r+RKe@8)fCFGT{a!6O$9?SghL<9I<-3L#p7vk$?E!mBUmh;*oj;|jyo
zFS=_)yX<X68f?%fcH!{LiCJmIs4y^8SMB^)yq-1+^Shlj%Im#WzYQR=)@r#?Jbq<7
z;5R@}RvKaNYsS7D_+i8F%*Xr=nW|^B$)Vn42juQ0Oe$e=DJGT6ql)O^QAre~^yX2K
zNRE%ufs$qL%po)15S?QQjFM}Vi1Nr=8ru5|+m9lusO7(XmSg{{&`Uc7S>AT8?{c|S
zfqRqf8*|Lz{v#VO+m-+c+Z>$?y45JlfKKS83$j{AmD7OWL47LLnk|8+Q&_}|z-Cbb
z3<WlefrwCG$tgzA!F3>899yI8-!-q_MMA^aHKBR^UiD>6q%-TE;hQC0Y@V(=3U^*?
zVOtX-m);HKg$h@XdH<UA$rMgAzFkEUejn2#2mv7Dcg8v7(Zj_E$jp!Mszvb&hPK*C
z_Qh3hoywe{3X|L`l%EYs3v#I!0`$&<88g}Gi;nXQjMT&s7ro)L%O@es<qSLu_|>a-
zFTX%5+4YeSnbEz_YLsP$vjRgKdP%OGG=QD=U*sqt#>oD-o}60+eu49$HSydaMjW-O
zHjxs>Tx%>wR;Byuk})r)X6tqhg9#Yv?y=wOzs#C|Eq57`lECfJ6?h|Ss%2<$(|<d$
zBx6v;RfJ$-`JwWfYN;xyE+%Q^!Uaw|2NX>6gpUUz>$yu;GF+K5EO=ec3p}RI8{(Cz
zF_t<|0DuiromC|$<<C6gnb~4(kQ&t|Cu)e<kt-fzQZ&I?VW3p<hZk8GUkv<EArG<#
z85^W?<yQpjnkXjFEZS$#sxeZVGIS#cLtjmuw7I5Eig$k8s)kp!t-4u&ZB6&5j#MW1
zC2Q6AR&{q<N)rc<<8quP44$rjy@^@cpXk$mWs{U)9J~sg=QmOR7XCnJc=E9w#k=3}
zD(zEJ;2tUMDJg1?TaG_&5x!u3mCEK`!og~{rX<mdDLxB%4T^t@BH0Dwr}zksDkcko
zu6+>oAj_0F63ag?5c3vDvMGhEB(=KW!j10QRkcx71f!htVWRt!`GNKadV$>%XFzA@
zl~dLZt<FA9ts+GyVAsb6UlG8mOrtTP&A5)nvly=Z>~|D+i&N9kNCo=IJ|`3hhH~v=
zb)uH1QI(3=E;rxIfPk<;|I2a)Z9Eyt86zp8R*=_{7xv^yy}Kj%H#>$s4VH_3Xb47v
zYPPg`j%u}tp#Y<dZ!2_&4L(vH{HYWv=l~v3Z)VGyWN=tFeCg}%>C7reDeg!)>dX6r
zk4Xj~Hdt|c9$~*L!iKftEcg%-%#>b852Va;F0s~>XRH^z@@zQ~;fgbHT|)YC@M<__
zDSB&UUtj1YX_WIncaR@}R3)=-?T|1eU{kTs6kX$2OBDSivvl;P$*Vl;&$615!3Sr2
z?R$Ldb*$}#1kXtwnc0e_Q8osd!(BnYkG_tg2bWNROaRb^4Yv3$D9qyQ7_rEzAt(RU
z6|!HhP@JO})3Z92W<G^fS7~t6xT|IOekRR%u%B8l$wD&jmYg4{0Pb`MP<v!JZLIS+
zQ9X-h_<C%VbHgQN_$lP7i-mv$G+7FwbqO4ilU$HnYFA+_-grhNh&*crh>8xl%Ck<`
zK#UHzS|dG}3Q<ET7eNYHXj_utEe$Tl07b!{JZUF2Mfov9Rb&@TGY9&;fakcXRM3li
zC+8=+O^WG9)~98W(R4UI66tFxpU6^4*VPfds6|R_W!8N}Z~}>x#3H}$Wl$lzeBmJo
zR9|qto<(AIvv{yyC?P%&t1_v7u^J>=%QwY?;WC}DKk0Lt<S;BET$=@DIV+w6Ky71S
zEm4aiqrxQ@x+)fK|7F0Gq=1)uH@@j{5!QpH>9bDX=UTr3PSR?9<HoX6{3fJ^XmH7L
z;gj{3PlYz0Z`aqptX=4$zansxCT_Fqr<;RPR)Oi<`B4dYuFSTsNCVTSGZ$h6%k6X1
z&8rhvS({~ikr|l@nQZwImI4O*`Wfcc{bRL)f+#20GiR6srzQwkK3xafaIq*cfb&Xm
zfv#|~sG!`;SiteD_Z2wl;CXPz2MTn;2RsiCke^TL3y;~)&EWLR!b)iHXOcwQ?dlIT
zOQRE$h3nbLS5yjL^_^mN1d&&7kt|FwVivT{61ps~S8}Q)ReVCK=uyOXkpit$!|k<p
zso1do8bD5GUZTh_w^5%=?s!fUQF1l@J`&>80!|kd(K(G9Ugv-M+uyv$yzUAbPCuth
zKdtk$s<iW{{lY!wjeWWf+8^A5=<0sDE`9B+7mF#U_Z{%@bMP7RSzWVami=5v480dB
zAs1&;Ntj_NBm`85^E8xVm?630d7(m%^za7768@}N*89$e8|3aHi2=m4z1ptJ#yS48
zl3v~$$mQjQ<>O(0aF7yXJ)$)4Top;(Z#o6oVnak6+qvBt){7M2*=(}HT8*#BfM7U-
zOs`u%e-%$eSIuh7y7mop4fkyMqtw+k%o99GVMq>ow(KCJ{J{|{pp~qe2$3M{`UAqI
zmXGEt?>xz7J4<L1DtXeXq*?jWu4lJ0y(V=x8%?id8*L@zOmAot{khrB*q+4gI&oz<
zaVa*b+cH$D0X?Z+)2Z@xDu1)F7UQQ%d?C=4u;$7@*FewaZ>r`dAy?9MwP)QD)v8to
z-ECDs7m*OINVV!+m1lxy%hl>5!xQ|o>iu=v$YY=@t^A=t*G-<y16BOZYi<g3-Rkjg
zj#1vRo-J}cSSo1hlu%WX)so(@j$5rqi1)SqTq1W$<XuEsoki<D^&m(Hi4JA`cCK^k
z5fOj2-foUw_9`!8)gS=dmPmBze#w)l+I|LzBE$nLz06c#{r4RqKX5&R-g&dJ3D5=)
zNd1C!t2-gt+j^RG>{;nO)lx#Br-TQ0$iQ?q8#w|*IZo&v>?65KTcFZfE%~|51k$$s
zh$I1LhG%WH`naBB0xNnb;Gh#`@==m8Gil8=x~KPs3%P<qRD%tA+5Vt1z3xmTR>7hC
zMi&MrzePctcTq4pP(#$w1jFQ*me+R5_2H$R_s+2hh;nX4cl&jv^GBhr>vTP%Cqb+p
zSkL$MG^h#4Y^j+t2)*9Pfre{9|1iR5{!C4SP5oKoOU1l{^P*dZH}o^fWwqowrS^|!
zo5^OZ{pM_Q>D+JqkZ!CP={zLAw>o9Y8|i#q{bCMW{d%3*{Bn&GXiDO-k!ba>jW^#J
zM`)3?MV8;5VCx-Nt!>+Gwrg|E;eEdQL%S~5{50jMr*&uIa^<b&7H24TvQ}qqO`TVo
zd1{~i%Q@!Pt~&rX)fux72E}M+Dmkbx{ZnRKd@yJ*4y+h0&dMQnN}f456%hKIPxh*`
zQ7UbMo06WWl(!DC@4cAvCpu*lg$J5GpYpFM_U=4$#C2F9E6;ElklR^DS&exaTQem0
zDt}Sp-h=k(JackiS!V-FPS{!bX6n5Sq?Gp@u?#F<ryNwJuyt*{gQ;t$n7#)52*h|x
zbEpBEqAQa^i90zy1pH|dTE*%L-*RPII5bs4QzR{+si8!t)qX7>;ZCxoAH_ChUPn!y
z!#kF@dICRXDY4#=M_4CMjo=OV<2(X00M*g6jYbtq;<|4UA9%FXu+EFM<EdV2;<60n
z#;*m#rUV*NG9N9i{Ihi)yO@?*Ts?I&c?2^ygNHBI-XTTLI3BFni&#)hS+v}W&k`Y^
zyM)#@*~{3^;Gf0k9l$S-r@Ak&%y<#MJlhK4fRzLi;^z{5irj<d?Ie?%zMlZ=du)wv
z`pbjA5E&53wJV$}{Cp@z6zmfP=CIqXisQi<Rp<-H%8PN%M!n}=6I?e|rmE+`5^3Fo
zP$b^GP5hft%Re6Ao%dUxompt!=hgOBd{&L@Va~w&?0to1%77X+mB5k~cm*wiC2tuo
zk9yDkb)h*}K+aBh@Bo7m{DlK*@m#^A{q^D(a{tefj5AME*Ja0YY4!!X>`I=GZCc%~
zIxC}OVd@U7@`f;_lK%QEP+_@OKfq*JvbSOD&Qr%Bh0^Xy4UMjKZurkz)K(n)4_!A}
zxami&8J!`lG&Lpwgj+GPo`DgeO}X}yMQq((I8>^&WnQ4z#8bZYf?mOjrs_8YBT8y~
zx3iY+>($r#QEcpiC9P_Wt>_NC6UtbV)`ONST(rzsliGuoD->2{8yRbo36uip%ZlXC
zByg45CVlX-f{=3{f-X<?rhl5*T<$5AuzU>1Uee{&F^zwSs#$%;GU;<fv(I_sX1jVW
zpucXg%o|`8AI=zB=|YQxd&bHnYX01W5=+ism`@oido^57C+Y78GJSEUjEt4Z<sRCM
zR6}TGvP?G!9c!2xki0Xzajctm$md*jbFa|=3GA$SW<s(umr}D)@QKN}x|5kX(i1qu
zc&5K@m(DYX#xz)G!NMi4);&JY9B*cP0LuGhE~wSwgy8$BSwZ!>AWwL<cB5|c-T6xU
zA)cL(mkBC()1Kwduw&+%|B|NayLdee^dcTzR<rt8+lS}0EsqW%%!lu-x97|^pD>Tv
zo%7AbeNr0i`~_y(2!=pjrgLwfzyvDq04re~Doi1(QkQv!8Sv}^c8XT}$O3c3ZNNl5
z62{X}ochbJaMvf^4-;^ysKBb;%h_^;H+I@WGu4c<XDmd$;|vhuJ%NO0jcQq&KGxm=
z;VMfqo7W`lWEKf)S~$~t^-%|+Ll%mdl8lK-YbMRYb~nt$_x}oJwKyghII8lDRlV?G
zxx2uMDSv2wYvQ0lL%DC5vyh#U*Z3%B^;m1O$ZI-{SE}<6j|)~f^*P7v5sS>!Tj<f3
zmS;^HWT``V=p}_6@uB@P>Y>@A?KO+cAw0gPHnh@)wFD+^g!tz<gVGP<#J8w68{LWz
zDH`n-Ym3T%SE@681Wo#F^Q3NQSEFXIJk%Dfi=<`N<xa;y`WPKp6(e&%Nby`*F=E{5
zLj;d`#h0#P_Nj<iaCes+J%~w>Ekww6$&sSAklXLoTL|xaOdYAl(Apra2r*L2M=_A!
zqi%^DbxGvN(DKo4WZ+0-XhyeZ-8k9Z#;m17r4RL|fM1nHvV4XT%Oxa7g{b-OEa|!c
zysh^R%44ZDdEF)U$M>3R{jvGZ+F8&jiqrO=J4y4Y5Z3XUHh8)t6xy?#ejrvbMt;k@
z&VCX}lFLgYU!ajK&Zx_1LMND$C>wE*X^MpfUW`?*F1{UD(oM&m2iO~m!t#={s>UCo
zgN9t@xtw~~^5yJN3*t%@qQ$G=d`neYkS@pM^>QZRATIng^__804%2IH$hCfFZI-h|
zNq`5pFeN(uDwO|uhz*0XqoxE7Uz4d4R{mz5KA);^3Y^rv@N{2Kypk2N&wSk+QYJ7n
zXjdq)kk8N<IWney8X6;q$ozb;ND@Q{@2C&|LW#@8e^P*)C?jBv7Z9-(y}+`ei7`}`
zXho##PZ^&`prDiU(G|A;J~JuhPK<U>mIl^IPbyEbkR0ae=)}ma)IQw1)vmkGyf&7S
z&mJGtaG_!M$yWR1edeu~eYf+1h@@h!a>!ycsSh?bGZ&j<N8KU8yxb_}a_1thd1G8D
z1ER#nuvm1eMiv(bD!qM}p62$R#b#l4D;?$xh(;7d1}5y9CpC?xH9naMEkfbvh7!AJ
z1El@B0+N(&rwhS#X>7ngqGGq&<Cd7Y>7s_f_`w4zR(K#=tqv<zi<mQ-3|34{oNz&T
zrhd<&_v}MU%m=dmVaA=T6q0eVo3T`W*KMS@XH1^!w3n8cw`R2{w7IlOc+#FJSe}X#
zCa-78*>#_mW4W)<+5V>sp&>j2o7bf@1iAS<6lFUl=CxNm1z9j;eixBtcNP)v)JEBZ
z?l*7ur?8io@T#@!4_!nQITM6}s5m8u;jH&g1gDK&cf?~Ka%`xOiGk1hRsO#H>hy+<
zgHHlplrZZR@Avt7QAOg>iRbi|aky&yM*{xxe=Vrr3+fz+Qr?14Vio`|ODP>iU}(&$
zcm4b%p3z}GH!K_^@$wzBRi~BjE|P}Eq!I3ne4Ob@i8%!EGmf8y!Wdu<s><>U%4b!t
zj(rt`uITHalOJl&R*i96!85sKDSmkyN4J2r@b?_a%2ISthia7mHfVuclX~zmLGY?n
zIu=TtO1e^x|MHw;>Cdb1jBBNfp;F!WPNFfPbZ@CK)o{UJI`Pu<vMj6Xphp0an_n|t
zb*XZ@eWKJHG(x(ULW2WGQi4wysmK>zkO{at!BXkk-`F@<x>z$f?Ol8L1Lpl>sHANw
zC|s6}zVR-ioL9HWAtbh5xcuo2WidskpYIthy!AVe*^LjF2?>;26DR9I+gZ?GCh7KC
zyX^t<I<wYBQSj>Q_gVT@A3Oa#%ftt&Gx`D9;G|Y)83LOKgxY$>jjN=T>W@O9QK8(j
zPNI+3+RMt!<mp7W-A!Eo<Kb|D8-<f*r$l~@$j9EVzF_cM(dTET)tHg6Za;_m@|dhZ
z*NqSV1^JYz=40<U6HNP9nVD(+$o4KZ^ZVc}U1|=yvWDZ^+N0(D)qw7$#P)Ha#20Jr
z-Am0h;iCzLcSD5ik?W4I+WkdAL7pEh@q8nyli3E(E`{+;|LsA;c!$A(isFUNv7yBM
z6bf^2><F03x%~O?OvRJs%gxO%jb+m)P2wMGN2{bfo{N3xk)gy>wHSqk_gI;V-RdH!
zH<Y3njkH1p;8F{@1cy;pJY1G}{Bx<j(3gKCC-s38{>drMpfEUWg|mEsDiRMrbNKP)
zlb-TR`E~|yE$aM=W!K4oXen)~1_!%o$#Ejf`uX{KRg(QT95b47&|y}TnHa<M2`hIx
z<M$TP!sOUPLkJp2&<TRv&jWm7%Git2c-DZ5*PJcqDM#&LtUZ^@J?zJ@Dx7{n5c{bn
zuu0C;YtpQ7|IvzP9oia6mZ#?cU*LSW=|V^)ESj9zS$P~uUocO4BFY`1#8pxsCYW>S
zYYX4}e2<@n3(^}zmWyF?3Z=&$>Cf@Z|Msk3DD;9@hf$02h_?Z1vdERvffTvDma8HJ
zGS#ew{A08IeM4j0wV!wjBY)Ym2o@=I2rWgMlbY(<hX!>N@1FmVKeB{TPc$3Va@OA!
zU&o^u`U~Rb=sjNfgfY#1q3}k7^1`c9AyO|Fs*Tx+J)?+1#hBMGwdr!)VpW|G*;4b$
z1MXszL)C%dUO;MCrvt-f@*2)O3X-v5jAMv*{)Qh*=7C%`5~mYS@W5p<-fa^Juor*B
z9Fq7)3tme_Oi?iQPA=8otciAh-F?CSw{Mu~SMGMBtalne?BhlTb>!fGf!W#2BRaia
z0xkYRNq3PrZMivo(oi>Q>5SNjnrJD?xxAZtquC?m9$AFsR>v~ItoO^WM%>l;%VWA#
zO7zu7qki|<g}TR=o6Ai9vLmK37dIUze+QdP;|1K4xJ|f6a3#1x++^JCxEpapas6<g
z95#*L;11&Cud~rKA~`)J;fCUJaC2~raVu~eaXWA)aYqkf=<*;RKgI3E-GY<9^RJmk
zEDaipy9L*Q|2N{O(7|=%F2_F<Hwrfamyi28?qS?o+z#9`xP!Q(IQfgDk;%9laC>n(
z4#Ux0&qq0KF>W?4=dii$Uh|H+S>H4ZBmCdVHcsFeWh3U_vW?2!`g{M*Y@>s4C}+cX
zJlhzxU4OR{=EV<(#waAMk8t@e-kNPRd{=*urkpPF#}Mw_LwfhSmh@GmlW-s5S){+w
zD+Q6E@JSNN_xJhUrN6y4-%sf8S~84!ye@yG`R2g!&+?5Mhs(hg;uhnU<5uCSa2s*k
zal3FY;11wgaMPcyTd>(25a)m4T$VAZJ<Hhkrz~UUCt1e5xW%~Y^I66ce((4j?lT>h
zbUMq3#6Rt9mhlkrl5R3_GjP6t;3Q2x?p<83I{lYaDg{cViBu%t;-u1s3t2{O=#q^8
zRK7o%*{ZR<D*RkN|Cd)d>94w%y)(WWk$n+5U)9j7zNEt2XX$(|@cRX*`rRJ(2J0_p
zXaCb+{Xqe1y9?GkYO{=C>$8k&aJ?J8)A;I!`@<l9K1zeCc5{~T!QM*?_`5y$iVnzl
ziyK|c?BMq+oZsl(gU@`~mmp($7N->4=fSoqjXjZYf!aGWvlTK%PR%yPjAH8Dl5Jdr
zyY9AZ<NKM}#;dqrjYB|Ve6}&?4rU3?#%ZXHy|kyjXTVpD@i+Pkr0mC^G>=>|d;YIb
zdT!pO!<<?4)sPY(?U|dcW{(W<1U<z5i_rReV;mmhFmjH)A1E!zR#X0Ze#2A#t2!Jc
zjZFFHmt-5s8?%hxZOCGUlE1BKadzfY=Jg4Nk#*-U-<p1BNlD3_LNpjg!=3i3r_42d
z8nSlmHW$P-OeA@Z(QsQ1N$vY~n|BVVY9QrdQsPpYh<?p}b+=i5Us|JH#R<XCjcNF5
zO{1w-*o!RQ9fUazJ?Y+Jr|=TCtXH}$c9iXe9q*N{iZG+r+&U!j|ND*zQ|XI4V%;ly
S&AX$vE$Y)+7x|poZT>GO-TUqU

delta 44929
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
O>62pXV)p3g_5TCpJ*71O

diff --git a/src/animation.h b/src/animation.h
new file mode 100644
index 0000000..49c20cf
--- /dev/null
+++ b/src/animation.h
@@ -0,0 +1,253 @@
+#ifndef H_ANIMATION
+#define H_ANIMATION
+
+#include "utils.h"
+#include "format.h"
+
+struct Animation {
+    TR::Level       *level;
+    TR::Model       *model;
+    TR::Animation   *anims;
+    int             state;
+    float           time, timeMax, delta, dir;
+    int             index, prev, next;
+    int             frameIndex, framePrev, framesCount;
+
+    TR::AnimFrame   *frameA, *frameB;
+    vec3            offset, jump;
+    bool            isEnded, isPrepareToNext, flip;
+
+    quat            *overrides;   // left & right arms animation frames
+    int             overrideMask;
+
+    Animation() : overrides(NULL) {}
+
+    Animation(TR::Level *level, TR::Model *model) : level(level), model(model), anims(model ? &level->anims[model->animation] : NULL), time(0), delta(0), dir(1.0f),
+                                                    index(-1), prev(0), next(0), overrides(NULL), overrideMask(0) {
+        if (anims) setAnim(0);
+    }
+
+    ~Animation() {
+        delete[] overrides;
+    }
+    
+    inline operator TR::Animation* () const { return anims + index; }
+
+    void initOverrides() {
+        overrides    = new quat[model->mCount];
+        overrideMask = 0;
+    }
+
+    void update() {
+        if (!isEnded) {
+            time += dir * Core::deltaTime;
+            isEnded = time <= 0.0f || time >= timeMax;
+            time = clamp(time, 0.0f, timeMax - EPS);
+        }
+        updateInfo();
+    }
+
+    int setAnim(int animIndex, int animFrame = 0, bool lerpToNext = true) {
+        TR::Animation *anim = anims + animIndex;
+        isEnded     = isPrepareToNext = false;
+        offset      = jump = vec3(0.0f);
+        prev        = index;
+        index       = animIndex;
+        next        = anims[index].nextAnimation - model->animation;
+        time        = (animFrame <= 0 ? -animFrame : (animFrame - anim->frameStart)) / 30.0f;
+        timeMax     = (anim->frameEnd - anim->frameStart + lerpToNext) / 30.0f;
+        framesCount = anim->frameEnd - anim->frameStart + 1;
+        updateInfo();
+        framePrev   = frameIndex - 1;
+        getCommand(anim, frameIndex, &offset, &jump, NULL);
+        return state = anim->state;
+    }
+
+    void playNext() {
+        setAnim(next, anims[index].nextFrame);
+    }
+
+    void updateInfo() {
+        ASSERT(model);
+        ASSERT(anims);
+        TR::Animation *anim = anims + index;
+
+    //    framePrev  = frameIndex;
+        frameIndex = int(time * 30.0f);
+
+    // get count of real frames
+        int fCount = (anim->frameEnd - anim->frameStart) / anim->frameRate + 1;
+    // real frame index & lerp delta
+        int fIndex = int(time * 30.0f) / anim->frameRate;
+        int k = fIndex * anim->frameRate;
+        delta = (time * 30.0f - k) / min((int)anim->frameRate, framesCount - k); // min is because in some cases framesCount > realFramesCount / frameRate * frameRate
+
+    // size of frame (in bytes)
+        int fSize = sizeof(TR::AnimFrame) + model->mCount * sizeof(uint16) * 2;
+
+        int fIndexA = fIndex % fCount, fIndexB = (fIndex + 1) % fCount;
+        frameA = (TR::AnimFrame*)&level->frameData[(anim->frameOffset + fIndexA * fSize) >> 1]; // >> 1 (div 2) because frameData is array of shorts
+ 
+        int frameNext = frameIndex + 1;
+        isPrepareToNext = !fIndexB;
+        if (isPrepareToNext) {
+            frameNext  = anim->nextFrame;
+            anim       = &level->anims[anim->nextAnimation];
+            frameNext -= anim->frameStart;
+            fIndexB    = frameNext / anim->frameRate;            
+        }
+
+        getCommand(anim, frameNext, NULL, NULL, &flip);
+
+        frameB = (TR::AnimFrame*)&level->frameData[(anim->frameOffset + fIndexB * fSize) >> 1];
+    }
+
+    bool isFrameActive(int index) {
+        return index > framePrev && index <= frameIndex;
+    }
+
+    bool canSetState(int state) {
+        TR::Animation *anim = anims + index;
+
+        if (state == anim->state)
+            return true;
+
+        for (int i = 0; i < anim->scCount; i++) {
+            TR::AnimState &s = level->states[anim->scOffset + i];
+            if (s.state == state)
+                for (int j = 0; j < s.rangesCount; j++) {
+                    TR::AnimRange &range = level->ranges[s.rangesOffset + j];
+                    if (anim->frameStart + frameIndex >= range.low && anim->frameStart + frameIndex <= range.high)
+                        return true;
+                }
+        }
+
+        return false;
+    }
+
+    bool setState(int state) {
+        TR::Animation *anim = anims + index;
+
+        if (state == anim->state)
+            return true;
+
+        bool exists = false;
+
+        for (int i = 0; i < anim->scCount; i++) {
+            TR::AnimState &s = level->states[anim->scOffset + i];
+            if (s.state == state) {
+                exists = true;
+                for (int j = 0; j < s.rangesCount; j++) {
+                    TR::AnimRange &range = level->ranges[s.rangesOffset + j];
+                    if (anim->frameStart + frameIndex >= range.low && anim->frameStart + frameIndex <= range.high) {
+                        setAnim(range.nextAnimation - model->animation, range.nextFrame);
+                        break;
+                    }
+                }
+            }
+        }
+
+        return exists;
+    }
+
+    float getSpeed() {
+        TR::Animation *anim = anims + index;
+        return anim->speed + anim->accel * (time * 30.0f);
+    }
+
+    void getCommand(TR::Animation *anim, int frameIndex, vec3 *offset, vec3 *jump, bool *flip) {
+        int16 *ptr = &level->commands[anim->animCommand];
+
+        if (offset) *offset = vec3(0.0f);
+        if (flip)   *flip   = false;
+
+        for (int i = 0; i < anim->acCount; i++) {
+            int cmd = *ptr++; 
+            switch (cmd) {
+                case TR::ANIM_CMD_OFFSET :
+                    if (offset) {
+                        offset->x = (float)*ptr++;
+                        offset->y = (float)*ptr++;
+                        offset->z = (float)*ptr++;
+                    } else
+                        ptr += 3;
+                    break;
+                case TR::ANIM_CMD_JUMP :
+                    if (jump) {
+                        jump->y = (float)*ptr++;
+                        jump->z = (float)*ptr++;
+                    } else
+                        ptr += 2;
+                    break;                
+                case TR::ANIM_CMD_SOUND  : ptr += 2; break;
+                case TR::ANIM_CMD_EFFECT :
+                    if (flip) {
+                        int frame = (*ptr++) - anim->frameStart;
+                        int fx    = (*ptr++) & 0x3FFF;
+                        *flip     = fx == TR::EFFECT_ROTATE_180 && frame == frameIndex;
+                    } else
+                        ptr += 2;
+                    break;
+            }
+        }
+    }
+
+    quat getJointRot(int joint) {
+        return lerpAngle(frameA->getAngle(joint), frameB->getAngle(joint), delta);
+    }
+
+    mat4 getJoints(mat4 matrix, int joint, bool postRot = false, mat4 *joints = NULL) {
+        TR::Animation *anim = anims + index;
+
+        vec3 offset = isPrepareToNext ? this->offset : vec3(0.0f);
+        matrix.translate(((vec3)frameA->pos).lerp(offset + frameB->pos, delta));
+
+        TR::Node *node = (int)model->node < level->nodesDataSize ? (TR::Node*)&level->nodesData[model->node] : NULL;
+
+        int sIndex = 0;
+        mat4 stack[16];
+
+        for (int i = 0; i < model->mCount; i++) {
+
+            if (i > 0 && node) {
+                TR::Node &t = node[i - 1];
+
+                if (t.flags & 0x01) matrix = stack[--sIndex];
+                if (t.flags & 0x02) stack[sIndex++] = matrix;
+
+                ASSERT(sIndex >= 0 && sIndex < 16);
+
+                matrix.translate(vec3((float)t.x, (float)t.y, (float)t.z));
+            }
+
+            if (i == joint && !postRot)
+                return matrix;
+
+            quat q;
+            if (overrideMask & (1 << i))
+                q = overrides[i];
+            else
+                q = getJointRot(i);
+            matrix = matrix * mat4(q, vec3(0.0f));
+
+            if (i == joint && postRot)
+                return matrix;
+
+            if (joints)
+                joints[i] = matrix;
+        }
+        return matrix;
+    }
+
+    Box getBoundingBox(const vec3 &pos, int dir) {
+        vec3 min = frameA->box.min().lerp(frameB->box.min(), delta);
+        vec3 max = frameA->box.max().lerp(frameB->box.max(), delta);
+        Box box(min, max);
+        box.rotate90(dir);
+        box.min += pos;
+        box.max += pos;
+        return box;
+    }
+};
+
+#endif
\ No newline at end of file
diff --git a/src/camera.h b/src/camera.h
index 22c96a8..6b40612 100644
--- a/src/camera.h
+++ b/src/camera.h
@@ -56,7 +56,9 @@ struct Camera : Controller {
     }
 
     virtual void update() {
-        actTargetEntity = owner->target;
+        int lookAt = -1;
+        if (owner->target > -1)     lookAt = owner->target;
+        if (actTargetEntity > -1)   lookAt = actTargetEntity;
 
         if (timer > 0.0f) {
             timer -= Core::deltaTime;
@@ -65,6 +67,7 @@ struct Camera : Controller {
                 if (room != getRoomIndex())
                     pos = lastDest;
                 actTargetEntity = actCamera = -1;
+                target = owner->getViewPoint();
             }
         }
     #ifdef FREE_CAMERA
@@ -91,28 +94,28 @@ struct Camera : Controller {
         angle.z = 0.0f;        
         //angle.x  = min(max(angle.x, -80 * DEG2RAD), 80 * DEG2RAD);
 
-        float lerpFactor = (actTargetEntity == -1) ? 6.0f : 10.0f;
+        float lerpFactor = (lookAt == -1) ? 6.0f : 10.0f;
         vec3 dir;
         target = target.lerp(owner->getViewPoint(), lerpFactor * Core::deltaTime);
 
         if (actCamera > -1) {
             TR::Camera &c = level->cameras[actCamera];
-            destPos = vec3(c.x, c.y, c.z);
+            destPos = vec3(float(c.x), float(c.y), float(c.z));
             if (room != getRoomIndex()) 
                 pos = destPos;
-            if (actTargetEntity > -1) {
-                TR::Entity &e = level->entities[actTargetEntity];
-                target = vec3(e.x, e.y, e.z);
+            if (lookAt > -1) {
+                TR::Entity &e = level->entities[lookAt];
+                target = ((Controller*)e.controller)->pos;
             }
         } else {
-            if (actTargetEntity > -1) {
-                TR::Entity &e = level->entities[actTargetEntity];
-                dir = (vec3(e.x, e.y, e.z) - target).normal();
+            if (lookAt > -1) {
+                TR::Entity &e = level->entities[lookAt];
+                dir = (((Controller*)e.controller)->pos - target).normal();
             } else
                 dir = getDir();
 
             int destRoom;
-            if ((owner->wpnState != Lara::Weapon::IS_HIDDEN || owner->state != Lara::STATE_BACK_JUMP) || actTargetEntity > -1) {
+            if ((!owner->emptyHands() || owner->state != Lara::STATE_BACK_JUMP) || lookAt > -1) {
                 vec3 eye = target - dir * CAMERA_OFFSET;
                 destPos = trace(owner->getRoomIndex(), target, eye, destRoom, true);
                 lastDest = destPos;
@@ -138,7 +141,7 @@ struct Camera : Controller {
                     room = info.roomAbove;
                 else
                     if (info.ceiling != 0xffff8100)
-                        pos.y = info.ceiling;
+                        pos.y = (float)info.ceiling;
             }
 
             if (pos.y > info.floor) {
@@ -146,7 +149,7 @@ struct Camera : Controller {
                     room = info.roomBelow;
                 else
                     if (info.floor != 0xffff8100)
-                        pos.y = info.floor;
+                        pos.y = (float)info.floor;
             }
 
         // play underwater sound when camera goes under water
diff --git a/src/character.h b/src/character.h
new file mode 100644
index 0000000..7b34d40
--- /dev/null
+++ b/src/character.h
@@ -0,0 +1,137 @@
+#ifndef H_CHARACTER
+#define H_CHARACTER
+
+#include "controller.h"
+
+struct Character : Controller {
+    int     target;
+    int     health;
+    float   tilt;
+    quat    rotHead, rotChest;
+
+    enum Stand { 
+        STAND_AIR, STAND_GROUND, STAND_SLIDE, STAND_HANG, STAND_UNDERWATER, STAND_ONWATER
+    }       stand;
+    int     input;
+
+    enum {  LEFT        = 1 << 1, 
+            RIGHT       = 1 << 2, 
+            FORTH       = 1 << 3, 
+            BACK        = 1 << 4, 
+            JUMP        = 1 << 5,
+            WALK        = 1 << 6,
+            ACTION      = 1 << 7,
+            WEAPON      = 1 << 8,
+            DEATH       = 1 << 9 };
+
+    vec3    velocity;
+    float   angleExt;
+
+    Character(TR::Level *level, int entity, int health) : Controller(level, entity), target(-1), health(100), tilt(0.0f), stand(STAND_GROUND), velocity(0.0f) {
+        animation.initOverrides();
+        rotHead  = rotChest = quat(0, 0, 0, 1);
+    }
+
+    virtual void hit(int damage) {
+        health -= damage;
+    };
+
+    virtual void checkRoom() {
+        TR::Level::FloorInfo info;
+        TR::Entity &e = getEntity();
+        level->getFloorInfo(e.room, e.x, e.z, info);
+
+        if (info.roomNext != 0xFF)
+            e.room = info.roomNext;        
+
+        if (info.roomBelow != 0xFF && e.y > info.floor)
+            e.room = info.roomBelow;       
+
+        if (info.roomAbove != 0xFF && e.y <= info.ceiling) {
+            if (stand == STAND_UNDERWATER && !level->rooms[info.roomAbove].flags.water) {
+                stand = STAND_ONWATER;
+                velocity.y = 0;
+                pos.y = float(info.ceiling);
+                updateEntity();
+            } else
+                if (stand != STAND_ONWATER)
+                    e.room = info.roomAbove;
+        }
+    }
+
+    virtual void cmdKill() {
+        health = 0;
+    }
+
+    virtual void  updatePosition()      {}
+    virtual Stand getStand()            { return stand; }
+    virtual int   getHeight()           { return 0; }
+    virtual int   getStateAir()         { return state; }
+    virtual int   getStateGround()      { return state; }
+    virtual int   getStateSlide()       { return state; }
+    virtual int   getStateHang()        { return state; }
+    virtual int   getStateUnderwater()  { return state; }
+    virtual int   getStateOnwater()     { return state; }
+    virtual int   getStateDeath()       { return state; }
+    virtual int   getStateDefault()     { return state; }
+    virtual int   getInput()            { return 0; }
+
+    virtual void updateState() {
+        int state = animation.state;
+
+        if (input & DEATH)
+            state = getStateDeath();        
+        else if (stand == STAND_GROUND)
+            state = getStateGround();
+        else if (stand == STAND_SLIDE)
+            state = getStateSlide();
+        else if (stand == STAND_HANG)
+            state = getStateHang();
+        else if (stand == STAND_AIR)
+            state = getStateAir();
+        else if (stand == STAND_UNDERWATER)
+            state = getStateUnderwater();
+        else
+            state = getStateOnwater();            
+
+        // try to set new state
+        if (!animation.setState(state))
+            animation.setState(getStateDefault());
+    }
+
+    virtual void updateTilt(bool active, float tiltSpeed, float tiltMax) {
+    // calculate turning tilt
+        if (active && (input & (LEFT | RIGHT)) && (tilt == 0.0f || (tilt < 0.0f && (input & LEFT)) || (tilt > 0.0f && (input & RIGHT)))) {
+            if (input & LEFT)  tilt -= tiltSpeed * Core::deltaTime;
+            if (input & RIGHT) tilt += tiltSpeed * Core::deltaTime;
+        } else
+            if (fabsf(tilt) > 0.01f) {
+                if (tilt > 0.0f)
+                    tilt -= min(tilt,  tiltSpeed * 4.0f * Core::deltaTime);
+                else
+                    tilt -= max(tilt, -tiltSpeed * 4.0f * Core::deltaTime);
+            } else
+                tilt = 0.0f;
+        tilt = clamp(tilt, -tiltMax, tiltMax);
+        
+        angle.z = tilt;
+    }
+
+    virtual void update() {
+        input = getInput();
+        stand = getStand();
+        updateState();
+        Controller::update();
+        updateVelocity();
+        updatePosition();
+    }
+
+    virtual void cmdJump(const vec3 &vel) {
+        velocity.x = sinf(angleExt) * vel.z;
+        velocity.y = vel.y;
+        velocity.z = cosf(angleExt) * vel.z;
+        stand = STAND_AIR;
+    }
+};
+
+#endif
\ No newline at end of file
diff --git a/src/controller.h b/src/controller.h
index 4723dde..76819a0 100644
--- a/src/controller.h
+++ b/src/controller.h
@@ -4,51 +4,25 @@
 #include "format.h"
 #include "frustum.h"
 #include "mesh.h"
+#include "animation.h"
 
 #define GRAVITY     6.0f
 #define NO_OVERLAP  0x7FFFFFFF
-
 #define SPRITE_FPS  10.0f
 
 struct Controller {
     TR::Level   *level;
     int         entity;
+    
+    Animation   animation;
+    int         &state;
 
-    enum Stand { 
-        STAND_AIR, STAND_GROUND, STAND_SLIDE, STAND_HANG, STAND_UNDERWATER, STAND_ONWATER
-    }       stand;
-    int     state;
-    int     mask;
-
-    enum {  LEFT        = 1 << 1, 
-            RIGHT       = 1 << 2, 
-            FORTH       = 1 << 3, 
-            BACK        = 1 << 4, 
-            JUMP        = 1 << 5,
-            WALK        = 1 << 6,
-            ACTION      = 1 << 7,
-            WEAPON      = 1 << 8,
-            DEATH       = 1 << 9 };
-
-    float   animTime;
-    int     animIndex, animPrev;
-    int     animPrevFrame;
-
-    vec3    pos, velocity;
+    vec3    pos;
     vec3    angle;
 
-    float   angleExt;
-
     int     *meshes;
     int     mCount;
 
-    // TODO: Character class
-    quat    *animOverrides;   // left & right arms animation frames
-    int     animOverrideMask;
-    mat4    *joints;
-    int     health; 
-    float   tilt;
-
     struct ActionCommand {
         TR::Action      action;
         int             value;
@@ -59,145 +33,39 @@ struct Controller {
         ActionCommand(TR::Action action, int value, float timer, ActionCommand *next = NULL) : action(action), value(value), timer(timer), next(next) {}
     } *actionCommand;
 
-    Controller(TR::Level *level, int entity) : level(level), entity(entity), velocity(0.0f), animTime(0.0f), animPrevFrame(0), actionCommand(NULL), mCount(0), meshes(NULL), animOverrides(NULL), animOverrideMask(0), joints(NULL) {
+    Controller(TR::Level *level, int entity) : level(level), entity(entity), animation(level, getModel()), state(animation.state), actionCommand(NULL), mCount(0), meshes(NULL) {
         TR::Entity &e = getEntity();
         pos       = vec3((float)e.x, (float)e.y, (float)e.z);
         angle     = vec3(0.0f, e.rotation, 0.0f);
-        stand     = STAND_GROUND;
-        animIndex = e.modelIndex > 0 ? getModel().animation : 0;
-        animPrev  = animIndex;
-        state     = level->anims[animIndex].state;
-        TR::Model &model = getModel();
-        health    = 100;
-        tilt      = 0.0f;
     }
 
     virtual ~Controller() {
         delete[] meshes;
-        delete[] animOverrides;
-        delete[] joints;
     }
 
     void initMeshOverrides() {
-        TR::Model &model = getModel();
-        mCount = model.mCount;
+        TR::Model *model = getModel();
+        mCount = model->mCount;
         meshes = mCount ? new int[mCount] : NULL;
         for (int i = 0; i < mCount; i++)
-            meshes[i] = model.mStart + i;
+            meshes[i] = model->mStart + i;
     }
 
-    void initAnimOverrides() {
-        TR::Model &model = getModel();
-
-        animOverrides    = new quat[model.mCount];
-        animOverrideMask = 0;
-
-        joints = new mat4[model.mCount];
-    }
-
-    void meshSwap(TR::Model &model, int mask) {
-        for (int i = 0; i < model.mCount; i++) {
-            int index = model.mStart + i;
+    void meshSwap(TR::Model *model, int mask) {
+        for (int i = 0; i < model->mCount; i++) {
+            int index = model->mStart + i;
             if (((1 << i) & mask) && level->meshOffsets[index])
                 meshes[i] = index;
         }
     }
 
-    int getFramesCount(int animIndex) {
-        TR::Animation &anim = level->anims[animIndex];
-        return (anim.frameEnd - anim.frameStart) / anim.frameRate + 1;
-    }
-
-    int getFrameIndex(int animIndex, float t) {
-        TR::Animation &anim = level->anims[animIndex];
-        return int(t * 30.0f / anim.frameRate) % ((anim.frameEnd - anim.frameStart) / anim.frameRate + 1);
-    }
-
-    void getFrames(TR::AnimFrame **frameA, TR::AnimFrame **frameB, float &t, int animIndex, float animTime, bool nextAnim = false, vec3 *move = NULL) {
-        TR::Animation *anim = &level->anims[animIndex];
-
-        t = animTime * 30.0f / anim->frameRate;
-        int fIndex = (int)t;
-        int fCount = (anim->frameEnd - anim->frameStart) / anim->frameRate + 1;
-
-        int fSize = sizeof(TR::AnimFrame) + getModel().mCount * sizeof(uint16) * 2;
-        t -= fIndex;
-
-        int fIndexA = fIndex % fCount, fIndexB = (fIndex + 1) % fCount;
-        *frameA = (TR::AnimFrame*)&level->frameData[(anim->frameOffset + fIndexA * fSize) >> 1];
-
-        if (!fIndexB) {
-            if (move)
-                *move = getAnimMove();
-            if (nextAnim) {
-                int nextFrame = anim->nextFrame;
-                anim = &level->anims[anim->nextAnimation];
-                fIndexB = (nextFrame - anim->frameStart) / anim->frameRate;
-            }
-        }
-        *frameB = (TR::AnimFrame*)&level->frameData[(anim->frameOffset + fIndexB * fSize) >> 1];
-    }
-
-    mat4 getJoint(int index, bool postRot = false) {
-        mat4 matrix;
-        matrix.identity();
-
-        matrix.translate(pos);
-        if (angle.y != 0.0f) matrix.rotateY(angle.y);
-        if (angle.x != 0.0f) matrix.rotateX(angle.x);
-        if (angle.z != 0.0f) matrix.rotateZ(angle.z);
-
-        TR::Animation *anim = &level->anims[animIndex];
-        TR::Model    &model = getModel();
-
-        float t;
-        vec3 move(0.0f);
-        TR::AnimFrame *frameA, *frameB;
-        getFrames(&frameA, &frameB, t, animIndex, animTime, true, &move);
-
-        TR::Node *node = (int)model.node < level->nodesDataSize ? (TR::Node*)&level->nodesData[model.node] : NULL;
-
-        matrix.translate(((vec3)frameA->pos).lerp(move + frameB->pos, t));
-
-        int sIndex = 0;
-        mat4 stack[20];
-
-        for (int i = 0; i < model.mCount; i++) {
-
-            if (i > 0 && node) {
-                TR::Node &t = node[i - 1];
-
-                if (t.flags & 0x01) matrix = stack[--sIndex];
-                if (t.flags & 0x02) stack[sIndex++] = matrix;
-
-                ASSERT(sIndex >= 0 && sIndex < 20);
-
-                matrix.translate(vec3(t.x, t.y, t.z));
-            }
-
-            if (i == index && !postRot)
-                return matrix;
-
-            quat q;
-            if (animOverrideMask & (1 << i))
-                q = animOverrides[i];
-            else
-                q = lerpAngle(frameA->getAngle(i), frameB->getAngle(i), t);
-            matrix = matrix * mat4(q, vec3(0.0f));
-
-            if (i == index && postRot)
-                return matrix;
-        }
-        return matrix;
-    }
-
     bool aim(int target, int joint, const vec4 &angleRange, quat &rot, quat *rotAbs = NULL) {
         if (target > -1) {
             TR::Entity &e = level->entities[target];
             Box box = ((Controller*)e.controller)->getBoundingBox();
             vec3 t = (box.min + box.max) * 0.5f;
 
-            mat4 m = getJoint(joint);
+            mat4 m = animation.getJoints(getMatrix(), joint);
             vec3 delta = (m.inverse() * t).normal();
 
             float angleY = clampAngle(atan2(delta.x, delta.z));
@@ -233,16 +101,17 @@ struct Controller {
 
     bool insideRoom(const vec3 &pos, int room) const {
         TR::Room &r = level->rooms[room];
-        vec3 min = vec3(r.info.x, r.info.yTop, r.info.z);
-        vec3 max = min + vec3(r.xSectors * 1024, r.info.yBottom - r.info.yTop, r.zSectors * 1024);
+        vec3 min = vec3((float)r.info.x, (float)r.info.yTop, (float)r.info.z);
+        vec3 max = min + vec3(float(r.xSectors * 1024), float(r.info.yBottom - r.info.yTop), float(r.zSectors * 1024));
 
         return  pos.x >= min.x && pos.x <= max.x &&
                 pos.y >= min.y && pos.y <= max.y &&
                 pos.z >= min.z && pos.z <= max.z;
     }
 
-    TR::Model& getModel() const {
-        return level->models[getEntity().modelIndex - 1];
+    TR::Model* getModel() const {
+        int index = getEntity().modelIndex;
+        return index > 0 ? &level->models[index - 1] : NULL;
     }
 
     TR::Entity& getEntity() const {
@@ -259,64 +128,6 @@ struct Controller {
         return getEntity().room;
     }
 
-    int setAnimation(int index, int frame = 0) {
-        animPrev  = animIndex;
-        animIndex = index;
-        TR::Animation &anim = level->anims[animIndex];
-        animTime  = (frame <= 0 ? -frame : (frame - anim.frameStart)) / 30.0f;
-        ASSERT(anim.frameStart <= anim.frameEnd);
-        animPrevFrame = int(animTime * 30.0f) - 1;
-        return state = anim.state;
-    }
-
-    bool canSetState(int state) {
-        TR::Animation *anim = &level->anims[animIndex];
-
-        if (state == anim->state)
-            return true;
-
-        int fIndex = int(animTime * 30.0f);
-
-        for (int i = 0; i < anim->scCount; i++) {
-            TR::AnimState &s = level->states[anim->scOffset + i];
-            if (s.state == state)
-                for (int j = 0; j < s.rangesCount; j++) {
-                    TR::AnimRange &range = level->ranges[s.rangesOffset + j];
-                    if (anim->frameStart + fIndex >= range.low && anim->frameStart + fIndex <= range.high)
-                        return true;
-                }
-        }
-
-        return false;
-    }
-
-    bool setState(int state) {
-        TR::Animation *anim = &level->anims[animIndex];
-
-        if (state == anim->state)
-            return true;
-
-        int fIndex = int(animTime * 30.0f);
-
-        bool exists = false;
-
-        for (int i = 0; i < anim->scCount; i++) {
-            TR::AnimState &s = level->states[anim->scOffset + i];
-            if (s.state == state) {
-                exists = true;
-                for (int j = 0; j < s.rangesCount; j++) {
-                    TR::AnimRange &range = level->ranges[s.rangesOffset + j];
-                    if (anim->frameStart + fIndex >= range.low && anim->frameStart + fIndex <= range.high) {
-                        setAnimation(range.nextAnimation, range.nextFrame);
-                        break;
-                    }
-                }
-            }
-        }
-
-        return exists;
-    }
-
     int getOverlap(int fromX, int fromY, int fromZ, int toX, int toZ) const {
         int dx, dz;
         TR::Room::Sector &s = level->getSector(getEntity().room, fromX, fromZ, dx, dz);
@@ -391,15 +202,7 @@ struct Controller {
     }
 
     virtual Box getBoundingBox() {
-        float t;
-        TR::AnimFrame *frameA, *frameB;
-        getFrames(&frameA, &frameB, t, animIndex, animTime, true);
-
-        Box box(frameA->box.min().lerp(frameB->box.min(), t), frameA->box.max().lerp(frameB->box.max(), t));
-        box.rotate90(getEntity().rotation.value / 0x4000);
-        box.min += pos;
-        box.max += pos;
-        return box;
+        return animation.getBoundingBox(pos, getEntity().rotation.value / 0x4000);
     }
 
     vec3 trace(int fromRoom, const vec3 &from, const vec3 &to, int &room, bool isCamera) { // TODO: use Bresenham
@@ -439,7 +242,7 @@ struct Controller {
                     int maxX = minX + 1024;
                     int maxZ = minZ + 1024;
 
-                    pos = vec3(clamp(px, minX, maxX), pos.y, clamp(pz, minZ, maxZ)) + boxNormal(px, pz) * 256.0f;
+                    pos = vec3(float(clamp(px, minX, maxX)), pos.y, float(clamp(pz, minZ, maxZ))) + boxNormal(px, pz) * 256.0f;
                     dir = (pos - from).normal();
                 }
             } else {
@@ -472,7 +275,7 @@ struct Controller {
         if (rand() % 10 <= 6) return;
         playSound(TR::SND_BUBBLE, pos, Sound::Flags::PAN);
     }
-
+    /*
     void collide() {
         TR::Entity &entity = getEntity();
 
@@ -510,7 +313,7 @@ struct Controller {
             }
         }
     }
-
+    */
     void activateNext() { // activate next entity (for triggers)
         if (!actionCommand || !actionCommand->next) {
             actionCommand = NULL;
@@ -555,93 +358,27 @@ struct Controller {
             actionCommand = NULL;
     }
 
-    virtual bool  activate(ActionCommand *cmd) { actionCommand = cmd; return true; } 
-    virtual void  doCustomCommand       (int curFrame, int prevFrame) {}
-    virtual void  updateVelocity()      {}
-    virtual void  checkRoom()           {}
-    virtual void  move()                {}
-    virtual Stand getStand()            { return STAND_AIR; }
-    virtual int   getHeight()           { return 0; }
-    virtual int   getStateAir()         { return state; }
-    virtual int   getStateGround()      { return state; }
-    virtual int   getStateSlide()       { return state; }
-    virtual int   getStateHang()        { return state; }
-    virtual int   getStateUnderwater()  { return state; }
-    virtual int   getStateOnwater()     { return state; }
-    virtual int   getStateDeath()       { return state; }
-    virtual int   getStateDefault()     { return state; }
-    virtual int   getInputMask()        { return 0; }
-    virtual void  hit(int damage)       { };
+    virtual bool  activate(ActionCommand *cmd)  { actionCommand = cmd; return true; } 
+    virtual void  doCustomCommand               (int curFrame, int prevFrame) {}
+    virtual void  updateVelocity()              {}
+    virtual void  checkRoom()                   {}
 
-    virtual int getState(Stand stand) {
-        TR::Animation *anim  = &level->anims[animIndex];
-
-        int state = anim->state;
-
-        if (mask & DEATH)
-            state = getStateDeath();        
-        else if (stand == STAND_GROUND)
-            state = getStateGround();
-        else if (stand == STAND_SLIDE)
-            state = getStateSlide();
-        else if (stand == STAND_HANG)
-            state = getStateHang();
-        else if (stand == STAND_AIR)
-            state = getStateAir();
-        else if (stand == STAND_UNDERWATER)
-            state = getStateUnderwater();
-        else
-            state = getStateOnwater();            
-
-        // try to set new state
-        if (!setState(state))
-            setState(getStateDefault());
-
-        return level->anims[animIndex].state;
-    }
-
-    virtual void updateBegin() {
-        mask  = getInputMask();
-        state = getState(stand = getStand());
-    }
-
-    virtual void updateEnd() {
-        TR::Entity &e = getEntity();
-        move();
+    virtual void  cmdOffset(const vec3 &offset) {
+        pos = pos + offset.rotateY(-angle.y);
         updateEntity();
+        checkRoom();
     }
 
-    virtual void updateState() {}
+    virtual void  cmdJump(const vec3 &vel)      {}
+    virtual void  cmdKill()                     {}
+    virtual void  cmdEmpty()                    {}
 
-    virtual vec3 getAnimMove() {
-        TR::Animation *anim = &level->anims[animIndex];
-        int16 *ptr = &level->commands[anim->animCommand];
-
-        for (int i = 0; i < anim->acCount; i++) {
-            int cmd = *ptr++; 
-            switch (cmd) {
-                case TR::ANIM_CMD_MOVE : { // cmd position
-                    int16 sx = *ptr++;
-                    int16 sy = *ptr++;
-                    int16 sz = *ptr++;
-                    return vec3((float)sx, (float)sy, (float)sz);
-                    break;
-                }
-                case TR::ANIM_CMD_SPEED  : // cmd jump speed
-                case TR::ANIM_CMD_SOUND  : // play sound
-                case TR::ANIM_CMD_EFFECT : // special commands
-                    ptr += 2;
-                    break;
-            }
-        }
-        return vec3(0.0f);
-    }
 
     virtual void updateAnimation(bool commands) {
-        int frameIndex = int((animTime += Core::deltaTime) * 30.0f);
-        TR::Animation *anim = &level->anims[animIndex];
-        bool endFrame = frameIndex > anim->frameEnd - anim->frameStart;
- 
+        animation.update();
+        
+        TR::Animation *anim = animation;
+
     // apply animation commands
         if (commands) {
             int16 *ptr = &level->commands[anim->animCommand];
@@ -649,50 +386,24 @@ struct Controller {
             for (int i = 0; i < anim->acCount; i++) {
                 int cmd = *ptr++; 
                 switch (cmd) {
-                    case TR::ANIM_CMD_MOVE : { // cmd position
-                        int16 sx = *ptr++;
-                        int16 sy = *ptr++;
-                        int16 sz = *ptr++;
-                        if (endFrame) {
-                            pos = pos + vec3(sx, sy, sz).rotateY(-angle.y);
-                            updateEntity();
-                            checkRoom();
-                            LOG("move: %d %d %d\n", (int)sx, (int)sy, (int)sz);
-                        }
-                        break;
-                    }
-                    case TR::ANIM_CMD_SPEED : { // cmd jump speed
-                        int16 sy = *ptr++;
-                        int16 sz = *ptr++;
-                        if (endFrame) {
-                            LOG("jump: %d %d\n", (int)sy, (int)sz);
-                            velocity.x = sinf(angleExt) * sz;
-                            velocity.y = sy;
-                            velocity.z = cosf(angleExt) * sz;
-                            stand = STAND_AIR;
-                        }
-                        break;
-                    }
-                    case TR::ANIM_CMD_EMPTY : // empty hands
-                        break;
-                    case TR::ANIM_CMD_KILL : // kill
-                        break;
-                    case TR::ANIM_CMD_SOUND  : // play sound
-                    case TR::ANIM_CMD_EFFECT : { // special commands
-                        int frame = (*ptr++);
-                        int id    = (*ptr++) & 0x3FFF;
-                        int idx   = frame - anim->frameStart;
-
-                        if (idx > animPrevFrame && idx <= frameIndex) {
+                    case TR::ANIM_CMD_OFFSET : ptr += 3;   break;
+                    case TR::ANIM_CMD_JUMP   : ptr += 2;   break;      
+                    case TR::ANIM_CMD_EMPTY  : cmdEmpty(); break;
+                    case TR::ANIM_CMD_KILL   : cmdKill();  break;
+                    case TR::ANIM_CMD_SOUND  :
+                    case TR::ANIM_CMD_EFFECT : {
+                        int frame = (*ptr++) - anim->frameStart;
+                        int fx    = (*ptr++) & 0x3FFF;
+                        if (animation.isFrameActive(frame)) {
                             if (cmd == TR::ANIM_CMD_EFFECT) {
-                                switch (id) {
-                                    case TR::EFFECT_ROTATE_180     : angle.y = angle.y + PI;    break;
+                                switch (fx) {
+                                    case TR::EFFECT_ROTATE_180     : angle.y = angle.y + PI; break;
                                     case TR::EFFECT_LARA_BUBBLES   : doBubbles(); break;
                                     case TR::EFFECT_LARA_HANDSFREE : break;
-                                    default : LOG("unknown special cmd %d (anim %d)\n", id, animIndex);
+                                    default : LOG("unknown special cmd %d (anim %d)\n", fx, animation.index);
                                 }
                             } else
-                                playSound(id, pos, Sound::Flags::PAN);
+                                playSound(fx, pos, Sound::Flags::PAN);
                         }
                         break;
                     }
@@ -700,21 +411,20 @@ struct Controller {
             }
         }
 
-        doCustomCommand(frameIndex, animPrevFrame);
+        if (animation.frameIndex != animation.framePrev)
+            doCustomCommand(animation.frameIndex, animation.framePrev);
 
-        if (endFrame) { // if animation is end - switch to next
-            setAnimation(anim->nextAnimation, anim->nextFrame);    
+        if (animation.isEnded) { // if animation is end - switch to next
+            if (animation.offset != 0.0f) cmdOffset(animation.offset);
+            if (animation.jump   != 0.0f) cmdJump(animation.jump);
+            animation.playNext();
             activateNext();
         } else
-            animPrevFrame = frameIndex;
+            animation.framePrev = animation.frameIndex;
     }
     
     virtual void update() {
-        updateBegin();
-        updateState();
-        updateAnimation(true);        
-        updateVelocity();
-        updateEnd();
+        updateAnimation(true);
     }
     
     void renderMesh(const mat4 &matrix, MeshBuilder *mesh, uint32 offsetIndex) {
@@ -739,139 +449,40 @@ struct Controller {
         mesh->renderShadowSpot();
     }
 
-    virtual void render(Frustum *frustum, MeshBuilder *mesh) {
-        TR::Entity &entity = getEntity();
-        TR::Model  &model  = getModel();
-
-        TR::Animation *anim  = &level->anims[animIndex];
-
-        mat4 matrix(Core::mModel);
+    mat4 getMatrix() {
+        mat4 matrix;
+        matrix.identity();
         matrix.translate(pos);
-        if (angle.y != 0.0f) matrix.rotateY(angle.y);
+        if (angle.y != 0.0f) matrix.rotateY(angle.y - (animation.flip ? PI * animation.delta : 0.0f));
         if (angle.x != 0.0f) matrix.rotateX(angle.x);
         if (angle.z != 0.0f) matrix.rotateZ(angle.z);
+        return matrix;
+    }
 
-        float t;
-        vec3 move(0.0f);
-        TR::AnimFrame *frameA, *frameB;
-        getFrames(&frameA, &frameB, t, animIndex, animTime, true, &move);
+    virtual void render(Frustum *frustum, MeshBuilder *mesh) { // TODO: animation.calcJoints
+        mat4 matrix = getMatrix();
 
-        vec3 bmin = frameA->box.min().lerp(frameB->box.min(), t);
-        vec3 bmax = frameA->box.max().lerp(frameB->box.max(), t);
-        if (frustum && !frustum->isVisible(matrix, bmin, bmax))
+        Box box = animation.getBoundingBox(vec3(0, 0, 0), 0);
+        if (frustum && !frustum->isVisible(matrix, box.min, box.max))
             return;
+
+        TR::Entity &entity = getEntity();
+        TR::Model  *model  = getModel();
         entity.flags.rendered = true;
 
-        TR::Node *node = (int)model.node < level->nodesDataSize ? (TR::Node*)&level->nodesData[model.node] : NULL;
+        mat4 joints[32]; // TODO: UBO heap
+        ASSERT(model->mCount <= 32);
 
-        matrix.translate(((vec3)frameA->pos).lerp(move + frameB->pos, t));
-
-        int sIndex = 0;
-        mat4 stack[20];
-
-        for (int i = 0; i < model.mCount; i++) {
-
-            if (i > 0 && node) {
-                TR::Node &t = node[i - 1];
-
-                if (t.flags & 0x01) matrix = stack[--sIndex];
-                if (t.flags & 0x02) stack[sIndex++] = matrix;
-
-                ASSERT(sIndex >= 0 && sIndex < 20);
-
-                matrix.translate(vec3(t.x, t.y, t.z));
-            }
-
-            quat q;
-            if (animOverrideMask & (1 << i))
-                q = animOverrides[i];
-            else
-                q = lerpAngle(frameA->getAngle(i), frameB->getAngle(i), t);
-            matrix = matrix * mat4(q, vec3(0.0f));
-            
-            if (meshes)
-                renderMesh(matrix, mesh, meshes[i]);
-            else
-                renderMesh(matrix, mesh, model.mStart + i);
-
-            if (joints)
-                joints[i] = matrix;
-        }
+        animation.getJoints(matrix, -1, true, joints);
+        for (int i = 0; i < model->mCount; i++)
+            renderMesh(joints[i], mesh, meshes ? meshes[i] : (model->mStart + i));
 
         if (TR::castShadow(entity.type)) {
             TR::Level::FloorInfo info;
             level->getFloorInfo(entity.room, entity.x, entity.z, info, true);
-            renderShadow(mesh, vec3(entity.x, info.floor - 16.0f, entity.z), (bmax + bmin) * 0.5f, (bmax - bmin) * 0.8f, entity.rotation);
+            renderShadow(mesh, vec3(float(entity.x), info.floor - 16.0f, float(entity.z)), box.center(), box.size() * 0.8f, angle.y);
         }
     }
-
-    quat lerpFrames(TR::AnimFrame *frameA, TR::AnimFrame *frameB,  float t, int index) {
-        return lerpAngle(frameA->getAngle(index), frameB->getAngle(index), t);
-    }
 };
 
-
-struct SpriteController : Controller {
-
-    enum {
-        FRAME_ANIMATED = -1,
-        FRAME_RANDOM   = -2,
-    };
-
-    int frame, flag;
-    bool instant;
-
-    SpriteController(TR::Level *level, int entity, bool instant = true, int frame = FRAME_ANIMATED) : Controller(level, entity), instant(instant), flag(frame) {
-        if (frame >= 0) { // specific frame
-            this->frame = frame;
-        } else if (frame == FRAME_RANDOM) { // random frame
-            this->frame = rand() % getSequence().sCount;
-        } else if (frame == FRAME_ANIMATED) { // animated
-            this->frame = 0;
-        }
-    }
-
-    TR::SpriteSequence& getSequence() {
-        return level->spriteSequences[-(getEntity().modelIndex + 1)];
-    }
-
-    void update() {
-        if (flag >= 0) return;
-
-        bool remove = false;
-        animTime += Core::deltaTime;
-
-        if (flag == FRAME_ANIMATED) {
-            frame = int(animTime * SPRITE_FPS);
-            TR::SpriteSequence &seq = getSequence();
-            if (instant && frame >= seq.sCount)
-                remove = true;
-            else
-                frame %= seq.sCount;
-        } else
-            if (instant && animTime >= (1.0f / SPRITE_FPS))
-                remove = true;
-
-        if (remove) {
-            level->entityRemove(entity);
-            delete this;
-        }
-    }
-
-    virtual void render(Frustum *frustum, MeshBuilder *mesh) {
-        mat4 m(Core::mModel);
-        m.translate(pos);
-        Core::active.shader->setParam(uModel, m);
-        mesh->renderSprite(-(getEntity().modelIndex + 1), frame);
-    }
-};
-
-void addSprite(TR::Level *level, TR::Entity::Type type, int room, int x, int y, int z, int frame = -1) {
-    int index = level->entityAdd(type, room, x, y, z, 0, -1);
-    if (index > -1) {
-        level->entities[index].intensity  = 0x1FFF - level->rooms[room].ambient;
-        level->entities[index].controller = new SpriteController(level, index, true, frame);
-    }
-}
-
 #endif
\ No newline at end of file
diff --git a/src/debug.h b/src/debug.h
index 4d7b0be..d8bb5ff 100644
--- a/src/debug.h
+++ b/src/debug.h
@@ -449,13 +449,13 @@ namespace Debug {
                     TR::Node *node = m.node < level.nodesDataSize ? (TR::Node*)&level.nodesData[m.node] : NULL;
 
                     if (!node) continue; // ???
-
+/*
                     if (e.type == m.type) {
                         ASSERT(m.animation < 0xFFFF);
 
                         int fSize = sizeof(TR::AnimFrame) + m.mCount * sizeof(uint16) * 2;
 
-                        TR::Animation *anim  = controller ? &level.anims[controller->animIndex] : &level.anims[m.animation];
+                        TR::Animation *anim  = controller->animation;
                         TR::AnimFrame *frame = (TR::AnimFrame*)&level.frameData[(anim->frameOffset + (controller ? int((controller->animTime * 30.0f / anim->frameRate)) * fSize : 0) >> 1)];
 
                         //mat4 m;
@@ -495,35 +495,39 @@ namespace Debug {
                             int offset = level.meshOffsets[m.mStart + k];
                             TR::Mesh *mesh = (TR::Mesh*)&level.meshData[offset / 2];
                             Debug::Draw::sphere(matrix * joint * mesh->center, mesh->collider.radius, mesh->collider.info ? vec4(1, 0, 0, 0.5f) : vec4(0, 1, 1, 0.5f));
-                            /*
+                            
                             { //if (e.id != 0) {
                                 char buf[255];
                                 sprintf(buf, "(%d) radius %d info %d flags %d", e.id, (int)mesh->collider.radius, (int)mesh->collider.info, (int)mesh->collider.flags);
                                 Debug::Draw::text(matrix * joint * mesh->center, vec4(0.5, 1, 0.5, 1), buf);
                             }
-                            */
+                            
                         }
-
                         Debug::Draw::box(matrix, frame->box.min(), frame->box.max(), vec4(1.0));
+
                         break;
                     }
+*/
                 
                 }
 
             }
         }
 
-        void info(const TR::Level &level, const TR::Entity &entity, int state, int anim, int frame) {
+        void info(const TR::Level &level, const TR::Entity &entity, Animation &anim) {
             char buf[255];
             sprintf(buf, "DIP = %d, TRI = %d, SND = %d", Core::stats.dips, Core::stats.tris, Sound::channelsCount);
             Debug::Draw::text(vec2(16, 16), vec4(1.0f), buf);
-            sprintf(buf, "pos = (%d, %d, %d), room = %d, state = %d, anim = %d, frame = %d", entity.x, entity.y, entity.z, entity.room, state, anim, frame);
+            sprintf(buf, "pos = (%d, %d, %d), room = %d", entity.x, entity.y, entity.z, entity.room);
             Debug::Draw::text(vec2(16, 32), vec4(1.0f), buf);
+            int rate = anim.anims[anim.index].frameRate;
+            sprintf(buf, "state = %d, anim = %d, next = %d, rate = %d, frame = %.2f / %d (%f)", anim.state, anim.index, anim.next, rate, anim.time * 30.0f, anim.framesCount, anim.delta);
+            Debug::Draw::text(vec2(16, 48), vec4(1.0f), buf);
             
             TR::Level::FloorInfo info;
             level.getFloorInfo(entity.room, entity.x, entity.z, info);
             sprintf(buf, "floor = %d, roomBelow = %d, roomAbove = %d, height = %d", info.floorIndex, info.roomBelow, info.roomAbove, info.floor - info.ceiling);
-            Debug::Draw::text(vec2(16, 48), vec4(1.0f), buf);
+            Debug::Draw::text(vec2(16, 64), vec4(1.0f), buf);
         }
     }
 }
diff --git a/src/enemy.h b/src/enemy.h
index ad29d4d..c588cf7 100644
--- a/src/enemy.h
+++ b/src/enemy.h
@@ -1,26 +1,11 @@
 #ifndef H_ENEMY
 #define H_ENEMY
 
-#include "controller.h"
+#include "character.h"
 
-struct Enemy : Controller {
-    int target;
-    quat rotHead, rotChest;
-    int baseAnim;
+struct Enemy : Character {
 
-    Enemy(TR::Level *level, int entity) : Controller(level, entity), target(-1) {
-        initAnimOverrides();
-        rotHead  = rotChest = quat(0, 0, 0, 1);
-        baseAnim = animIndex;
-    }
-
-    virtual Stand getStand() {
-        return STAND_GROUND;
-    }
-
-    virtual void hit(int damage) {
-        health -= damage;
-    };
+    Enemy(TR::Level *level, int entity, int health) : Character(level, entity, health) {}
 
     virtual bool activate(ActionCommand *cmd) {
         Controller::activate(cmd);
@@ -38,66 +23,40 @@ struct Enemy : Controller {
     }
 
     virtual void updateVelocity() {
-        TR::Animation *anim = &level->anims[animIndex];
-        float speed = anim->speed + anim->accel * (animTime * 30.0f);
+        TR::Animation *anim = animation;
+        float speed = anim->speed + anim->accel * (animation.time * 30.0f);
         velocity = getDir() * speed;
     }
 
-    virtual void move() {
+    virtual void updatePosition() {
         if (!getEntity().flags.active) return;
         vec3 p = pos;
         pos += velocity * Core::deltaTime * 30.0f;
         TR::Level::FloorInfo info;
-        level->getFloorInfo(getRoomIndex(), (int)pos.x, (int)pos.z, info);
+        level->getFloorInfo(getRoomIndex(), (int)pos.x, (int)pos.z, info, true);
         if (pos.y - info.floor > 1024) {
             pos = p;
             return;
         }
         if (stand == STAND_GROUND)
-            pos.y = info.floor;
+            pos.y = float(info.floor);
         updateEntity();
         checkRoom();
     }
 
-    virtual void checkRoom() {
-        TR::Level::FloorInfo info;
-        TR::Entity &e = getEntity();
-        level->getFloorInfo(e.room, e.x, e.z, info);
-
-        if (info.roomNext != 0xFF)
-            e.room = info.roomNext;        
-
-        if (info.roomBelow != 0xFF && e.y > info.floor)
-            e.room = info.roomBelow;       
-
-        if (info.roomAbove != 0xFF && e.y <= info.ceiling) {
-            if (stand == STAND_UNDERWATER && !level->rooms[info.roomAbove].flags.water) {
-                stand = STAND_ONWATER;
-                velocity.y = 0;
-                pos.y = info.ceiling;
-                updateEntity();
-            } else
-                if (stand != STAND_ONWATER)
-                    e.room = info.roomAbove;
-        }
-    }
-
     void setOverrides(bool active, int chest, int head) {
         int mask = 0;
-        if (head  > -1) mask |= (1 << head);
-        if (chest > -1) mask |= (1 << chest);
+        if (active && head  > -1) {
+            animation.overrides[head] = animation.getJointRot(head);
+            animation.overrideMask |=  (1 << head);
+        } else
+            animation.overrideMask &= ~(1 << head);
 
-        if (active)
-            animOverrideMask |= mask;
-        else
-            animOverrideMask &= ~mask;
-
-        TR::AnimFrame *frameA, *frameB;
-        float t;
-
-        getFrames(&frameA, &frameB, t, animIndex, animTime, true);
-        animOverrides[chest] = lerpFrames(frameA, frameB, t, chest);
-        animOverrides[head]  = lerpFrames(frameA, frameB, t, head);
+        if (active && chest  > -1) {
+            animation.overrides[chest] = animation.getJointRot(chest);
+            animation.overrideMask |=  (1 << chest);
+        } else
+            animation.overrideMask &= ~(1 << chest);
     }
 
     void lookAt(int target, int chest, int head) {
@@ -105,11 +64,11 @@ struct Enemy : Controller {
         quat rot;
 
         if (chest > -1) {
-            if (aim(target, chest, vec4(-PI * 0.4f, PI * 0.4f, -PI * 0.75f, PI * 0.75f), rot))
+            if (aim(target, chest, vec4(-PI * 0.8f, PI * 0.8f, -PI * 0.75f, PI * 0.75f), rot))
                 rotChest = rotChest.slerp(quat(0, 0, 0, 1).slerp(rot, 0.5f), speed);
             else 
                 rotChest = rotChest.slerp(quat(0, 0, 0, 1), speed);
-            animOverrides[chest] = rotChest * animOverrides[chest];
+            animation.overrides[chest] = rotChest * animation.overrides[chest];
         }
 
         if (head > -1) {
@@ -117,14 +76,16 @@ struct Enemy : Controller {
                 rotHead = rotHead.slerp(rot, speed);
             else
                 rotHead = rotHead.slerp(quat(0, 0, 0, 1), speed);
-            animOverrides[head] = rotHead * animOverrides[head];
+            animation.overrides[head] = rotHead * animation.overrides[head];
         }
     }
 
-    virtual int getInputMask() {
+    virtual int getInput() {
         if (target > -1) {
-            vec3 v = (((Controller*)level->entities[target].controller)->pos - pos).normal();
-            float d = atan2(v.x, v.z) - angle.y;
+            vec3 a = (((Controller*)level->entities[target].controller)->pos - pos).normal();
+            vec3 b = getDir();
+            vec3 n = vec3(0, 1, 0);
+            float d = atan2(b.cross(a).dot(n), a.dot(b));
             if (fabsf(d) > 0.01f)
                 return d < 0 ? LEFT : RIGHT;
         }
@@ -135,6 +96,9 @@ struct Enemy : Controller {
 
 #define WOLF_TURN_FAST   PI
 #define WOLF_TURN_SLOW   (PI / 3.0f)
+#define WOLF_TILT_MAX    (PI / 6.0f)
+#define WOLF_TILT_SPEED  WOLF_TILT_MAX
+
 
 struct Wolf : Enemy {
 
@@ -163,7 +127,7 @@ struct Wolf : Enemy {
         JOINT_HEAD     = 3
     };
 
-    Wolf(TR::Level *level, int entity) : Enemy(level, entity) {}
+    Wolf(TR::Level *level, int entity) : Enemy(level, entity, 100) {}
 
     virtual int getStateGround() {
         // STATE_SLEEP     -> STATE_STOP
@@ -178,9 +142,9 @@ struct Wolf : Enemy {
 
         if (health <= 0) {
             switch (state) {
-                case STATE_RUN  : return setAnimation(baseAnim + ANIM_DEATH_RUN);
-                case STATE_JUMP : return setAnimation(baseAnim + ANIM_DEATH_JUMP);
-                default         : return setAnimation(baseAnim + ANIM_DEATH);
+                case STATE_RUN  : return animation.setAnim(ANIM_DEATH_RUN);
+                case STATE_JUMP : return animation.setAnim(ANIM_DEATH_JUMP);
+                default         : return animation.setAnim(ANIM_DEATH);
             }
         }
 
@@ -191,7 +155,7 @@ struct Wolf : Enemy {
         switch (state) {
             case STATE_SLEEP    : return STATE_STOP;
             case STATE_STOP     : return STATE_HOWL;
-            case STATE_GROWL    : return STATE_STALKING;
+            case STATE_GROWL    : return randf() > 0.5f ? STATE_STALKING : STATE_RUN;
             case STATE_STALKING : if (health < 70) return STATE_RUN; break;
         }
 
@@ -215,7 +179,7 @@ struct Wolf : Enemy {
         float w = 0.0f;
         if (state == STATE_RUN || state == STATE_STALKING) {
             w = state == STATE_RUN ? WOLF_TURN_FAST : WOLF_TURN_SLOW;
-            if (mask & LEFT) w = -w;
+            if (input & LEFT) w = -w;
                 
             if (w != 0.0f) {
                 w *= Core::deltaTime;
@@ -226,12 +190,14 @@ struct Wolf : Enemy {
             velocity = vec3(0.0f);
     }
 
-    virtual void move() {
+    virtual void updatePosition() {
+        updateTilt(state == STATE_RUN, WOLF_TILT_SPEED, WOLF_TILT_MAX);
+
         if (state == STATE_DEATH) {
-            animOverrideMask = 0;
+            animation.overrideMask = 0;
             return;
         }
-        Enemy::move();
+        Enemy::updatePosition();
         setOverrides(state == STATE_STALKING || state == STATE_RUN, JOINT_CHEST, JOINT_HEAD);
         lookAt(target, JOINT_CHEST, JOINT_HEAD);
     }
@@ -244,7 +210,7 @@ struct Bear : Enemy {
         STATE_STOP   = 1,
     };
 
-    Bear(TR::Level *level, int entity) : Enemy(level, entity) {}
+    Bear(TR::Level *level, int entity) : Enemy(level, entity, 100) {}
 
     virtual int getStateGround() {
         return state;
@@ -259,14 +225,14 @@ struct Bat : Enemy {
         STATE_FLY    = 2,
     };
 
-    Bat(TR::Level *level, int entity) : Enemy(level, entity) {}
+    Bat(TR::Level *level, int entity) : Enemy(level, entity, 100) {}
 
     virtual Stand getStand() {
         return STAND_AIR;
     }
 
     virtual int getStateAir() {
-        animTime = 0.0f;
+        animation.time = 0.0f;
         return STATE_AWAKE;
     }
 };
diff --git a/src/format.h b/src/format.h
index 746e34b..f81b74c 100644
--- a/src/format.h
+++ b/src/format.h
@@ -5,13 +5,14 @@
 
 #define MAX_RESERVED_ENTITIES 64
 #define MAX_SECRETS_COUNT     16
+#define MAX_TRIGGER_COMMANDS  32
 
 namespace TR {
 
     enum {
         ANIM_CMD_NONE       ,
-        ANIM_CMD_MOVE       ,
-        ANIM_CMD_SPEED      ,
+        ANIM_CMD_OFFSET     ,
+        ANIM_CMD_JUMP       ,
         ANIM_CMD_EMPTY      ,
         ANIM_CMD_KILL       ,
         ANIM_CMD_SOUND      ,
@@ -106,6 +107,15 @@ namespace TR {
         SND_SECRET          = 173,
     };
 
+    enum {
+        MODEL_LARA          = 0,
+        MODEL_PISTOLS       = 1,
+        MODEL_SHOTGUN       = 2,
+        MODEL_MAGNUMS       = 3,
+        MODEL_UZIS          = 4,
+        MODEL_LARA_SPEC     = 5,
+    };
+
     enum Action : uint16 {
         ACTIVATE        ,   // activate item
         CAMERA_SWITCH   ,   // switch to camera
@@ -419,6 +429,17 @@ namespace TR {
         bool isEnemy() {
             return type >= ENEMY_TWIN && type <= ENEMY_LARSON;
         }
+
+        int isItem() {
+            return (type >= WEAPON_PISTOLS && type <= AMMO_UZIS) ||
+                   (type >= PUZZLE_1 && type <= PUZZLE_4) ||
+                   (type >= KEY_1 && type <= KEY_4) ||
+                   (type == MEDIKIT_SMALL || type == MEDIKIT_BIG || type == ARTIFACT || type == PICKUP);
+        }
+
+        bool isBlock() {
+            return type >= TR::Entity::BLOCK_1 && type <= TR::Entity::BLOCK_2;
+        }
     };
 
     struct Animation {
@@ -463,11 +484,13 @@ namespace TR {
         vec3 max() const { return vec3((float)maxX, (float)maxY, (float)maxZ); }
     };
 
+    #pragma warning( push )
+    #pragma warning( disable : 4200 ) // zero-sized array warning
     struct AnimFrame {
         MinMax  box;
-        Vertex  pos;   // Starting offset for this model
+        Vertex  pos;
         int16   aCount;
-        uint16  angles[0];          // angle frames in YXZ order
+        uint16  angles[0];  // angle frames in YXZ order
 
         vec3 getAngle(int index) {
             #define ANGLE_SCALE (2.0f * PI / 1024.0f)
@@ -475,7 +498,7 @@ namespace TR {
             uint16 b = angles[index * 2 + 0];
             uint16 a = angles[index * 2 + 1];
 
-            return vec3((a & 0x3FF0) >> 4, ( ((a & 0x000F) << 6) | ((b & 0xFC00) >> 10)), b & 0x03FF) * ANGLE_SCALE;
+            return vec3(float((a & 0x3FF0) >> 4), float( ((a & 0x000F) << 6) | ((b & 0xFC00) >> 10)), float(b & 0x03FF)) * ANGLE_SCALE;
         }
     };
 
@@ -483,6 +506,7 @@ namespace TR {
         int16   count;        // number of texture offsets - 1 in group
         int16   textures[0];  // offsets into objectTextures[]
     };
+    #pragma warning( push )
 
     struct Node {
         uint32  flags;
@@ -715,7 +739,7 @@ namespace TR {
             int trigCmdCount;
             Trigger trigger;
             FloorData::TriggerInfo trigInfo;
-            FloorData::TriggerCommand trigCmd[16];
+            FloorData::TriggerCommand trigCmd[MAX_TRIGGER_COMMANDS];
 
             vec3 getNormal() {
                 return vec3((float)-slantX, -4.0f, (float)-slantZ).normal();
@@ -734,7 +758,8 @@ namespace TR {
         bool    secrets[MAX_SECRETS_COUNT];
         void    *cameraController;
 
-        Level(Stream &stream, bool demo) {
+        Level(const char *name, bool demo) {
+            Stream stream(name);
         // read version
             stream.read(version);
         // tiles
@@ -1039,6 +1064,7 @@ namespace TR {
                         info.trigInfo       = (*fd++).triggerInfo;
                         FloorData::TriggerCommand trigCmd;
                         do {
+                            ASSERT(info.trigCmdCount < MAX_TRIGGER_COMMANDS);
                             trigCmd = (*fd++).triggerCmd; // trigger action
                             info.trigCmd[info.trigCmdCount++] = trigCmd;
                         } while (!trigCmd.end);                       
diff --git a/src/game.h b/src/game.h
index 81526b1..e29cb48 100644
--- a/src/game.h
+++ b/src/game.h
@@ -12,8 +12,9 @@ namespace Game {
 
     void init() {
         Core::init();
-        Stream stream("LEVEL2_DEMO.PHD");
-        level = new Level(stream, true);
+        level = new Level("LEVEL2_DEMO.PHD", true, false);
+        //level = new Level("GYM.PHD", false, true);
+        //level = new Level("LEVEL4.PHD", false, false);
 
         #ifndef __EMSCRIPTEN__    
             //Sound::play(Sound::openWAD("05_Lara's_Themes.wav"), 1, 1, 0);
@@ -29,7 +30,13 @@ namespace Game {
     }
 
     void update() {
+        float dt = Core::deltaTime;
+        if (Input::down[ikR]) // slow motion (for animation debugging)
+            Core::deltaTime /= 50.0f;
+
         level->update();
+
+        Core::deltaTime = dt;
     }
 
     void render() {
diff --git a/src/lara.h b/src/lara.h
index 73f8bfd..2c67f38 100644
--- a/src/lara.h
+++ b/src/lara.h
@@ -3,20 +3,23 @@
 /*****************************************/
 /*     Desine sperare qui hic intras     */
 /*****************************************/
-#include "controller.h"
+#include "character.h"
 #include "trigger.h"
+#include "sprite.h"
 
 #define TURN_FAST           PI
 #define TURN_FAST_BACK      PI * 3.0f / 4.0f
 #define TURN_NORMAL         PI / 2.0f
 #define TURN_SLOW           PI / 3.0f
-#define TILT_MAX            (PI / 18.0f)
-#define TILT_SPEED          TILT_MAX
 #define TURN_WATER_FAST     PI * 3.0f / 4.0f
 #define TURN_WATER_SLOW     PI * 2.0f / 3.0f
+
+#define TILT_MAX            (PI / 18.0f)
+#define TILT_SPEED          TILT_MAX
+
 #define GLIDE_SPEED         50.0f
 
-#define LARA_HANG_OFFSET    735
+#define LARA_HANG_OFFSET    735.0f
 
 #define PICKUP_FRAME_GROUND     40
 #define PICKUP_FRAME_UNDERWATER 16
@@ -28,10 +31,7 @@
 #define FLASH_LIGHT_COLOR   vec4(0.8f, 0.7f, 0.3f, 2048 * 2048)
 #define TARGET_MAX_DIST     (8.0f * 1024.0f)
 
-struct Lara : Controller {
-
-    ActionCommand actionList[MAX_TRIGGER_ACTIONS];
-    int lastPickUp;
+struct Lara : Character {
 
     // http://www.tombraiderforums.com/showthread.php?t=148859
     enum {
@@ -165,6 +165,8 @@ struct Lara : Controller {
         BODY_LOWER      = BODY_HIP    | BODY_LEG_L  | BODY_LEG_R,
     };
 
+    bool home;
+
     struct Weapon {
         enum Type  { EMPTY, PISTOLS, SHOTGUN, MAGNUMS, UZIS, MAX };
         enum State { IS_HIDDEN, IS_ARMED, IS_FIRING };
@@ -180,38 +182,32 @@ struct Lara : Controller {
 
     struct Arm {
         int             target;
-        int             lastFrame;
         float           shotTimer;
-        float           weight;
-        float           animDir;
-        float           animTime;
-        float           animMaxTime;
-        int             animIndex;
         quat            rot, rotAbs;
-        Weapon::Anim    anim;        
+        Weapon::Anim    anim;
+        Animation       animation;
     } arms[2];
 
-    int  target;
-    quat rotHead, rotChest;
+    ActionCommand actionList[MAX_TRIGGER_ACTIONS];
+    int lastPickUp;
 
-    Lara(TR::Level *level, int entity) : Controller(level, entity), wpnCurrent(Weapon::EMPTY), wpnNext(Weapon::EMPTY), chestOffset(pos), target(-1) {
+    Lara(TR::Level *level, int entity, bool home) : Character(level, entity, 100), home(home), wpnCurrent(Weapon::EMPTY), wpnNext(Weapon::EMPTY), chestOffset(pos) {
         initMeshOverrides();
-        initAnimOverrides();
         for (int i = 0; i < 2; i++) {
             arms[i].shotTimer = MUZZLE_FLASH_TIME + 1.0f;
-            arms[i].animTime  = 0.0f;
             arms[i].rot       = quat(0, 0, 0, 1);
             arms[i].rotAbs    = quat(0, 0, 0, 1);
         }
 
-        rotHead = rotChest = quat(0, 0, 0, 1);
         memset(weapons, -1, sizeof(weapons));
-        weapons[Weapon::PISTOLS].ammo = 0;
-        weapons[Weapon::SHOTGUN].ammo = 9000;
-        weapons[Weapon::MAGNUMS].ammo = 9000;
-        weapons[Weapon::UZIS   ].ammo = 9000;
-
-        wpnSet(Weapon::PISTOLS);
+        if (!home) {
+            weapons[Weapon::PISTOLS].ammo = 0;
+            weapons[Weapon::SHOTGUN].ammo = 9000;
+            weapons[Weapon::MAGNUMS].ammo = 9000;
+            weapons[Weapon::UZIS   ].ammo = 9000;
+            wpnSet(Weapon::PISTOLS);
+        } else
+            meshSwap(&level->models[TR::MODEL_LARA_SPEC], BODY_UPPER | BODY_LOWER);
     #ifdef _DEBUG
 /*
     // gym 
@@ -261,33 +257,38 @@ struct Lara : Controller {
 */
         updateEntity();
     #endif
+        chestOffset = animation.getJoints(getMatrix(), 7).getPos();
     }
     
     void wpnSet(Weapon::Type wType) {
         wpnCurrent = wType;
         wpnState   = Weapon::IS_FIRING;
+
+        arms[0].animation = arms[1].animation = Animation(level, &level->models[wType == Weapon::SHOTGUN ? TR::MODEL_SHOTGUN : TR::MODEL_PISTOLS]);
+
         wpnSetAnim(arms[0], Weapon::IS_HIDDEN, Weapon::Anim::NONE, 0.0f, 0.0f);
         wpnSetAnim(arms[1], Weapon::IS_HIDDEN, Weapon::Anim::NONE, 0.0f, 0.0f);
     }
 
     void wpnSetAnim(Arm &arm, Weapon::State wState, Weapon::Anim wAnim, float wAnimTime, float wAnimDir, bool playing = true) {
+        arm.animation.setAnim(wpnGetAnimIndex(wAnim), 0, wAnim == Weapon::Anim::FIRE);
+        arm.animation.dir = playing ? wAnimDir : 0.0f;
+
         if (arm.anim != wAnim)
-            arm.lastFrame = 0xFFFF;
+            arm.animation.frameIndex = 0xFFFF;
 
-        arm.anim      = wAnim;
-        arm.animIndex = wpnGetAnimIndex(wAnim);
-        TR::Animation &anim = level->anims[arm.animIndex];
-
-        arm.animDir     = playing ? wAnimDir : 0.0f;
-        arm.animMaxTime = (anim.frameEnd - anim.frameStart) / 30.0f;
+        arm.anim = wAnim;
 
         if (wAnimDir > 0.0f) 
-            arm.animTime = wAnimTime;
+            arm.animation.time = wAnimTime;
         else 
             if (wAnimDir < 0.0f)
-                arm.animTime = arm.animMaxTime + wAnimTime;
+                arm.animation.time = arm.animation.timeMax + wAnimTime;
+        arm.animation.updateInfo();
 
         wpnSetState(wState);
+
+        LOG("set anim\n");
     }
 
     int wpnGetDamage() {
@@ -333,21 +334,21 @@ struct Lara : Controller {
             resetMask &= ~(BODY_LEG_L1 | BODY_LEG_R1);
 
         // restore original meshes first
-        meshSwap(level->models[Weapon::EMPTY], resetMask);
+        meshSwap(&level->models[Weapon::EMPTY], resetMask);
         // replace some parts
-        meshSwap(level->models[wpnCurrent], mask);
+        meshSwap(&level->models[wpnCurrent], mask);
         // have a shotgun in inventory place it on the back if another weapon is in use
         if (wpnCurrent != Weapon::SHOTGUN && weapons[Weapon::SHOTGUN].ammo != -1) 
-            meshSwap(level->models[Weapon::SHOTGUN], BODY_CHEST);
+            meshSwap(&level->models[Weapon::SHOTGUN], BODY_CHEST);
         // mesh swap to angry Lara's head while firing (from uzis model)
         if (wState == Weapon::IS_FIRING)                                        
-            meshSwap(level->models[Weapon::UZIS], BODY_HEAD);
+            meshSwap(&level->models[Weapon::UZIS], BODY_HEAD);
 
         wpnState   = wState;
     }
 
     bool emptyHands() {
-        return arms[0].anim == Weapon::Anim::NONE;
+        return wpnCurrent == Weapon::EMPTY || arms[0].anim == Weapon::Anim::NONE;
     }
 
     bool canDrawWeapon() {
@@ -396,8 +397,8 @@ struct Lara : Controller {
             if (wpnCurrent != Weapon::SHOTGUN) {
                 wpnSetAnim(arms[0], wpnState, Weapon::Anim::PREPARE, 0.0f, 1.0f);
                 wpnSetAnim(arms[1], wpnState, Weapon::Anim::PREPARE, 0.0f, 1.0f);
-            } else 
-                wpnSetAnim(arms[0], wpnState, Weapon::Anim::UNHOLSTER, 0.0f, 1.0f);
+            } else
+                wpnSetAnim(arms[0], wpnState, Weapon::Anim::UNHOLSTER, 0.0f, 1.0f);            
         }
     }
 
@@ -418,26 +419,24 @@ struct Lara : Controller {
     }
 
     int wpnGetAnimIndex(Weapon::Anim wAnim) {
-        int baseAnim = level->models[wpnCurrent == Weapon::SHOTGUN ? Weapon::SHOTGUN : Weapon::PISTOLS].animation;
-
         if (wpnCurrent == Weapon::SHOTGUN) {
             switch (wAnim) {
                 case Weapon::Anim::PREPARE   : ASSERT(false); break;    // rifle has no prepare animation
-                case Weapon::Anim::UNHOLSTER : return baseAnim + 1;
-                case Weapon::Anim::HOLSTER   : return baseAnim + 3;
+                case Weapon::Anim::UNHOLSTER : return 1;
+                case Weapon::Anim::HOLSTER   : return 3;
                 case Weapon::Anim::HOLD      : 
-                case Weapon::Anim::AIM       : return baseAnim;
-                case Weapon::Anim::FIRE      : return baseAnim + 2;
+                case Weapon::Anim::AIM       : return 0;
+                case Weapon::Anim::FIRE      : return 2;
                 default : ;
             }
         } else
             switch (wAnim) {
-                case Weapon::Anim::PREPARE   : return baseAnim + 1;
-                case Weapon::Anim::UNHOLSTER : return baseAnim + 2;
+                case Weapon::Anim::PREPARE   : return 1;
+                case Weapon::Anim::UNHOLSTER : return 2;
                 case Weapon::Anim::HOLSTER   : ASSERT(false); break;    // pistols has no holster animation (it's reversed unholster)
                 case Weapon::Anim::HOLD      : 
-                case Weapon::Anim::AIM       : return baseAnim;
-                case Weapon::Anim::FIRE      : return baseAnim + 3;
+                case Weapon::Anim::AIM       : return 0;
+                case Weapon::Anim::FIRE      : return 3;
                 default : ;
             }
         return 0;
@@ -456,21 +455,25 @@ struct Lara : Controller {
     void wpnFire() {
         bool armShot[2] = { false, false };
         for (int i = 0; i < 2; i++) {
-            int frameIndex = getFrameIndex(arms[i].animIndex, arms[i].animTime);
             if (arms[i].anim == Weapon::Anim::FIRE) {
-                if (frameIndex < arms[i].lastFrame) {
-                    if ((mask & ACTION) && (target == -1 || (target > -1 && arms[i].target > -1))) {
-                        armShot[i] = true;
-                    } else
-                        wpnSetAnim(arms[i], Weapon::IS_ARMED, Weapon::Anim::AIM, 0.0f, -1.0f, target == -1);
-                }
-            // shotgun reload sound
-                if (wpnCurrent == Weapon::SHOTGUN) { 
-                    if (frameIndex >= 10 && arms[i].lastFrame < 10)
-                        playSound(TR::SND_SHOTGUN_RELOAD, pos, Sound::Flags::PAN);
+                Animation &anim = arms[i].animation;
+                //int realFrameIndex = int(arms[i].animation.time * 30.0f / anim->frameRate) % ((anim->frameEnd - anim->frameStart) / anim->frameRate + 1);
+                if (anim.frameIndex != anim.framePrev) {
+                    if (anim.frameIndex == 0) { //realFrameIndex < arms[i].animation.framePrev) {
+                        if ((input & ACTION) && (target == -1 || (target > -1 && arms[i].target > -1))) {
+                            armShot[i] = true;
+                        } else
+                            wpnSetAnim(arms[i], Weapon::IS_ARMED, Weapon::Anim::AIM, 0.0f, -1.0f, target == -1);
+                    }
+                // shotgun reload sound
+                    if (wpnCurrent == Weapon::SHOTGUN) { 
+                        if (anim.frameIndex == 10)
+                            playSound(TR::SND_SHOTGUN_RELOAD, pos, Sound::Flags::PAN);
+                    }
                 }
+
             }
-            arms[i].lastFrame = frameIndex;
+            arms[i].animation.framePrev = arms[i].animation.frameIndex;
 
             if (wpnCurrent == Weapon::SHOTGUN) break;
         }
@@ -486,37 +489,35 @@ struct Lara : Controller {
         vec3  nearPos;
         bool  hasShot = false;
 
-        for (int i = 0; i < count; i++) {
-            Arm *arm;
+        for (int i = 0; i < count; i++) {            
             int armIndex;
             if (wpnCurrent == Weapon::SHOTGUN) {
                 if (!rightHand) continue;
-                arm = &arms[0];
                 armIndex = 0;
             } else {
                 if (!(i ? leftHand : rightHand)) continue;
-                arm = &arms[i];
                 armIndex = i;
             }
+            Arm *arm = &arms[armIndex];
             
             arm->shotTimer = 0.0f;
             hasShot = true;
 
             int joint = wpnCurrent == Weapon::SHOTGUN ? 8 : (i ? 11 : 8);
 
-            vec3 p = getJoint(joint, false).getPos();
+            vec3 p = animation.getJoints(getMatrix(), joint, false).getPos();
             vec3 d = arm->rotAbs * vec3(0, 0, 1);
             vec3 t = p + d * (24.0f * 1024.0f) + ((vec3(randf(), randf(), randf()) * 2.0f) - vec3(1.0f)) * 1024.0f;
 
             int room;
             vec3 hit = trace(getRoomIndex(), p, t, room, false);
             if (target > -1 && checkHit(target, p, hit, hit)) {
-                ((Controller*)level->entities[target].controller)->hit(wpnGetDamage());
+                ((Character*)level->entities[target].controller)->hit(wpnGetDamage());
                 hit -= d * 64.0f;
-                addSprite(level, TR::Entity::BLOOD, room, (int)hit.x, (int)hit.y, (int)hit.z, SpriteController::FRAME_ANIMATED);
+                Sprite::add(level, TR::Entity::BLOOD, room, (int)hit.x, (int)hit.y, (int)hit.z, Sprite::FRAME_ANIMATED);
             } else {
                 hit -= d * 64.0f;
-                addSprite(level, TR::Entity::SPARK, room, (int)hit.x, (int)hit.y, (int)hit.z, SpriteController::FRAME_RANDOM);
+                Sprite::add(level, TR::Entity::SPARK, room, (int)hit.x, (int)hit.y, (int)hit.z, Sprite::FRAME_RANDOM);
 
                 float dist = (hit - p).length();
                 if (dist < nearDist) {
@@ -525,7 +526,7 @@ struct Lara : Controller {
                 }
             }
 
-            Core::lightPos[1 + armIndex]   = getJoint(armIndex == 0 ? 10 : 13, false).getPos();
+            Core::lightPos[1 + armIndex]   = animation.getJoints(getMatrix(), armIndex == 0 ? 10 : 13, false).getPos();
             Core::lightColor[1 + armIndex] = FLASH_LIGHT_COLOR;
         }
 
@@ -551,7 +552,7 @@ struct Lara : Controller {
         }
 
     // apply weapon state changes
-        if (mask & WEAPON) {
+        if (input & WEAPON) {
             if (emptyHands())
                 wpnDraw();
             else
@@ -562,18 +563,18 @@ struct Lara : Controller {
             bool isRifle = wpnCurrent == Weapon::SHOTGUN;
 
             for (int i = 0; i < 2; i++) {
-                if (arms[i].target > -1 || ((mask & ACTION) && target == -1)) {
+                if (arms[i].target > -1 || ((input & ACTION) && target == -1)) {
                     if (arms[i].anim == Weapon::Anim::HOLD)
                         wpnSetAnim(arms[i], wpnState, Weapon::Anim::AIM, 0.0f, 1.0f);
                 } else
                     if (arms[i].anim == Weapon::Anim::AIM)
-                        arms[i].animDir = -1.0f;
+                        arms[i].animation.dir = -1.0f;
 
                 if (isRifle) break;
             }
 
-            for (int i = 0; i < 2; i++){
-                arms[i].animTime  += Core::deltaTime * arms[i].animDir;
+            for (int i = 0; i < 2; i++) {
+                arms[i].animation.update();
                 arms[i].shotTimer += Core::deltaTime;
 
                 float intensity = clamp((0.1f - arms[i].shotTimer) * 20.0f, 0.0f, 1.0f);
@@ -593,23 +594,26 @@ struct Lara : Controller {
         for (int i = 0; i < 2; i++) {
             Arm &arm = arms[i];
 
-            if (arm.animDir >= 0.0f && arm.animTime >= arm.animMaxTime)
+            if (!arm.animation.isEnded) continue;                
+
+            if (arm.animation.dir >= 0.0f)
                 switch (arm.anim) {
-                    case Weapon::Anim::PREPARE   : wpnSetAnim(arm, Weapon::IS_ARMED, Weapon::Anim::UNHOLSTER, arm.animTime - arm.animMaxTime, 1.0f); break;
+                    case Weapon::Anim::PREPARE   : wpnSetAnim(arm, Weapon::IS_ARMED, Weapon::Anim::UNHOLSTER, arm.animation.time - arm.animation.timeMax, 1.0f); break;
                     case Weapon::Anim::UNHOLSTER : wpnSetAnim(arm, Weapon::IS_ARMED, Weapon::Anim::HOLD, 0.0f, 1.0f, false); break;
-                    case Weapon::Anim::AIM       : 
-                        if (mask & ACTION)
-                            wpnSetAnim(arm, Weapon::IS_FIRING, Weapon::Anim::FIRE, arm.animTime - arm.animMaxTime, wpnCurrent == Weapon::UZIS ? 2.0f : 1.0f);
+                    case Weapon::Anim::AIM       :
+                    case Weapon::Anim::FIRE      :
+                        if (input & ACTION)
+                            wpnSetAnim(arm, Weapon::IS_FIRING, Weapon::Anim::FIRE, arm.animation.time - arm.animation.timeMax, wpnCurrent == Weapon::UZIS ? 2.0f : 1.0f);
                         else
                             wpnSetAnim(arm, Weapon::IS_ARMED, Weapon::Anim::AIM, 0.0f, -1.0f, false);
                         break;
                     default : ;
                 };
         
-            if (arm.animDir < 0.0f && arm.animTime <= 0.0f)
+            if (arm.animation.dir < 0.0f)
                 switch (arm.anim) {
                     case Weapon::Anim::PREPARE   : wpnSetAnim(arm, Weapon::IS_HIDDEN, Weapon::Anim::NONE,    0.0f, 1.0f, false);    break;
-                    case Weapon::Anim::UNHOLSTER : wpnSetAnim(arm, Weapon::IS_HIDDEN, Weapon::Anim::PREPARE, arm.animTime, -1.0f);  break;
+                    case Weapon::Anim::UNHOLSTER : wpnSetAnim(arm, Weapon::IS_HIDDEN, Weapon::Anim::PREPARE, arm.animation.time, -1.0f);  break;
                     case Weapon::Anim::AIM       : wpnSetAnim(arm, Weapon::IS_ARMED,  Weapon::Anim::HOLD,    0.0f, 1.0f, false);    break;
                     default : ;
                 };
@@ -618,66 +622,64 @@ struct Lara : Controller {
 
     void animateShotgun() {
         Arm &arm = arms[0];
-        if (arm.animDir >= 0.0f)
-            switch (arm.anim) {
-                case Weapon::Anim::UNHOLSTER : 
-                    if (arm.animTime >= arm.animMaxTime)
-                        wpnSetAnim(arm, Weapon::IS_ARMED, Weapon::Anim::HOLD, 0.0f, 1.0f, false);
-                    else if (arm.animTime >= arm.animMaxTime * 0.3f)
-                        wpnSetAnim(arm, Weapon::IS_ARMED, arm.anim, arm.animTime, 1.0f);
-                    break;
-                case Weapon::Anim::HOLSTER : 
-                    if (arm.animTime >= arm.animMaxTime)
-                        wpnSetAnim(arm, Weapon::IS_HIDDEN, Weapon::Anim::NONE, 0.0f, 1.0f, false);  
-                    else if (arm.animTime >= arm.animMaxTime * 0.7f)
-                        wpnSetAnim(arm, Weapon::IS_HIDDEN, arm.anim, arm.animTime, 1.0f);
-                    break;
-                case Weapon::Anim::AIM :
-                    if (arm.animTime >= arm.animMaxTime) {
-                        if (mask & ACTION)
-                            wpnSetAnim(arm, Weapon::IS_FIRING, Weapon::Anim::FIRE, arm.animTime - arm.animMaxTime, 1.0f);
+        if (arm.animation.dir >= 0.0f) {
+            if (arm.animation.isEnded) {
+                switch (arm.anim) {
+                    case Weapon::Anim::UNHOLSTER : wpnSetAnim(arm, Weapon::IS_ARMED,  Weapon::Anim::HOLD, 0.0f, 1.0f, false); break;
+                    case Weapon::Anim::HOLSTER   : wpnSetAnim(arm, Weapon::IS_HIDDEN, Weapon::Anim::NONE, 0.0f, 1.0f, false); break;
+                    case Weapon::Anim::AIM       :
+                    case Weapon::Anim::FIRE      :
+                        if (input & ACTION)
+                            wpnSetAnim(arm, Weapon::IS_FIRING, Weapon::Anim::FIRE, arm.animation.time - arm.animation.timeMax, 1.0f);
                         else
-                            wpnSetAnim(arm, Weapon::IS_ARMED, Weapon::Anim::AIM, 0.0f, -1.0f, false);
+                            wpnSetAnim(arm, Weapon::IS_ARMED,  Weapon::Anim::AIM, 0.0f, -1.0f, false);
+                        break;
+                    default : ;
+                }
+            } else 
+                if (arm.animation.frameIndex != arm.animation.framePrev) {
+                    float delta = arm.animation.time / arm.animation.timeMax;
+                    switch (arm.anim) {
+                        case Weapon::Anim::UNHOLSTER : if (delta >= 0.3f) wpnSetAnim(arm, Weapon::IS_ARMED,  arm.anim, arm.animation.time, 1.0f); break;
+                        case Weapon::Anim::HOLSTER   : if (delta >= 0.7f) wpnSetAnim(arm, Weapon::IS_HIDDEN, arm.anim, arm.animation.time, 1.0f); break;
+                        default : ;
                     }
-                    break;
-                default : ;
-            };
-
-        if (arm.animDir < 0.0f && arm.animTime <= 0.0f)
-            if (arm.anim == Weapon::Anim::AIM)
+                }
+        } else
+            if (arm.animation.isEnded && arm.anim == Weapon::Anim::AIM)
                 wpnSetAnim(arm, Weapon::IS_ARMED, Weapon::Anim::HOLD, 0.0f, 1.0f, false);
     }
 
     void updateOverrides() {
-    // update animation overrides
-        TR::AnimFrame *frameA, *frameB;
-        float t;
-
         // head & chest        
-        animOverrideMask |= BODY_CHEST | BODY_HEAD;
+        animation.overrideMask |= BODY_CHEST | BODY_HEAD;
+
+        animation.overrides[ 7] = animation.getJointRot( 7);
+        animation.overrides[14] = animation.getJointRot(14);        
+
+    /* TODO: shotgun full body animation
+        if (wpnCurrent == Weapon::SHOTGUN) {
+            animation.frameA = arms[0].animation.frameA;
+            animation.frameB = arms[0].animation.frameB;
+            animation.delta  = arms[0].animation.delta;
+        }
+    */
 
-        getFrames(&frameA, &frameB, t, animIndex, animTime, true);
-        animOverrides[ 7] = lerpFrames(frameA, frameB, t,  7);
-        animOverrides[14] = lerpFrames(frameA, frameB, t, 14);
-        
-        
         if (!emptyHands()) {
             // right arm
             Arm *arm = &arms[0];
-            getFrames(&frameA, &frameB, t, arm->animIndex, arm->animTime);
-            animOverrides[ 8] = lerpFrames(frameA, frameB, t,  8);
-            animOverrides[ 9] = lerpFrames(frameA, frameB, t,  9);
-            animOverrides[10] = lerpFrames(frameA, frameB, t, 10);
+            animation.overrides[ 8] = arm->animation.getJointRot( 8);
+            animation.overrides[ 9] = arm->animation.getJointRot( 9);
+            animation.overrides[10] = arm->animation.getJointRot(10);
             // left arm
             if (wpnCurrent != Weapon::SHOTGUN) arm = &arms[1];
-            getFrames(&frameA, &frameB, t, arm->animIndex, arm->animTime);
-            animOverrides[11] = lerpFrames(frameA, frameB, t, 11);
-            animOverrides[12] = lerpFrames(frameA, frameB, t, 12);
-            animOverrides[13] = lerpFrames(frameA, frameB, t, 13);
+            animation.overrides[11] = arm->animation.getJointRot(11);
+            animation.overrides[12] = arm->animation.getJointRot(12);
+            animation.overrides[13] = arm->animation.getJointRot(13);
 
-            animOverrideMask |= BODY_ARM_R | BODY_ARM_L;
+            animation.overrideMask |=  (BODY_ARM_R | BODY_ARM_L);
         } else
-            animOverrideMask &= ~(BODY_ARM_R | BODY_ARM_L);
+            animation.overrideMask &= ~(BODY_ARM_R | BODY_ARM_L);
 
         lookAt(target);
         
@@ -687,7 +689,7 @@ struct Lara : Controller {
             aimPistols();
     }
 
-    void lookAt(int target) {
+    void lookAt(int target) { // TODO: character lookAt        
         float speed = 8.0f * Core::deltaTime;
         quat rot;
 
@@ -696,14 +698,14 @@ struct Lara : Controller {
             rotChest = rotChest.slerp(quat(0, 0, 0, 1).slerp(rot, 0.5f), speed);
         else 
             rotChest = rotChest.slerp(quat(0, 0, 0, 1), speed);
-        animOverrides[7] = rotChest * animOverrides[7];
+        animation.overrides[7] = rotChest * animation.overrides[7];
 
         // head
         if (aim(target, 14, vec4(-PI * 0.25f, PI * 0.25f, -PI * 0.5f, PI * 0.5f), rot))
             rotHead = rotHead.slerp(rot, speed);
         else
             rotHead = rotHead.slerp(quat(0, 0, 0, 1), speed);
-        animOverrides[14] = rotHead * animOverrides[14];
+        animation.overrides[14] = rotHead * animation.overrides[14];
     }
 
     void aimShotgun() {
@@ -730,12 +732,12 @@ struct Lara : Controller {
             if (arm.anim == Weapon::Anim::FIRE)
                 t = 1.0f;
             else if (arm.anim == Weapon::Anim::AIM)
-                t = arm.animTime / arm.animMaxTime;
+                t = arm.animation.time / arm.animation.timeMax;
             else
                 t = 0.0f;
 
             arm.rot = arm.rot.slerp(rot, speed);
-            animOverrides[joint] = animOverrides[joint].slerp(arm.rot * animOverrides[joint], t);
+            animation.overrides[joint] = animation.overrides[joint].slerp(arm.rot * animation.overrides[joint], t);
         }
     }
 
@@ -745,13 +747,13 @@ struct Lara : Controller {
             return;
         }
 
-        if (!(mask & ACTION)) {
+        if (!(input & ACTION)) {
             target = getTarget();
             arms[0].target = arms[1].target = target;
         } else
             if (target > -1) {
                 TR::Entity &e = level->entities[target];
-                vec3 to   = vec3(e.x, e.y, e.z);
+                vec3 to   = ((Controller*)e.controller)->pos;
                 vec3 from = pos - vec3(0, 512, 0);
                 arms[0].target = arms[1].target = checkOcclusion(from, to, (to - from).length()) ? target : -1;
             }
@@ -759,20 +761,20 @@ struct Lara : Controller {
 
     int getTarget() {
         vec3 dir = getDir().normal();
-        int dist = TARGET_MAX_DIST;// * TARGET_MAX_DIST;
+        float dist = TARGET_MAX_DIST;// * TARGET_MAX_DIST;
 
         int index = -1;
         for (int i = 0; i < level->entitiesCount; i++) {
             TR::Entity &e = level->entities[i];
             if (!e.flags.active || !e.isEnemy()) continue;
-            Controller *controller = (Controller*)e.controller;
+            Character *controller = (Character*)e.controller;
             if (controller->health <= 0) continue;
 
             vec3 p = controller->pos;
             vec3 v = p - pos;
             if (dir.dot(v.normal()) <= 0.5f) continue; // target is out of sight -60..+60 degrees
 
-            int d = v.length();
+            float d = v.length();
             if (d < dist && checkOcclusion(pos - vec3(0, 512, 0), p, d) ) {
                 index = i;
                 dist  = d;
@@ -801,7 +803,11 @@ struct Lara : Controller {
             return false;
     }
 
-    bool waterOut(int &outState) {
+    virtual void cmdEmpty() {
+        wpnHide();
+    }
+
+    bool waterOut() {
         // TODO: playSound 36
         vec3 dst = pos + getDir() * 32.0f;
 
@@ -811,15 +817,9 @@ struct Lara : Controller {
 
         int h = int(pos.y - infoDst.floor);
 
-        if (h > 0 && h <= 256) { // possibility check
-            if (!setState(STATE_STOP)) { // can't set water out state
-                outState = STATE_STOP;
-                return true;
-            }
-            outState = state;
-
+        if (h > 0 && h <= 256 && (state == STATE_SURF_TREAD || animation.setState(STATE_SURF_TREAD)) && animation.setState(STATE_STOP)) { // possibility check
             alignToWall();
-            dst.y   -= pos.y - infoDst.floor;
+            dst.y  -= pos.y - infoDst.floor;
             pos     = dst;  // set new position
 
             getEntity().room = infoCur.roomAbove;
@@ -840,38 +840,16 @@ struct Lara : Controller {
                 if (abs(item.x - e.x) > 256 || abs(item.z - e.z) > 256)
                     continue;
 
-                switch (item.type) {
-                    case TR::Entity::WEAPON_PISTOLS :
-                    case TR::Entity::WEAPON_SHOTGUN :
-                    case TR::Entity::WEAPON_MAGNUMS :
-                    case TR::Entity::WEAPON_UZIS    :
-                    case TR::Entity::AMMO_SHOTGUN   :
-                    case TR::Entity::AMMO_MAGNUMS   :
-                    case TR::Entity::AMMO_UZIS      :
-                    case TR::Entity::MEDIKIT_SMALL  :
-                    case TR::Entity::MEDIKIT_BIG    :
-                    case TR::Entity::PUZZLE_1       :
-                    case TR::Entity::PUZZLE_2       :
-                    case TR::Entity::PUZZLE_3       :
-                    case TR::Entity::PUZZLE_4       :
-                    case TR::Entity::PICKUP         :
-                    case TR::Entity::KEY_1          :
-                    case TR::Entity::KEY_2          :
-                    case TR::Entity::KEY_3          :
-                    case TR::Entity::KEY_4          :
-                    case TR::Entity::ARTIFACT       :
-                        lastPickUp = i;
-                        angle.x = 0.0f;
-                        pos.x = item.x;
-                        pos.y = item.y;
-                        pos.z = item.z;
-                        if (stand == STAND_UNDERWATER) { // TODO: lerp to pos/angle
-                            pos = pos - getDir() * 256.0f;
-                            pos.y -= 256;
-                        }
-                        updateEntity();                       
-                        return true;
-                    default : ;
+                if (item.isItem()) {
+                    lastPickUp = i;
+                    angle.x = 0.0f;
+                    pos = ((Controller*)item.controller)->pos;
+                    if (stand == STAND_UNDERWATER) { // TODO: lerp to pos/angle
+                        pos -= getDir() * 256.0f;
+                        pos.y -= 256;
+                    }
+                    updateEntity();                       
+                    return true;
                 }
             }
         }
@@ -882,7 +860,7 @@ struct Lara : Controller {
         return fabsf(shortAngle(rotation, getEntity().rotation)) < PI * 0.25f;
     }
 
-    void doTrigger() {
+    void checkTrigger() {
         if (actionCommand) return;
 
         TR::Entity &e = getEntity();
@@ -890,7 +868,7 @@ struct Lara : Controller {
         level->getFloorInfo(e.room, e.x, e.z, info);
 
         if (!info.trigCmdCount) return; // has no trigger
-        bool isActive = (level->entities[info.trigCmd[0].args].flags.active);
+        bool isActive = level->entities[info.trigCmd[0].args].flags.active != 0;
         if (info.trigInfo.once == 1 && isActive) return; // once trigger is already activated
 
         int actionState = state;
@@ -903,14 +881,14 @@ struct Lara : Controller {
                 break;
             case TR::Level::Trigger::SWITCH :
                 actionState = (isActive && stand == STAND_GROUND) ? STATE_SWITCH_UP : STATE_SWITCH_DOWN;
-                if ((mask & ACTION) == 0 || state == actionState || !emptyHands())
+                if ((input & ACTION) == 0 || state == actionState || !emptyHands())
                     return;
                 if (!checkAngle(level->entities[info.trigCmd[0].args].rotation))
                     return;
                 break;
             case TR::Level::Trigger::KEY :
                 actionState = STATE_USE_KEY;
-                if (isActive || (mask & ACTION) == 0 || state == actionState || !emptyHands())   // TODO: STATE_USE_PUZZLE
+                if (isActive || (input & ACTION) == 0 || state == actionState || !emptyHands())   // TODO: STATE_USE_PUZZLE
                     return;
                 if (!checkAngle(level->entities[info.trigCmd[0].args].rotation))
                     return;
@@ -925,13 +903,13 @@ struct Lara : Controller {
         }
 
         // try to activate Lara state
-        if (!setState(actionState)) return;
+        if (!animation.setState(actionState)) return;
 
         if (info.trigger == TR::Level::Trigger::SWITCH || info.trigger == TR::Level::Trigger::KEY) {
             TR::Entity &p = level->entities[info.trigCmd[0].args];
             angle.y = p.rotation;
             angle.x = 0;
-            pos = vec3(p.x, p.y, p.z) + vec3(sinf(angle.y), 0, cosf(angle.y)) * (stand == STAND_GROUND ? 384 : 128);
+            pos = ((Controller*)p.controller)->pos + vec3(sinf(angle.y), 0, cosf(angle.y)) * (stand == STAND_GROUND ? 384.0f : 128.0f);
             velocity = vec3(0.0f);
             updateEntity();
         }
@@ -973,7 +951,7 @@ struct Lara : Controller {
         vec3 offset = chestOffset;
         if (stand != STAND_UNDERWATER)
             offset.y -= 256.0f;
-        if (wpnState != Weapon::IS_HIDDEN)
+        if (!emptyHands())
             offset.y -= 256.0f;
 
         return offset;
@@ -981,9 +959,9 @@ struct Lara : Controller {
 
     virtual Stand getStand() {
         if (state == STATE_HANG || state == STATE_HANG_LEFT || state == STATE_HANG_RIGHT) {
-            if (mask & ACTION)
+            if (input & ACTION)
                 return STAND_HANG;
-            setAnimation(ANIM_HANG_FALL);
+            animation.setAnim(ANIM_HANG_FALL);
             velocity = vec3(0.0f);
             pos.y += 128.0f;
             updateEntity();
@@ -1009,7 +987,7 @@ struct Lara : Controller {
             if (e.y + 8 >= info.floor && (abs(info.slantX) > 2 || abs(info.slantZ) > 2)) {
                 if (stand == STAND_AIR)
                     playSound(TR::SND_LANDING, pos, Sound::Flags::PAN);
-                pos.y = info.floor;
+                pos.y = float(info.floor);
                 updateEntity();
 
                 if (stand == STAND_GROUND || stand == STAND_AIR)
@@ -1023,7 +1001,7 @@ struct Lara : Controller {
 
         if (e.y + extra >= info.floor) {
             if (stand != STAND_GROUND) {
-                pos.y = info.floor;
+                pos.y = float(info.floor);
                 updateEntity();
             }
             return STAND_GROUND;
@@ -1044,7 +1022,7 @@ struct Lara : Controller {
         if (state == STATE_REACH && getDir().dot(vec3(velocity.x, 0.0f, velocity.z)) < 0)
             velocity.x = velocity.z = 0.0f;
 
-        if ((state == STATE_REACH || state == STATE_UP_JUMP) && (mask & ACTION) && emptyHands()) {
+        if ((state == STATE_REACH || state == STATE_UP_JUMP) && (input & ACTION) && emptyHands()) {
 
             if (state == STATE_REACH && velocity.y < 0.0f)
                 return state;
@@ -1071,34 +1049,30 @@ struct Lara : Controller {
                 if (state == STATE_REACH) {
                     return STATE_HANG; // TODO: ANIM_HANG_WALL / ANIM_HANG_NOWALL
                 } else
-                    return setAnimation(ANIM_HANG, -15);
+                    return animation.setAnim(ANIM_HANG, -15);
             }
         }
 
         if (state == STATE_FORWARD_JUMP) {
             if (emptyHands()) {
-                if (mask & ACTION) return STATE_REACH;
-                if ((mask & (FORTH | WALK)) == (FORTH | WALK)) return STATE_SWAN_DIVE;
+                if (input & ACTION) return STATE_REACH;
+                if ((input & (FORTH | WALK)) == (FORTH | WALK)) return STATE_SWAN_DIVE;
             }
         } else 
             if (state != STATE_SWAN_DIVE && state != STATE_REACH && state != STATE_FALL && state != STATE_UP_JUMP && state != STATE_BACK_JUMP && state != STATE_LEFT_JUMP && state != STATE_RIGHT_JUMP)
-                return setAnimation(ANIM_FALL);
+                return animation.setAnim(ANIM_FALL);
 
         return state;
     }
 
-    float distTo(const TR::Entity &e) {
-        return (pos - vec3(e.x, e.y, e.z)).length();
-    }
-
     Block* getBlock() {
-        int x = getEntity().x;
-        int y = getEntity().y;
-        int z = getEntity().z;
+        int x = (int)pos.x;
+        int y = (int)pos.y;
+        int z = (int)pos.z;
 
         for (int i = 0; i < level->entitiesCount; i++) {
             TR::Entity &e = level->entities[i];
-            if ((e.type == TR::Entity::BLOCK_1 || e.type == TR::Entity::BLOCK_2) && e.y == y) {
+            if (e.isBlock() && e.y == y) {
                 int dx = abs(e.x - x);
                 int dz = abs(e.z - z);
                 if ((dx <= (512 + 128) && dz <= (512 - 128)) ||
@@ -1119,39 +1093,39 @@ struct Lara : Controller {
     virtual int getStateGround() {
         angle.x = 0.0f;
 
-        if ((mask & ACTION) && emptyHands() && doPickUp())
+        if ((input & ACTION) && emptyHands() && doPickUp())
             return STATE_PICK_UP;
 
-        if ( (mask & (FORTH | ACTION)) == (FORTH | ACTION) && (animIndex == ANIM_STAND || animIndex == ANIM_STAND_NORMAL) && emptyHands()) {
+        if ((input & (FORTH | ACTION)) == (FORTH | ACTION) && (animation.index == ANIM_STAND || animation.index == ANIM_STAND_NORMAL) && emptyHands()) { // TODO: get rid of animation.index 
             vec3 p = pos + getDir() * 64.0f;
             TR::Level::FloorInfo info;
             level->getFloorInfo(getRoomIndex(), (int)p.x, (int)p.z, info, true);
             int h = (int)pos.y - info.floor;
             
-            int aIndex = animIndex;
+            int aIndex = animation.index;
             if (info.floor == info.ceiling || h < 256 + 128) {
                 ; // do nothing
             } else if (h <= 2 * 256 + 128) {
                 aIndex = ANIM_CLIMB_2;
-                pos.y  = info.floor + 512;
+                pos.y  = info.floor + 512.0f;
             } else if (h <= 3 * 256 + 128) {
                 aIndex = ANIM_CLIMB_3;
-                pos.y  = info.floor + 768;
+                pos.y  = info.floor + 768.0f;
             } else if (h <= 7 * 256 + 128)
                 aIndex = ANIM_CLIMB_JUMP;            
 
-            if (aIndex != animIndex) {
+            if (aIndex != animation.index) {
                 alignToWall();
-                return setAnimation(aIndex);
+                return animation.setAnim(aIndex);
             }
         }
 
-        if ( (mask & (FORTH | BACK)) == (FORTH | BACK) && (state == STATE_STOP || state == STATE_RUN) )
-            return setAnimation(ANIM_STAND_ROLL_BEGIN);
+        if ( (input & (FORTH | BACK)) == (FORTH | BACK) && (state == STATE_STOP || state == STATE_RUN) )
+            return animation.setAnim(ANIM_STAND_ROLL_BEGIN);
 
         // ready to jump
         if (state == STATE_COMPRESS) {
-            switch (mask & (RIGHT | LEFT | FORTH | BACK)) {
+            switch (input & (RIGHT | LEFT | FORTH | BACK)) {
                 case RIGHT  : return STATE_RIGHT_JUMP;
                 case LEFT   : return STATE_LEFT_JUMP;
                 case FORTH  : return STATE_FORWARD_JUMP;
@@ -1161,30 +1135,30 @@ struct Lara : Controller {
         }
 
         // jump button is pressed
-        if (mask & JUMP) {   
-            if ((mask & FORTH) && state == STATE_FORWARD_JUMP)
+        if (input & JUMP) {   
+            if ((input & FORTH) && state == STATE_FORWARD_JUMP)
                 return STATE_RUN;
             if (state == STATE_RUN)
                 return STATE_FORWARD_JUMP;
-            if (animIndex == ANIM_SLIDE_BACK)
+            if (animation.index == ANIM_SLIDE_BACK) // TODO: animation index? %)
                 return STATE_SLIDE_BACK;                
             return STATE_COMPRESS;
         }
         
         // walk button is pressed
-        if (mask & WALK) {      
-            if (mask & FORTH) return STATE_WALK;
-            if (mask & BACK)  return STATE_BACK;
-            if (mask & LEFT)  return STATE_STEP_LEFT;
-            if (mask & RIGHT) return STATE_STEP_RIGHT;
+        if (input & WALK) {      
+            if (input & FORTH) return STATE_WALK;
+            if (input & BACK)  return STATE_BACK;
+            if (input & LEFT)  return STATE_STEP_LEFT;
+            if (input & RIGHT) return STATE_STEP_RIGHT;
             return STATE_STOP;
         } 
 
-        if ((mask & ACTION) && emptyHands()) {
-            if (state == STATE_PUSH_PULL_READY && (mask & (FORTH | BACK))) {
-                int pushState = (mask & FORTH) ? STATE_PUSH_BLOCK : STATE_PULL_BLOCK;
+        if ((input & ACTION) && emptyHands()) {
+            if (state == STATE_PUSH_PULL_READY && (input & (FORTH | BACK))) {
+                int pushState = (input & FORTH) ? STATE_PUSH_BLOCK : STATE_PULL_BLOCK;
                 Block *block = getBlock();                
-                if (canSetState(pushState) && block->doMove(mask & FORTH)) {
+                if (animation.canSetState(pushState) && block->doMove((input & FORTH) != 0)) {
                     alignToWall(128.0f);
                     return pushState;
                 }
@@ -1195,14 +1169,14 @@ struct Lara : Controller {
         }
 
         // only dpad buttons pressed
-        if (mask & FORTH) return STATE_RUN;
-        if (mask & BACK)  return STATE_FAST_BACK;
-        if (mask & (LEFT | RIGHT)) {
+        if (input & FORTH) return STATE_RUN;
+        if (input & BACK)  return STATE_FAST_BACK;
+        if (input & (LEFT | RIGHT)) {
             if (state == STATE_FAST_TURN)
                 return state;
 
-            if (mask & LEFT)  return (state == STATE_TURN_LEFT  && animPrev == animIndex) ? STATE_FAST_TURN : STATE_TURN_LEFT;
-            if (mask & RIGHT) return (state == STATE_TURN_RIGHT && animPrev == animIndex) ? STATE_FAST_TURN : STATE_TURN_RIGHT;
+            if (input & LEFT)  return (state == STATE_TURN_LEFT  && animation.prev == animation.index) ? STATE_FAST_TURN : STATE_TURN_LEFT;
+            if (input & RIGHT) return (state == STATE_TURN_RIGHT && animation.prev == animation.index) ? STATE_FAST_TURN : STATE_TURN_RIGHT;
         }
 
         return STATE_STOP;
@@ -1232,37 +1206,37 @@ struct Lara : Controller {
 
             angle.y = dir;
             updateEntity();
-            setAnimation(aIndex);
+            animation.setAnim(aIndex);
         }
     }
 
     virtual int getStateSlide() {
-        if (mask & JUMP)
+        if (input & JUMP)
             return state == STATE_SLIDE ? STATE_FORWARD_JUMP : STATE_BACK_JUMP;
         return state;
     }
 
     virtual int getStateHang() {
-        if (mask & LEFT)  return STATE_HANG_LEFT;
-        if (mask & RIGHT) return STATE_HANG_RIGHT;
-        if (mask & FORTH) {
+        if (input & LEFT)  return STATE_HANG_LEFT;
+        if (input & RIGHT) return STATE_HANG_RIGHT;
+        if (input & FORTH) {
             // possibility check
             TR::Level::FloorInfo info;
             vec3 p = pos + getDir() * 128.0f;
             level->getFloorInfo(getRoomIndex(), (int)p.x, (int)p.z, info, true);
             if (info.floor - info.ceiling >= 768)
-                return (mask & WALK) ? STATE_HANDSTAND : STATE_HANG_UP;          
+                return (input & WALK) ? STATE_HANDSTAND : STATE_HANG_UP;          
         }
         return STATE_HANG;
     }
 
     virtual int getStateUnderwater() {
-        if (mask == ACTION && doPickUp())
+        if (input == ACTION && doPickUp())
             return STATE_PICK_UP;
 
         if (state == STATE_FORWARD_JUMP || state == STATE_UP_JUMP || state == STATE_BACK_JUMP || state == STATE_LEFT_JUMP || state == STATE_RIGHT_JUMP || state == STATE_FALL || state == STATE_REACH) {
-            addSprite(level, TR::Entity::Type::WATER_SPLASH, getRoomIndex(), (int)pos.x, (int)pos.y, (int)pos.z);
-            return setAnimation(ANIM_WATER_FALL);
+            Sprite::add(level, TR::Entity::Type::WATER_SPLASH, getRoomIndex(), (int)pos.x, (int)pos.y, (int)pos.z);
+            return animation.setAnim(ANIM_WATER_FALL); // TODO: wronng animation
         }
         
         if (state == STATE_SWAN_DIVE) {
@@ -1270,7 +1244,7 @@ struct Lara : Controller {
             return STATE_DIVE;
         }
             
-        if (mask & JUMP) return STATE_SWIM;
+        if (input & JUMP) return STATE_SWIM;
 
         return (state == STATE_SWIM || velocity.y > GLIDE_SPEED) ? STATE_GLIDE : STATE_TREAD;
     }
@@ -1281,23 +1255,23 @@ struct Lara : Controller {
         if (state == STATE_WATER_OUT) return state;
 
         if (state != STATE_SURF_TREAD && state != STATE_SURF_LEFT && state != STATE_SURF_RIGHT && state != STATE_SURF_SWIM && state != STATE_SURF_BACK && state != STATE_STOP)
-            return setAnimation(ANIM_TO_ONWATER);
+            return animation.setAnim(ANIM_TO_ONWATER);
 
-        if (mask & FORTH) {
-            if (mask & JUMP) { 
+        if (input & FORTH) {
+            if (input & JUMP) { 
                 angle.x = -PI * 0.25f;
-                return setAnimation(ANIM_TO_UNDERWATER);
+                return animation.setAnim(ANIM_TO_UNDERWATER);
             }
 
-            if ((mask & ACTION) && waterOut(state)) return state;
+            if ((input & ACTION) && waterOut()) return state;
 
             return STATE_SURF_SWIM;
         }
         
-        if (mask & BACK)  return STATE_SURF_BACK;
-        if (mask & WALK) {
-            if (mask & LEFT)  return STATE_SURF_LEFT;
-            if (mask & RIGHT) return STATE_SURF_RIGHT;         
+        if (input & BACK)  return STATE_SURF_BACK;
+        if (input & WALK) {
+            if (input & LEFT)  return STATE_SURF_LEFT;
+            if (input & RIGHT) return STATE_SURF_RIGHT;         
         }
         return STATE_SURF_TREAD;
     }
@@ -1307,7 +1281,7 @@ struct Lara : Controller {
     }
 
     virtual int getStateDefault() {
-        if (state == STATE_DIVE || (state == STATE_RUN && (mask & JUMP)) ) return state;
+        if (state == STATE_DIVE || (state == STATE_RUN && (input & JUMP)) ) return state;
         switch (stand) {
             case STAND_GROUND     : return STATE_STOP;
             case STAND_HANG       : return STATE_HANG;
@@ -1318,78 +1292,42 @@ struct Lara : Controller {
         return STATE_FALL;
     }
 
-    virtual int getInputMask() {
-        mask = 0;
+    virtual int getInput() {
+        input = 0;
         int &p = Input::joy.POV;
-        if (Input::down[ikW] || Input::down[ikUp]    || p == 8 || p == 1 || p == 2)     mask |= FORTH;
-        if (Input::down[ikD] || Input::down[ikRight] || p == 2 || p == 3 || p == 4)     mask |= RIGHT;
-        if (Input::down[ikS] || Input::down[ikDown]  || p == 4 || p == 5 || p == 6)     mask |= BACK;
-        if (Input::down[ikA] || Input::down[ikLeft]  || p == 6 || p == 7 || p == 8)     mask |= LEFT;
-        if (Input::down[ikJoyB])                                                        mask  = FORTH | BACK; // roll
-        if (Input::down[ikJoyRT] || Input::down[ikX])                                   mask  = WALK | RIGHT; // step right
-        if (Input::down[ikJoyLT] || Input::down[ikZ])                                   mask  = WALK | LEFT;  // step left
-        if (Input::down[ikSpace] || Input::down[ikJoyX])                                mask |= JUMP;
-        if (Input::down[ikShift] || Input::down[ikJoyLB])                               mask |= WALK;
-        if (Input::down[ikE] || Input::down[ikCtrl] || Input::down[ikJoyA])             mask |= ACTION;
-        if (Input::down[ikQ] || Input::down[ikAlt]  || Input::down[ikJoyY])             mask |= WEAPON;
-        if (health <= 0)                                                                mask  = DEATH;
-        return mask;
+        if (Input::down[ikW] || Input::down[ikUp]    || p == 8 || p == 1 || p == 2)     input |= FORTH;
+        if (Input::down[ikD] || Input::down[ikRight] || p == 2 || p == 3 || p == 4)     input |= RIGHT;
+        if (Input::down[ikS] || Input::down[ikDown]  || p == 4 || p == 5 || p == 6)     input |= BACK;
+        if (Input::down[ikA] || Input::down[ikLeft]  || p == 6 || p == 7 || p == 8)     input |= LEFT;
+        if (Input::down[ikJoyB])                                                        input  = FORTH | BACK; // roll
+        if (Input::down[ikJoyRT] || Input::down[ikX])                                   input  = WALK | RIGHT; // step right
+        if (Input::down[ikJoyLT] || Input::down[ikZ])                                   input  = WALK | LEFT;  // step left
+        if (Input::down[ikSpace] || Input::down[ikJoyX])                                input |= JUMP;
+        if (Input::down[ikShift] || Input::down[ikJoyLB])                               input |= WALK;
+        if (Input::down[ikE] || Input::down[ikCtrl] || Input::down[ikJoyA])             input |= ACTION;
+        if (Input::down[ikQ] || Input::down[ikAlt]  || Input::down[ikJoyY])             input |= WEAPON;
+        if (health <= 0)                                                                input  = DEATH;
+        return input;
     }
 
-    virtual void updateState() {
-        doTrigger();
-
-        TR::Animation *anim  = &level->anims[animIndex];
-
-        int fCount = anim->frameEnd - anim->frameStart;
-        int fIndex = int(animTime * 30.0f);
-
-        float rot = 0.0f;
-
-#ifdef _DEBUG
-        // show state transitions for current animation        
-        static bool lState = false;
-        if (Input::down[ikEnter]) {
-            if (!lState) {
-                lState = true;
-                
-                static int snd_id = 81;
-                playSound(snd_id, pos, 0);
-                
-                LOG("sound: %d\n", snd_id++);
-                /*
-                LOG("state: %d\n", anim->state);
-                for (int i = 0; i < anim->scCount; i++) {
-                    auto &sc = level->states[anim->scOffset + i];
-                    LOG("-> %d : ", (int)sc.state);
-                    for (int j = 0; j < sc.rangesCount; j++) {
-                        TR::AnimRange &range = level->ranges[sc.rangesOffset + j];
-                        LOG("%d ", range.nextAnimation);
-                    }
-                    LOG("\n");
-                }
-                */
+    virtual void doCustomCommand(int curFrame, int prevFrame) {
+        if (state == STATE_PICK_UP) {
+            if (!level->entities[lastPickUp].flags.invisible) {
+                int pickupFrame = stand == STAND_GROUND ? PICKUP_FRAME_GROUND : PICKUP_FRAME_UNDERWATER;                
+                if (curFrame >= pickupFrame)
+                    level->entities[lastPickUp].flags.invisible = true; // TODO: add to inventory
             }
-            
-        } else 
-            lState = false;
-#endif
-    // calculate turn tilt
-        if (state == STATE_RUN && (mask & (LEFT | RIGHT)) && (tilt == 0.0f || (tilt < 0.0f && (mask & LEFT)) || (tilt > 0.0f && (mask & RIGHT)))) {
-            if (mask & LEFT)  tilt -= TILT_SPEED * Core::deltaTime;
-            if (mask & RIGHT) tilt += TILT_SPEED * Core::deltaTime;
-        } else
-            if (fabsf(tilt) > 0.01f)
-                tilt -= sign(tilt) * TILT_SPEED * 4.0f * Core::deltaTime;
-            else
-                tilt = 0.0f;
-        tilt = clamp(tilt, -TILT_MAX, TILT_MAX);
-        
-        angle.z = tilt;
+        }
+    }
 
-            
+    virtual void updateAnimation(bool commands) {
+        Controller::updateAnimation(commands);
+        updateWeapon();
+    }
+
+    virtual void updateVelocity() {            
     // get turning angle
-        float w = (mask & LEFT) ? -1.0f : ((mask & RIGHT) ? 1.0f : 0.0f);
+        float w = (input & LEFT) ? -1.0f : ((input & RIGHT) ? 1.0f : 0.0f);
 
         if (state == STATE_SWIM || state == STATE_GLIDE)
             w *= TURN_WATER_FAST;
@@ -1411,12 +1349,12 @@ struct Lara : Controller {
         if (w != 0.0f) {
             w *= Core::deltaTime;
             angle.y += w; 
-            velocity = velocity.rotateY(-w);
+            velocity = velocity.rotateY(-w); // in-air velocity rotation control
         }
 
     // pitch (underwater only)
-        if (stand == STAND_UNDERWATER && (mask & (FORTH | BACK)) ) {
-            angle.x += ((mask & FORTH) ? -TURN_WATER_SLOW : TURN_WATER_SLOW) * 0.5f * Core::deltaTime;
+        if (stand == STAND_UNDERWATER && (input & (FORTH | BACK)) ) {
+            angle.x += ((input & FORTH) ? -TURN_WATER_SLOW : TURN_WATER_SLOW) * 0.5f * Core::deltaTime;
             angle.x = clamp(angle.x, -PI * 0.5f, PI * 0.5f);
         }
 
@@ -1443,26 +1381,6 @@ struct Lara : Controller {
                 angleExt +=  PI * 0.5f;
                 break;
         }
-    }
-
-    
-    virtual void doCustomCommand(int curFrame, int prevFrame) {
-        if (state == STATE_PICK_UP) {
-            if (!level->entities[lastPickUp].flags.invisible) {
-                int pickupFrame = stand == STAND_GROUND ? PICKUP_FRAME_GROUND : PICKUP_FRAME_UNDERWATER;                
-                if (curFrame >= pickupFrame)
-                    level->entities[lastPickUp].flags.invisible = true; // TODO: add to inventory
-            }
-        }
-    }
-
-    virtual void updateAnimation(bool commands) {
-        Controller::updateAnimation(commands);
-        updateWeapon();
-    }
-
-    virtual void updateVelocity() {
-        TR::Animation *anim = &level->anims[animIndex];
 
         switch (stand) {
             case STAND_AIR :
@@ -1482,8 +1400,8 @@ struct Lara : Controller {
                         speed = 15.0f;
                         break;
                     default :
-                        speed = anim->speed + anim->accel * (animTime * 30.0f);
-                        if (animIndex == ANIM_STAND_ROLL_END) 
+                        speed = animation.getSpeed();
+                        if (animation.index == ANIM_STAND_ROLL_END) 
                             speed = -speed;
                 }
 
@@ -1509,7 +1427,7 @@ struct Lara : Controller {
             }
             case STAND_UNDERWATER : {
                 float speed = 0.0f;
-                if (animIndex == ANIM_TO_UNDERWATER)
+                if (animation.index == ANIM_TO_UNDERWATER)
                     speed = 15.0f;
                 if (state == STATE_SWIM)
                     speed = 35.0f;
@@ -1524,32 +1442,16 @@ struct Lara : Controller {
         }
     }
 
-    virtual void checkRoom() {
-        TR::Level::FloorInfo info;
-        TR::Entity &e = getEntity();
-        level->getFloorInfo(e.room, e.x, e.z, info);
+    virtual void updatePosition() { // TODO: sphere / bbox collision
+        updateTilt(state == STATE_RUN, TILT_SPEED, TILT_MAX);
 
-        if (info.roomNext != 0xFF)
-            e.room = info.roomNext;        
+        if (velocity.length() >= 0.001f) 
+            move();
 
-        if (info.roomBelow != 0xFF && e.y > info.floor)
-            e.room = info.roomBelow;       
-
-        if (info.roomAbove != 0xFF && e.y <= info.ceiling) {
-            if (stand == STAND_UNDERWATER && !level->rooms[info.roomAbove].flags.water) {
-                stand = STAND_ONWATER;
-                velocity.y = 0;
-                pos.y = info.ceiling;
-                updateEntity();
-            } else
-                if (stand != STAND_ONWATER)
-                    e.room = info.roomAbove;
-        }
+        checkTrigger();
     }
 
-    virtual void move() { // TODO: sphere / bbox collision
-        if (velocity.length() < 0.001f) return;
-
+    void move() {
         vec3 offset = velocity * Core::deltaTime * 30.0f;
 
         vec3 p = pos;
@@ -1560,11 +1462,12 @@ struct Lara : Controller {
         level->getFloorInfo(e.room, (int)pos.x, (int)pos.z, info, true);
 
     // get frame to get height
-        TR::Animation *anim  = &level->anims[animIndex];
+        TR::Animation *anim  = animation;
 
         bool canPassGap = (info.floor - info.ceiling) >= (stand == STAND_GROUND ? 768 : 512);
         float f = info.floor - pos.y;
         float c = pos.y - info.ceiling;
+
         /*
         Box eBox = Box(pos - vec3(128.0f, 0.0f, 128.0f), pos + vec3(128.0, getHeight(), 128.0f)); // getBoundingBox();
         // check static meshes in the room
@@ -1601,12 +1504,9 @@ struct Lara : Controller {
         */
         if (canPassGap)
             switch (stand) {
-                case STAND_AIR        : {
-                    int fSize = sizeof(TR::AnimFrame) + getModel().mCount * sizeof(uint16) * 2;
-                    TR::AnimFrame *frame = (TR::AnimFrame*)&level->frameData[((anim->frameOffset + (int(animTime * 30.0f / anim->frameRate) * fSize)) >> 1)];
-
-                    f = info.floor   - (pos.y + frame->box.maxY);
-                    c = (pos.y + frame->box.minY) - info.ceiling;
+                case STAND_AIR : {
+                    f = info.floor - (pos.y + animation.frameA->box.maxY);
+                    c = (pos.y + animation.frameA->box.minY) - info.ceiling;
                     canPassGap = f >= -256;
                     if (canPassGap && c < 0) {
                         if (c > -256) { // position correction for ceiling step (less than 256)
@@ -1619,7 +1519,7 @@ struct Lara : Controller {
                     }
                     break;
                 }
-                case STAND_GROUND     : {                    
+                case STAND_GROUND : {                    
                     if (state == STATE_WALK || state == STATE_BACK) 
                         canPassGap = fabsf(f) <= (256.0f + 128.0f);
                     else
@@ -1647,7 +1547,7 @@ struct Lara : Controller {
                 default : ;
             }
 
-        bool isLeftFoot = (anim->frameEnd - anim->frameStart) / 2 > int(animTime * 30.0f);
+        bool isLeftFoot = animation.framesCount / 2 > animation.frameIndex;
 
         if (!canPassGap) {
             pos = p; // TODO: use smart ejection
@@ -1661,7 +1561,7 @@ struct Lara : Controller {
                     }
 
                     if (velocity.x != 0.0f || velocity.z != 0.0f) {
-                        setAnimation(ANIM_SMASH_JUMP);
+                        animation.setAnim(ANIM_SMASH_JUMP);
                         velocity.x = -velocity.x * 0.5f;
                         velocity.z = -velocity.z * 0.5f;
                         if (offset.y < 0.0f)
@@ -1674,11 +1574,11 @@ struct Lara : Controller {
                 case STAND_GROUND :
                 case STAND_HANG   :
                     if (f <= -(256 * 3 - 128) && state == STATE_RUN)
-                        setAnimation(isLeftFoot ? ANIM_SMASH_RUN_LEFT : ANIM_SMASH_RUN_RIGHT);
+                        animation.setAnim(isLeftFoot ? ANIM_SMASH_RUN_LEFT : ANIM_SMASH_RUN_RIGHT);
                     else if (stand == STAND_HANG)
-                        setAnimation(ANIM_HANG, -21);
+                        animation.setAnim(ANIM_HANG, -21);
                     else if (state != STATE_ROLL_1 && state != STATE_ROLL_2)
-                        setAnimation(ANIM_STAND);
+                        animation.setAnim(ANIM_STAND);
                     velocity.x = velocity.z = 0.0f;
                     break;
                 default : ;// no smash animation
@@ -1689,21 +1589,21 @@ struct Lara : Controller {
 
                 if (h >= 256 && state == STATE_FAST_BACK) {
                     stand = STAND_AIR;
-                    setAnimation(ANIM_FALL);
+                    animation.setAnim(ANIM_FALL);
                 } else if (h >= 128 && (state == STATE_WALK || state == STATE_BACK)) { // descend
-                    if (state == STATE_WALK) setAnimation(isLeftFoot ? ANIM_WALK_DESCEND_LEFT : ANIM_WALK_DESCEND_RIGHT);
-                    if (state == STATE_BACK) setAnimation(isLeftFoot ? ANIM_BACK_DESCEND_LEFT : ANIM_BACK_DESCEND_RIGHT);
-                    pos.y = info.floor;
+                    if (state == STATE_WALK) animation.setAnim(isLeftFoot ? ANIM_WALK_DESCEND_LEFT : ANIM_WALK_DESCEND_RIGHT);
+                    if (state == STATE_BACK) animation.setAnim(isLeftFoot ? ANIM_BACK_DESCEND_LEFT : ANIM_BACK_DESCEND_RIGHT);
+                    pos.y = float(info.floor);
                 } else if (h > -1.0f) {
                     pos.y = min((float)info.floor, pos.y += DESCENT_SPEED * Core::deltaTime);
                 } else if (h > -128) {
-                    pos.y = info.floor;
+                    pos.y = float(info.floor);
                 } else if (h >= -(256 + 128) && (state == STATE_RUN || state == STATE_WALK)) { // ascend
-                    if (state == STATE_RUN)  setAnimation(isLeftFoot ? ANIM_RUN_ASCEND_LEFT  : ANIM_RUN_ASCEND_RIGHT);
-                    if (state == STATE_WALK) setAnimation(isLeftFoot ? ANIM_WALK_ASCEND_LEFT : ANIM_WALK_ASCEND_RIGHT);
-                    pos.y = info.floor;
+                    if (state == STATE_RUN)  animation.setAnim(isLeftFoot ? ANIM_RUN_ASCEND_LEFT  : ANIM_RUN_ASCEND_RIGHT);
+                    if (state == STATE_WALK) animation.setAnim(isLeftFoot ? ANIM_WALK_ASCEND_LEFT : ANIM_WALK_ASCEND_RIGHT);
+                    pos.y = float(info.floor);
                 } else
-                    pos.y = info.floor;
+                    pos.y = float(info.floor);
             }
 
         updateEntity();
@@ -1724,11 +1624,12 @@ struct Lara : Controller {
 
     virtual void render(Frustum *frustum, MeshBuilder *mesh) {
         Controller::render(frustum, mesh);
-        chestOffset = joints[7].getPos();
+        chestOffset = animation.getJoints(getMatrix(), 7).getPos(); // TODO: move to update func
 
         if (wpnCurrent != Weapon::SHOTGUN) {
-            renderMuzzleFlash(mesh, joints[10], vec3(-10, -50, 150), arms[0].shotTimer);
-            renderMuzzleFlash(mesh, joints[13], vec3( 10, -50, 150), arms[1].shotTimer);
+            mat4 matrix = getMatrix();
+            renderMuzzleFlash(mesh, animation.getJoints(matrix, 10), vec3(-10, -50, 150), arms[0].shotTimer);
+            renderMuzzleFlash(mesh, animation.getJoints(matrix, 13), vec3( 10, -50, 150), arms[1].shotTimer);
         }
     }
 };
diff --git a/src/level.h b/src/level.h
index bebcd31..a813abf 100644
--- a/src/level.h
+++ b/src/level.h
@@ -30,7 +30,7 @@ struct Level {
 
     float       time;
 
-    Level(Stream &stream, bool demo) : level{stream, demo}, time(0.0f), lara(NULL) {
+    Level(const char *name, bool demo, bool home) : level(name, demo), time(0.0f), lara(NULL) {
         #ifdef _DEBUG
             Debug::init();
         #endif
@@ -44,8 +44,10 @@ struct Level {
             TR::Entity &entity = level.entities[i];
             switch (entity.type) {
                 case TR::Entity::LARA : 
+                    entity.controller = (lara = new Lara(&level, i, home));
+                    break;
                 case TR::Entity::LARA_CUT :
-                    entity.controller = (lara = new Lara(&level, i));
+                    entity.controller = (lara = new Lara(&level, i, false));
                     break;
                 case TR::Entity::ENEMY_WOLF            :   
                     entity.controller = new Wolf(&level, i);
@@ -71,7 +73,7 @@ struct Level {
                 case TR::Entity::ENEMY_CENTAUR         :   
                 case TR::Entity::ENEMY_MUMMY           :   
                 case TR::Entity::ENEMY_LARSON          :
-                    entity.controller = new Enemy(&level, i);
+                    entity.controller = new Enemy(&level, i, 100);
                     break;
                 case TR::Entity::DOOR_1                :
                 case TR::Entity::DOOR_2                :
@@ -108,7 +110,7 @@ struct Level {
                     if (entity.modelIndex > 0)
                         entity.controller = new Controller(&level, i);
                     else
-                        entity.controller = new SpriteController(&level, i, 0);
+                        entity.controller = new Sprite(&level, i, 0);
             }
         }
 
@@ -232,7 +234,7 @@ struct Level {
         PROFILE_MARKER("ROOM");
 
         TR::Room &room = level.rooms[roomIndex];
-        vec3 offset = vec3(room.info.x, 0.0f, room.info.z);
+        vec3 offset = vec3(float(room.info.x), 0.0f, float(room.info.z));
 
         Shader *sh = setRoomShader(room, 1.0f);
 
@@ -251,9 +253,11 @@ struct Level {
                 TR::StaticMesh *sMesh = level.getMeshByID(rMesh.meshID);
                 ASSERT(sMesh != NULL);
 
+                if (!mesh->meshMap[sMesh->mesh]) continue;
+
             // check visibility
                 Box box;
-                vec3 offset = vec3(rMesh.x, rMesh.y, rMesh.z);
+                vec3 offset = vec3((float)rMesh.x, (float)rMesh.y, (float)rMesh.z);
                 sMesh->getBox(false, rMesh.rotation, box);
                 if (!camera->frustum->isVisible(offset + box.min, offset + box.max))
                     continue;
@@ -343,7 +347,7 @@ struct Level {
         int j = room;
             for (int i = 0; i < level.rooms[j].lightsCount; i++) {
                 TR::Room::Light &light = level.rooms[j].lights[i];
-                float d = (pos - vec3(light.x, light.y, light.z)).length2();
+                float d = (pos - vec3(float(light.x), float(light.y), float(light.z))).length2();
                 if (idx == -1 || d < dist) {
                     idx = i;
                     dist = d;
@@ -360,7 +364,7 @@ struct Level {
         if (idx > -1) {
             TR::Room::Light &light = level.rooms[room].lights[idx];
             float c = level.rooms[room].lights[idx].intensity / 8191.0f;
-            Core::lightPos[0]   = vec3(light.x, light.y, light.z);
+            Core::lightPos[0]   = vec3(float(light.x), float(light.y), float(light.z));
             Core::lightColor[0] = vec4(c, c, c, (float)light.attenuation * (float)light.attenuation);
         } else {
             Core::lightPos[0]   = vec3(0);
@@ -389,7 +393,7 @@ struct Level {
             setRoomShader(room, c)->bind();
             Core::active.shader->setParam(uColor, Core::color);
             // get light parameters for entity
-            getLight(vec3(entity.x, entity.y, entity.z), entity.room);
+            getLight(((Controller*)entity.controller)->pos, entity.room);
         }
 
         if (entity.modelIndex < 0) { // sprite
@@ -482,7 +486,7 @@ struct Level {
         //    Debug::Level::portals(level);
         //    Debug::Level::meshes(level);
         //    Debug::Level::entities(level);
-        Debug::Level::info(level, lara->getEntity(), (int)lara->state, lara->animIndex, int(lara->animTime * 30.0f));
+        Debug::Level::info(level, lara->getEntity(), lara->animation);
         Debug::end();
     #endif
     }
diff --git a/src/libs/minimp3/minimp3.cpp b/src/libs/minimp3/minimp3.cpp
index d76e499..cae9609 100644
--- a/src/libs/minimp3/minimp3.cpp
+++ b/src/libs/minimp3/minimp3.cpp
@@ -2504,16 +2504,16 @@ int mp3_decode_init() {
         for(i=0; i<512*16; i++){
             int exponent= (i>>4);
             double f= libc_pow(i&15, 4.0 / 3.0) * libc_pow(2, (exponent-400)*0.25 + FRAC_BITS + 5);
-            expval_table[exponent][i&15]= f;
+            expval_table[exponent][i&15]= uint32_t(f);
             if((i&15)==1)
-                exp_table[exponent]= f;
+                exp_table[exponent]= uint32_t(f);
         }
 
         for(i=0;i<7;i++) {
             float f;
             int v;
             if (i != 6) {
-                f = tan((double)i * M_PI / 12.0);
+                f = float(tan((double)i * M_PI / 12.0));
                 v = FIXR(f / (1.0 + f));
             } else {
                 v = FIXR(1.0);
@@ -2522,7 +2522,7 @@ int mp3_decode_init() {
             is_table[1][6 - i] = v;
         }
         for(i=7;i<16;i++)
-            is_table[0][i] = is_table[1][i] = 0.0;
+            is_table[0][i] = is_table[1][i] = 0;
 
         for(i=0;i<16;i++) {
             double f;
@@ -2540,7 +2540,7 @@ int mp3_decode_init() {
         for(i=0;i<8;i++) {
             float ci, cs, ca;
             ci = ci_table[i];
-            cs = 1.0 / sqrt(1.0 + ci * ci);
+            cs = float(1.0 / sqrt(1.0 + ci * ci));
             ca = cs * ci;
             csa_table[i][0] = FIXHR(cs/4);
             csa_table[i][1] = FIXHR(ca/4);
diff --git a/src/platform/web/index.html b/src/platform/web/index.html
index d8cee04..6cca02b 100644
--- a/src/platform/web/index.html
+++ b/src/platform/web/index.html
@@ -3,8 +3,8 @@
 		<head><title>OpenLara</title></head>
 		<body>
 			<span id="status">Starting...</span>
-			<canvas id="canvas" width="160" height="120" oncontextmenu="event.preventDefault()"></canvas><br>
-			<span id="info"><a target="_blank" href="https://github.com/XProger/OpenLara">OpenLara on github</a><br>controls:<br>keyboad: move - WASD / arrows, jump - Space, action - E/Ctrl, draw weapon - Q, change weapon - 1-4, walk - Shift, side steps - ZX/walk+direction, camera - MouseR)<br>gamepad: PSX controls on XBox controller</span>
+			<canvas id="canvas" width="16" height="16" oncontextmenu="event.preventDefault()"></canvas><br>
+			<span id="info"><a target="_blank" href="https://github.com/XProger/OpenLara">OpenLara on github</a><br>controls:<br>keyboad: move - WASD / arrows, jump - Space, action - E/Ctrl, draw weapon - Q, change weapon - 1-4, walk - Shift, side steps - ZX/walk+direction, camera - MouseR)<br>gamepad: PSX controls on XBox controller<br>FullScreen: Alt + Enter</span>
 
 			<script type='text/javascript'>
 				var statusElement = document.getElementById('status');
diff --git a/src/platform/win/OpenLara.vcxproj b/src/platform/win/OpenLara.vcxproj
index ca5850b..8f1a050 100644
--- a/src/platform/win/OpenLara.vcxproj
+++ b/src/platform/win/OpenLara.vcxproj
@@ -151,7 +151,9 @@
     <ClCompile Include="main.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="..\..\animation.h" />
     <ClInclude Include="..\..\camera.h" />
+    <ClInclude Include="..\..\character.h" />
     <ClInclude Include="..\..\controller.h" />
     <ClInclude Include="..\..\core.h" />
     <ClInclude Include="..\..\debug.h" />
@@ -166,6 +168,7 @@
     <ClInclude Include="..\..\mesh.h" />
     <ClInclude Include="..\..\shader.h" />
     <ClInclude Include="..\..\sound.h" />
+    <ClInclude Include="..\..\sprite.h" />
     <ClInclude Include="..\..\texture.h" />
     <ClInclude Include="..\..\format.h" />
     <ClInclude Include="..\..\trigger.h" />
diff --git a/src/platform/win/main.cpp b/src/platform/win/main.cpp
index 6af750d..193901c 100644
--- a/src/platform/win/main.cpp
+++ b/src/platform/win/main.cpp
@@ -311,14 +311,12 @@ int CALLBACK WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLi
             if (time <= lastTime)
                 continue;
 
-            float slow = Input::down[ikR] ? 8.0f : 1.0f;
-
             float delta = min(1.0f, (time - lastTime) * 0.001f);
             EnterCriticalSection(&sndCS);
             while (delta > EPS) {
-                Core::deltaTime = min(delta, 1.0f / 30.0f) / slow;
+                Core::deltaTime = min(delta, 1.0f / 30.0f);
                 Game::update();
-                delta -= Core::deltaTime * slow;
+                delta -= Core::deltaTime;
             }
             LeaveCriticalSection(&sndCS);
             lastTime = time;
diff --git a/src/sprite.h b/src/sprite.h
new file mode 100644
index 0000000..424ed6b
--- /dev/null
+++ b/src/sprite.h
@@ -0,0 +1,70 @@
+#ifndef H_SPRITE
+#define H_SPRITE
+
+#include "controller.h"
+
+struct Sprite : Controller {
+
+    enum {
+        FRAME_ANIMATED = -1,
+        FRAME_RANDOM   = -2,
+    };
+
+    bool  instant;
+    int   frame, flag;
+    float time;
+
+    Sprite(TR::Level *level, int entity, bool instant = true, int frame = FRAME_ANIMATED) : Controller(level, entity), instant(instant), flag(frame), time(0.0f) {
+        if (frame >= 0) { // specific frame
+            this->frame = frame;
+        } else if (frame == FRAME_RANDOM) { // random frame
+            this->frame = rand() % getSequence().sCount;
+        } else if (frame == FRAME_ANIMATED) { // animated
+            this->frame = 0;
+        }
+    }
+
+    static void add(TR::Level *level, TR::Entity::Type type, int room, int x, int y, int z, int frame = -1) {
+        int index = level->entityAdd(type, room, x, y, z, 0, -1);
+        if (index > -1) {
+            level->entities[index].intensity  = 0x1FFF - level->rooms[room].ambient;
+            level->entities[index].controller = new Sprite(level, index, true, frame);
+        }
+    }
+
+    TR::SpriteSequence& getSequence() {
+        return level->spriteSequences[-(getEntity().modelIndex + 1)];
+    }
+
+    void update() {
+        if (flag >= 0) return;
+
+        bool remove = false;
+        time += Core::deltaTime;
+
+        if (flag == FRAME_ANIMATED) {
+            frame = int(time * SPRITE_FPS);
+            TR::SpriteSequence &seq = getSequence();
+            if (instant && frame >= seq.sCount)
+                remove = true;
+            else
+                frame %= seq.sCount;
+        } else
+            if (instant && time >= (1.0f / SPRITE_FPS))
+                remove = true;
+
+        if (remove) {
+            level->entityRemove(entity);
+            delete this;
+        }
+    }
+
+    virtual void render(Frustum *frustum, MeshBuilder *mesh) {
+        mat4 m(Core::mModel);
+        m.translate(pos);
+        Core::active.shader->setParam(uModel, m);
+        mesh->renderSprite(-(getEntity().modelIndex + 1), frame);
+    }
+};
+
+#endif
\ No newline at end of file
diff --git a/src/trigger.h b/src/trigger.h
index 1b10db0..3a59de8 100644
--- a/src/trigger.h
+++ b/src/trigger.h
@@ -2,6 +2,7 @@
 #define H_TRIGGER
 
 #include "controller.h"
+#include "sprite.h"
 
 struct Trigger : Controller {
 
@@ -50,7 +51,7 @@ struct Trigger : Controller {
         }
 
         if (!inState())
-            setState(state != baseState ? baseState : (entity.type == TR::Entity::TRAP_BLADE ? 2 : (baseState ^ 1)));
+            animation.setState(state != baseState ? baseState : (entity.type == TR::Entity::TRAP_BLADE ? 2 : (baseState ^ 1)));
 
         updateAnimation(true);
         updateEntity();
@@ -58,7 +59,7 @@ struct Trigger : Controller {
 };
 
 struct Dart : Controller {
-
+    vec3 velocity;
     vec3 dir;
     bool inWall;    // dart starts from wall
 
@@ -67,7 +68,8 @@ struct Dart : Controller {
     }
 
     virtual void update() {
-        velocity = dir * level->anims[animIndex].speed;
+        TR::Animation *anim = animation;
+        velocity = dir * animation.getSpeed();
         pos = pos + velocity * (Core::deltaTime * 30.0f);
         updateEntity();
         TR::Level::FloorInfo info;
@@ -77,7 +79,7 @@ struct Dart : Controller {
                 TR::Entity &e = getEntity();
                 
                 vec3 p = pos - dir * 64.0f; // wall offset = 64
-                addSprite(level, TR::Entity::SPARK, e.room, (int)p.x, (int)p.y, (int)p.z, SpriteController::FRAME_RANDOM);
+                Sprite::add(level, TR::Entity::SPARK, e.room, (int)p.x, (int)p.y, (int)p.z, Sprite::FRAME_RANDOM);
 
                 level->entityRemove(entity);
                 delete this;
@@ -99,14 +101,13 @@ struct Dartgun : Trigger {
         // add dart (bullet)
         TR::Entity &entity = getEntity();
 
-        vec3 pos = vec3(0.0f, -512.0f, 256.0f).rotateY(PI - entity.rotation);
-        pos = pos + vec3(entity.x, entity.y, entity.z);
+        vec3 p = pos + vec3(0.0f, -512.0f, 256.0f).rotateY(PI - entity.rotation);
 
-        int dartIndex = level->entityAdd(TR::Entity::TRAP_DART, entity.room, (int)pos.x, (int)pos.y, (int)pos.z, entity.rotation, entity.intensity);
+        int dartIndex = level->entityAdd(TR::Entity::TRAP_DART, entity.room, (int)p.x, (int)p.y, (int)p.z, entity.rotation, entity.intensity);
         if (dartIndex > -1)
             level->entities[dartIndex].controller = new Dart(level, dartIndex);
 
-        addSprite(level, TR::Entity::SMOKE, entity.room, (int)pos.x, (int)pos.y, (int)pos.z);
+        Sprite::add(level, TR::Entity::SMOKE, entity.room, (int)p.x, (int)p.y, (int)p.z);
 
         playSound(TR::SND_DART, pos, Sound::Flags::PAN);
 
@@ -159,7 +160,7 @@ struct Block : Controller {
         level->getFloorInfo(e.room, e.x + (int)dir.x, e.z + (int)dir.z, info, true);
         if ((info.slantX | info.slantZ) || info.floor != e.y)
             return false;        
-        if (!setState(push ? STATE_PUSH : STATE_PULL))
+        if (!animation.setState(push ? STATE_PUSH : STATE_PULL))
             return false;
         updateFloor(false);
         return true;
diff --git a/src/utils.h b/src/utils.h
index a8d318a..afe56eb 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -22,7 +22,7 @@
     #ifdef PROFILE
         #define LOG(...) printf(__VA_ARGS__)
     #else
-        #define LOG(...)
+        #define LOG(...) 0
     #endif
 #endif
 
@@ -115,6 +115,9 @@ struct vec3 {
 
     float& operator [] (int index) const { return ((float*)this)[index]; }
 
+    bool operator == (float s) const { return x == s && y == s && z == s; }
+    bool operator != (float s) const { return !(*this == s); }
+
     vec3& operator += (const vec3 &v) { x += v.x; y += v.y; z += v.z; return *this; }
     vec3& operator -= (const vec3 &v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
     vec3& operator *= (const vec3 &v) { x *= v.x; y *= v.y; z *= v.z; return *this; }
@@ -534,6 +537,14 @@ struct Box {
     Box() {}
     Box(const vec3 &min, const vec3 &max) : min(min), max(max) {}
 
+    vec3 center() const {
+        return (min + max) * 0.5f;
+    }
+
+    vec3 size() const {
+        return max - min;
+    }
+
     void rotate90(int n) {
         switch (n) {
             case 0  : break;