From 01ba51796cc583e9a6152b91c22cad3098d4de18 Mon Sep 17 00:00:00 2001
From: Istrebitel <no.ads.starsabre@gmail.com>
Date: Thu, 30 Mar 2017 21:19:43 +0300
Subject: [PATCH] Turn Based Progress #1

- TB UI for when it's our turn
- TB UI for when it's not our turn
- TB cost to fire
- AI properly interacting with AI
- Interrupt properly working
- TU Reserving
---
 data/battle/battlescape-buttons-large.xcf     |  Bin 0 -> 10388 bytes
 data/battle/battlescape-buttons-res-aim.png   |  Bin 0 -> 1435 bytes
 data/battle/battlescape-buttons-res-auto.png  |  Bin 0 -> 1507 bytes
 data/battle/battlescape-buttons-res-kneel.png |  Bin 0 -> 1301 bytes
 data/battle/battlescape-buttons-res-snap.png  |  Bin 0 -> 1378 bytes
 ...tons.xcf => battlescape-buttons-small.xcf} |  Bin
 data/battle/battlescape-icons-fixed-138.png   |  Bin 422 -> 401 bytes
 data/battle/battlescape-icons-fixed-139.png   |  Bin 448 -> 429 bytes
 data/battle/battlescape-icons-fixed-305.png   |  Bin 0 -> 837 bytes
 data/forms/battle/battle.form                 |   48 +-
 data/forms/battle/battle_rt_tab3.form         |    4 +-
 data/forms/battle/battle_tb_plan_popup.form   |   33 +
 data/forms/battle/battle_tb_tab3.form         |   10 +-
 data/forms/battle/battle_tb_tab4.form         |   57 +-
 data/forms/battle/battle_tb_tab5.form         |   15 -
 game/state/aequipment.cpp                     |  176 +-
 game/state/aequipment.h                       |    7 +-
 game/state/agent.cpp                          |    2 +-
 game/state/battle/ai/ai.cpp                   |  114 +-
 game/state/battle/ai/ai.h                     |   12 +-
 game/state/battle/battle.cpp                  |  182 +-
 game/state/battle/battle.h                    |   27 +-
 game/state/battle/battleexplosion.cpp         |   14 +-
 game/state/battle/battleexplosion.h           |    3 +
 game/state/battle/battlehazard.cpp            |   81 +-
 game/state/battle/battlehazard.h              |    8 +-
 game/state/battle/battleitem.cpp              |    5 +
 game/state/battle/battleitem.h                |    4 +
 game/state/battle/battlemap.cpp               |   18 +-
 game/state/battle/battlemap.h                 |    4 +-
 game/state/battle/battlemappart.cpp           |    5 +-
 game/state/battle/battlemappart.h             |    2 +
 game/state/battle/battleunit.cpp              |  851 +++++---
 game/state/battle/battleunit.h                |   98 +-
 game/state/battle/battleunitmission.cpp       |   76 +-
 game/state/battle/battleunitmission.h         |   15 +-
 game/state/gamestate_serialize.xml            |   27 +-
 game/state/tileview/collision.cpp             |   10 +-
 game/state/tileview/collision.h               |    1 +
 game/state/tileview/pathfinding.cpp           |    2 +-
 game/state/tileview/tile.h                    |    3 +-
 game/ui/CMakeLists.txt                        |    2 +
 game/ui/battle/battleturnbasedconfirmbox.cpp  |   70 +
 game/ui/battle/battleturnbasedconfirmbox.h    |   41 +
 game/ui/battle/battleview.cpp                 | 1781 ++++++++++-------
 game/ui/battle/battleview.h                   |   20 +-
 game/ui/gameui.vcxproj                        |    2 +
 game/ui/gameui.vcxproj.filters                |    6 +
 game/ui/tileview/battletileview.cpp           |   25 +-
 tools/extractors/docs/tb.txt                  |   44 +-
 tools/extractors/extract_agent_types.cpp      |   10 +-
 .../extract_unit_animation_pack_bsk.cpp       |    7 +
 52 files changed, 2678 insertions(+), 1244 deletions(-)
 create mode 100644 data/battle/battlescape-buttons-large.xcf
 create mode 100644 data/battle/battlescape-buttons-res-aim.png
 create mode 100644 data/battle/battlescape-buttons-res-auto.png
 create mode 100644 data/battle/battlescape-buttons-res-kneel.png
 create mode 100644 data/battle/battlescape-buttons-res-snap.png
 rename data/battle/{battlescape-buttons.xcf => battlescape-buttons-small.xcf} (100%)
 create mode 100644 data/battle/battlescape-icons-fixed-305.png
 create mode 100644 data/forms/battle/battle_tb_plan_popup.form
 delete mode 100644 data/forms/battle/battle_tb_tab5.form
 create mode 100644 game/ui/battle/battleturnbasedconfirmbox.cpp
 create mode 100644 game/ui/battle/battleturnbasedconfirmbox.h

diff --git a/data/battle/battlescape-buttons-large.xcf b/data/battle/battlescape-buttons-large.xcf
new file mode 100644
index 0000000000000000000000000000000000000000..247e5ceb325f4e6a7fdc1c0025f7cab8220c9dac
GIT binary patch
literal 10388
zcmeI1Pi))B8O1r&-*v_|6Q|o07!(Sy1(HRSdXaSR>8(I73slD*6o>W_aO@~{fv}hM
zq+?OIfQ~&F1&==T;G>Qe(7Bg~DWC=o!ouj5MS--Ntt|F^LsFL3B(1nHHoGvbk%q%J
z)NtnKnWy<SoX1ZZ&(_u(>&~Wa;P@EnTa>|Z6^SvttsvEZ_-n(UgyT9=8R-Vn`$?X3
zsK^99tqt6^={#<4*v*Zn&Lb2VxXz4QJG<_t-PqaQbROMaxV65qw!OLiv~f#+G@ouf
zY&TZ#uIeKr^HFl?HmW|%sG44H<Y%brvz;gHHD_z1@lpC+D0H(5ld|T|ww&FDv$giA
zy+if4*VlLK-AMzf_UWRyWVR~xLvpa+7)JHTFqZ#_ZoFd{jo+nL@R<$*^=b9TZP$KE
z7fpJ@QAMKOUq`AZc~ZWY<ndw9D3FGZ1*9~8Wh&37@{3dXW#s9;=}|)_t)GrOl_iJy
zqa>5I8d~$Gvt{OEI{!s^Ym%7p%kpMqy!qcbszk=QDxI_1<#)~Wz|6_K!+owwm*X|l
zZ8InHcKkQE4`-*<#>4jR?xwx7)_!6)owe<)o#wjp%zo6oxB7#-PqsE_zDg%rbjnvY
z(Uzzo@lpGIl9`%lYk!z6tNn@2kFB=bbjNLrStFzE_V4unz1R7~vW!nU1OG$+)xhgK
zz}W+D5VCL-g<({Qz8k*s5BDCd>f)Z+E4i#Uc01QQRkzf8<#syprF~rbw#VcZkM&IV
z3tiY_J?0(nANI@rvFtDQN79r1_xgW7-0$tVu9moay`Fd2ANb5K%L)?nN1iYJn$HHG
zX<dAO7eeSD`&=reUsY9?RrTB-WXOCa!%)9!VM&fXY07f=H<hiGHCYc$w0-1B8J5Do
z<mmK0qew;z(SM-yJQ+pkr#a+IzJ@rKzs$S4k|oK}+G8}l6#g|=Mi0hA+z`Df!*Y0(
ztz`aHWy+C~QdQJZ){_tXYd+H*E<L}T)!`Vrl|CeW^o-Z9_WyCx)vJ0$y#1AZhW_1W
z_^9vy%frCx0c*JJcIS47wO_}l*7q&e7+WCF?l!w)TN7w^V**=XuGNu5piBvr*#t@=
zunPjaL|_*Lc2fcmaOr(-WDDUf5QN=n2oE%bf*=&O&=4N<_PSjSVK;_Q5`+Q}3P5Q4
zf*_Qi9g;4FunS=Vp%@PJt2(TU>hQTQGi3fygrR-`LNT_5DFERxTPtb;5ZX-80}zBc
zI(^S55(FWXwk=`^&z3Xs8sb>~GEY7fB>@P<F&YjCb7k~kfRI{%<^sZOB_JG{Vl)(D
zSQ#E=J-H+Zb%zU^AUxgS7&<^G0HG~x4dG-&R`rN@2P+2*{d>UhQ9mFE;{j`QZJQvp
zPeJGqgpP*LnSpSiK2&+rpu#kGe=-f8f>2*dAZ&3yfso4MnJ|Ws6NJ3QrywLr0^vY0
zRpu2WrbaErRZY=M7(cSs#SlXFIS&H;ss?pl4W6q(hD-%K#7N-<2>H0hO%4cyY%Q;G
zK-gk@ga;r9b9DNiQN#&CC|fNaLwL5F@z)T?@|St?fS2g&`7v4z2y<ohRDh6L06ieg
zRx))pF!?CpJg5XmSx-Jt*A&wo&ReRS)!{LO91ym6YYIY)$o&%t(Z2*CpFoJqjjrPm
zgbpC2({v`hAB~OZ-bKG@7m)e_`Y~9)w|f6w@-Y?NLj7j_Jjti+#Scd7SF>f-Z|R)1
z@49CD3(K&qj(f))ckrM5-*cFll}>Gb6LUTFFGpGa#fQZ(z4AN`W=R{DAZtnXeWk+1
z6U&ls7Q&@z%km=I1JK>VXlcf-oFSdhs)W|Ws1!7D`RnRZn0>cv+A&|<JKcn@H@7I@
z>y0c55R2W(k)FxF<W77T2-5~)XZw>SZA*fz1=sh7LqaSyB>7f=5IZp>FS1v7x|>F9
z%8Z;LozI96Vu=kYXd)2%dU_D%05Rt@VsC0drVt}{;GJbafLQE3QpBj%#Cs^%1G810
z$9*hm(~-U6svsc5QoE7A&=X=OcH>3<-85oTR^trmd^Up+OH4*V6M@*J!^rn3dVNk;
z?8IT*dzTzWx<!qK-uSa_?a7W0uHE?OY}t48=|wsW(=+AOyseUAmmxjo)!%~0&}L<7
zYouTizw{ZHAoXU)+usejNS^`9;1(7OHbjcuhOn6p)c$X;p-s!w21vnTe(5)8EvDc1
zZ-39@BK-zXgKGe4SSPc$J&IiiZ?RVWEqD%XUZ%D=3KsQC-!Y5YH)Chx<9Eq-q+xmZ
ziJL!}^%xX3zxnBG+0AEkev!W8ds(5G724aE{e|qP%r&24Hhw)TIH0333ko3{HS!RW
zsjK`gjVmEyHDQ6v;1E>8!o7*bD2aJQEHdYkBIZKUg0Ec+5gUp_F6ClfMaN|dqAkm+
zDr<Rx7E1?OD8iKy)`G9F`X-_*raVS~EHljV!5p!bi*ys3oi9gJzz%+VYj!e%DPRYi
z8N|-%J^h%SA>74qWFwMNALj2>fE@vL^0yzrjsQFPf-nL*@isxs&Ky#NN;Et9Qm|tq
zT0)T$uv4U~B%<6P$?~u&YI*SyumclDfvJp+gi!!H2#%QI7;!CP=Tvm$gE>MX7ikYt
zc4((z5(oi1a0^rH%<My4Q?yHgDJ3uVu@E3Y5{z01fYgKhZ3D2w!A`ya>~OG?FVO77
zzyD))=8z)7q1nlof}IwE92DRHJ4L!mBFc?zEC*Fy%L{8*I;=tQq>PS?*}=+h@?(Uf
TPT0Xvq(O}dJ1G0ABN_h#H}f9V

literal 0
HcmV?d00001

diff --git a/data/battle/battlescape-buttons-res-aim.png b/data/battle/battlescape-buttons-res-aim.png
new file mode 100644
index 0000000000000000000000000000000000000000..a027b55b826de4fa7741abe33692081e845aae06
GIT binary patch
literal 1435
zcmV;M1!Ve(P)<h;3K|Lk000e1NJLTq001@s000#T1^@s64SgL&00006VoOIv0RI60
z0RN!9r;`8x010qNS#tmY3ljhU3ljkVnw%H_000McNliru;R78F9V{_(1i1hJ1t>{G
zK~z}7)t7BZTW1u<|FK9WC=F}-!QfCkM&{P0I%nFE+sZYqZ)7D#W7?GUEeLjCp>DK<
z!Ace?YrhD7NLQ3Dq$3lRScG2tVjN;Z+N5nr+!|~!kuu`i3hhcjg0yEJw%jEqvDUc_
zKmB;lz2|wJ!+CuKB9VxiGzT&FbPg3V8GIhkx?|y%LiGP&flw$!JRZlw!h#?tVbtl9
zClQ~YUw3S*sllW0L)0skh{xj)3WWfG9N&Ep%1TRd<JJwdwVlA^q-)(!b5H}n-w&x&
ziU)xJ?=b)X%d(``>&fkPQ+IbaJ$v?yy1ToHi1_uTOP7d<GBWZ1|3RbCL>$MFR;wkJ
zWvQsBm_#BG0f0avk<i(*XW^gnqxhX-IGs)~3<IariQ;YBQet_3Z7nbNI2@2lr3eH9
zYsz3Gk~NnS=O^DUaSx8;ke640>FHno%rUW842Q#k536>jC@~C!Co?lR+}g_X-o1NJ
zDwTLLGXuR|j~6dqte#un##`T;@$K}T6nXM_+0IYg&*$+#rcfXli9jqCV}AbW-#HeI
zMp0Q=iR(i{U>Js1_67oIZf?fiyLWNu(4jO=eSR#Xe5ITk9Km+Ye%ND+Z=~mTyHVfL
z0;ki7#+n-5qtR#-n>TOab4<XpED1MmL}N`2Zr{Gm8`s?2jIpsXXbx&{lN&>8>j4Z5
z^rNx&JnXSWsPl7qa&2e$@5!`&vMuF5du$Ph-9KYspdau38bGK>ipJjaS@n}y+qf53
z?N?E~yBdQdBdC%}F)=ZLtvhzW<8a{Bt5*nx!idFw$MfgU1p<jgLh2(&;PZHR<CIDz
z+-^6Tnwl^<=}Ix``iZY`K=&CgSCrtmZx;QwE2zKt4KMGvUCGGH6(wm#E@fiBO!_u!
zA8H%-!e+Ihie+(qXb8J@?E*JGj<V9yv>XG=vQ)29k)f-Lv|25h&1TZ;^~7-;b#``A
zFc>1E(L|xh92rDHzAAZ(^7-nNEMJZWk&wJa`8@SZWy(6+KBjXQC>RXU8N(UkIF63B
zx0BgyCaqRWhORDBC={8i;z~T0DXf<AbmTW!EEXI+dNeD){B$oAWn1A0hS5Gd4SQ@6
z+co<!H8=uwelDC}n9}r=sssP6#}fU_AQEQnbJ=KX)1-JVvCh;VSK~2ABoZ=oby2-a
zMLj(|q|@ohX0uU8M+c3MkCV}8qF^vYrgIn4!Y^@&WFuF~rQx`ApX6{1Mdrw8G?Clu
zrjCvdvfAyW)9I+Er-$lQDmr!Q6iFl!Dlh+-^78VCpFCFTv4n9;b7eJ?L#EtX%N%<n
zkA)(0Z(J}kacLMXS2$MdF}{yg$Ycon{iv?4PU&N9Z72ACGGrfKwxq9=$)*3eZ<b##
z*D_kvO|V$|R@}#OqR}Wni^=73IGs)?6bg)vjzXza!eZ^?`&f&*2{vorKW1{Xwpsi5
z3FO^bZ&p2vwGS$_3ZtW=VE>vK<#IWE9uK5aY1-tGBNmJKvBc$afngXp91c{mEQW`N
zQMa!Sy}cK)d$)Yem}n7+wIdjYIzJbVU^uH@-M%^u{y2z+h6em}^ClREfy?DWg-nJ(
zAdo&QhC<<t9-Fv!4OJ|QD+2>4XP7nPEp-Fb`MLP6M8eCfJHLWGwutuG>DTHHj*MX6
zo;|Pin4qMjgx)VNN8y%2Oa~ueXVph*{uKGQc*lDmlClr*DEu&eR@}5{6TN)-l7CjO
pS8mv_0R;sGc>MS=78Vu+e*giYRne$+>C*rJ002ovPDHLkV1n0iq3!?x

literal 0
HcmV?d00001

diff --git a/data/battle/battlescape-buttons-res-auto.png b/data/battle/battlescape-buttons-res-auto.png
new file mode 100644
index 0000000000000000000000000000000000000000..8f272b7482c1a9cd0836c2afd4c30748c6b962db
GIT binary patch
literal 1507
zcmV<91swW`P)<h;3K|Lk000e1NJLTq001@s000#T1^@s64SgL&00006VoOIv0RI60
z0RN!9r;`8x010qNS#tmY3ljhU3ljkVnw%H_000McNliru;R78F9sys03l9JQ1#n43
zK~z}7)t7BZTUQvz|FN{Gpj7%o*I+TVj5}SM>YTQ#x0P$^D?v1B;v#*`Ea?Y7=tjjA
zCTXZ!?I0k-R+KHIBbDg1I2uc59JZ0PiB3$n1s623jaY3#Cqf8fpM6-pnEGDbhM#_%
zlk-3K{PUdiJm(0`ms}zM7=1p9_@pHCI~<#i`}XX^p!-)aF|la+)&RfXFAzjTL{K0Q
zfJUQ%+w0ww<{VZl`uh412m~M$3Nbl3DF_iCJP3_OgKgWlLI3#;Y@eCkG_1N(f$^as
zNF);M-Mbe;p%8&U0001v<4CPmlig`2y<Sff6BDG@>xqc?c71(45z(TY8~=Y$tJRUk
zVj-ncNgT&fWMmXYL_`n(2pEQ;s;VjsJRLyP{wUaNHn1!Uo6Ux(Lx+OGo|B%=_dBds
zNF)-tT&@jcl2p3vwwwF@{PoSP!(y=@G&CH8gTKJ<_X|QqA`z@sE8a~!8YE&_7UM%h
zIHOQtd}s)|-cJ1SX&K5MwqxA#9n{e~G39&+wOWm-sj0OydMCDjQ-?1GpYZ+jzqc6s
z`uZS~$@um4I~+)oO5yf;Argu3;>B|ag+c&8h|lLkLP7%Wx3qv|SzhdPxsacqkKW#1
z6c-ocj^ZNHT03w@aS_E=Z=g4P|37^7`&#+5xgCcKbI>|HvnHM0ZbxQ80c<uKvQty}
zi28g!?B2bHKVt%p<4Cw;2eMOB@%Zs$-duiuJ~}%)QTSmY9#}e&-EbYZ#0;b{(XhIQ
z@kv7y%;qL26h%wY_`xB_!?vPzdWPp2`_C|&oACCZE_fm($Zog}OG(AD^O(&|NY6fn
zyRCPTav}xI?d?dENYLHgjp!ps;ILZp^5si-Jj0lt{tJ_nlL7(5FeE>F7X1zfZ%!tY
z!EU!BFE0;|9`*2(tIm9cCev*csZOt%U&o6Vn0%cV`bU=3n~aS}&pri{(S$^f!~K>P
z96NRlmaZ<u95}GxjPVhRPfEh@zyMNGQi38@QgSKCROZdAL5n$Dm;<YO7}A(%jKv<u
zxpU`WFc=nP&4IUq%-j+)(2NWQ&3D=RY=Q2px&{=;^I$MGt~z2NKA(@zI?2h&u-R;o
zN~P%N=zvTn<F~`yKWF<`hs)k)JjY^><IC?mS2SfX7;xG947bD#4j1MGnVLIm^02Lo
z>WWmSVKz4*SDuTGjt+3IvSV^`GWs13NF<U4XAB(2QD$x~RaRG%QmLf6x;j#;)nu_)
zsJy(K+-?tPwL0>6M@e_BCaBIWSKn5msicr9BZTCP3?nt0z_%BxkGg9$<aT?gqOyW4
z77Lx%XsE8Pj+9CzRaRG%R4QFi$G|WQRaRG1W^OLk*4C0rr6QBbM5U#r)Ya8RTCI-U
zZV&0M)sV+Kx~ihR8qPQ6j0~gt`g)%8F9&+Po;==B(rR^NciO46w3Ljkt)x<^sJ6D2
zGIMjOtgMU}hM~B)_bD_ql-3oo_0ky`#+$2*5YoiN1kcyU|ECdK4`1Jg^UW<b{!Jpb
z>a3_x6rrWH?Tu3Xa;g79{|Mi{f9bO&bsL@)4aP>kjupuBU@|tYoAZmc$=Jwe#e*Zx
zC3Oa4<C?N!h)5*juO&S_Jz!ZDR;v|>9EY~HHe{q_prPR=PMk>IFwUj+xwh3k40+gA
zSlz=*>N3(Y(0r#ESy@^5@xcSIEQ_9=9>gal!R2x-yeoP<!;40&``$eyavW}(&4^>!
z4dV~;EWS9;^{13yLF@DkG$Vs6>YLl!k#_RriV+it#bSCVE{=a*A5DC3L!To5CZ9Ne
z0uvL9--mx&cvsxDYZuMV&hpRd&B`rXwjew_9Ajf+@caFOzX9)Z9nOvAQ{Vsq002ov
JPDHLkV1htN&R+lk

literal 0
HcmV?d00001

diff --git a/data/battle/battlescape-buttons-res-kneel.png b/data/battle/battlescape-buttons-res-kneel.png
new file mode 100644
index 0000000000000000000000000000000000000000..317ed89e2e1a947f7bbc571f42f52cedfa50784c
GIT binary patch
literal 1301
zcmV+w1?u{VP)<h;3K|Lk000e1NJLTq001@s000#T1^@s64SgL&00006VoOIv0RI60
z0RN!9r;`8x010qNS#tmY3ljhU3ljkVnw%H_000McNliru;R78F9tXDKt~vk!1foeq
zK~z}7)t6sLTW1)?pD1lAR2pcDG&oGxi_FfZy3Ew!S;H|_v>qh>NurSoF3Xk{yl8Jk
zb|G1)W9}m0g~LsXxZ#{i3L+<MniG*m;*MsbZVN8Nj9n=G1MNfzq1bm9TMjy_SnJk#
z_2WC|d(ZbiJm>x1?~^s#uMz;PJX%44PKQ}hJa9a9@)Q;$zd)UP7K7jRA(2SPWD13X
zlF1|-4hJIf_<<BB3If96Fp|k6<Z?NlK7A@nQ=K^jhr@xxM-IdN*%vtSZ2iEn{gYNa
zjK!eQXpoha1-V>~WHJc=0L!vuv)L##9U`~eO;4UYA-CI2L?n%SdU}Y6UdYt^*FmS#
zMLf@w#bP0rWhpy5hZG700f0=cR#SU>JLVSVkn=_kg25mdhCwhGL{47bCflpZ%B1I_
zAV8zhV19mn->5SfcKq#9>u=02l?TuB$jHdV;^NOpBoeYTrBVq&5b$>4g-t;W!{A{o
zh9<LFVmKTI$8mTVi@|2IVRdzNU-{4Vwp%}y->fJ?XD}cVk3*?c;_>50kjv!&fVAc1
zWoWfp+!+}G!!T0t^!z+(YiltxGlRy)#(kwBZ50dGn&G(n{Y%G(LLrpb)gc%R;&Mre
z<mmG9GESU0Db-k-QmMqK&xfL-A_Rj$Xti1hf&f!h75sibObsU7zds4P{p!APVR#hh
zOjYo#J==AhslkN1_wJ&iq5|VS9~g$g<m9BZE56XN0-X+gARvh|7!2@wz2G<wKHd+r
zxgJA9gRnMzh!M~2U9tbYJY4?z^G!^>KWC~!OjU@Qqlb3=Js<CfvBn6m*9-RVS}QIt
z#;hnpqtR?}3@po1xzR{%9UWw`Sg5<Zn`|~4@jOpAZrq?qBuY-Fi=y!ra^39Q)9%%#
zkkfSb(H*%{yz6EsMIupZZEGc-=c(D@pziK&vREwC*3m%*gJH|A2(?;GZ5<s{ZZuL?
zR~K2WRvH)>pq7>v3Iqb=bh;=KiIVGPCq?5cd)}H~MO-w#LQbcPLen8?X=$N;kB6*Q
zD|K~sQMu7b*RNkEwOUR2`R`IjMh3l-W83w$-O$EpB{2hblO%4t{`j9dwpUR-Jw2Pm
z*ch!e-Z<~IIkp#WbZR5rZnwk(S7WK<x2vuFt}z+QvLrut3<WwJmgeT5*Xt1uhf!Nw
z3%}nFyZtJLh6Z6a*JH$U8}-&J7##R!PrOy2Le0@b@T@)C!VhMD+cCbbrW$?yz0kj}
z$MEPV3N;!`OibX-^XDN70-isAj%aiVYiob}b-GXWu~|_>adGjMKGxUYEA_FunraO6
z_wJb~5lx|=z}s6liMv&xLiv}UZX4g%-}_R1Y+J|lm6eztA4hd{HO9uqz;WCwv0>;d
zNyK;NkHB#p?$uOC;?9|>urNG|OCIlz-zhCE-IZgq?Cc!6a_wWxiXtwTlwfLV3LM8l
z5CrHeD>3f#fh{ZhU-8n#ix?XlLs3x?_&@-;r%!J=-OE%e6}^?8FI}%M6uz^sSCM~{
zKTQ7!b?#aGzVz!>$BrLAPV4LI(zW`aGCe&VnVFe*@ZbRwiG=J=lK-6*N4g+500000
LNkvXXu0mjfDa~Tz

literal 0
HcmV?d00001

diff --git a/data/battle/battlescape-buttons-res-snap.png b/data/battle/battlescape-buttons-res-snap.png
new file mode 100644
index 0000000000000000000000000000000000000000..b1e58e24fb72bbe54127c5bbe38f0ec42eb21f53
GIT binary patch
literal 1378
zcmV-o1)chdP)<h;3K|Lk000e1NJLTq001@s000#T1^@s64SgL&00006VoOIv0RI60
z0RN!9r;`8x010qNS#tmY3ljhU3ljkVnw%H_000McNliru;R78F9X8An{lfqN1n)^i
zK~z}7)t6sLn^zddpIF+jg3_?Ilm>^PWn}GKs&l3-`C9qRS~W;X<DYaXE3}yqFTAJ>
zY$#MhsGHqIz>91W*(8okqQoNYXK{WGA(A%MiRrfBLJ}Dx(m&9y1VRw|?qbV_X=1xJ
zuEVPz=Wrg*d3n$KKIcfzx3&=gEI(XEg-V6_Kw#5x@9w==4E+klfrA+OZUD(-QX-K`
zrIbpgU^bf(ip4f%Z~;NU+}s>esT3H7!ILLXBn9&Q`(ZYlv2FV{*gyXg+gDaM4ZALP
z;z1+=rBaDKd-i}~7^G4u0020SBa_KQ{#ifS?RI+n_%Ye-b|NBi+}GDfM3j^1_5TO0
zRvYm=PX>d5IF6%|l2VdNr33&Hg+f7HU0qnXw}8^OOX2hRz_KiSJ|9ZU$}-Y^>f}jr
zJ|GBCDwPNZgBwPbM)SgJm)?Kv`O@d$c^-v@#aLYY1<7PmQXrGbAP559t2&$^Vp$ds
zA`zTxX%RU$H;0CX20VyFU^1ET^y$;r=f1bF{aXjVSiB?7Kfm94`=`%09|%CD(I6Cy
zK_-*o(W8f87zO}P5Rb=ESy_o&BO_p0Rus<$gJ^7Q#NE4harW%l4d=b#F}&Y=3f{!Z
zE9v}xKkAyA;Pd&Qt*H?+8jr`ZYu9eE#v~la5wl|lv^6!jefzc;Tw`M+CMPG+{BbiT
z_(`<1oPq0T8T3V4;Z3YSU$hlp%N5WZ*asmL#b?eTcsxUBX*nbE`Ssq!3eNd|hQ~96
zcm4<>T%v^5*#o|{Geeh)C$%5py7xM&k5yxMYz$ROC8npRvG33!1Ox%ko;^c297Q7W
z=igm19*?6!r2;=Sg(F9fz~}QpqtRe|d>jo84PsCp&k!!mFX2|(6_J+)Zy+MC!ll6*
z81at6c<$2-u3euF&ULg5T4xXL4Ua+V?14A20<E(LuA^mH`n8<kC!y2pFg`vG?w?vy
ztJRnf1fWzZvoZ#b<ET!jBTIKT84Lz;I2>d$nTY3k>ged8P$*1RtBu03WwKqpmRA?E
zNEw<fDH3U7D>KFxDU(xYyLyd6p)hq?I*I3bI&U_U!{H!<!9bSoZqjHpSzQqdg@P>I
z-BhR3QEzWA8I4AAyWP~@-cD0fQ)IQ;C=?2l?dmlO$CmSM(I&Q%+^x+SLAhI-#o%)3
z!m(wtT5aT?^;3I$JGs1GG8&E4+uKWZIvriSc##we1(lb7NQH%klvl>q^R<7=wZWu=
zwMdzq{`f{SmQPSblyx2Z`uaq!eH^^;jOEK*wY8~h%x<@5UBeeOj@QkY=wlTs6`~6Z
zsIIQg@Uhm`HqlQ;yrVc{`~*Yp!MylQg<SNt3-e3j_*UDMb#+bp(-?5|zq*gj2Le#5
z)mc6^;OZBBtVw?wZdZTaTx-^DSHJiI*}pWqu5Q59|4KeqAd|_&XUWXW3|N+hAPA`9
zIE;>tqV_~BoX)Rs?3jAPm^SP5SO`U-FWL$r6kS(Wd!iP@-w&g{z8*hLOn_xs%*@Q7
zLZw157|ebvhQraE8JoU&6IC3CL5~OJEW2U+L0>OE$I|oF9hc!vtiZgq_)`7w*ceV6
zKmO8;N#t@ly<1)`ey<N#eXyZlk^ho+W`Ba>z(M>T{Vl7;Bs+KRq}A0`@msxFxn;{1
k6c-oc{{8z%CX<rC03QUCn7?+>Y5)KL07*qoM6N<$f`*ETKmY&$

literal 0
HcmV?d00001

diff --git a/data/battle/battlescape-buttons.xcf b/data/battle/battlescape-buttons-small.xcf
similarity index 100%
rename from data/battle/battlescape-buttons.xcf
rename to data/battle/battlescape-buttons-small.xcf
diff --git a/data/battle/battlescape-icons-fixed-138.png b/data/battle/battlescape-icons-fixed-138.png
index e59927f0d34d515be025dc2e89636966d1c9a6f5..9b94f5b06c61a701b1628b599aaa57eb32374d4b 100644
GIT binary patch
delta 355
zcmV-p0i6D(1CaxeBo78+OGiWi{{a60|De66laW3be*gz`Nliru;R78F7#IBy8Q1^-
z0Uk+2K~z}7-Ip<LgD@0^e<BYZ9O)qu$!rW{W8fMca|BN2gK&W!fQ_M%GEfOiL5hcN
z=~5F)i=tNW8uL%j)*JZrS$-xUqU-bF0GDLHhp#!-wJQVRDr*eVG({{WvMlowtQ^1z
z2W71Ve*iSr0#)S&NEAhVt&~D6B`RZXV5d`qFx>V{%_roe$9-okWxwYHiDBbg*FkxB
z1Yg_sn~cqHp@_V_INsZK8f?jEt)aDM0~H)V08kXgk8AJ1rU1AA1-BtCgW|spEd}^6
z#^z2yMAsxq5r$jjc|IH1*vMb|ev_x&4liZ-N%gHbSH>pp8S>`xxCgj25ZfH%o?mQW
zT!zNkV5Jdj13I5C>jOL1HM-8+<`{YWyD~MOKLACejI5r`B#Zz6002ovPDHLkV1j-|
BnVA3p

delta 396
zcmV;70dxM51EvFzB!2;OQb$4nuFf3k00004XF*Lt006O%3;baP00009a7bBm000ie
z000ie0hKEb8vp<SJ4r-AR9HvdmqD(AFc3h;zjEPEYJy4Kl>~PzxBv%m=@B>?N8kWl
zfCI2|^Y@ZyA`5rQ)Q(Y<pwc$KyktU4yO@{hG%#U|o!6TU5PxE|QX@C{+ivCaCRSG!
z1VI44??V`da?wTdqL6Y@ERJKS>l&gcg6U!b%h^nA`~P^Jr$zvrb12Ia@;twa2@$}2
z{(BR15iABuR?W%Fvg}ce3jv%lwbebSC`D7TA30LEEQOqQJ2iqwF_WZeD#I4W#YiYg
z5*fAxpDqtwP=E3$^NPOpZ^1sp9@8$?PWaRLP_&EnB{+2bT}VuOk70t8Btmmc7^7=l
zH^z=4(N`g2Xr%~aJw|jTZc2zSE=F`6Gu=Xju^wxK0{0T_xhbrDdDs#ntclrXlw$k+
qaeQL<_k1{1*ITg(^?ED-TmT}$pj99gKc)Zx002ovP6b4+LSTZTL!_1f

diff --git a/data/battle/battlescape-icons-fixed-139.png b/data/battle/battlescape-icons-fixed-139.png
index 51e75d3cac01b8b062827f6d4aff81a10453d079..ec18bddb6d392c881cdca8d508abd4dc06029363 100644
GIT binary patch
delta 383
zcmV-_0f7F%1FZv)Bo78+OGiWi{{a60|De66laW3be*gz`Nliru;R78F7%HV_RmlJV
z0Xj)UK~z}7)tIqvgD?<=e<}|h9LY#Tf{lS}47^6iJOWSV2jK-eGO%T6r3^&EQjqGQ
zTe|cJp+TrEXTm?-SqJ#@Z^0Q)DRp_-??H-pJFHdjhXaM4pvW47BuNlSi8M`D30Cyr
z1VLGAe*plswLn#^0wf56E)K&Gk(8*6xq=;!HGF^571iI6k1m>LBxN^728n**scjLi
za0|XQ%?~r4`bnr1+rzci&|0(I|Fdasa>2ct1e53a-JDCp6%ff4pm6PwD+k5W4siiK
zjAL`lQ%YUpIDzkPkY(9yU_(d#TK5}0Z?||YWs2LD>c1+>@~#t84$(MWKgZ(Ex)o_c
zQ-It+vx5yMI0iTdv>M080J(wK-ilLz+(7J|$5KGfdPUbj=ktdfupuD#uYtBT*AKK}
dJgzJx?+e@I!_Yi;8lC_E002ovPDHLkV1nkKs&xPW

delta 422
zcmV;X0a^a71Hc22B!2;OQb$4nuFf3k00004XF*Lt006O%3;baP00009a7bBm000ie
z000ie0hKEb8vp<SRY^oaR9HvdmoaXGKoCVIsZux+mas%RkZ?!A1vo%TAAyr`1P;Ij
zC@JXNq&Jc+g(98JtoK{8lNGVqS%o}l#4fv_d71&iljnKI_kYcXK)7D((LDLsZq@N3
z)^{DnaZFJZQIaHTagJ1Vt>lzgmSxoUJ*8<%FRK;3Ef#v)-^cfTJt7K%fZDdDs;bUn
zVHneL`FatXBU}uY?1s)O%ko+*2tx`yPj8(cC`vt4>{*R8l2S!csF37qx6>oK7Lx!%
zd7i6qA;^4t#(!*q<XPq?#?~K&+mTz*y4Y>P_s*wcU2H7Dsq4Q5V%DEAP7p~lm~+A$
zrghthwIUd+5SUsiV7(Qarcp=S!<4w`{O$FRBKGna69l$}fOy4Bf+itbg3c;-?|dp^
zV!*W!5ElckgaE|EzZF@4gM~OSmt?>Hlotaogc$yNJ|7&qb1M#^PyZK)PB572$Mi&a
Q82|tP07*qoM6N<$f_59Y&;S4c

diff --git a/data/battle/battlescape-icons-fixed-305.png b/data/battle/battlescape-icons-fixed-305.png
new file mode 100644
index 0000000000000000000000000000000000000000..9481cb39370a61180e88afc4b2390999f373ecca
GIT binary patch
literal 837
zcmV-L1G@Z)P)<h;3K|Lk000e1NJLTq001@s000#T1^@s64SgL&00006VoOIv0RI60
z0RN!9r;`8x010qNS#tmY3ljhU3ljkVnw%H_000McNliru;R78F76W-!;41(C0@6uD
zK~z}7)t51A+dve@|1KIXAj1s`*n>a@Yv_<6kU*9U9Xx0$WN5)lMvoaXbm#}j(6M92
zE{1jpbh*JphKvow;6Mi(Y|vnX1%6;bZ!n~TeOF1A64`MY{HD|0d#Cq%@7+78z&U?7
z`A|oxVq;rn)c0}qqp6>Xs9-3l+R@QgLfzlrLz)clYBgN9T6*3f3c$w<JH;Jv)7mO1
z3IkY{g?_&e3WC_0K|z4SlM?_ysq_zwa}FZX<IK$$I<HfM0Ou1_DiyTbZ8%O9gF$Z&
z7S(Gun=v~-;k3N~^obzH;}`Lj?e1o-*@*x@=7$FB`opEgJ;zBk;+z8+Yq{n63a$|I
zcYnEDtpp<h&kBT*R8(a*V+@=zFve01i>L1~{q}QhuA&g=dLCRMP%4#j+es-gV+`SF
zgtBR37>3zkJ`u{M3BxczMBtpmT0kY6N?6;E!2y8Tx=Y<Ws;fll-gzGO&o2-PfpXc-
z)hHC$5^PF2>QWqrp@xf<T>^^VbmuQRc2mbO+sGUpyD?Z7K)5JHHJ7%B-YWu^M~vKx
z%me^fd|sNAG0qaJ<D<71&x|U?D15c!FWCkpS1$G3U@GEK=aS<zr=n8r_z<5O`dK%R
z1mGqlHyFR^#v<C=vvJ^00RXplQIDUJ`sMfe)zbKwnmyILo_jwUcqK_@>%gDl)-L}4
zjH#?e%TGB{?f7d)SOF^gO?}C{S=FH0@pU;y$E!&6oOL}f_ZfYWjLl>SgPFQR@tf{i
z-71<T066^o6(roXyWiSi6bAY(o5^sa=ge%~VJ1U;&VF5-VgLN%(F^+7V1blSSM#5#
zzfmC7B8J1|ebeUF%GhL*-lh#H5zN0~HVXCj>{OqvnQ9bX9S{Pp5cuuYpLRNjPX)(u
z9_oz-Mty(r3B|VPM^kE_+wC?clPLy+9*C$=a2)61Reu&YB+-kVhzfrJRzOYbvKEkq
P00000NkvXXu0mjf*;9Je

literal 0
HcmV?d00001

diff --git a/data/forms/battle/battle.form b/data/forms/battle/battle.form
index a9fb4fa54..3fc38345e 100644
--- a/data/forms/battle/battle.form
+++ b/data/forms/battle/battle.form
@@ -30,26 +30,26 @@ TACBORD9 = Turn-Based Interrupt - NOT USED HERE
       </graphicbutton>
       <checkbox id="BUTTON_FOLLOW_AGENT">
         <position x="4" y="7"/>
-        <size width="53" height="21"/>
+        <size width="54" height="21"/>
         <image/>
         <imagechecked>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:141:xcom3/tacdata/tactical.pal</imagechecked>
       </checkbox>
       <checkbox id="BUTTON_TOGGLE_STRATMAP">
         <position x="4" y="30"/>
-        <size width="53" height="21"/>
+        <size width="54" height="21"/>
         <image/>
         <imagechecked>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:133:xcom3/tacdata/tactical.pal</imagechecked>
       </checkbox>
       <tristatebox id="BUTTON_LAYERING">
         <position x="4" y="53"/>
-        <size width="53" height="21"/>
+        <size width="54" height="21"/>
         <image/>
         <image2>battle/battlescape-icons-fixed-139.png</image2>
         <image3>battle/battlescape-icons-fixed-138.png</image3>
       </tristatebox>
       <graphicbutton id="BUTTON_SHOW_OPTIONS">
         <position x="4" y="99"/>
-        <size width="53" height="21"/>
+        <size width="54" height="21"/>
         <image/>
         <imagedepressed>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:136:xcom3/tacdata/tactical.pal</imagedepressed>
       </graphicbutton>
@@ -146,25 +146,25 @@ TACBORD9 = Turn-Based Interrupt - NOT USED HERE
       <!-- Time Controls (Disabled in Turn Based) -->
       <radiobutton id="BUTTON_SPEED0" groupid="SPEED">
         <position x="583" y="7"/>
-        <size width="53" height="21"/>
+        <size width="54" height="21"/>
         <image/>
         <imagechecked>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:144:xcom3/tacdata/tactical.pal</imagechecked>
       </radiobutton>
       <radiobutton id="BUTTON_SPEED1" groupid="SPEED">
         <position x="583" y="53"/>
-        <size width="53" height="21"/>
+        <size width="54" height="21"/>
         <image/>
         <imagechecked>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:146:xcom3/tacdata/tactical.pal</imagechecked>
       </radiobutton>
       <radiobutton id="BUTTON_SPEED2" groupid="SPEED">
         <position x="583" y="76"/>
-        <size width="53" height="21"/>
+        <size width="54" height="21"/>
         <image/>
         <imagechecked>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:148:xcom3/tacdata/tactical.pal</imagechecked>
       </radiobutton>
       <radiobutton id="BUTTON_SPEED3" groupid="SPEED">
         <position x="583" y="99"/>
-        <size width="53" height="21"/>
+        <size width="54" height="21"/>
         <image/>
         <imagechecked>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:150:xcom3/tacdata/tactical.pal</imagechecked>
       </radiobutton>
@@ -175,9 +175,37 @@ TACBORD9 = Turn-Based Interrupt - NOT USED HERE
         <font>smalfont</font>
       </label>
       <!-- Turn Controls (Disabled in Real Time) -->
-      <graphicbutton id="BUTTON_ENDTURN">
+      <tristatebox id="BUTTON_RESERVE_AIMED">
+        <position x="583" y="7"/>
+        <size width="54" height="21"/>
+        <image/>
+        <image2>battle/battlescape-icons-fixed-305.png</image2>
+		<image3>battle/battlescape-buttons-res-aim.png</image3>
+      </tristatebox>
+      <tristatebox id="BUTTON_RESERVE_SNAP">
+        <position x="583" y="30"/>
+        <size width="54" height="21"/>
+        <image/>
+        <image2>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:304:xcom3/tacdata/tactical.pal</image2>
+		<image3>battle/battlescape-buttons-res-snap.png</image3>
+      </tristatebox>
+      <tristatebox id="BUTTON_RESERVE_AUTO">
+        <position x="583" y="53"/>
+        <size width="54" height="21"/>
+        <image/>
+        <image2>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:303:xcom3/tacdata/tactical.pal</image2>
+		<image3>battle/battlescape-buttons-res-auto.png</image3>
+      </tristatebox>
+      <tristatebox id="BUTTON_RESERVE_KNEEL">
+        <position x="583" y="76"/>
+        <size width="54" height="21"/>
+        <image/>
+        <image2>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:306:xcom3/tacdata/tactical.pal</image2>
+		<image3>battle/battlescape-buttons-res-kneel.png</image3>
+      </tristatebox>
+	  <graphicbutton id="BUTTON_ENDTURN">
         <position x="583" y="99"/>
-        <size width="53" height="21"/>
+        <size width="54" height="21"/>
         <image/>
         <imagedepressed>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:307:xcom3/tacdata/tactical.pal</imagedepressed>
       </graphicbutton>
diff --git a/data/forms/battle/battle_rt_tab3.form b/data/forms/battle/battle_rt_tab3.form
index 36cc8653e..adeb1e7df 100644
--- a/data/forms/battle/battle_rt_tab3.form
+++ b/data/forms/battle/battle_rt_tab3.form
@@ -27,13 +27,13 @@
         <image/>
         <imagedepressed>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:317:xcom3/tacdata/tactical.pal</imagedepressed>
       </graphicbutton>
-      <label id="DELAY_TEXT" text="Delay  =  6.5s.">
+      <label id="DELAY_TEXT">
         <position x="262" y="40"/>
         <size width="116" height="12"/>
         <alignment horizontal="centre" vertical="centre"/>
         <font>smalfont</font>
       </label>
-      <label id="RANGE_TEXT" text="Range  =  4.5m.">
+      <label id="RANGE_TEXT">
         <position x="262" y="91"/>
         <size width="116" height="12"/>
         <alignment horizontal="centre" vertical="centre"/>
diff --git a/data/forms/battle/battle_tb_plan_popup.form b/data/forms/battle/battle_tb_plan_popup.form
new file mode 100644
index 000000000..779410de8
--- /dev/null
+++ b/data/forms/battle/battle_tb_plan_popup.form
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<openapoc>
+  <!-- Turn-Based Finishing Action Confirmation -->
+  <form id="FORM_BATTLE_UI_TB_5">
+    <style minwidth="640" minheight="128">
+      <position x="centre" y="bottom"/>
+      <size width="640" height="128"/>
+      <backcolour r="128" g="96" b="80"/>
+      <graphic>
+        <size width="640" height="128"/>
+        <image>RAW:xcom3/tacdata/tacbord8.dat:640:128:xcom3/tacdata/tactical.pal</image>
+      </graphic>
+	  <label id="MESSAGE">
+        <position x="48" y="5"/>
+        <size width="544" height="40"/>
+        <alignment horizontal="centre" vertical="centre"/>
+        <font>smalfont</font>
+      </label>
+	  <graphicbutton id="BUTTON_OK">
+        <position x="224" y="56"/>
+        <size width="54" height="25"/>
+        <image/>
+        <imagedepressed>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:317:xcom3/tacdata/tactical.pal</imagedepressed>
+      </graphicbutton>
+	  <graphicbutton id="BUTTON_CANCEL">
+        <position x="339" y="56"/>
+        <size width="54" height="25"/>
+        <image/>
+        <imagedepressed>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:318:xcom3/tacdata/tactical.pal</imagedepressed>
+      </graphicbutton>
+    </style>
+  </form>
+</openapoc>
diff --git a/data/forms/battle/battle_tb_tab3.form b/data/forms/battle/battle_tb_tab3.form
index e9c561233..4f3acfc78 100644
--- a/data/forms/battle/battle_tb_tab3.form
+++ b/data/forms/battle/battle_tb_tab3.form
@@ -27,13 +27,13 @@
         <image/>
         <imagedepressed>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:317:xcom3/tacdata/tactical.pal</imagedepressed>
       </graphicbutton>
-      <label id="DELAY_TEXT" text="Delay  =  6.5s.">
-        <position x="262" y="40"/>
-        <size width="116" height="12"/>
+      <label id="DELAY_TEXT">
+        <position x="273" y="37"/>
+        <size width="94" height="25"/>
         <alignment horizontal="centre" vertical="centre"/>
         <font>smalfont</font>
       </label>
-      <label id="RANGE_TEXT" text="Range  =  4.5m.">
+      <label id="RANGE_TEXT">
         <position x="262" y="91"/>
         <size width="116" height="12"/>
         <alignment horizontal="centre" vertical="centre"/>
@@ -42,7 +42,7 @@
       <scroll id="DELAY_SLIDER">
         <position x="263" y="78"/>
         <size width="114" height="15"/>
-        <range min="0" max="29"/>
+        <range min="0" max="5"/>
         <gripperimage>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:84:xcom3/tacdata/tactical.pal</gripperimage>
       </scroll>
       <scroll id="RANGE_SLIDER">
diff --git a/data/forms/battle/battle_tb_tab4.form b/data/forms/battle/battle_tb_tab4.form
index 84b351351..d8ba7efb5 100644
--- a/data/forms/battle/battle_tb_tab4.form
+++ b/data/forms/battle/battle_tb_tab4.form
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <openapoc>
-  <!-- Turn-Based Grenade Prime -->
+  <!-- Turn-Based Not My Turn -->
   <form id="FORM_BATTLE_UI_TB_4">
     <style minwidth="640" minheight="128">
       <position x="centre" y="bottom"/>
@@ -10,6 +10,61 @@
         <size width="640" height="128"/>
         <image>RAW:xcom3/tacdata/tacbord9.dat:640:128:xcom3/tacdata/tactical.pal</image>
       </graphic>
+	   <!-- Layers -->
+      <radiobutton id="BUTTON_LAYER_1" groupid="LAYER">
+        <position x="314" y="113"/>
+        <size width="13" height="8"/>
+        <image>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:100:xcom3/tacdata/tactical.pal</image>
+        <imagechecked>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:33:xcom3/tacdata/tactical.pal</imagechecked>
+      </radiobutton>
+      <radiobutton id="BUTTON_LAYER_2" groupid="LAYER">
+        <position x="314" y="104"/>
+        <size width="13" height="8"/>
+        <image>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:101:xcom3/tacdata/tactical.pal</image>
+        <imagechecked>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:34:xcom3/tacdata/tactical.pal</imagechecked>
+      </radiobutton>
+      <radiobutton id="BUTTON_LAYER_3" groupid="LAYER">
+        <position x="314" y="95"/>
+        <size width="13" height="8"/>
+        <image>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:102:xcom3/tacdata/tactical.pal</image>
+        <imagechecked>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:35:xcom3/tacdata/tactical.pal</imagechecked>
+      </radiobutton>
+      <radiobutton id="BUTTON_LAYER_4" groupid="LAYER">
+        <position x="314" y="86"/>
+        <size width="13" height="8"/>
+        <image>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:103:xcom3/tacdata/tactical.pal</image>
+        <imagechecked>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:36:xcom3/tacdata/tactical.pal</imagechecked>
+      </radiobutton>
+      <radiobutton id="BUTTON_LAYER_5" groupid="LAYER">
+        <position x="314" y="77"/>
+        <size width="13" height="8"/>
+        <image>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:104:xcom3/tacdata/tactical.pal</image>
+        <imagechecked>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:37:xcom3/tacdata/tactical.pal</imagechecked>
+      </radiobutton>
+      <radiobutton id="BUTTON_LAYER_6" groupid="LAYER">
+        <position x="314" y="68"/>
+        <size width="13" height="8"/>
+        <image>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:105:xcom3/tacdata/tactical.pal</image>
+        <imagechecked>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:38:xcom3/tacdata/tactical.pal</imagechecked>
+      </radiobutton>
+      <radiobutton id="BUTTON_LAYER_7" groupid="LAYER">
+        <position x="314" y="59"/>
+        <size width="13" height="8"/>
+        <image>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:106:xcom3/tacdata/tactical.pal</image>
+        <imagechecked>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:39:xcom3/tacdata/tactical.pal</imagechecked>
+      </radiobutton>
+      <radiobutton id="BUTTON_LAYER_8" groupid="LAYER">
+        <position x="314" y="50"/>
+        <size width="13" height="8"/>
+        <image>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:107:xcom3/tacdata/tactical.pal</image>
+        <imagechecked>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:40:xcom3/tacdata/tactical.pal</imagechecked>
+      </radiobutton>
+      <radiobutton id="BUTTON_LAYER_9" groupid="LAYER">
+        <position x="314" y="41"/>
+        <size width="13" height="8"/>
+        <image>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:108:xcom3/tacdata/tactical.pal</image>
+        <imagechecked>PCK:xcom3/tacdata/icons.pck:xcom3/tacdata/icons.tab:41:xcom3/tacdata/tactical.pal</imagechecked>
+      </radiobutton>
     </style>
   </form>
 </openapoc>
diff --git a/data/forms/battle/battle_tb_tab5.form b/data/forms/battle/battle_tb_tab5.form
deleted file mode 100644
index 7bbda930d..000000000
--- a/data/forms/battle/battle_tb_tab5.form
+++ /dev/null
@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<openapoc>
-  <!-- Turn-Based Grenade Prime -->
-  <form id="FORM_BATTLE_UI_TB_5">
-    <style minwidth="640" minheight="128">
-      <position x="centre" y="bottom"/>
-      <size width="640" height="128"/>
-      <backcolour r="128" g="96" b="80"/>
-      <graphic>
-        <size width="640" height="128"/>
-        <image>RAW:xcom3/tacdata/tacbord8.dat:640:128:xcom3/tacdata/tactical.pal</image>
-      </graphic>
-    </style>
-  </form>
-</openapoc>
diff --git a/game/state/aequipment.cpp b/game/state/aequipment.cpp
index 918954291..cba7acc0c 100644
--- a/game/state/aequipment.cpp
+++ b/game/state/aequipment.cpp
@@ -168,9 +168,7 @@ int AEquipment::getAccuracy(BodyState bodyState, MovementState movementState,
 	switch (movementState)
 	{
 		case MovementState::None:
-			LogWarning("Before *0.8f %f", agentDispersion);
 			agentDispersion *= 0.8f;
-			LogWarning("After *0.8f %f", agentDispersion);
 			break;
 		case MovementState::Running:
 			agentDispersion *= 1.25f;
@@ -246,17 +244,34 @@ int AEquipment::getAccuracy(BodyState bodyState, MovementState movementState,
 	return std::max(0, (int)(100.0f - totalDispersion * 100.0f));
 }
 
+int AEquipment::getFireCost(WeaponAimingMode fireMode)
+{
+	return getPayloadType()->fire_delay / (int)fireMode;
+}
+
+int AEquipment::getFireCost(WeaponAimingMode fireMode, int maxTU)
+{
+	return getFireCost(fireMode) * maxTU / 100;
+}
+
 void AEquipment::stopFiring()
 {
 	weapon_fire_ticks_remaining = 0;
 	readyToFire = false;
 }
 
-void AEquipment::startFiring(WeaponAimingMode fireMode)
+void AEquipment::startFiring(WeaponAimingMode fireMode, bool instant)
 {
 	if (ammo == 0)
 		return;
-	weapon_fire_ticks_remaining = getPayloadType()->fire_delay * 4 / (int)fireMode;
+	if (instant)
+	{
+		weapon_fire_ticks_remaining = TICKS_PER_SECOND / 4;
+	}
+	else
+	{
+		weapon_fire_ticks_remaining = getPayloadType()->fire_delay * TICKS_MULTIPLIER / (int)fireMode;
+	}
 	readyToFire = false;
 	aimingMode = fireMode;
 }
@@ -326,7 +341,7 @@ void AEquipment::loadAmmo(GameState &state, sp<AEquipment> ammoItem)
 	}
 }
 
-void AEquipment::update(GameState &state, unsigned int ticks)
+void AEquipment::updateInner(GameState &state, unsigned int ticks)
 {
 	// Recharge update
 	auto payload = getPayloadType();
@@ -341,6 +356,24 @@ void AEquipment::update(GameState &state, unsigned int ticks)
 		}
 	}
 
+	// Process primed explosives
+	if (primed && activated)
+	{
+		if (triggerDelay > ticks)
+		{
+			triggerDelay -= ticks;
+		}
+		else
+		{
+			triggerDelay = 0;
+		}
+	}
+}
+
+void AEquipment::update(GameState &state, unsigned int ticks)
+{
+	bool realTime = state.current_battle->mode == Battle::Mode::RealTime;
+
 	// Firing update
 	if (weapon_fire_ticks_remaining > 0)
 	{
@@ -377,7 +410,7 @@ void AEquipment::update(GameState &state, unsigned int ticks)
 					}
 					else if (ownerAgent->unit->fire_aiming_mode != aimingMode)
 					{
-						startFiring(ownerAgent->unit->fire_aiming_mode);
+						startFiring(ownerAgent->unit->fire_aiming_mode, !realTime);
 					}
 					break;
 				case AEquipmentSlotType::RightHand:
@@ -388,7 +421,7 @@ void AEquipment::update(GameState &state, unsigned int ticks)
 					}
 					else if (ownerAgent->unit->fire_aiming_mode != aimingMode)
 					{
-						startFiring(ownerAgent->unit->fire_aiming_mode);
+						startFiring(ownerAgent->unit->fire_aiming_mode, !realTime);
 					}
 					break;
 				// If weapon was moved to any other slot from hands, stop firing
@@ -429,87 +462,82 @@ void AEquipment::update(GameState &state, unsigned int ticks)
 		}
 	}
 
-	// Process primed explosives
-	if (primed)
+	if (primed && !activated && !ownerAgent)
 	{
-		if (!activated && !ownerAgent)
-		{
-			activated = true;
-		}
+		activated = true;
+	}
+
+	if (realTime)
+	{
+		updateInner(state, ticks);
+	}
 
-		if (activated)
+	if (primed && activated && triggerDelay == 0)
+	{
+		auto payload = getPayloadType();
+		switch (triggerType)
+		{
+		case TriggerType::None:
+			LogError("Primed activated item with no trigger?");
+			break;
+		case TriggerType::Contact:
 		{
-			if (triggerDelay > ticks)
+			auto item = ownerItem.lock();
+			if (item)
 			{
-				triggerDelay -= ticks;
+				if (!item->falling)
+				{
+					item->die(state);
+				}
 			}
 			else
 			{
-				triggerDelay = 0;
+				// Contact trigger in inventory? Blow up!
+				explode(state);
 			}
-
-			if (triggerDelay == 0)
+			break;
+		}
+		case TriggerType::Proximity:
+		case TriggerType::Boomeroid:
+		{
+			auto item = ownerItem.lock();
+			if (item)
+			{
+				// Nothing, triggered by moving units
+			}
+			else
 			{
-				switch (triggerType)
+				// Proxy trigger in inventory? Blow up!
+				if (payload->damage_type->effectType !=
+					DamageType::EffectType::Brainsucker)
 				{
-					case TriggerType::None:
-						LogError("Primed activated item with no trigger?");
-						break;
-					case TriggerType::Contact:
-					{
-						auto item = ownerItem.lock();
-						if (item)
-						{
-							if (!item->falling)
-							{
-								item->die(state);
-							}
-						}
-						else
-						{
-							// Contact trigger in inventory? Blow up!
-							explode(state);
-						}
-						break;
-					}
-					case TriggerType::Proximity:
-					case TriggerType::Boomeroid:
-					{
-						auto item = ownerItem.lock();
-						if (item)
-						{
-							// Nothing, triggered by moving units
-						}
-						else
-						{
-							// Proxy trigger in inventory? Blow up!
-							if (payload->damage_type->effectType !=
-							    DamageType::EffectType::Brainsucker)
-							{
-								explode(state);
-							}
-						}
-						break;
-					}
-					case TriggerType::Timed:
-					{
-						auto item = ownerItem.lock();
-						if (item)
-						{
-							item->die(state);
-						}
-						else
-						{
-							explode(state);
-						}
-						break;
-					}
+					explode(state);
 				}
 			}
+			break;
+		}
+		case TriggerType::Timed:
+		{
+			auto item = ownerItem.lock();
+			if (item)
+			{
+				item->die(state);
+			}
+			else
+			{
+				explode(state);
+			}
+			break;
+		}
 		}
 	}
 }
 
+void AEquipment::updateTB(GameState &state)
+{
+	updateInner(state, TICKS_PER_TURN);
+}
+
 void AEquipment::prime(bool onImpact, int triggerDelay, float triggerRange)
 {
 	if (type->type != AEquipmentType::Type::Grenade && type->type != AEquipmentType::Type::Ammo)
@@ -555,7 +583,7 @@ void AEquipment::explode(GameState &state)
 		case AEquipmentType::Type::Grenade:
 			state.current_battle->addExplosion(state, position, type->explosion_graphic,
 			                                   type->damage_type, type->damage,
-			                                   type->explosion_depletion_rate, ownerUnit);
+			                                   type->explosion_depletion_rate, ownerUnit ? ownerUnit->owner : (ownerAgent ? ownerAgent->owner : ownerOrganisation), ownerUnit);
 			break;
 		case AEquipmentType::Type::Weapon:
 		case AEquipmentType::Type::Ammo:
@@ -571,7 +599,7 @@ void AEquipment::explode(GameState &state)
 			{
 				state.current_battle->addExplosion(state, position, payload->explosion_graphic,
 				                                   payload->damage_type, payload->damage,
-				                                   payload->explosion_depletion_rate, ownerUnit);
+				                                   payload->explosion_depletion_rate, ownerUnit ? ownerUnit->owner : (ownerAgent ? ownerAgent->owner : ownerOrganisation), ownerUnit);
 				break;
 			}
 			// Otherwise shoot stray shots into air
diff --git a/game/state/aequipment.h b/game/state/aequipment.h
index af5a8fa76..19cfd1f52 100644
--- a/game/state/aequipment.h
+++ b/game/state/aequipment.h
@@ -85,17 +85,22 @@ class AEquipment : public std::enable_shared_from_this<AEquipment>
 	int getAccuracy(BodyState bodyState, MovementState movementState, WeaponAimingMode fireMode,
 	                bool thrown = false, float cloakingDispersion = 0.0f);
 
+	// Returned value assumes 100 max TU and must be scaled
+	int getFireCost(WeaponAimingMode fireMode);
+	int getFireCost(WeaponAimingMode fireMode, int maxTU);
 	bool isFiring() const { return weapon_fire_ticks_remaining > 0 || readyToFire; };
 	bool canFire() const;
 	bool canFire(Vec3<float> to) const;
 	bool needsReload() const;
 	void stopFiring();
-	void startFiring(WeaponAimingMode fireMode);
+	void startFiring(WeaponAimingMode fireMode, bool instant);
 
 	// Support nullptr ammoItem for auto-reloading
 	void loadAmmo(GameState &state, sp<AEquipment> ammoItem = nullptr);
 
 	void update(GameState &state, unsigned int ticks);
+	void updateTB(GameState &state);
+	void updateInner(GameState &state, unsigned int ticks);
 
 	// Wether this weapon works like brainsucker launcher, throwing it's ammunition instead of
 	// firing a projectile
diff --git a/game/state/agent.cpp b/game/state/agent.cpp
index 6d6e49b07..92f4b7221 100644
--- a/game/state/agent.cpp
+++ b/game/state/agent.cpp
@@ -382,7 +382,7 @@ int Agent::getTULimit(int reactionValue) const
 	}
 	else if (reactionValue >= getReactionValue())
 	{
-		return modified_stats.time_units + 1;
+		return modified_stats.time_units;
 	}
 	else
 	{
diff --git a/game/state/battle/ai/ai.cpp b/game/state/battle/ai/ai.cpp
index 93c3d4983..3d8d98462 100644
--- a/game/state/battle/ai/ai.cpp
+++ b/game/state/battle/ai/ai.cpp
@@ -130,7 +130,7 @@ const UString UnitAI::getName()
 
 bool AIDecision::isEmpty() { return !action && !movement; }
 
-void UnitAIList::init(GameState &state, BattleUnit &u)
+void UnitAIBlock::init(GameState &state, BattleUnit &u)
 {
 	// FIXME: Actually read this option
 	bool USER_OPTION_USE_HARDCORE_AI = false;
@@ -152,7 +152,7 @@ void UnitAIList::init(GameState &state, BattleUnit &u)
 	reset(state, u);
 }
 
-void UnitAIList::reset(GameState &state, BattleUnit &u)
+void UnitAIBlock::reset(GameState &state, BattleUnit &u)
 {
 	ticksLastThink = state.gameTime.getTicks();
 	ticksUntilReThink = randBoundsExclusive(state.rng, 0, (int)TICKS_PER_SECOND);
@@ -163,21 +163,37 @@ void UnitAIList::reset(GameState &state, BattleUnit &u)
 	}
 }
 
-AIDecision UnitAIList::think(GameState &state, BattleUnit &u)
+AIDecision UnitAIBlock::think(GameState &state, BattleUnit &u)
 {
 	auto curTicks = state.gameTime.getTicks();
 	if (ticksLastThink + ticksUntilReThink > curTicks)
 	{
 		return {};
 	}
-
+	bool interrupt = false;
+	if (state.current_battle->mode == Battle::Mode::TurnBased)
+	{
+		if (!state.current_battle->interruptQueue.empty())
+		{
+			return{};
+		}
+		if (u.owner != state.current_battle->currentActiveOrganisation || !state.current_battle->interruptUnits.empty())
+		{
+			auto it = state.current_battle->interruptUnits.find({ &state, u.id });
+			interrupt = it != state.current_battle->interruptUnits.end() && u.agent->modified_stats.time_units > it->second;
+			if (!interrupt)
+			{
+				return{};
+			}
+		}
+	}
 	ticksLastThink = curTicks;
 	ticksUntilReThink = AI_THINK_INTERVAL;
 
 	AIDecision decision = {};
 	for (auto ai : aiList)
 	{
-		auto result = ai->think(state, u);
+		auto result = ai->think(state, u, interrupt);
 		auto newDecision = std::get<0>(result);
 		auto halt = std::get<1>(result);
 		if (!newDecision.isEmpty())
@@ -201,7 +217,7 @@ AIDecision UnitAIList::think(GameState &state, BattleUnit &u)
 	return decision;
 }
 
-void UnitAIList::notifyUnderFire(Vec3<int> position)
+void UnitAIBlock::notifyUnderFire(Vec3<int> position)
 {
 	for (auto &ai : aiList)
 	{
@@ -213,7 +229,7 @@ void UnitAIList::notifyUnderFire(Vec3<int> position)
 	}
 }
 
-void UnitAIList::notifyHit(Vec3<int> position)
+void UnitAIBlock::notifyHit(Vec3<int> position)
 {
 	for (auto &ai : aiList)
 	{
@@ -225,7 +241,7 @@ void UnitAIList::notifyHit(Vec3<int> position)
 	}
 }
 
-void UnitAIList::notifyEnemySpotted(Vec3<int> position)
+void UnitAIBlock::notifyEnemySpotted(Vec3<int> position)
 {
 	for (auto &ai : aiList)
 	{
@@ -480,7 +496,7 @@ std::tuple<AIDecision, float, unsigned>
 VanillaUnitAI::getWeaponDecision(GameState &state, BattleUnit &u, sp<AEquipment> e,
                                  StateRef<BattleUnit> target)
 {
-	if (u.canAttackUnit(target, e) != WeaponStatus::NotFiring)
+	if (state, u.canAttackUnit(state, target, e) != WeaponStatus::NotFiring)
 	{
 		auto action = mksp<AIAction>();
 		action->item = e;
@@ -875,12 +891,14 @@ AIDecision VanillaUnitAI::thinkInternal(GameState &state, BattleUnit &u)
 
 	if (!reThink)
 	{
+		routine(state, u);
 		return lastDecision;
 	}
 
 	auto result = u.visibleEnemies.empty() ? thinkGreen(state, u) : thinkRed(state, u);
 	auto decision = std::get<0>(result);
 	lastDecision = decision;
+	routine(state, u);
 
 	if (decision.isEmpty())
 	{
@@ -890,14 +908,12 @@ AIDecision VanillaUnitAI::thinkInternal(GameState &state, BattleUnit &u)
 	ticksLastThink = state.gameTime.getTicks();
 	ticksUntilReThink = std::get<2>(result);
 
-	routine(state, u);
-
 	return decision;
 }
 
-std::tuple<AIDecision, bool> VanillaUnitAI::think(GameState &state, BattleUnit &u)
+std::tuple<AIDecision, bool> VanillaUnitAI::think(GameState &state, BattleUnit &u, bool interrupt)
 {
-	active = u.isAIControlled(state);
+	active = u.isAIControlled(state) && !interrupt;
 
 	if (!active)
 	{
@@ -916,7 +932,7 @@ std::tuple<AIDecision, bool> VanillaUnitAI::think(GameState &state, BattleUnit &
 
 void VanillaUnitAI::routine(GameState &state, BattleUnit &u)
 {
-	static const Vec3<int> NONE = {0, 0, 0};
+	static const Vec3<int> NONE = { 0, 0, 0 };
 
 	// Reload all guns
 	for (auto &e : u.agent->equipment)
@@ -949,7 +965,7 @@ void VanillaUnitAI::routine(GameState &state, BattleUnit &u)
 				continue;
 			}
 			if ((e->getPayloadType()->range > maxRange) ||
-			    (e->getPayloadType()->range == maxRange && e->getPayloadType()->damage > maxDamage))
+				(e->getPayloadType()->range == maxRange && e->getPayloadType()->damage > maxDamage))
 			{
 				maxRange = e->getPayloadType()->range;
 				maxDamage = e->getPayloadType()->damage;
@@ -962,6 +978,25 @@ void VanillaUnitAI::routine(GameState &state, BattleUnit &u)
 		}
 	}
 
+	// AI preferences
+	u.fire_aiming_mode = WeaponAimingMode::Snap;
+	u.fire_permission_mode = BattleUnit::FirePermissionMode::AtWill;
+	if (state.current_battle->mode == Battle::Mode::TurnBased)
+	{
+		// Ensure at least half of move is available for moving
+		u.setReserveKneelMode(KneelingMode::Kneeling);
+		u.setReserveShotMode(ReserveShotMode::Aimed);
+		int kneelCost = u.reserve_kneel_mode == KneelingMode::None ? 0 : BattleUnitMission::getBodyStateChangeCost(u, BodyState::Standing, BodyState::Kneeling);
+		if (u.reserveShotCost + kneelCost > u.initialTU / 2)
+		{
+			u.setReserveShotMode(ReserveShotMode::Snap);
+		}
+		if (u.reserveShotCost + kneelCost> u.initialTU / 2)
+		{
+			u.setReserveKneelMode(KneelingMode::None);
+		}
+	}
+
 	// Update aiState
 	{
 		attackerPosition = NONE;
@@ -1041,7 +1076,7 @@ UString AIDecision::getName()
 
 void LowMoraleUnitAI::reset(GameState &, BattleUnit &) { ticksActionAvailable = 0; }
 
-std::tuple<AIDecision, bool> LowMoraleUnitAI::think(GameState &state, BattleUnit &u)
+std::tuple<AIDecision, bool> LowMoraleUnitAI::think(GameState &state, BattleUnit &u, bool interrupt)
 {
 	switch (u.getAIType())
 	{
@@ -1167,7 +1202,7 @@ std::tuple<AIDecision, bool> LowMoraleUnitAI::think(GameState &state, BattleUnit
 							}
 							else
 							{
-								if (u.canAttackUnit(victim) != WeaponStatus::NotFiring)
+								if (u.canAttackUnit(state, victim) != WeaponStatus::NotFiring)
 								{
 									decision.action = mksp<AIAction>();
 									decision.action->type = AIAction::Type::AttackWeaponUnit;
@@ -1193,7 +1228,7 @@ std::tuple<AIDecision, bool> LowMoraleUnitAI::think(GameState &state, BattleUnit
 							}
 							else
 							{
-								if (u.canAttackUnit(target) != WeaponStatus::NotFiring)
+								if (u.canAttackUnit(state, target) != WeaponStatus::NotFiring)
 								{
 									decision.action = mksp<AIAction>();
 									decision.action->type = AIAction::Type::AttackWeaponUnit;
@@ -1254,11 +1289,15 @@ void DefaultUnitAI::notifyUnderFire(Vec3<int> position) { attackerPosition = pos
 
 void DefaultUnitAI::notifyHit(Vec3<int> position) { attackerPosition = position; }
 
-std::tuple<AIDecision, bool> DefaultUnitAI::think(GameState &state, BattleUnit &u)
+std::tuple<AIDecision, bool> DefaultUnitAI::think(GameState &state, BattleUnit &u, bool interrupt)
 {
 	static const Vec3<int> NONE = {0, 0, 0};
 
-	active = true;
+	// Default AI should not work in turn based when it's our turn to act
+	// We can assume that if it's not our turn then we're interrupting
+	// Otherwise no AI would work
+	active = state.current_battle->mode == Battle::Mode::RealTime 
+		|| u.owner != state.current_battle->currentActiveOrganisation;
 
 	if (!active)
 	{
@@ -1351,7 +1390,7 @@ std::tuple<AIDecision, bool> DefaultUnitAI::think(GameState &state, BattleUnit &
 				// closest attackable
 				if (!targetEnemy || !targetEnemy->isConscious() ||
 				    enemies.find(targetEnemy) == enemies.end() ||
-				    u.canAttackUnit(targetEnemy) == WeaponStatus::NotFiring)
+				    u.canAttackUnit(state, targetEnemy) == WeaponStatus::NotFiring)
 				{
 					targetEnemy.clear();
 					// Make a list of enemies sorted by distance to them
@@ -1374,7 +1413,7 @@ std::tuple<AIDecision, bool> DefaultUnitAI::think(GameState &state, BattleUnit &
 					// Pick enemy that is closest and can be attacked
 					for (auto entry : enemiesByDistance)
 					{
-						weaponStatus = u.canAttackUnit(entry.second);
+						weaponStatus = u.canAttackUnit(state, entry.second);
 						if (weaponStatus != WeaponStatus::NotFiring)
 						{
 							targetEnemy = entry.second;
@@ -1399,8 +1438,8 @@ std::tuple<AIDecision, bool> DefaultUnitAI::think(GameState &state, BattleUnit &
 		}
 	}
 
-	// Enzyme
-	if (u.enzymeDebuffIntensity > 0 && !u.isMoving() && u.canMove())
+	// Enzyme random running (only works in real time)
+	if (state.current_battle->mode == Battle::Mode::RealTime && u.enzymeDebuffIntensity > 0 && !u.isMoving() && u.canMove())
 	{
 		// Move to a random adjacent tile
 		auto from = u.tileObject->getOwningTile();
@@ -1445,7 +1484,7 @@ std::tuple<AIDecision, bool> DefaultUnitAI::think(GameState &state, BattleUnit &
 
 void BehaviorUnitAI::reset(GameState &, BattleUnit &) {}
 
-std::tuple<AIDecision, bool> BehaviorUnitAI::think(GameState &state, BattleUnit &u)
+std::tuple<AIDecision, bool> BehaviorUnitAI::think(GameState &state, BattleUnit &u, bool interrupt)
 {
 	std::ignore = state;
 	std::ignore = u;
@@ -1486,7 +1525,6 @@ std::list<std::pair<std::list<StateRef<BattleUnit>>, AIDecision>>
 VanillaTacticalAI::think(GameState &state, StateRef<Organisation> o)
 {
 	static const int VANILLA_TACTICAL_AI_THINK_INTERVAL = TICKS_PER_SECOND / 8;
-
 	auto curTicks = state.gameTime.getTicks();
 	if (ticksLastThink + ticksUntilReThink > curTicks)
 	{
@@ -1495,6 +1533,21 @@ VanillaTacticalAI::think(GameState &state, StateRef<Organisation> o)
 
 	ticksLastThink = curTicks;
 	ticksUntilReThink = VANILLA_TACTICAL_AI_THINK_INTERVAL;
+	
+	// If turn based allow turn end when we're finished
+	// Also cancel all missions
+	if (state.current_battle->mode == Battle::Mode::TurnBased && state.current_battle->ticksWithoutAction >= TICKS_END_TURN)
+	{
+		state.current_battle->turnEndAllowed = true;
+		for (auto u : state.current_battle->units)
+		{
+			if (u.second->owner != o || !u.second->isConscious())
+			{
+				continue;
+			}
+			u.second->cancelMissions(state);
+		}
+	}
 
 	// Find an idle unit that needs orders
 	for (auto u : state.current_battle->units)
@@ -1581,12 +1634,21 @@ TacticalAIBlock::think(GameState &state)
 		return {};
 	}
 
+	if (state.current_battle->mode == Battle::Mode::TurnBased && (!state.current_battle->interruptUnits.empty() || !state.current_battle->interruptQueue.empty()))
+	{
+		return{};
+	}
+
 	ticksLastThink = curTicks;
 	ticksUntilReThink = AI_THINK_INTERVAL;
 
 	std::list<std::pair<std::list<StateRef<BattleUnit>>, AIDecision>> result;
 	for (auto &o : this->aiList)
 	{
+		if (state.current_battle->mode == Battle::Mode::TurnBased && o.first != state.current_battle->currentActiveOrganisation)
+		{
+			continue;
+		}
 		auto decisions = o.second->think(state, o.first);
 		result.insert(result.end(), decisions.begin(), decisions.end());
 	}
diff --git a/game/state/battle/ai/ai.h b/game/state/battle/ai/ai.h
index 75393945e..8769f4685 100644
--- a/game/state/battle/ai/ai.h
+++ b/game/state/battle/ai/ai.h
@@ -159,7 +159,7 @@ class UnitAI
 
 	virtual void reset(GameState &, BattleUnit &){};
 	// Returns decision that was made, and wether we should stop going forward on the AI chain
-	virtual std::tuple<AIDecision, bool> think(GameState &, BattleUnit &) { return {}; };
+	virtual std::tuple<AIDecision, bool> think(GameState &, BattleUnit &, bool interrupt) { return {}; };
 
 	virtual void notifyUnderFire(Vec3<int>){};
 	virtual void notifyHit(Vec3<int>){};
@@ -184,7 +184,7 @@ class UnitAIHelper
 	static void ensureItemInSlot(GameState &state, sp<AEquipment> item, AEquipmentSlotType slot);
 };
 
-class UnitAIList
+class UnitAIBlock
 {
   public:
 	std::vector<sp<UnitAI>> aiList;
@@ -211,7 +211,7 @@ class LowMoraleUnitAI : public UnitAI
 	uint64_t ticksActionAvailable = 0;
 
 	void reset(GameState &state, BattleUnit &u) override;
-	std::tuple<AIDecision, bool> think(GameState &state, BattleUnit &u) override;
+	std::tuple<AIDecision, bool> think(GameState &state, BattleUnit &u, bool interrupt) override;
 };
 
 // AI that handles unit's automatic actions (turning to attacker, visible enemy, firing held
@@ -228,7 +228,7 @@ class DefaultUnitAI : public UnitAI
 	Vec3<int> attackerPosition = {0, 0, 0};
 
 	void reset(GameState &state, BattleUnit &u) override;
-	std::tuple<AIDecision, bool> think(GameState &state, BattleUnit &u) override;
+	std::tuple<AIDecision, bool> think(GameState &state, BattleUnit &u, bool interrupt) override;
 
 	void notifyUnderFire(Vec3<int> position) override;
 	void notifyHit(Vec3<int> position) override;
@@ -241,7 +241,7 @@ class BehaviorUnitAI : public UnitAI
 	BehaviorUnitAI();
 
 	void reset(GameState &state, BattleUnit &u) override;
-	std::tuple<AIDecision, bool> think(GameState &state, BattleUnit &u) override;
+	std::tuple<AIDecision, bool> think(GameState &state, BattleUnit &u, bool interrupt) override;
 };
 
 // AI that handles vanilla alien and civilian behavior
@@ -270,7 +270,7 @@ class VanillaUnitAI : public UnitAI
 
 	// Calculate AI's next decision, then do the routine
 	// If unit has group AI, and patrol decision is made, the group will move together
-	std::tuple<AIDecision, bool> think(GameState &state, BattleUnit &u) override;
+	std::tuple<AIDecision, bool> think(GameState &state, BattleUnit &u, bool interrupt) override;
 
 	void notifyUnderFire(Vec3<int> position) override;
 	void notifyHit(Vec3<int> position) override;
diff --git a/game/state/battle/battle.cpp b/game/state/battle/battle.cpp
index 037d84303..48b23513b 100644
--- a/game/state/battle/battle.cpp
+++ b/game/state/battle/battle.cpp
@@ -135,6 +135,10 @@ void Battle::initBattle(GameState &state, bool first)
 		// Place units into squads directly to their positions
 		for (auto &u : this->units)
 		{
+			if (u.second->squadNumber == -1)
+			{
+				continue;
+			}
 			forces[u.second->owner].squads[u.second->squadNumber].units[u.second->squadPosition] =
 			    u.second;
 		}
@@ -429,7 +433,7 @@ sp<BattleUnit> Battle::spawnUnit(GameState &state, StateRef<Organisation> owner,
 	unit->setBodyState(state, curState);
 	unit->setMission(state, BattleUnitMission::changeStance(*unit, tarState));
 	unit->assignToSquad(*state.current_battle);
-	unit->refreshUnitVisibilityAndVision(state, unit->position);
+	unit->refreshUnitVisibilityAndVision(state);
 
 	unit->strategyImages = state.battle_common_image_list->strategyImages;
 	unit->burningDoodad = state.battle_common_image_list->burningDoodad;
@@ -443,7 +447,7 @@ sp<BattleUnit> Battle::spawnUnit(GameState &state, StateRef<Organisation> owner,
 sp<BattleExplosion> Battle::addExplosion(GameState &state, Vec3<int> position,
                                          StateRef<DoodadType> doodadType,
                                          StateRef<DamageType> damageType, int power,
-                                         int depletionRate, StateRef<BattleUnit> ownerUnit)
+                                         int depletionRate, StateRef<Organisation> ownerOrg, StateRef<BattleUnit> ownerUnit)
 {
 	// FIXME: Actually read this option
 	bool USER_OPTION_EXPLOSIONS_DAMAGE_IN_THE_END = true;
@@ -464,7 +468,7 @@ sp<BattleExplosion> Battle::addExplosion(GameState &state, Vec3<int> position,
 
 	// Explosion
 	auto explosion = mksp<BattleExplosion>(position, damageType, power, depletionRate,
-	                                       USER_OPTION_EXPLOSIONS_DAMAGE_IN_THE_END, ownerUnit);
+	                                       USER_OPTION_EXPLOSIONS_DAMAGE_IN_THE_END, ownerOrg, ownerUnit);
 	explosions.insert(explosion);
 	return explosion;
 }
@@ -510,6 +514,18 @@ sp<BattleItem> Battle::placeItem(GameState &state, sp<AEquipment> item, Vec3<flo
 	bitem->strategySprite = state.battle_common_image_list->strategyImages->at(480);
 	bitem->item = item;
 	item->ownerItem = bitem;
+	if (item->ownerUnit)
+	{
+		bitem->owner = item->ownerUnit->owner;
+	}
+	else if (item->ownerAgent)
+	{
+		bitem->owner = item->ownerAgent->owner;
+	}
+	else
+	{
+		bitem->owner = item->ownerOrganisation;
+	}
 	bitem->position = position;
 	if (map)
 	{
@@ -519,12 +535,13 @@ sp<BattleItem> Battle::placeItem(GameState &state, sp<AEquipment> item, Vec3<flo
 	return bitem;
 }
 
-sp<BattleHazard> Battle::placeHazard(GameState &state, StateRef<DamageType> type,
+sp<BattleHazard> Battle::placeHazard(GameState &state, StateRef<Organisation> owner, StateRef<DamageType> type,
                                      Vec3<int> position, int ttl, int power,
                                      int initialAgeTTLDivizor, bool delayVisibility)
 {
 	bool fire = type->hazardType->fire;
 	auto hazard = mksp<BattleHazard>(state, type, delayVisibility);
+	hazard->owner = owner;
 	hazard->position = position;
 	hazard->position += Vec3<float>{0.5f, 0.5f, 0.5f};
 	if (fire)
@@ -613,6 +630,7 @@ void Battle::updateProjectiles(GameState &state, unsigned int ticks)
 	}
 	for (auto it = this->projectiles.begin(); it != this->projectiles.end();)
 	{
+		state.current_battle->ticksWithoutAction = 0;
 		auto &p = *it++;
 		auto c = p->checkProjectileCollision(*map);
 		if (c)
@@ -636,7 +654,7 @@ void Battle::updateProjectiles(GameState &state, unsigned int ticks)
 			{
 				auto explosion = addExplosion(state, c.position, c.projectile->doodadType,
 				                              c.projectile->damageType, c.projectile->damage,
-				                              c.projectile->depletionRate, c.projectile->firerUnit);
+				                              c.projectile->depletionRate, c.projectile->firerUnit->owner, c.projectile->firerUnit);
 				displayDoodad = false;
 			}
 			else
@@ -882,6 +900,65 @@ void Battle::update(GameState &state, unsigned int ticks)
 {
 	TRACE_FN_ARGS1("ticks", Strings::fromInteger(static_cast<int>(ticks)));
 
+	if (mode == Mode::TurnBased)
+	{
+		ticksWithoutAction += ticks;
+		// Interrupt for lowmorales
+		if (!lowMoraleProcessed && interruptQueue.empty() && interruptUnits.empty())
+		{
+			lowMoraleProcessed = true;
+			for (auto &u : units)
+			{
+				if (u.second->owner != currentActiveOrganisation || !u.second->isConscious() || u.second->moraleState == MoraleState::Normal || u.second->agent->modified_stats.time_units == 0)
+				{
+					continue;
+				}
+				lowMoraleProcessed = false;
+				ticksWithoutAction = TICKS_BEGIN_INTERRUPT;
+				interruptQueue.emplace(StateRef<BattleUnit>(&state, u.first), 0);
+				LogWarning("Message! Unit on lowmorale is going nuts!");
+				break;
+			}
+		}
+		// Add units from queue to interrupt list
+		if (!interruptQueue.empty() && ticksWithoutAction >= TICKS_BEGIN_INTERRUPT)
+		{
+			for (auto &e : interruptQueue)
+			{
+				interruptUnits.emplace(e.first, e.second);
+			}
+			interruptQueue.clear();
+			ticksWithoutAction = 0;
+			turnEndAllowed = false;
+		}
+		// Turn end condition
+		if (ticksWithoutAction >= TICKS_END_TURN)
+		{
+			if (interruptUnits.empty())
+			{
+				if (turnEndAllowed)
+				{
+					endTurn(state);
+				}
+			}
+			else
+			{ 
+				// Spend remaining TUs of low morale units
+				for (auto &e : interruptUnits)
+				{
+					if (e.first->moraleState != MoraleState::Normal)
+					{
+						// Complains about const?...
+						e.first.getSp()->spendRemainingTU(state);
+					}
+				}
+				interruptUnits.clear();
+				ticksWithoutAction = 0;
+				turnEndAllowed = false;
+			}
+		}
+	}
+
 	Trace::start("Battle::update::projectiles->update");
 	updateProjectiles(state, ticks);
 	Trace::end("Battle::update::projectiles->update");
@@ -926,11 +1003,11 @@ void Battle::update(GameState &state, unsigned int ticks)
 	}
 	Trace::end("Battle::update::items->update");
 	Trace::start("Battle::update::scanners->update");
-	Trace::end("Battle::update::scanners->update");
 	for (auto &o : this->scanners)
 	{
 		o.second->update(state, ticks);
 	}
+	Trace::end("Battle::update::scanners->update");
 	Trace::start("Battle::update::units->update");
 	for (auto &o : this->units)
 	{
@@ -958,6 +1035,47 @@ void Battle::update(GameState &state, unsigned int ticks)
 	Trace::end("Battle::update::pathfinding");
 }
 
+void Battle::updateTBBegin(GameState & state)
+{
+	ticksWithoutAction = 0;
+	turnEndAllowed = false;
+	lowMoraleProcessed = false;
+
+	Trace::start("Battle::updateTBBegin::units->update");
+	for (auto &o : this->units)
+	{
+		if (o.second->owner == currentActiveOrganisation)
+		{
+			o.second->updateTB(state);
+		}
+	}
+	Trace::end("Battle::updateTBBegin::units->update");
+}
+
+void Battle::updateTBEnd(GameState & state)
+{
+	Trace::start("Battle::updateTBEnd::hazards->update");
+	for (auto it = this->hazards.begin(); it != this->hazards.end();)
+	{
+		auto d = *it++;
+		if (d->owner == currentActiveOrganisation)
+		{
+			d->updateTB(state);
+		}
+	}
+	Trace::end("Battle::updateTBEnd::hazards->update");
+	Trace::start("Battle::updateTBEnd::items->update");
+	for (auto it = this->items.begin(); it != this->items.end();)
+	{
+		auto p = *it++;
+		if (p->owner == currentActiveOrganisation)
+		{
+			p->updateTB(state);
+		}
+	}
+	Trace::end("Battle::updateTBEnd::items->update");
+}
+
 int Battle::getLosBlockID(int x, int y, int z) const
 {
 	return tileToLosBlock.at(z * size.x * size.y + y * size.x + x);
@@ -1040,25 +1158,24 @@ void Battle::accuracyAlgorithmBattle(GameState &state, Vec3<float> firePosition,
 		}
 	}
 
-	// Vertical misses always go down
-	float k1 = rnd[1] * std::sqrt(-2 * std::log(rnd[0]) / rnd[0]);
-	// Horizontal misses go left or right randomly
+	float k1 = (2 * randBoundsInclusive(state.rng, 0, 1) - 1)  *rnd[1] * std::sqrt(-2 * std::log(rnd[0]) / rnd[0]);
 	float k2 = (2 * randBoundsInclusive(state.rng, 0, 1) - 1) * rnd[2] *
 	           std::sqrt(-2 * std::log(rnd[0]) / rnd[0]);
 
+	// Vertical misses only go down
 	auto diffVertical =
 	    Vec3<float>{length_vector * delta.x * delta.z, length_vector * delta.y * delta.z,
-	                -length_vector * (delta.x * delta.x + delta.y * delta.y)} *
+	               std::min(0.0f, -length_vector * (delta.x * delta.x + delta.y * delta.y))} *
 	    k1;
 	auto diffHorizontal = Vec3<float>{-delta.y, delta.x, 0.0f} * k2;
 
 	auto diff = (diffVertical + diffHorizontal) *
 	            (thrown ? Vec3<float>{3.0f, 3.0f, 0.0f} : Vec3<float>{1.0f, 1.0f, 0.33f});
-
+	LogWarning("Offset %s Diff %s Target %s Becomes %s", delta, diff, target, target+diff);
 	target += diff;
 }
 
-void Battle::beginTurn()
+void Battle::beginTurn(GameState &state)
 {
 	if (mode != Mode::TurnBased)
 	{
@@ -1066,37 +1183,41 @@ void Battle::beginTurn()
 		return;
 	}
 
-	LogWarning("Implement beginning turn!");
-
+	// Cancel mind control and stuff
 	for (auto &u : units)
 	{
 		if (u.second->owner != currentActiveOrganisation)
 		{
 			continue;
 		}
-		u.second->agent->modified_stats.restoreTU();
+		u.second->stopAttackPsi(state);
 	}
-}
-
-void Battle::endTurn()
-{
-	if (mode != Mode::TurnBased)
+	for (auto &u : units)
 	{
-		LogError("endTurn called in real time?");
-		return;
+		if (u.second->owner != currentActiveOrganisation)
+		{
+			continue;
+		}
+		u.second->beginTurn(state);
 	}
 
-	LogWarning("Implement ending turn!");
+	updateTBBegin(state);
+}
+
+void Battle::endTurn(GameState &state)
+{
+	updateTBEnd(state);
 
 	// Pass turn to next org, if final org - increment turn counter and pass to first org
-	auto it = std::find(participants.begin(), participants.end(), currentActiveOrganisation)++;
+	auto it = ++std::find(participants.begin(), participants.end(), currentActiveOrganisation);
 	if (it == participants.end())
 	{
 		currentTurn++;
 		it = participants.begin();
 	}
 	currentActiveOrganisation = *it;
-	beginTurn();
+
+	beginTurn(state);
 }
 
 void Battle::giveInterruptChanceToUnits(GameState &state, StateRef<BattleUnit> giver, int reactionValue)
@@ -1116,14 +1237,11 @@ void Battle::giveInterruptChanceToUnits(GameState &state, StateRef<BattleUnit> g
 
 void Battle::giveInterruptChanceToUnit(StateRef<BattleUnit> receiver, int reactionValue)
 {
-	if (mode != Mode::TurnBased)
-	{
-		return;
-	}
-	if (receiver->owner == currentActiveOrganisation)
+	if (mode != Mode::TurnBased || receiver->owner == currentActiveOrganisation || receiver->getAIType() == AIType::None)
 	{
 		return;
 	}
+
 	if (receiver->agent->getReactionValue() > reactionValue)
 	{
 		interruptQueue.emplace(receiver, receiver->agent->getTULimit(reactionValue));
@@ -1752,10 +1870,10 @@ void Battle::enterBattle(GameState &state)
 			LogError("Unit %s cannot Stand, Fly, Kneel or go Prone!", u->agent->type.id);
 		}
 		// Miscellaneous
-		u->agent->modified_stats.restoreTU();
+		u->beginTurn(state);
 		u->resetGoal();
 	}
-
+	
 	state.current_battle->initBattle(state, true);
 
 	// Find first player unit
diff --git a/game/state/battle/battle.h b/game/state/battle/battle.h
index 0d6228ceb..4bc445e3c 100644
--- a/game/state/battle/battle.h
+++ b/game/state/battle/battle.h
@@ -24,6 +24,10 @@ namespace OpenApoc
 #define VOXEL_Z_BATTLE (20)
 
 static const unsigned TICKS_PER_TURN = TICKS_PER_SECOND * 4;
+// Amount of ticks that must pass without any action in order for turn end to trigger
+static const unsigned TICKS_END_TURN = TICKS_PER_SECOND * 2;
+// Amount of ticks that must pass for interrupt to begin
+static const unsigned TICKS_BEGIN_INTERRUPT = TICKS_PER_SECOND / 2;
 
 class BattleCommonImageList;
 class BattleCommonSampleList;
@@ -158,7 +162,13 @@ class Battle : public std::enable_shared_from_this<Battle>
 	// Who's turn is it
 	StateRef<Organisation> currentActiveOrganisation;
 	// Turn number
-	int currentTurn = 0;
+	unsigned int currentTurn = 0;
+	// Ticks without action in TB
+	unsigned int ticksWithoutAction = 0;
+	// Turn end allowed by current org
+	bool turnEndAllowed = false;
+	// Low morale units were processed at turn start
+	bool lowMoraleProcessed = false;
 	// Units queued to get interrupt after this update
 	std::map<StateRef<BattleUnit>, int> interruptQueue;
 	// Units currently interrupting
@@ -172,6 +182,8 @@ class Battle : public std::enable_shared_from_this<Battle>
 	std::list<StateRef<BattleUnit>> battleViewSelectedUnits;
 
 	void update(GameState &state, unsigned int ticks);
+	void updateTBBegin(GameState &state);
+	void updateTBEnd(GameState &state);
 
 	void updateProjectiles(GameState &state, unsigned int ticks);
 	void updateVision(GameState &state);
@@ -181,7 +193,8 @@ class Battle : public std::enable_shared_from_this<Battle>
 
 	sp<BattleExplosion> addExplosion(GameState &state, Vec3<int> position,
 	                                 StateRef<DoodadType> doodadType,
-	                                 StateRef<DamageType> damageType, int power, int depletionRate,
+	                                 StateRef<DamageType> damageType, int power, int depletionRate, 
+									 StateRef<Organisation> ownerOrg,
 	                                 StateRef<BattleUnit> ownerUnit = nullptr);
 	sp<BattleDoor> addDoor(GameState &state);
 	sp<Doodad> placeDoodad(StateRef<DoodadType> type, Vec3<float> position);
@@ -192,7 +205,7 @@ class Battle : public std::enable_shared_from_this<Battle>
 	sp<BattleUnit> placeUnit(GameState &state, StateRef<Agent> agent);
 	sp<BattleUnit> placeUnit(GameState &state, StateRef<Agent> agent, Vec3<float> position);
 	sp<BattleItem> placeItem(GameState &state, sp<AEquipment> item, Vec3<float> position);
-	sp<BattleHazard> placeHazard(GameState &state, StateRef<DamageType> type, Vec3<int> position,
+	sp<BattleHazard> placeHazard(GameState &state, StateRef<Organisation> owner, StateRef<DamageType> type, Vec3<int> position,
 	                             int ttl, int power, int initialAgeTTLDivizor = 1,
 	                             bool delayVisibility = true);
 	sp<BattleScanner> addScanner(GameState &state, AEquipment &item);
@@ -203,10 +216,10 @@ class Battle : public std::enable_shared_from_this<Battle>
 
 	// Turn based functions
 
-	// Called when new organisation's turn is starting
-	void beginTurn();
-	// Called when current active organisation decides to end their turn
-	void endTurn();
+	// Begin new org's turn
+	void beginTurn(GameState &state);
+	// End current org's turn
+	void endTurn(GameState &state);
 	// Give interrupt chance to hostile units that see this unit
 	void giveInterruptChanceToUnits(GameState &state, StateRef<BattleUnit> giver, int reactionValue);
 	// Give interrupt chance to a unit
diff --git a/game/state/battle/battleexplosion.cpp b/game/state/battle/battleexplosion.cpp
index f7b749326..e1d90406d 100644
--- a/game/state/battle/battleexplosion.cpp
+++ b/game/state/battle/battleexplosion.cpp
@@ -22,12 +22,12 @@
 namespace OpenApoc
 {
 BattleExplosion::BattleExplosion(Vec3<int> position, StateRef<DamageType> damageType, int power,
-                                 int depletionRate, bool damageInTheEnd,
+                                 int depletionRate, bool damageInTheEnd,StateRef<Organisation> ownerOrg,
                                  StateRef<BattleUnit> ownerUnit)
     : position(position), power(power), ticksUntilExpansion(TICKS_MULTIPLIER * 2),
       locationsToExpand({{{position, {power, power}}}, {}, {}}), damageInTheEnd(damageInTheEnd),
       locationsVisited({position}), damageType(damageType), depletionRate(depletionRate),
-      ownerUnit(ownerUnit)
+      ownerUnit(ownerUnit), ownerOrganisation(ownerOrg)
 {
 }
 
@@ -60,7 +60,7 @@ void BattleExplosion::die(GameState &state)
 		}
 		if (existingHazard)
 		{
-			existingHazard->ticksUntilNextUpdate = TICKS_PER_HAZARD_UPDATE;
+			existingHazard->nextUpdateTicksAccumulated = 0;
 		}
 	}
 }
@@ -89,13 +89,13 @@ void BattleExplosion::damage(GameState &state, const TileMap &map, Vec3<int> pos
 	{
 		StateRef<DamageType> dtSmoke = {&state, "DAMAGETYPE_SMOKE"};
 		state.current_battle->placeHazard(
-		    state, dtSmoke, pos, dtSmoke->hazardType->getLifetime(state), damage, 2, false);
+		    state, ownerOrganisation, dtSmoke, pos, dtSmoke->hazardType->getLifetime(state), damage, 2, false);
 	}
 	// Explosions with no custom explosion doodad spawn hazards when dealing damage
 	else if (!damageType->explosionDoodad)
 	{
 		state.current_battle->placeHazard(
-		    state, damageType, pos, damageType->hazardType->getLifetime(state), damage, 1, false);
+		    state, ownerOrganisation, damageType, pos, damageType->hazardType->getLifetime(state), damage, 1, false);
 	}
 	// Gas does no direct damage
 	if (damageType->doesImpactDamage())
@@ -331,6 +331,8 @@ void BattleExplosion::grow(GameState &state)
 {
 	auto &map = *state.current_battle->map;
 
+	state.current_battle->ticksWithoutAction = 0;
+
 	for (int i = 0; i < 2; i++)
 	{
 		locationsToExpand.emplace_back();
@@ -339,7 +341,7 @@ void BattleExplosion::grow(GameState &state)
 		{
 			if (damageType->hazardType && damageType->explosionDoodad)
 			{
-				state.current_battle->placeHazard(state, damageType, pos.first,
+				state.current_battle->placeHazard(state, ownerOrganisation, damageType, pos.first,
 				                                  damageType->hazardType->getLifetime(state),
 				                                  pos.second.x);
 			}
diff --git a/game/state/battle/battleexplosion.h b/game/state/battle/battleexplosion.h
index aaf0904f0..06b91ed34 100644
--- a/game/state/battle/battleexplosion.h
+++ b/game/state/battle/battleexplosion.h
@@ -12,6 +12,7 @@ class TileMap;
 class Battle;
 class BattleUnit;
 class DamageType;
+class Organisation;
 class BattleUnit;
 
 class BattleExplosion : public std::enable_shared_from_this<BattleExplosion>
@@ -38,6 +39,7 @@ class BattleExplosion : public std::enable_shared_from_this<BattleExplosion>
 	StateRef<DamageType> damageType;
 	int depletionRate = 0;
 	StateRef<BattleUnit> ownerUnit;
+	StateRef<Organisation> ownerOrganisation;
 
 	std::set<StateRef<BattleUnit>> affectedUnits;
 
@@ -51,6 +53,7 @@ class BattleExplosion : public std::enable_shared_from_this<BattleExplosion>
 
 	BattleExplosion(Vec3<int> position, StateRef<DamageType> damageType, int power,
 	                int depletionRate, bool damageInTheEnd,
+					StateRef<Organisation> ownerOrg,
 	                StateRef<BattleUnit> ownerUnit = nullptr);
 	BattleExplosion() = default;
 	~BattleExplosion() = default;
diff --git a/game/state/battle/battlehazard.cpp b/game/state/battle/battlehazard.cpp
index abe6284b2..cc8f05110 100644
--- a/game/state/battle/battlehazard.cpp
+++ b/game/state/battle/battlehazard.cpp
@@ -30,8 +30,7 @@ BattleHazard::BattleHazard(GameState &state, StateRef<DamageType> damageType, bo
 		ticksUntilVisible =
 		    std::max((unsigned)0, (hazardType->doodadType->lifetime - 4) * TICKS_MULTIPLIER);
 	}
-	ticksUntilNextUpdate = TICKS_PER_HAZARD_UPDATE;
-	ticksUntilNextFrameChange =
+	frameChangeTicksAccumulated =
 	    randBoundsInclusive(state.rng, (unsigned)0, TICKS_PER_HAZARD_UPDATE);
 }
 
@@ -39,8 +38,10 @@ void BattleHazard::die(GameState &state, bool violently)
 {
 	auto this_shared = shared_from_this();
 	state.current_battle->hazards.erase(this_shared);
-	this->tileObject->removeFromMap();
-	this->tileObject.reset();
+
+	tileObject->removeFromMap();
+	tileObject.reset();
+	
 	if (!violently)
 	{
 		return;
@@ -49,7 +50,7 @@ void BattleHazard::die(GameState &state, bool violently)
 	if (damageType->effectType == DamageType::EffectType::Fire)
 	{
 		StateRef<DamageType> dtSmoke = {&state, "DAMAGETYPE_SMOKE"};
-		state.current_battle->placeHazard(state, dtSmoke, position,
+		state.current_battle->placeHazard(state, owner, dtSmoke, position,
 		                                  dtSmoke->hazardType->getLifetime(state), power, 6);
 	}
 }
@@ -216,7 +217,7 @@ bool BattleHazard::expand(GameState &state, const TileMap &map, const Vec3<int>
 			{
 				existingHazard->die(state, false);
 			}
-			state.current_battle->placeHazard(state, spreadDamageType, {to.x, to.y, to.z},
+			state.current_battle->placeHazard(state, owner, spreadDamageType, {to.x, to.y, to.z},
 			                                  spreadDamageType->hazardType->getLifetime(state), 0,
 			                                  1, false);
 		}
@@ -240,7 +241,7 @@ bool BattleHazard::expand(GameState &state, const TileMap &map, const Vec3<int>
 		{
 
 			auto hazard = state.current_battle->placeHazard(
-			    state, spreadDamageType, {to.x, to.y, to.z}, fireSmoke ? ttl : lifetime,
+			    state, owner, spreadDamageType, {to.x, to.y, to.z}, fireSmoke ? ttl : lifetime,
 			    fireSmoke ? 1 : power, fireSmoke ? 6 : 1, false);
 			if (hazard && !fireSmoke)
 			{
@@ -425,32 +426,12 @@ void BattleHazard::applyEffect(GameState &state)
 	}
 }
 
-void BattleHazard::update(GameState &state, unsigned int ticks)
+void BattleHazard::updateInner(GameState &state, unsigned int ticks)
 {
-	if (ticksUntilVisible > 0)
+	nextUpdateTicksAccumulated += ticks;
+	while (nextUpdateTicksAccumulated >= TICKS_PER_HAZARD_UPDATE)
 	{
-		if (ticksUntilVisible > ticks)
-		{
-			ticksUntilVisible -= ticks;
-		}
-		else
-		{
-			ticksUntilVisible = 0;
-		}
-	}
-
-	ticksUntilNextFrameChange -= ticks;
-	if (ticksUntilNextFrameChange <= 0)
-	{
-		ticksUntilNextFrameChange += TICKS_PER_HAZARD_UPDATE;
-		frame++;
-		frame %= hazardType->fire ? 2 : HAZARD_FRAME_COUNT;
-	}
-
-	ticksUntilNextUpdate -= ticks;
-	if (ticksUntilNextUpdate <= 0)
-	{
-		ticksUntilNextUpdate += TICKS_PER_HAZARD_UPDATE;
+		nextUpdateTicksAccumulated -= TICKS_PER_HAZARD_UPDATE;
 		if (hazardType->fire)
 		{
 			// Explanation for how fire works is at the end of battlehazard.h
@@ -478,6 +459,7 @@ void BattleHazard::update(GameState &state, unsigned int ticks)
 			if (age >= 130)
 			{
 				die(state);
+				return;
 			}
 		}
 		else
@@ -495,11 +477,48 @@ void BattleHazard::update(GameState &state, unsigned int ticks)
 			if (age >= lifetime)
 			{
 				die(state);
+				return;
 			}
 		}
 	}
 }
 
+void BattleHazard::update(GameState &state, unsigned int ticks)
+{
+	bool realTime = state.current_battle->mode == Battle::Mode::RealTime;
+
+	if (ticksUntilVisible > 0)
+	{
+		if (ticksUntilVisible > ticks)
+		{
+			ticksUntilVisible -= ticks;
+		}
+		else
+		{
+			ticksUntilVisible = 0;
+		}
+	}
+
+	frameChangeTicksAccumulated += ticks;
+	while (frameChangeTicksAccumulated >= TICKS_PER_HAZARD_UPDATE)
+	{
+		frameChangeTicksAccumulated -= TICKS_PER_HAZARD_UPDATE;
+		frame++;
+		frame %= hazardType->fire ? 2 : HAZARD_FRAME_COUNT;
+	}
+
+	if (realTime)
+	{
+		updateInner(state, ticks);
+	}
+}
+
+
+void BattleHazard::updateTB(GameState &state)
+{
+	updateInner(state, TICKS_PER_TURN);
+}
+
 void BattleHazard::updateTileVisionBlock(GameState &state)
 {
 	int visionBlock =
diff --git a/game/state/battle/battlehazard.h b/game/state/battle/battlehazard.h
index 0879b06de..24cb3d0bd 100644
--- a/game/state/battle/battlehazard.h
+++ b/game/state/battle/battlehazard.h
@@ -21,6 +21,7 @@ class TileObjectBattleHazard;
 class DamageType;
 class HazardType;
 class GameState;
+class Organisation;
 class TileMap;
 
 class BattleHazard : public std::enable_shared_from_this<BattleHazard>
@@ -39,8 +40,9 @@ class BattleHazard : public std::enable_shared_from_this<BattleHazard>
 	unsigned age = 0;
 	unsigned int frame = 0;
 	unsigned ticksUntilVisible = 0;
-	unsigned ticksUntilNextFrameChange = 0;
-	unsigned ticksUntilNextUpdate = 0;
+	unsigned frameChangeTicksAccumulated = 0;
+	unsigned nextUpdateTicksAccumulated = 0;
+	StateRef<Organisation> owner;
 
 	bool expand(GameState &state, const TileMap &map, const Vec3<int> &to, unsigned ttl,
 	            bool fireSmoke = false);
@@ -50,6 +52,8 @@ class BattleHazard : public std::enable_shared_from_this<BattleHazard>
 	void updateTileVisionBlock(GameState &state);
 
 	void update(GameState &state, unsigned int ticks);
+	void updateInner(GameState &state, unsigned int ticks);
+	void updateTB(GameState &state);
 
 	BattleHazard() = default;
 	BattleHazard(GameState &state, StateRef<DamageType> damageType, bool delayVisibility = true);
diff --git a/game/state/battle/battleitem.cpp b/game/state/battle/battleitem.cpp
index 817bc82b8..8836ab852 100644
--- a/game/state/battle/battleitem.cpp
+++ b/game/state/battle/battleitem.cpp
@@ -141,6 +141,11 @@ Collision BattleItem::checkItemCollision(Vec3<float> previousPosition, Vec3<floa
 	return c;
 }
 
+void BattleItem::updateTB(GameState &state)
+{
+	item->updateTB(state);
+}
+
 void BattleItem::update(GameState &state, unsigned int ticks)
 {
 	item->update(state, ticks);
diff --git a/game/state/battle/battleitem.h b/game/state/battle/battleitem.h
index abb8be9c9..11b5af584 100644
--- a/game/state/battle/battleitem.h
+++ b/game/state/battle/battleitem.h
@@ -19,6 +19,7 @@ class Battle;
 class BattleUnit;
 class AEquipment;
 class Image;
+class Organisation;
 class DamageType;
 
 class BattleItem : public std::enable_shared_from_this<BattleItem>
@@ -45,6 +46,8 @@ class BattleItem : public std::enable_shared_from_this<BattleItem>
 
 	unsigned int ticksUntilCollapse = 0;
 
+	StateRef<Organisation> owner;
+
 	// Check if we are still supported, and collapse if not
 	void tryCollapse();
 	void collapse();
@@ -57,6 +60,7 @@ class BattleItem : public std::enable_shared_from_this<BattleItem>
 	void hopTo(GameState &state, Vec3<float> targetPosition);
 
 	void update(GameState &state, unsigned int ticks);
+	void updateTB(GameState &state);
 
 	BattleItem() = default;
 	~BattleItem() = default;
diff --git a/game/state/battle/battlemap.cpp b/game/state/battle/battlemap.cpp
index 8e4251c55..b6b3aa183 100644
--- a/game/state/battle/battlemap.cpp
+++ b/game/state/battle/battlemap.cpp
@@ -169,7 +169,7 @@ sp<Battle> BattleMap::createBattle(GameState &state, StateRef<Organisation> orga
 	// FIXME: Generate list of agent types for enemies (and civs) properly
 	addDebugTroops(state, player_agents);
 
-	return ufo->type->battle_map->createBattle(state, organisation, player_agents, craft,
+	return ufo->type->battle_map->createBattle(state, ufo->owner, organisation, player_agents, craft,
 	                                           Battle::MissionType::UfoRecovery, ufo.id);
 }
 
@@ -271,7 +271,7 @@ sp<Battle> BattleMap::createBattle(GameState &state, StateRef<Organisation> orga
 		player_agents.push_back(state.agent_generator.createAgent(state, pair.first, pair.second));
 	}
 
-	return building->battle_map->createBattle(state, organisation, player_agents, craft,
+	return building->battle_map->createBattle(state,building->owner, organisation, player_agents, craft,
 	                                          missionType, building.id);
 }
 
@@ -836,7 +836,7 @@ bool BattleMap::generateMap(std::vector<sp<BattleMapSector>> &sec_map, Vec3<int>
 sp<Battle>
 BattleMap::fillMap(std::vector<std::list<std::pair<Vec3<int>, sp<BattleMapPart>>>> &doors,
                    bool &spawnCivilians, std::vector<sp<BattleMapSector>> sec_map, Vec3<int> size,
-                   GameState &state, StateRef<Organisation> target_organisation,
+                   GameState &state, StateRef<Organisation> propertyOwner, StateRef<Organisation> target_organisation,
                    std::list<StateRef<Agent>> &agents, StateRef<Vehicle> player_craft,
                    Battle::MissionType mission_type, UString mission_location_id)
 {
@@ -887,6 +887,7 @@ BattleMap::fillMap(std::vector<std::list<std::pair<Vec3<int>, sp<BattleMapPart>>
 					auto s = mksp<BattleMapPart>();
 
 					auto initialPosition = pair.first + shift;
+					s->owner = propertyOwner;
 					s->position = initialPosition;
 					s->queueCollapse();
 					s->position += Vec3<float>(0.5f, 0.5f, 0.0f);
@@ -948,6 +949,7 @@ BattleMap::fillMap(std::vector<std::list<std::pair<Vec3<int>, sp<BattleMapPart>>
 					auto s = mksp<BattleMapPart>();
 
 					auto initialPosition = pair.first + shift;
+					s->owner = propertyOwner;
 					s->position = initialPosition;
 					s->queueCollapse();
 					s->position += Vec3<float>(0.5f, 0.5f, 0.0f);
@@ -965,6 +967,7 @@ BattleMap::fillMap(std::vector<std::list<std::pair<Vec3<int>, sp<BattleMapPart>>
 					auto s = mksp<BattleMapPart>();
 
 					auto initialPosition = pair.first + shift;
+					s->owner = propertyOwner;
 					s->position = initialPosition;
 					s->queueCollapse();
 					s->position += Vec3<float>(0.5f, 0.5f, 0.0f);
@@ -984,7 +987,7 @@ BattleMap::fillMap(std::vector<std::list<std::pair<Vec3<int>, sp<BattleMapPart>>
 						case BattleMapPartType::AutoConvert::Fire:
 						{
 							StateRef<DamageType> dt = {&state, "DAMAGETYPE_INCENDIARY"};
-							b->placeHazard(state, dt, pair.first + shift,
+							b->placeHazard(state, propertyOwner, dt, pair.first + shift,
 							               // Make it already hot
 							               dt->hazardType->getLifetime(state) * 2, 0, 1, false);
 							break;
@@ -992,7 +995,7 @@ BattleMap::fillMap(std::vector<std::list<std::pair<Vec3<int>, sp<BattleMapPart>>
 						case BattleMapPartType::AutoConvert::Smoke:
 						{
 							StateRef<DamageType> dt = {&state, "DAMAGETYPE_SMOKE"};
-							b->placeHazard(state, dt, pair.first + shift,
+							b->placeHazard(state, propertyOwner, dt, pair.first + shift,
 							               dt->hazardType->getLifetime(state), 1, 2, false);
 							break;
 						}
@@ -1001,6 +1004,7 @@ BattleMap::fillMap(std::vector<std::list<std::pair<Vec3<int>, sp<BattleMapPart>>
 							auto s = mksp<BattleMapPart>();
 
 							auto initialPosition = pair.first + shift;
+							s->owner = propertyOwner;
 							s->position = initialPosition;
 							s->queueCollapse();
 							s->position += Vec3<float>(0.5f, 0.5f, 0.0f);
@@ -1279,7 +1283,7 @@ void BattleMap::unloadTiles()
 	LogInfo("Unloaded sector tiles.");
 }
 
-sp<Battle> BattleMap::createBattle(GameState &state, StateRef<Organisation> target_organisation,
+sp<Battle> BattleMap::createBattle(GameState &state, StateRef<Organisation> propertyOwner, StateRef<Organisation> target_organisation,
                                    std::list<StateRef<Agent>> &agents,
                                    StateRef<Vehicle> player_craft, Battle::MissionType mission_type,
                                    UString mission_location_id)
@@ -1297,7 +1301,7 @@ sp<Battle> BattleMap::createBattle(GameState &state, StateRef<Organisation> targ
 	}
 
 	// Step 02: Fill map with map parts
-	auto b = fillMap(doors, spawnCivilians, sec_map, size, state, target_organisation, agents,
+	auto b = fillMap(doors, spawnCivilians, sec_map, size, state, propertyOwner, target_organisation, agents,
 	                 player_craft, mission_type, mission_location_id);
 
 	// Step 03: Link adjacent doors
diff --git a/game/state/battle/battlemap.h b/game/state/battle/battlemap.h
index f10e0866b..431588c93 100644
--- a/game/state/battle/battlemap.h
+++ b/game/state/battle/battlemap.h
@@ -60,7 +60,7 @@ class BattleMap : public StateObject
 	                               StateRef<Vehicle> player_craft,
 	                               StateRef<Building> target_building);
 
-	sp<Battle> createBattle(GameState &state, StateRef<Organisation> target_organisation,
+	sp<Battle> createBattle(GameState &state, StateRef<Organisation> propertyOwner, StateRef<Organisation> target_organisation,
 	                        std::list<StateRef<Agent>> &agents, StateRef<Vehicle> player_craft,
 	                        Battle::MissionType mission_type, UString mission_location_id);
 
@@ -71,7 +71,7 @@ class BattleMap : public StateObject
 
 	sp<Battle> fillMap(std::vector<std::list<std::pair<Vec3<int>, sp<BattleMapPart>>>> &doors,
 	                   bool &spawnCivilians, std::vector<sp<BattleMapSector>> sec_map,
-	                   Vec3<int> size, GameState &state, StateRef<Organisation> target_organisation,
+	                   Vec3<int> size, GameState &state, StateRef<Organisation> propertyOwner, StateRef<Organisation> target_organisation,
 	                   std::list<StateRef<Agent>> &agents, StateRef<Vehicle> player_craft,
 	                   Battle::MissionType mission_type, UString mission_location_id);
 
diff --git a/game/state/battle/battlemappart.cpp b/game/state/battle/battlemappart.cpp
index 8538194a8..38a287e5b 100644
--- a/game/state/battle/battlemappart.cpp
+++ b/game/state/battle/battlemappart.cpp
@@ -26,7 +26,7 @@ void BattleMapPart::die(GameState &state, bool explosive, bool violently)
 		{
 			state.current_battle->addExplosion(state, position, nullptr, type->explosion_type,
 			                                   type->explosion_power,
-			                                   type->explosion_depletion_rate);
+			                                   type->explosion_depletion_rate, owner);
 			// Make it die so that it doesn't blow up twice!
 			explosive = false;
 		}
@@ -1287,7 +1287,7 @@ void BattleMapPart::update(GameState &state, unsigned int ticks)
 			{
 				StateRef<DamageType> dtSmoke = {&state, "DAMAGETYPE_SMOKE"};
 				auto hazard = state.current_battle->placeHazard(
-				    state, dtSmoke, position, dtSmoke->hazardType->getLifetime(state), 2,
+				    state, owner, dtSmoke, position, dtSmoke->hazardType->getLifetime(state), 2,
 				    destroyed ? 6 : 12);
 				if (hazard)
 				{
@@ -1305,6 +1305,7 @@ void BattleMapPart::update(GameState &state, unsigned int ticks)
 						auto rubble = mksp<BattleMapPart>();
 						Vec3<int> initialPosition = position;
 						rubble->damaged = true;
+						rubble->owner = owner;
 						rubble->position = initialPosition;
 						rubble->position += Vec3<float>(0.5f, 0.5f, 0.0f);
 						rubble->type = type->rubble.front();
diff --git a/game/state/battle/battlemappart.h b/game/state/battle/battlemappart.h
index 83182a009..5950f7096 100644
--- a/game/state/battle/battlemappart.h
+++ b/game/state/battle/battlemappart.h
@@ -18,6 +18,7 @@ class Collision;
 class TileObjectBattleMapPart;
 class BattleItem;
 class BattleDoor;
+class Organisation;
 
 class BattleMapPart : public std::enable_shared_from_this<BattleMapPart>
 {
@@ -40,6 +41,7 @@ class BattleMapPart : public std::enable_shared_from_this<BattleMapPart>
 
 	bool supportedItems = false;
 	std::list<std::pair<Vec3<int>, BattleMapPartType::Type>> supportedParts;
+	StateRef<Organisation> owner;
 
 	// Ticks for animation of non-doors
 	int animation_frame_ticks = 0;
diff --git a/game/state/battle/battleunit.cpp b/game/state/battle/battleunit.cpp
index f1a7508c0..1e23d0211 100644
--- a/game/state/battle/battleunit.cpp
+++ b/game/state/battle/battleunit.cpp
@@ -116,7 +116,7 @@ bool BattleUnit::isFatallyWounded()
 	return false;
 }
 
-void BattleUnit::setPosition(GameState &state, const Vec3<float> &pos)
+void BattleUnit::setPosition(GameState &state, const Vec3<float> &pos, bool goal)
 {
 	auto oldPosition = position;
 	position = pos;
@@ -132,29 +132,54 @@ void BattleUnit::setPosition(GameState &state, const Vec3<float> &pos)
 	{
 		shadowObject->setPosition(tileObject->getCenter());
 	}
+	if (oldPosition != position)
+	{
+		state.current_battle->ticksWithoutAction = 0;
+	}
 	if ((Vec3<int>)oldPosition != (Vec3<int>)position)
 	{
 		state.current_battle->notifyScanners(position);
-		refreshUnitVisibilityAndVision(state, oldPosition);
-		state.current_battle->giveInterruptChanceToUnits(state, { &state, id }, agent->getReactionValue());
+		tilesMoved++;
 		if (agent->type->spreadHazardDamageType)
 		{
 			state.current_battle->placeHazard(
-			    state, agent->type->spreadHazardDamageType, oldPosition,
+			    state, owner, agent->type->spreadHazardDamageType, oldPosition,
 			    agent->type->spreadHazardDamageType->hazardType->getLifetime(state),
 			    randBoundsInclusive(state.rng, agent->type->spreadHazardMinPower,
 			                        agent->type->spreadHazardMaxPower),
 			    agent->type->spreadHazardTTLDivizor, false);
 		}
+		else if (enzymeDebuffIntensity > 0)
+		{
+			spawnEnzymeSmoke(state, position);
+		}
+	}
+	if (goal)
+	{
+		onReachGoal(state);
 	}
 }
 
-void BattleUnit::refreshUnitVisibility(GameState &state, Vec3<float> oldPosition)
+void BattleUnit::refreshUnitVisibility(GameState &state)
 {
-	// Update other units's vision of this unit
-	// FIXME: Do this properly? Only update vision to this unit, not to everything?
-	state.current_battle->queueVisionRefresh(position);
-	state.current_battle->queueVisionRefresh(oldPosition);
+	for (auto &entry : state.current_battle->units)
+	{
+		auto unit = entry.second;
+		if (!unit->isConscious())
+		{
+			continue;
+		}
+		auto vec = (Vec3<int>)position - (Vec3<int>)unit->position;
+		bool canNotSee = false;
+		// Quick check it's to the right side of us and in range
+		if ((vec.x > 0 && unit->facing.x < 0) || (vec.y > 0 && unit->facing.y < 0) ||
+			(vec.x < 0 && unit->facing.x > 0) || (vec.y < 0 && unit->facing.y > 0) ||
+			(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z > 400))
+		{
+			canNotSee = true;
+		}
+		unit->refreshUnitVision(state, canNotSee, { &state, id });
+	}
 }
 
 bool BattleUnit::isWithinVision(Vec3<int> pos)
@@ -207,9 +232,10 @@ bool BattleUnit::isWithinVision(Vec3<int> pos)
 	return true;
 }
 
-void BattleUnit::calculateVisionToTerrain(GameState &, Battle &battle, TileMap &map,
+void BattleUnit::calculateVisionToTerrain(GameState &state, Battle &battle, TileMap &map,
                                           Vec3<float> eyesPos)
 {
+	static const int lazyLimit = 5 * 9;
 	std::set<int> discoveredBlocks;
 	auto &visibleBlocks = battle.visibleBlocks.at(owner);
 
@@ -223,6 +249,8 @@ void BattleUnit::calculateVisionToTerrain(GameState &, Battle &battle, TileMap &
 		}
 	}
 
+	auto blocksToCheck = std::set<int>();
+	int totalChecks = 0;
 	// Calc los to other blocks we haven't seen yet
 	for (int idx = 0; idx < (int)visibleBlocks.size(); idx++)
 	{
@@ -232,9 +260,48 @@ void BattleUnit::calculateVisionToTerrain(GameState &, Battle &battle, TileMap &
 			continue;
 		}
 
+		totalChecks++;
+		blocksToCheck.insert(idx);
+		if (totalChecks >= lazyLimit)
+		{
+			break;
+		}
+	}
+
+	if (totalChecks >= lazyLimit)
+	{
+		calculateVisionToLosBlocksLazy(state, battle, map, eyesPos, discoveredBlocks);
+	}
+	else
+	{
+		calculateVisionToLosBlocks(state, battle, map, eyesPos, discoveredBlocks, blocksToCheck);
+	}
+
+	// Reveal all discovered blocks
+	for (auto idx : discoveredBlocks)
+	{
+		auto l = battle.losBlocks.at(idx);
+		for (int x = l->start.x; x < l->end.x; x++)
+		{
+			for (int y = l->start.y; y < l->end.y; y++)
+			{
+				for (int z = l->start.z; z < l->end.z; z++)
+				{
+					battle.setVisible(owner, x, y, z);
+				}
+			}
+		}
+	}
+}
+
+void BattleUnit::calculateVisionToLosBlocks(GameState & state, Battle & battle, TileMap & map, Vec3<float> eyesPos, std::set<int> &discoveredBlocks, std::set<int> &blocksToCheck)
+{
+	auto &visibleBlocks = battle.visibleBlocks.at(owner);
+	for (auto idx: blocksToCheck)
+	{
 		// Get block and its center
 		auto &l = *battle.losBlocks.at(idx);
-		auto centerXY = Vec3<int>{(l.start.x + l.end.x) / 2, (l.start.y + l.end.y) / 2, 0};
+		auto centerXY = Vec3<int>{ (l.start.x + l.end.x) / 2, (l.start.y + l.end.y) / 2, 0 };
 		// Set target to center
 		bool targetFound = false;
 		auto target = centerXY;
@@ -262,19 +329,19 @@ void BattleUnit::calculateVisionToTerrain(GameState &, Battle &battle, TileMap &
 		{
 			// Get point in the middle of our sight forward
 			int dist =
-			    facing.x != 0 && facing.y != 0 ? VIEW_DISTANCE * 100 / 141 / 2 : VIEW_DISTANCE / 2;
+				facing.x != 0 && facing.y != 0 ? VIEW_DISTANCE * 100 / 141 / 2 : VIEW_DISTANCE / 2;
 			auto sightMiddleXY = (Vec3<int>)position;
 			sightMiddleXY.x += facing.x * dist;
 			sightMiddleXY.y += facing.y * dist;
 			// Get point closest to that point
 			target.x =
-			    std::abs(l.start.x - sightMiddleXY.x) < std::abs(l.end.x - 1 - sightMiddleXY.x)
-			        ? l.start.x
-			        : l.end.x - 1;
+				std::abs(l.start.x - sightMiddleXY.x) < std::abs(l.end.x - 1 - sightMiddleXY.x)
+				? l.start.x
+				: l.end.x - 1;
 			target.y =
-			    std::abs(l.start.y - sightMiddleXY.y) < std::abs(l.end.y - 1 - sightMiddleXY.y)
-			        ? l.start.y
-			        : l.end.y - 1;
+				std::abs(l.start.y - sightMiddleXY.y) < std::abs(l.end.y - 1 - sightMiddleXY.y)
+				? l.start.y
+				: l.end.y - 1;
 			if (posZ >= l.start.z && posZ < l.end.z)
 			{
 				target.z = posZ;
@@ -297,8 +364,8 @@ void BattleUnit::calculateVisionToTerrain(GameState &, Battle &battle, TileMap &
 		// If target is found then we can try to los to this block
 		if (targetFound)
 		{
-			auto c = map.findCollision(eyesPos, {target.x + 0.5f, target.y + 0.5f, target.z + 0.5f},
-			                           mapPartSet, tileObject, true, false, VIEW_DISTANCE);
+			auto c = map.findCollision(eyesPos, { target.x + 0.5f, target.y + 0.5f, target.z + 0.5f },
+				mapPartSet, tileObject, true, false, VIEW_DISTANCE);
 
 			// FIXME: Handle collisions with left/right/ground that prevent seeing inside
 			// If going positive on axes, we must shorten our beam a little bit, so that if
@@ -311,55 +378,97 @@ void BattleUnit::calculateVisionToTerrain(GameState &, Battle &battle, TileMap &
 			}
 		}
 	}
+}
 
-	// Reveal all discovered blocks
-	for (auto idx : discoveredBlocks)
+void BattleUnit::calculateVisionToLosBlocksLazy(GameState & state, Battle & battle, TileMap & map, Vec3<float> eyesPos, std::set<int> &discoveredBlocks)
+{
+	auto &visibleBlocks = battle.visibleBlocks.at(owner);
+	auto &tileToLosBlock = battle.tileToLosBlock;
+	
+	// Basically, we're checking in five directions on Z-scale, and in five directions on  XY scale
+	// Values are picked so that atan of these values give relatively even angle distributions
+
+	// First value is multiplier for XY part of vector, second value is vector's Z
+	static const std::vector<Vec2<float>> zTarget = { { 0.18f,1.0f },{ 1.0f,1.0f },{ 1.0f,0.55f },{ 1.0f,0.18f },{ 1.0f,0.0f },{ 1.0f,-0.18f },{ 1.0f,-0.55f },{ 1.0f,-1.0f },{ 0.18f,-1.0f } };
+	// First value is X, second value is Y
+	static const std::vector<Vec2<float>> diagTarget = { { 0.18f,1.0f },{ 0.55f,1.0f },{ 1.0f,1.0f },{ 1.0f,0.55f },{ 1.0f,0.18f } };
+	// Value for the coordinate which is zero in the facing (Y if facing along X etc.)
+	static const std::vector<float> dirTarget = { -0.82f, -0.45f, 0.0f, 0.45f, 0.82f };
+
+	for (int z = 0; z < 9; z++)
 	{
-		auto l = battle.losBlocks.at(idx);
-		for (int x = l->start.x; x < l->end.x; x++)
+		for (int xy = 0; xy < 5; xy++)
 		{
-			for (int y = l->start.y; y < l->end.y; y++)
+			Vec3<float> targetVector;
+			if (facing.x != 0 && facing.y != 0)
 			{
-				for (int z = l->start.z; z < l->end.z; z++)
+				targetVector = { (float)facing.x * diagTarget.at(xy).x * zTarget.at(z).x, (float)facing.y * diagTarget.at(xy).y * zTarget.at(z).x, zTarget.at(z).y };
+			}
+			else if (facing.x!=0)
+			{
+				targetVector = { (float)facing.x * zTarget.at(z).x,  dirTarget.at(xy) * zTarget.at(z).x, zTarget.at(z).y };
+			}
+			else
+			{
+				targetVector = { dirTarget.at(xy) * zTarget.at(z).x, (float)facing.y * zTarget.at(z).x, zTarget.at(z).y };
+
+			}
+			targetVector = glm::normalize(targetVector) * (float)VIEW_DISTANCE;
+
+			auto c = map.findCollision(eyesPos, eyesPos+targetVector,
+				mapPartSet, tileObject, true, false, VIEW_DISTANCE, true);
+
+			for (auto &t : c.passedTiles)
+			{
+				auto idx = tileToLosBlock.at(t.z * battle.size.x * battle.size.y + t.y * battle.size.x + t.x);
+				if (!visibleBlocks.at(idx))
 				{
-					battle.setVisible(owner, x, y, z);
+					visibleBlocks.at(idx) = true;
+					discoveredBlocks.insert(idx);
 				}
 			}
 		}
 	}
 }
 
+bool BattleUnit::calculateVisionToUnit(GameState &state, Battle &battle, TileMap &map,
+	Vec3<float> eyesPos, BattleUnit &u)
+{
+	// Unit unconscious, we own this unit or can't see it, skip
+	if (!u.isConscious() || u.owner == owner || !isWithinVision(u.position))
+	{
+		return false;
+	}
+	auto target = u.tileObject->getCenter();
+	if (u.isLarge())
+	{
+		// Offset search for large units as they can get caught up in ground
+		// that is supposed to allow units to go through it but blocks LOS
+		auto targetvVectorDelta = glm::normalize(target - eyesPos) * 0.75f;
+		target -= targetvVectorDelta;
+
+	}
+	auto c =
+		map.findCollision(eyesPos, target, mapPartSet, tileObject, true, false, VIEW_DISTANCE);
+	if (c || c.outOfRange)
+	{
+		return false;
+	}
+	return true;
+}
 void BattleUnit::calculateVisionToUnits(GameState &state, Battle &battle, TileMap &map,
                                         Vec3<float> eyesPos)
 {
 	for (auto &entry : battle.units)
 	{
-		auto &u = *entry.second;
-		// Unit unconscious, we own this unit or can't see it, skip
-		if (!u.isConscious() || u.owner == owner || !isWithinVision(u.position))
+		if (calculateVisionToUnit(state, battle, map, eyesPos, *entry.second))
 		{
-			continue;
-		}
- 		auto target = u.tileObject->getCenter();
-		if (u.isLarge())
-		{
-			// Offset search for large units as they can get caught up in ground
-			// that is supposed to allow units to go through it but blocks LOS
-			auto targetvVectorDelta = glm::normalize( target - eyesPos) * 0.75f;
-			target -= targetvVectorDelta;
-
-		}
-		auto c =
-		    map.findCollision(eyesPos, target, mapPartSet, tileObject, true, false, VIEW_DISTANCE);
-		if (c || c.outOfRange)
-		{
-			continue;
+			visibleUnits.emplace(&state, entry.first);
 		}
-		visibleUnits.emplace(&state, entry.first);
 	}
 }
 
-void BattleUnit::refreshUnitVision(GameState &state, bool forceBlind)
+void BattleUnit::refreshUnitVision(GameState &state, bool forceBlind, StateRef<BattleUnit> targetUnit)
 {
 	auto &battle = *state.current_battle;
 	auto &map = *battle.map;
@@ -368,7 +477,7 @@ void BattleUnit::refreshUnitVision(GameState &state, bool forceBlind)
 	visibleEnemies.clear();
 
 	// Vision is actually updated only if conscious, otherwise we clear visible units and that's it
-	if (!forceBlind && isConscious())
+	if (isConscious())
 	{
 		// FIXME: This likely won't work properly for large units
 		// Idea here is to LOS from the center of the occupied tile
@@ -376,9 +485,32 @@ void BattleUnit::refreshUnitVision(GameState &state, bool forceBlind)
 		    (int)position.x + 0.5f, (int)position.y + 0.5f,
 		    (int)position.z +
 		        ((float)agent->type->bodyType->muzzleZPosition.at(current_body_state)) / 40.0f};
-
-		calculateVisionToTerrain(state, battle, map, eyesPos);
-		calculateVisionToUnits(state, battle, map, eyesPos);
+		if (!targetUnit)
+		{
+			if (!forceBlind)
+			{
+				calculateVisionToTerrain(state, battle, map, eyesPos);
+				calculateVisionToUnits(state, battle, map, eyesPos);
+			}
+		}
+		else
+		{
+			visibleUnits = lastVisibleUnits;
+			if (!forceBlind && calculateVisionToUnit(state, battle, map, eyesPos, *targetUnit))
+			{
+				if (visibleUnits.find(targetUnit) == visibleUnits.end())
+				{
+					visibleUnits.insert(targetUnit);
+				}
+			}
+			else
+			{
+				if (visibleUnits.find(targetUnit) != visibleUnits.end())
+				{
+					visibleUnits.erase(targetUnit);
+				}
+			}
+		}
 	}
 
 	// Add newly visible units to owner's list and enemy list
@@ -424,10 +556,10 @@ void BattleUnit::refreshUnitVision(GameState &state, bool forceBlind)
 	}
 }
 
-void BattleUnit::refreshUnitVisibilityAndVision(GameState &state, Vec3<float> oldPosition)
+void BattleUnit::refreshUnitVisibilityAndVision(GameState &state)
 {
 	refreshUnitVision(state);
-	refreshUnitVisibility(state, oldPosition);
+	refreshUnitVisibility(state);
 }
 
 void BattleUnit::resetGoal()
@@ -437,6 +569,98 @@ void BattleUnit::resetGoal()
 	atGoal = true;
 }
 
+void BattleUnit::onReachGoal(GameState & state)
+{
+	// Remember who seen us before (for interrupt)
+	std::set<StateRef<BattleUnit>> enemiesThatSeenUsBefore;
+	if (state.current_battle->mode == Battle::Mode::TurnBased)
+	{
+		auto srthis = StateRef<BattleUnit>(&state, id);
+		for (auto &u : state.current_battle->units)
+		{
+			if (u.second->visibleEnemies.find(srthis) != u.second->visibleEnemies.end())
+			{
+				enemiesThatSeenUsBefore.insert(srthis);
+			}
+		}
+	}
+	refreshUnitVisibilityAndVision(state);
+	// Interrupt
+	if (state.current_battle->mode == Battle::Mode::TurnBased)
+	{
+		auto srthis = StateRef<BattleUnit>(&state, id);
+		for (auto &u : state.current_battle->units)
+		{
+			if (u.second->visibleEnemies.find(srthis) != u.second->visibleEnemies.end())
+			{
+				//Mutual surprise rule: unit can interrupt us only if 
+				// - he has seen us before
+				// - we don't see him now
+				if (enemiesThatSeenUsBefore.find({ &state, u.first }) != enemiesThatSeenUsBefore.end() || visibleEnemies.find({ &state, u.first }) == visibleEnemies.end())
+				{
+					state.current_battle->giveInterruptChanceToUnit({ &state, u.first }, agent->getReactionValue());
+				}
+			}
+		}
+	}
+}
+
+int BattleUnit::getAttackCost(GameState & state, AEquipment& item, Vec3<int> tile)
+{
+	static const std::map<Vec2<int>, int> facing_dir_map = {
+		{ { 0, -1 }, 0 },{ { 1, -1 }, 1 },{ { 1, 0 }, 2 },{ { 1, 1 }, 3 },
+		{ { 0, 1 }, 4 },{ { -1, 1 }, 5 },{ { -1, 0 }, 6 },{ { -1, -1 }, 7 } };
+	static const std::map<int, Vec2<int>> dir_facing_map = {
+		{ 0,{ 0, -1 } },{ 1,{ 1, -1 } },{ 2,{ 1, 0 } },{ 3,{ 1, 1 } },
+		{ 4,{ 0, 1 } },{ 5,{ -1, 1 } },{ 6,{ -1, 0 } },{ 7,{ -1, -1 } } };
+
+	int totalCost = 0;
+
+	// Step 1: Turning cost
+
+	auto targetFacing = BattleUnitMission::getFacing(*this, tile);
+	bool turning = goalFacing != targetFacing;
+	if (turning)
+	{
+		int curFacing = facing_dir_map.at(goalFacing);
+		int tarFacing = facing_dir_map.at(targetFacing);
+		if (tarFacing > 7)
+			tarFacing -= 8;
+
+		int clockwiseDistance = tarFacing - curFacing;
+		if (clockwiseDistance < 0)
+		{
+			clockwiseDistance += 8;
+		}
+		int counterClockwiseDistance = curFacing - tarFacing;
+		if (counterClockwiseDistance < 0)
+		{
+			counterClockwiseDistance += 8;
+		}
+		totalCost = std::min(clockwiseDistance, counterClockwiseDistance) * BattleUnitMission::getTurnCost(*this);
+	}
+
+	// Step 2: Body state change cost
+
+	if (turning)
+	{
+		if (target_body_state == BodyState::Prone)
+		{
+			totalCost += BattleUnitMission::getBodyStateChangeCost(*this, BodyState::Prone, BodyState::Kneeling);
+		}
+		if (movement_mode == MovementMode::Prone && kneeling_mode == KneelingMode::None)
+		{
+			totalCost += BattleUnitMission::getBodyStateChangeCost(*this, BodyState::Kneeling, BodyState::Prone);
+		}
+	}
+
+	// Step 3: Actual cost to fire the weapon
+
+	totalCost += item.getFireCost(fire_aiming_mode, initialTU);
+
+	return totalCost;
+}
+
 void BattleUnit::setFocus(GameState &state, StateRef<BattleUnit> unit)
 {
 	StateRef<BattleUnit> sru = {&state, id};
@@ -457,76 +681,91 @@ void BattleUnit::setFocus(GameState &state, StateRef<BattleUnit> unit)
 	focusUnit->focusedByUnits.push_back(sru);
 }
 
-void BattleUnit::startAttacking(GameState &state, WeaponStatus status)
+bool BattleUnit::startAttacking(GameState &state, WeaponStatus status)
 {
 	switch (state.current_battle->mode)
 	{
 		case Battle::Mode::TurnBased:
-			// In Turn based we cannot override firing
-			if (isAttacking())
-			{
-				return;
-			}
-			// In Turn based we cannot fire both hands
-			if (status == WeaponStatus::FiringBothHands)
+		{
+			if (moraleState == MoraleState::Normal)
 			{
-				// Right hand has priority
-				auto rhItem = agent->getFirstItemInSlot(AEquipmentSlotType::RightHand);
-				if (rhItem && rhItem->canFire())
+				// In Turn based we cannot fire both hands (unless zerking)
+				if (status == WeaponStatus::FiringBothHands)
 				{
-					status = WeaponStatus::FiringRightHand;
+					// Right hand has priority
+					auto rhItem = agent->getFirstItemInSlot(AEquipmentSlotType::RightHand);
+					if (rhItem && rhItem->canFire())
+					{
+						status = WeaponStatus::FiringRightHand;
+					}
+					else
+					{
+						// We don't care what's in the left hand,
+						// we will just cancel firing in update() if there's nothing to fire
+						status = WeaponStatus::FiringLeftHand;
+					}
 				}
-				else
+				// Check TU
+				auto weapon = (status == WeaponStatus::FiringRightHand) ? agent->getFirstItemInSlot(AEquipmentSlotType::RightHand) : agent->getFirstItemInSlot(AEquipmentSlotType::LeftHand);
+				if (weapon && !canAfford(state, getAttackCost(state, *weapon, targetTile), true, true))
 				{
-					// We don't care what's in the left hand,
-					// we will just cancel firing in update() if there's nothing to fire
-					status = WeaponStatus::FiringLeftHand;
+					return false;
 				}
 			}
 			break;
+		}
 		case Battle::Mode::RealTime:
+		{
 			// Start firing both hands if added one hand to another
 			if ((weaponStatus == WeaponStatus::FiringLeftHand &&
-			     status == WeaponStatus::FiringRightHand) ||
-			    (weaponStatus == WeaponStatus::FiringRightHand &&
-			     status == WeaponStatus::FiringLeftHand))
+				status == WeaponStatus::FiringRightHand) ||
+				(weaponStatus == WeaponStatus::FiringRightHand &&
+					status == WeaponStatus::FiringLeftHand))
 			{
 				status = WeaponStatus::FiringBothHands;
 			}
 			break;
+		}
 	}
 
 	weaponStatus = status;
 	ticksUntillNextTargetCheck = 0;
 	timesTargetMIA = 0;
+	return true;
 }
 
-void BattleUnit::startAttacking(GameState &state, StateRef<BattleUnit> unit, WeaponStatus status)
+bool BattleUnit::startAttacking(GameState &state, StateRef<BattleUnit> unit, WeaponStatus status)
 {
+	// Attack on a unit that is downed is replaced with an attack on the occupied tile's ground
+	if (!unit->isConscious())
+	{
+		return startAttacking(state, unit->tileObject->getVoxelCentrePosition(), status, true);
+	}
 	// Attack on a friendly unit is replaced with an attack on the occupied tile's center
 	if (unit->owner == owner)
 	{
-		startAttacking(state, unit->tileObject->getVoxelCentrePosition(), status);
-		return;
+		return startAttacking(state, unit->tileObject->getVoxelCentrePosition(), status);
 	}
-	// Attack on a unit that is downed is replaced with an attack on the occupied tile's ground
-	if (!unit->isConscious())
+	targetTile = unit->position;
+	if (!startAttacking(state, status))
 	{
-		startAttacking(state, unit->tileObject->getVoxelCentrePosition(), status, true);
-		return;
+		return false;
 	}
-	startAttacking(state, status);
 	targetUnit = unit;
-	targetTile = unit->position;
 	targetingMode = TargetingMode::Unit;
+	return true;
 }
 
-void BattleUnit::startAttacking(GameState &state, Vec3<int> tile, WeaponStatus status,
+bool BattleUnit::startAttacking(GameState &state, Vec3<int> tile, WeaponStatus status,
                                 bool atGround)
 {
-	startAttacking(state, status);
 	targetTile = tile;
+	if (!startAttacking(state, status))
+	{
+		return false;
+	}
 	targetingMode = atGround ? TargetingMode::TileGround : TargetingMode::TileCenter;
+	return true;
 }
 
 void BattleUnit::stopAttacking()
@@ -537,21 +776,22 @@ void BattleUnit::stopAttacking()
 	ticksUntillNextTargetCheck = 0;
 }
 
-WeaponStatus BattleUnit::canAttackUnit(sp<BattleUnit> unit)
+WeaponStatus BattleUnit::canAttackUnit(GameState &state, sp<BattleUnit> unit)
 {
-	return canAttackUnit(unit, agent->getFirstItemInSlot(AEquipmentSlotType::RightHand),
+	return canAttackUnit(state, unit, agent->getFirstItemInSlot(AEquipmentSlotType::RightHand),
 	                     agent->getFirstItemInSlot(AEquipmentSlotType::LeftHand));
 }
 
-WeaponStatus BattleUnit::canAttackUnit(sp<BattleUnit> unit, sp<AEquipment> rightHand,
+WeaponStatus BattleUnit::canAttackUnit(GameState &state, sp<BattleUnit> unit, sp<AEquipment> rightHand,
                                        sp<AEquipment> leftHand)
 {
+	bool realTime = state.current_battle->mode == Battle::Mode::RealTime;
 	auto targetPosition = unit->tileObject->getVoxelCentrePosition();
 	if (hasLineToUnit(unit))
 	{
 		// One of held weapons is in range
-		bool rightCanFire = rightHand && rightHand->canFire(targetPosition);
-		bool leftCanFire = leftHand && leftHand->canFire(targetPosition);
+		bool rightCanFire = rightHand && rightHand->canFire(targetPosition) && (realTime || canAfford(state, getAttackCost(state, *rightHand, unit->position), true, true));
+		bool leftCanFire = leftHand && leftHand->canFire(targetPosition) && (realTime || canAfford(state, getAttackCost(state, *leftHand, unit->position), true, true));
 		if (rightCanFire && leftCanFire)
 		{
 			return WeaponStatus::FiringBothHands;
@@ -665,6 +905,7 @@ int BattleUnit::getPsiChance(StateRef<BattleUnit> target, PsiStatus status,
 bool BattleUnit::startAttackPsi(GameState &state, StateRef<BattleUnit> target, PsiStatus status,
                                 StateRef<AEquipmentType> item)
 {
+	bool realTime = state.current_battle->mode == Battle::Mode::RealTime;
  	if (agent->modified_stats.psi_energy < getPsiCost(status))
 	{
 		return false;
@@ -674,6 +915,10 @@ bool BattleUnit::startAttackPsi(GameState &state, StateRef<BattleUnit> target, P
 	if (success)
 	{
 		fw().soundBackend->playSample(listRandomiser(state.rng, *psiSuccessSounds), position);
+		if (!realTime)
+		{
+			psiTarget->applyPsiAttack(state, *this, psiStatus, psiItem, false);
+		}
 		return true;
 	}
 	else
@@ -793,37 +1038,108 @@ void BattleUnit::changeOwner(GameState &state, StateRef<Organisation> newOwner)
 	removeFromSquad(*state.current_battle);
 	owner = newOwner;
 	assignToSquad(*state.current_battle);
-	refreshUnitVisibilityAndVision(state, position);
+	refreshUnitVisibilityAndVision(state);
+}
+
+void BattleUnit::setReserveShotMode(ReserveShotMode mode)
+{
+	reserve_shot_mode = mode;
+	refreshReserveCost();
+}
+
+void BattleUnit::setReserveKneelMode(KneelingMode mode)
+{
+	if (!agent->isBodyStateAllowed(BodyState::Kneeling))
+	{
+		mode = KneelingMode::None;
+	}
+	reserve_kneel_mode = mode;
+}
+
+void BattleUnit::refreshReserveCost()
+{
+	reserveShotCost = 0;
+	if (reserve_shot_mode == ReserveShotMode::None)
+	{
+		return;
+	}
+	auto e1 = agent->getFirstItemInSlot(AEquipmentSlotType::RightHand);
+	auto e2 = agent->getFirstItemInSlot(AEquipmentSlotType::LeftHand);
+	auto weapon = e1 && e1->canFire() ? e1 : (e2 && e2->canFire() ? e2 : nullptr);
+	if (weapon)
+	{
+		reserveShotCost = weapon->getFireCost((WeaponAimingMode)reserve_shot_mode, initialTU);
+	}
 }
 
-bool BattleUnit::canAfford(GameState &state, int cost) const
+bool BattleUnit::canAfford(GameState &state, int cost, bool ignoreKneelReserve, bool ignoreShootReserve) const
 {
-	if (state.current_battle->mode == Battle::Mode::RealTime)
+	if (state.current_battle->mode == Battle::Mode::RealTime || !isConscious())
 	{
 		return true;
 	}
+	// When not our turn we ignore reserve setting anyway
+	ignoreKneelReserve = ignoreKneelReserve || state.current_battle->currentActiveOrganisation != owner;
+	ignoreShootReserve = ignoreShootReserve || state.current_battle->currentActiveOrganisation != owner;
+	if (!ignoreKneelReserve && reserve_kneel_mode != KneelingMode::None)
+	{
+		cost += BattleUnitMission::getBodyStateChangeCost(*this, BodyState::Standing, BodyState::Kneeling);
+	}
+	if (!ignoreShootReserve && reserve_shot_mode != ReserveShotMode::None)
+	{
+		cost += reserveShotCost;
+	} 
 	return agent->modified_stats.time_units >= cost;
 }
 
-bool BattleUnit::spendTU(GameState &state, int cost)
+bool BattleUnit::spendTU(GameState &state, int cost, bool ignoreKneelReserve, bool ignoreShootReserve, bool allowInterrupt)
 {
-	if (state.current_battle->mode == Battle::Mode::RealTime)
+	if (state.current_battle->mode == Battle::Mode::RealTime || !isConscious())
 	{
 		return true;
 	}
-	if (cost > agent->modified_stats.time_units)
+	if (!canAfford(state, cost, ignoreKneelReserve, ignoreShootReserve))
 	{
 		return false;
 	}
 	agent->modified_stats.time_units -= cost;
+	state.current_battle->ticksWithoutAction = 0;
+	// If doing any action other than moving that triggers reaction, we give interrupt chance here
+	// If moving we do not give it here, and instead give interrupt chance when changing tiles
+	if (allowInterrupt)
+	{
+		state.current_battle->giveInterruptChanceToUnits(state, { &state, id }, agent->getReactionValue());
+	}
 	return true;
 }
 
-int BattleUnit::getThrowCost() { return agent->current_stats.time_units * 18 / 100; }
+void BattleUnit::spendRemainingTU(GameState &state, bool allowInterrupt)
+{
+	agent->modified_stats.time_units = 0;
+	if (allowInterrupt)
+	{
+		state.current_battle->giveInterruptChanceToUnits(state, { &state, id }, agent->getReactionValue());
+	}
+}
+
+int BattleUnit::getThrowCost() const { return initialTU * 18 / 100; }
+
+int BattleUnit::getMedikitCost() const { return initialTU * 375 / 1000; }
 
-int BattleUnit::getMedikitCost() { return agent->current_stats.time_units * 375 / 1000; }
+int BattleUnit::getMotionScannerCost() const { return initialTU * 10 / 100; }
 
-int BattleUnit::getMotionScannerCost() { return agent->current_stats.time_units * 10 / 100; }
+int BattleUnit::getTeleporterCost() const { return initialTU * 55 / 100; }
+
+void BattleUnit::beginTurn(GameState & state)
+{
+	tilesMoved = 0;
+	agent->modified_stats.restoreTU();
+	initialTU = agent->modified_stats.time_units;
+	if (!missions.empty() && missions.front()->type == BattleUnitMission::Type::AcquireTU)
+	{
+		missions.front()->allowContinue = true;
+	}
+}
 
 int BattleUnit::getMaxHealth() const { return this->agent->current_stats.health; }
 
@@ -875,7 +1191,7 @@ bool BattleUnit::isStatic() const
 
 bool BattleUnit::isBusy() const
 {
-	return !missions.empty() || !visibleEnemies.empty() || isAttacking();
+	return !missions.empty() || isAttacking() || (getAIType()!=AIType::Civilian && getAIType()!=AIType::None && !visibleEnemies.empty());
 }
 
 bool BattleUnit::isAttacking() const { return weaponStatus != WeaponStatus::NotFiring; }
@@ -1163,6 +1479,7 @@ bool BattleUnit::applyDamage(GameState &state, int power, StateRef<DamageType> d
 	{
 		enzymeDebuffIntensity += power * 2;
 		enzymeDebuffTicksAccumulated = 0;
+		applyEnzymeEffect(state);
 	}
 
 	// Find out armor type
@@ -1317,6 +1634,8 @@ bool BattleUnit::handleCollision(GameState &state, Collision &c)
 
 void BattleUnit::updateStateAndStats(GameState &state, unsigned int ticks)
 {
+	bool realTime = state.current_battle->mode == Battle::Mode::RealTime;
+
 	if (isDead())
 	{
 		return;
@@ -1350,7 +1669,7 @@ void BattleUnit::updateStateAndStats(GameState &state, unsigned int ticks)
 	}
 
 	// Morale
-	if (isConscious())
+	if ((realTime || owner == state.current_battle->currentActiveOrganisation) && isConscious())
 	{
 		if (moraleStateTicksRemaining > 0)
 		{
@@ -1473,12 +1792,6 @@ void BattleUnit::updateStateAndStats(GameState &state, unsigned int ticks)
 		}
 	} // End of Fatal Wounds and Healing
 
-	// Turn off Jetpacks
-	if (current_body_state != BodyState::Flying)
-	{
-		flyingSpeedModifier = 0;
-	}
-
 	// Process enzyme
 	if (enzymeDebuffIntensity > 0)
 	{
@@ -1487,39 +1800,7 @@ void BattleUnit::updateStateAndStats(GameState &state, unsigned int ticks)
 		{
 			enzymeDebuffTicksAccumulated -= TICKS_PER_ENZYME_EFFECT;
 
-			// Spawn smoke
-			// FIXME: Ensure this is proper, for now just emulating vanilla crudely
-			// This makes smoke spawned by enzyme grow smaller when debuff runs out
-			int divisor = std::max(1, 36 / enzymeDebuffIntensity);
-			StateRef<DamageType> smokeDamageType = {&state, "DAMAGETYPE_SMOKE"};
-			// Power of 0 means no spread
-			state.current_battle->placeHazard(state, smokeDamageType, position,
-			                                  smokeDamageType->hazardType->getLifetime(state), 0,
-			                                  divisor, false);
-
-			// Damage random item
-			if (agent->type->inventory && !agent->equipment.empty())
-			{
-				auto item = listRandomiser(state.rng, agent->equipment);
-				item->armor -= enzymeDebuffIntensity / 2;
-
-				// Item destroyed
-				if (item->armor <= 0)
-				{
-					if (item->type->type == AEquipmentType::Type::Grenade)
-					{
-						item->explode(state);
-					}
-					else
-					{
-						agent->removeEquipment(item);
-					}
-				}
-			}
-
-			// Finally, reduce debuff
-
-			enzymeDebuffIntensity--;
+			applyEnzymeEffect(state);
 		}
 	}
 
@@ -1541,12 +1822,6 @@ void BattleUnit::updateStateAndStats(GameState &state, unsigned int ticks)
 			fireDebuffTicksRemaining -= TICKS_PER_FIRE_EFFECT;
 		}
 	}
-
-	// Remove headcrab
-	if (brainSucker && !brainSucker->isConscious())
-	{
-		brainSucker.clear();
-	}
 }
 
 void BattleUnit::updateEvents(GameState &state)
@@ -1652,6 +1927,8 @@ void BattleUnit::updateEvents(GameState &state)
 
 void BattleUnit::updateIdling(GameState &state)
 {
+	bool realTime = state.current_battle->mode == Battle::Mode::RealTime;
+
 	// Idling check
 	if (missions.empty() && isConscious())
 	{
@@ -1668,64 +1945,70 @@ void BattleUnit::updateIdling(GameState &state)
 		// Reach goal before everything else
 		if (!atGoal)
 		{
-			addMission(state, BattleUnitMission::Type::ReachGoal);
+			// The only way unit can suddenly become not at goal when idling is if either 
+			// map part died under him, or dirt fell from above on him
+			// Either way, moving to goal is not the correct way to solve this
+			startFalling(state);
 		}
-		else
+		else if (realTime ||
+			(state.current_battle->interruptQueue.empty()
+				&& (owner == state.current_battle->currentActiveOrganisation
+					|| state.current_battle->interruptUnits.find({ &state, id }) != state.current_battle->interruptUnits.end())))
 		{
 			// Kneel if not kneeling and should kneel
 			if (kneeling_mode == KneelingMode::Kneeling &&
-			    current_body_state != BodyState::Kneeling && canKneel() &&
-			    canAfford(state, BattleUnitMission::getBodyStateChangeCost(*this, target_body_state,
-			                                                               BodyState::Kneeling)))
+				current_body_state != BodyState::Kneeling && canKneel() &&
+				canAfford(state, BattleUnitMission::getBodyStateChangeCost(*this, target_body_state,
+					BodyState::Kneeling), true))
 			{
 				setMission(state, BattleUnitMission::changeStance(*this, BodyState::Kneeling));
 			}
 			// Go prone if not prone and should stay prone
 			else if (movement_mode == MovementMode::Prone &&
-			         current_body_state != BodyState::Prone &&
-			         kneeling_mode != KneelingMode::Kneeling && canProne(position, facing) &&
-			         canAfford(state, BattleUnitMission::getBodyStateChangeCost(
-			                              *this, target_body_state, BodyState::Prone)))
+				current_body_state != BodyState::Prone &&
+				kneeling_mode != KneelingMode::Kneeling && canProne(position, facing) &&
+				canAfford(state, BattleUnitMission::getBodyStateChangeCost(
+					*this, target_body_state, BodyState::Prone)))
 			{
 				setMission(state, BattleUnitMission::changeStance(*this, BodyState::Prone));
 			}
 			// Stand up if not standing up and should stand up
 			else if ((movement_mode == MovementMode::Walking ||
-			          movement_mode == MovementMode::Running) &&
-			         kneeling_mode != KneelingMode::Kneeling &&
-			         current_body_state != BodyState::Standing &&
-			         current_body_state != BodyState::Flying)
+				movement_mode == MovementMode::Running) &&
+				kneeling_mode != KneelingMode::Kneeling &&
+				current_body_state != BodyState::Standing &&
+				current_body_state != BodyState::Flying)
 			{
 				if (agent->isBodyStateAllowed(BodyState::Standing))
 				{
 					if (canAfford(state, BattleUnitMission::getBodyStateChangeCost(
-					                         *this, target_body_state, BodyState::Standing)))
+						*this, target_body_state, BodyState::Standing)))
 					{
 						setMission(state,
-						           BattleUnitMission::changeStance(*this, BodyState::Standing));
+							BattleUnitMission::changeStance(*this, BodyState::Standing));
 					}
 				}
 				else if (agent->isBodyStateAllowed(BodyState::Flying))
 				{
 					if (canAfford(state, BattleUnitMission::getBodyStateChangeCost(
-					                         *this, target_body_state, BodyState::Flying)))
+						*this, target_body_state, BodyState::Flying)))
 					{
 						setMission(state,
-						           BattleUnitMission::changeStance(*this, BodyState::Flying));
+							BattleUnitMission::changeStance(*this, BodyState::Flying));
 					}
 				}
 				else
 				{
 					LogError("Hmm? Agent ordered to move walking without a standing/flying valid "
-					         "body state?");
+						"body state?");
 				}
 			}
 			// Stop flying if we can stand
 			else if (current_body_state == BodyState::Flying &&
-			         tileObject->getOwningTile()->getCanStand(isLarge()) &&
-			         agent->isBodyStateAllowed(BodyState::Standing) &&
-			         canAfford(state, BattleUnitMission::getBodyStateChangeCost(
-			                              *this, target_body_state, BodyState::Standing)))
+				tileObject->getOwningTile()->getCanStand(isLarge()) &&
+				agent->isBodyStateAllowed(BodyState::Standing) &&
+				canAfford(state, BattleUnitMission::getBodyStateChangeCost(
+					*this, target_body_state, BodyState::Standing)))
 			{
 				setMission(state, BattleUnitMission::changeStance(*this, BodyState::Standing));
 			}
@@ -1755,6 +2038,10 @@ void BattleUnit::updateIdling(GameState &state)
 
 void BattleUnit::updateCheckBeginFalling(GameState &state)
 {
+	if (retreated)
+	{
+		return;
+	}
 	if (current_movement_state == MovementState::Brainsuck)
 	{
 		return;
@@ -1789,7 +2076,7 @@ void BattleUnit::updateCheckBeginFalling(GameState &state)
 			// If not flying and has no support - fall!
 			if (!hasSupport && !canFly())
 			{
-				startFalling();
+				startFalling(state);
 			}
 			// If flying and not supported both on current and goal locations - start flying
 			// Note: Throwing units can "hover" in standing body state
@@ -1811,6 +2098,10 @@ void BattleUnit::updateCheckBeginFalling(GameState &state)
 
 void BattleUnit::updateBody(GameState &state, unsigned int &bodyTicksRemaining)
 {
+	if (retreated)
+	{
+		return;
+	}
 	if (bodyTicksRemaining > 0)
 	{
 		if (body_animation_ticks_remaining > bodyTicksRemaining)
@@ -1846,7 +2137,7 @@ void BattleUnit::updateBody(GameState &state, unsigned int &bodyTicksRemaining)
 	}
 }
 
-bool BattleUnit::updateMovementFalling(GameState &state, unsigned int &moveTicksRemaining, bool &)
+void BattleUnit::updateMovementFalling(GameState &state, unsigned int &moveTicksRemaining, bool &)
 {
 	// Falling consumes remaining move ticks
 	auto fallTicksRemaining = moveTicksRemaining / (agent->modified_stats.getMovementSpeed() *
@@ -1945,6 +2236,7 @@ bool BattleUnit::updateMovementFalling(GameState &state, unsigned int &moveTicks
 					{
 						int facingDelta = BattleUnitMission::getFacingDelta(facing, unit->facing);
 						cancelMissions(state, true);
+						spendRemainingTU(state, true);
 						setMission(state, BattleUnitMission::brainsuck(*this, {&state, unit->id},
 						                                               facingDelta));
 					}
@@ -1985,7 +2277,7 @@ bool BattleUnit::updateMovementFalling(GameState &state, unsigned int &moveTicks
 			LogError("Unit at %f %f fell off the end of the world!?", newPosition.x, newPosition.y);
 			die(state, false);
 			destroyed = true;
-			return true;
+			return;
 		}
 		// Jump goal reached
 		if (launched)
@@ -2007,8 +2299,8 @@ bool BattleUnit::updateMovementFalling(GameState &state, unsigned int &moveTicks
 				launched = false;
 			}
 		}
-
-		setPosition(state, newPosition);
+		bool movedTiles = (Vec3<int>)position != (Vec3<int>)newPosition;
+		setPosition(state, newPosition, movedTiles);
 		triggerProximity(state);
 	}
 
@@ -2030,12 +2322,12 @@ bool BattleUnit::updateMovementFalling(GameState &state, unsigned int &moveTicks
 			if (!isConscious())
 			{
 				// Bodies drop to the exact spot they fell upon
-				setPosition(state, {position.x, position.y, restingPosition.z});
+				setPosition(state, {position.x, position.y, restingPosition.z}, true);
 			}
 			else
 			{
 				// Conscious units drop to resting position
-				setPosition(state, restingPosition);
+				setPosition(state, restingPosition, true);
 			}
 			resetGoal();
 			// FIXME: Deal fall damage before nullifying this
@@ -2043,10 +2335,10 @@ bool BattleUnit::updateMovementFalling(GameState &state, unsigned int &moveTicks
 			velocity = {0.0f, 0.0f, 0.0f};
 		}
 	}
-	return false;
+	return;
 }
 
-bool BattleUnit::updateMovementNormal(GameState &state, unsigned int &moveTicksRemaining,
+void BattleUnit::updateMovementNormal(GameState &state, unsigned int &moveTicksRemaining,
                                       bool &wasUsingLift)
 {
 	// We are moving and not falling
@@ -2124,13 +2416,13 @@ bool BattleUnit::updateMovementNormal(GameState &state, unsigned int &moveTicksR
 					                                distanceToGoal / FLYING_ACCELERATION_DIVISOR);
 				}
 				moveTicksRemaining -= distanceToGoal * moveTicksConsumeRate;
-				setPosition(state, goalPosition);
+				setPosition(state, goalPosition, true);
 				triggerProximity(state);
-				goalPosition = getPosition();
+				goalPosition = position;
 			}
 			if (getNewGoal(state))
 			{
-				return true;
+				return;
 			}
 		}
 
@@ -2183,14 +2475,14 @@ bool BattleUnit::updateMovementNormal(GameState &state, unsigned int &moveTicksR
 		{
 			if (getNewGoal(state))
 			{
-				return true;
+				return;
 			}
 		}
 	}
-	return false;
+	return;
 }
 
-bool BattleUnit::updateMovementBrainsucker(GameState &state, unsigned int &moveTicksRemaining,
+void BattleUnit::updateMovementBrainsucker(GameState &state, unsigned int &moveTicksRemaining,
 	bool &wasUsingLift)
 {
 	Vec3<float> nextGoal;
@@ -2201,18 +2493,19 @@ bool BattleUnit::updateMovementBrainsucker(GameState &state, unsigned int &moveT
 		// Just increment ticks passed to play animation
 		movement_ticks_passed += moveTicksRemaining / BASE_MOVETICKS_CONSUMPTION_RATE;
 		moveTicksRemaining = 0;
-		setPosition(state, goalPosition);
+		bool movedTiles = (Vec3<int>)position != (Vec3<int>)goalPosition;
+		setPosition(state, goalPosition, movedTiles);
 		atGoal = true;
 	}
 	else
 	{
 		resetGoal();
-		startFalling();
+		startFalling(state);
 	}
-	return false;
+	return;
 }
 
-bool BattleUnit::updateMovementJumping(GameState &state, unsigned int &moveTicksRemaining,
+void BattleUnit::updateMovementJumping(GameState &state, unsigned int &moveTicksRemaining,
 	bool &wasUsingLift)
 {
 	// Check if jump complete
@@ -2221,7 +2514,8 @@ bool BattleUnit::updateMovementJumping(GameState &state, unsigned int &moveTicks
 		// Jump complete, await body state change
 		if (position.z <= goalPosition.z && velocity.z < 0.0f)
 		{
-			return getNewGoal(state);
+			getNewGoal(state);
+			return;
 		}
 	}
 	// Launch us in the air
@@ -2249,14 +2543,24 @@ bool BattleUnit::updateMovementJumping(GameState &state, unsigned int &moveTicks
 		newPosition += this->velocity / (float)TICK_SCALE / VELOCITY_SCALE_BATTLE;
 	}
 	setPosition(state, newPosition);
-	return false;
+	return;
 }
 
-bool BattleUnit::updateMovement(GameState &state, unsigned int &moveTicksRemaining,
+void BattleUnit::updateMovement(GameState &state, unsigned int &moveTicksRemaining,
                                 bool &wasUsingLift)
 {
+	if (retreated)
+	{
+		return;
+	}
 	if (moveTicksRemaining > 0)
 	{
+		// Turn off Jetpacks
+		if (current_body_state != BodyState::Flying)
+		{
+			flyingSpeedModifier = 0;
+		}
+
 		// If falling then process falling
 		if (falling)
 		{
@@ -2276,11 +2580,15 @@ bool BattleUnit::updateMovement(GameState &state, unsigned int &moveTicksRemaini
 			return updateMovementNormal(state, moveTicksRemaining, wasUsingLift);
 		}
 	}
-	return false;
+	return;
 }
 
 void BattleUnit::updateHands(GameState &, unsigned int &handsTicksRemaining)
 {
+	if (retreated)
+	{
+		return;
+	}
 	if (handsTicksRemaining > 0)
 	{
 		if (firing_animation_ticks_remaining > 0)
@@ -2326,7 +2634,10 @@ void BattleUnit::updateHands(GameState &, unsigned int &handsTicksRemaining)
 
 void BattleUnit::updateTurning(GameState &state, unsigned int &turnTicksRemaining, unsigned int const handsTicksRemaining)
 {
-	// Try turning
+	if (retreated)
+	{
+		return;
+	}
 	if (turnTicksRemaining > 0)
 	{
 		// If firing then consume turning ticks since we can't turn while firing
@@ -2407,6 +2718,10 @@ void BattleUnit::updateDisplayedItem()
 			setHandState(HandState::AtEase);
 		}
 	}
+	if (displayedItem != lastDisplayedItem)
+	{
+		refreshReserveCost();
+	}
 }
 
 bool BattleUnit::updateAttackingRunCanFireChecks(GameState &state, unsigned int ticks,
@@ -2524,9 +2839,15 @@ bool BattleUnit::updateAttackingRunCanFireChecks(GameState &state, unsigned int
 
 void BattleUnit::updateAttacking(GameState &state, unsigned int ticks)
 {
+	bool realTime = state.current_battle->mode == Battle::Mode::RealTime;
 	// Process attacking
 	if (isAttacking())
 	{
+		// Cancel acquire TU mission if attempting to attack
+		if (!missions.empty() && missions.front()->type == BattleUnitMission::Type::AcquireTU)
+		{
+			cancelMissions(state);
+		}
 		// Prepare all needed positions
 		static const Vec3<float> offsetTile = {0.5f, 0.5f, 0.0f};
 		static const Vec3<float> offsetTileGround = {0.5f, 0.5f, 10.0f / 40.0f};
@@ -2623,11 +2944,11 @@ void BattleUnit::updateAttacking(GameState &state, unsigned int ticks)
 			{
 				if (weaponRight && !weaponRight->isFiring())
 				{
-					weaponRight->startFiring(fire_aiming_mode);
+					weaponRight->startFiring(fire_aiming_mode, !realTime);
 				}
 				if (weaponLeft && !weaponLeft->isFiring())
 				{
-					weaponLeft->startFiring(fire_aiming_mode);
+					weaponLeft->startFiring(fire_aiming_mode, !realTime);
 				}
 			}
 
@@ -2666,7 +2987,7 @@ void BattleUnit::updateAttacking(GameState &state, unsigned int ticks)
 								timesTargetMIA = 1;
 							}
 						}
-						else
+						else if(realTime || spendTU(state, getAttackCost(state, *firingWeapon, targetTile), true, true, true))
 						{
 							firingWeapon->fire(state, targetPosition,
 							                   targetingMode == TargetingMode::Unit ? targetUnit
@@ -2678,14 +2999,18 @@ void BattleUnit::updateAttacking(GameState &state, unsigned int ticks)
 							setHandState(HandState::Firing);
 							weaponFired = true;
 						}
+						else
+						{
+							stopAttacking();
+						}
 					}
 				}
 			}
 
-			// If fired weapon at ground - stop firing that hand
-			// (unless zerking, in which case go on)
-			if (weaponFired && moraleState != MoraleState::Berserk &&
-			    targetingMode != TargetingMode::Unit)
+			// Cancel firing (unless zerking):
+			// - If turn based
+			// - If fired weapon at ground - stop firing that hand
+			if (weaponFired && moraleState != MoraleState::Berserk && (!realTime || targetingMode != TargetingMode::Unit))
 			{
 				switch (weaponStatus)
 				{
@@ -2747,6 +3072,7 @@ void BattleUnit::updateAttacking(GameState &state, unsigned int ticks)
 
 void BattleUnit::updatePsi(GameState &state, unsigned int ticks)
 {
+	bool realTime = state.current_battle->mode == Battle::Mode::RealTime;
 	if (psiStatus != PsiStatus::NotEngaged)
 	{
 		auto e1 = agent->getFirstItemInSlot(AEquipmentSlotType::RightHand);
@@ -2764,7 +3090,7 @@ void BattleUnit::updatePsi(GameState &state, unsigned int ticks)
 		{
 			stopAttackPsi(state);
 		}
-		else
+		else if (realTime)
 		{
 			ticksAccumulatedToNextPsiCheck += ticks;
 			while (ticksAccumulatedToNextPsiCheck >= TICKS_PER_PSI_CHECK)
@@ -2791,25 +3117,7 @@ void BattleUnit::updateAI(GameState &state, unsigned int)
 	{
 		return;
 	}
-	// Check that unit is allowed to act now
-	switch (state.current_battle->mode)
-	{
-		case Battle::Mode::TurnBased:
-		{
-			// FIXME: Implement TB AI properly, implement interrupts
-			if (owner != state.current_battle->currentActiveOrganisation)
-			{
-				return;
-			}
-			break;
-		}
-		case Battle::Mode::RealTime:
-		{
-			// in RT the AI is always active?
-			break;
-		}
-	}
-
+	
 	// Decide
 	auto decision = aiList.think(state, *this);
 	if (!decision.isEmpty())
@@ -2821,6 +3129,8 @@ void BattleUnit::updateAI(GameState &state, unsigned int)
 
 void BattleUnit::update(GameState &state, unsigned int ticks)
 {
+	bool realTime = state.current_battle->mode == Battle::Mode::RealTime;
+
 	// Animate
 	body_animation_ticks_static += ticks;
 
@@ -2840,8 +3150,11 @@ void BattleUnit::update(GameState &state, unsigned int ticks)
 
 	// Update the unit
 
-	// Miscellaneous state updates, as well as unit's stats
-	updateStateAndStats(state, ticks);
+	if (realTime)
+	{
+		// Miscellaneous state updates, as well as unit's stats
+		updateStateAndStats(state, ticks);
+	}
 	// Unit events - was under fire, was requested to give way etc.
 	updateEvents(state);
 	// Idling: Auto-movement, auto-body change when idling
@@ -2883,15 +3196,15 @@ void BattleUnit::update(GameState &state, unsigned int ticks)
 			updateCheckBeginFalling(state);
 			updateBody(state, bodyTicksRemaining);
 			updateHands(state, handsTicksRemaining);
-			// Quit if retreated as a result
-			if (updateMovement(state, moveTicksRemaining, wasUsingLift))
-			{
-				return;
-			}
+			updateMovement(state, moveTicksRemaining, wasUsingLift);
 			updateTurning(state, turnTicksRemaining, handsTicksRemaining);
 			updateDisplayedItem();
 		}
 	}
+	if (retreated)
+	{
+		return;
+	}
 	// Unit's attacking state
 	updateAttacking(state, ticks);
 	// Unit's psi attack state
@@ -2902,6 +3215,22 @@ void BattleUnit::update(GameState &state, unsigned int ticks)
 	triggerBrainsuckers(state);
 }
 
+void BattleUnit::updateTB(GameState & state)
+{
+	// Destroyed or retreated units do not exist in the battlescape
+	if (destroyed || retreated)
+	{
+		return;
+	}
+
+	// Update Items
+	for (auto item : agent->equipment)
+		item->updateTB(state);
+
+	// Miscellaneous state updates, as well as unit's stats
+	updateStateAndStats(state, TICKS_PER_TURN);
+}
+
 void BattleUnit::triggerProximity(GameState &state)
 {
 	auto it = state.current_battle->items.begin();
@@ -2967,8 +3296,12 @@ void BattleUnit::triggerBrainsuckers(GameState &state)
 	}
 }
 
-void BattleUnit::startFalling()
+void BattleUnit::startFalling(GameState &state)
 {
+	if (target_body_state == BodyState::Jumping)
+	{
+		setBodyState(state, BodyState::Standing);
+	}
 	setMovementState(MovementState::None);
 	falling = true;
 	launched = false;
@@ -3069,7 +3402,7 @@ void BattleUnit::launch(GameState &state, Vec3<float> targetPosition, BodyState
 	{
 		return;
 	}
-	startFalling();
+	startFalling(state);
 	launchGoal = targetPosition;
 	launched = true;
 	velocity = (glm::normalize(targetVectorXY) * velocityXY + Vec3<float>{0.0f, 0.0f, velocityZ}) *
@@ -3146,6 +3479,47 @@ void BattleUnit::requestGiveWay(const BattleUnit &requestor,
 	}
 }
 
+void BattleUnit::applyEnzymeEffect(GameState & state)
+{
+	spawnEnzymeSmoke(state, position);
+
+	// Damage random item
+	if (agent->type->inventory && !agent->equipment.empty())
+	{
+		auto item = listRandomiser(state.rng, agent->equipment);
+		item->armor -= enzymeDebuffIntensity / 2;
+
+		// Item destroyed
+		if (item->armor <= 0)
+		{
+			if (item->type->type == AEquipmentType::Type::Grenade)
+			{
+				item->explode(state);
+			}
+			else
+			{
+				agent->removeEquipment(item);
+			}
+		}
+	}
+
+	// Finally, reduce debuff
+
+	enzymeDebuffIntensity--;
+}
+
+void BattleUnit::spawnEnzymeSmoke(GameState & state, Vec3<int> pos)
+{
+	// FIXME: Ensure this is proper, for now just emulating vanilla crudely
+	// This makes smoke spawned by enzyme grow smaller when debuff runs out
+	int divisor = std::max(1, 36 / enzymeDebuffIntensity);
+	StateRef<DamageType> smokeDamageType = { &state, "DAMAGETYPE_SMOKE" };
+	// Power of 0 means no spread
+	state.current_battle->placeHazard(state, owner, smokeDamageType, position,
+		smokeDamageType->hazardType->getLifetime(state), 0,
+		divisor, false);
+}
+
 void BattleUnit::executeGroupAIDecision(GameState &state, AIDecision &decision,
                                         std::list<StateRef<BattleUnit>> &units)
 {
@@ -3257,7 +3631,7 @@ void BattleUnit::executeAIMovement(GameState &state, AIMovement &movement)
 	            {
 	                if (e->type->type == AEquipmentType::Type::Teleporter &&
 	                    e->ammo == e->type->max_ammo &&
-	                    canAfford(state, agent->current_stats.time_units * 55 / 100))
+	                    canAfford(state, getTeleportCost()))
 	                {
 	                    useTeleporter = true;
 	                    break;
@@ -3418,7 +3792,8 @@ void BattleUnit::dropDown(GameState &state)
 	resetGoal();
 	setHandState(HandState::AtEase);
 	setBodyState(state, target_body_state);
-	startFalling();
+	startFalling(state);
+	brainSucker.clear();
 	fireDebuffTicksRemaining = 0;
 	enzymeDebuffIntensity = 0;
 	moraleState = MoraleState::Normal;
@@ -3520,7 +3895,7 @@ void BattleUnit::die(GameState &state, bool violently, bool bledToDeath)
 				case AEquipmentType::Type::Popper:
 					state.current_battle->addExplosion(
 					    state, position, e->type->damage_type->explosionDoodad,
-					    e->type->damage_type, e->type->damage, e->type->explosion_depletion_rate);
+					    e->type->damage_type, e->type->damage, e->type->explosion_depletion_rate, owner);
 					break;
 				case AEquipmentType::Type::Spawner:
 				{
@@ -3715,7 +4090,10 @@ bool BattleUnit::useItem(GameState &state, sp<AEquipment> item)
 						return false;
 					}
 				}
-				state.current_battle->addScanner(state, *item);
+				else
+				{
+					state.current_battle->addScanner(state, *item);
+				}
 			}
 			item->inUse = !item->inUse;
 			return true;
@@ -4170,6 +4548,8 @@ bool BattleUnit::addMission(GameState &state, BattleUnitMission::Type type)
 			return addMission(state, BattleUnitMission::restartNextMission(*this));
 		case BattleUnitMission::Type::ReachGoal:
 			return addMission(state, BattleUnitMission::reachGoal(*this));
+		case BattleUnitMission::Type::AcquireTU:
+			return addMission(state, BattleUnitMission::acquireTU(*this));
 		case BattleUnitMission::Type::DropItem:
 		case BattleUnitMission::Type::ThrowItem:
 		case BattleUnitMission::Type::Snooze:
@@ -4177,7 +4557,6 @@ bool BattleUnit::addMission(GameState &state, BattleUnitMission::Type type)
 		case BattleUnitMission::Type::Turn:
 		case BattleUnitMission::Type::Brainsuck:
 		case BattleUnitMission::Type::Jump:
-		case BattleUnitMission::Type::AcquireTU:
 		case BattleUnitMission::Type::GotoLocation:
 		case BattleUnitMission::Type::Teleport:
 			LogError("Cannot add mission by type if it requires parameters");
@@ -4190,7 +4569,7 @@ bool BattleUnit::cancelMissions(GameState &state, bool forced)
 {
 	if (forced)
 	{
-		// Drop gear used by missions
+		// Drop gear used by missions, remove headcrab
 		std::list<sp<AEquipment>> itemsToDrop;
 		for (auto &m : missions)
 		{
@@ -4198,6 +4577,10 @@ bool BattleUnit::cancelMissions(GameState &state, bool forced)
 			{
 				itemsToDrop.push_back(m->item);
 			}
+			if (m->targetUnit && m->type == BattleUnitMission::Type::Brainsuck)
+			{
+				m->targetUnit->brainSucker.clear();
+			}
 		}
 		missions.clear();
 		for (auto it : itemsToDrop)
@@ -4340,7 +4723,7 @@ bool BattleUnit::setMission(GameState &state, BattleUnitMission *mission)
 			{
 				// FIXME: actually read the option
 				bool USER_OPTION_ALLOW_INSTANT_THROWS = true;
-				if (USER_OPTION_ALLOW_INSTANT_THROWS && canAfford(state, getThrowCost()))
+				if (USER_OPTION_ALLOW_INSTANT_THROWS && canAfford(state, getThrowCost(), true))
 				{
 					setMovementState(MovementState::None);
 					setBodyState(state, BodyState::Standing);
diff --git a/game/state/battle/battleunit.h b/game/state/battle/battleunit.h
index 7582547c5..5150c857f 100644
--- a/game/state/battle/battleunit.h
+++ b/game/state/battle/battleunit.h
@@ -33,7 +33,7 @@
 // Base movement ticks consumption rate, this allows us to divide by 2,3,4,5,6,8,9,10,12,15,18,20..
 #define BASE_MOVETICKS_CONSUMPTION_RATE 360
 // Movement cost in TUs for walking movement to adjacent (non-diagonal) tile
-#define STANDART_MOVE_TU_COST 2
+#define STANDART_MOVE_TU_COST 4
 
 namespace OpenApoc
 {
@@ -87,6 +87,14 @@ enum class WeaponAimingMode
 	Auto = 4
 };
 
+enum class ReserveShotMode
+{
+	Aimed = 1,
+	Snap = 2,
+	Auto = 4,
+	None = 0
+};
+
 // Unit's general type, used in pathfinding
 enum class BattleUnitType
 {
@@ -232,6 +240,10 @@ class BattleUnit : public StateObject, public std::enable_shared_from_this<Battl
 	unsigned int moraleStateTicksRemaining = 0;
 	// Ticks accumulated towards next morale check
 	unsigned int moraleTicksAccumulated = 0;
+	// TU at turn start (used to calculate percentage of TU)
+	int initialTU = 0;
+	// TU to reserve for shot
+	int reserveShotCost = 0;
 
 	// User set modes
 
@@ -241,6 +253,9 @@ class BattleUnit : public StateObject, public std::enable_shared_from_this<Battl
 	MovementMode movement_mode = MovementMode::Walking;
 	KneelingMode kneeling_mode = KneelingMode::None;
 
+	ReserveShotMode reserve_shot_mode = ReserveShotMode::None;
+	KneelingMode reserve_kneel_mode = KneelingMode::None;
+
 	// Body
 
 	// Time, in game ticks, until body animation is finished
@@ -288,6 +303,8 @@ class BattleUnit : public StateObject, public std::enable_shared_from_this<Battl
 	unsigned int collisionIgnoredTicks = 0;
 	// Current falling speed
 	Vec3<float> velocity;
+	// Movement counter for TB motion scanner
+	unsigned int tilesMoved = 0;
 
 	// Turning
 
@@ -324,7 +341,7 @@ class BattleUnit : public StateObject, public std::enable_shared_from_this<Battl
 	std::list<Vec2<int>> giveWayRequestData;
 
 	// AI list
-	UnitAIList aiList;
+	UnitAIBlock aiList;
 
 	// [Methods]
 
@@ -345,18 +362,20 @@ class BattleUnit : public StateObject, public std::enable_shared_from_this<Battl
 
 	// Attacking and turning to hostiles
 
+	// Get full cost of attacking (including turn and pose change)
+	int getAttackCost(GameState &state, AEquipment& item, Vec3<int> tile);
 	void setFocus(GameState &state, StateRef<BattleUnit> unit);
-	void startAttacking(GameState &state, StateRef<BattleUnit> unit,
+	bool startAttacking(GameState &state, StateRef<BattleUnit> unit,
 	                    WeaponStatus status = WeaponStatus::FiringBothHands);
-	void startAttacking(GameState &state, Vec3<int> tile,
+	bool startAttacking(GameState &state, Vec3<int> tile,
 	                    WeaponStatus status = WeaponStatus::FiringBothHands, bool atGround = false);
 	void stopAttacking();
 	// Returns which hands can be used for an attack (or none if attack cannot be made)
 	// Checks wether target unit is in range, and clear LOF exists to it
-	WeaponStatus canAttackUnit(sp<BattleUnit> unit);
+	WeaponStatus canAttackUnit(GameState &state, sp<BattleUnit> unit);
 	// Returns wether unit can be attacked by one of the two supplied weapons
 	// Checks wether target unit is in range, and clear LOF exists to it
-	WeaponStatus canAttackUnit(sp<BattleUnit> unit, sp<AEquipment> rightHand,
+	WeaponStatus canAttackUnit(GameState &state, sp<BattleUnit> unit, sp<AEquipment> rightHand,
 	                           sp<AEquipment> leftHand = nullptr);
 	// Clear LOF means no friendly fire and no map part in between
 	// Clear LOS means nothing in between
@@ -403,7 +422,7 @@ class BattleUnit : public StateObject, public std::enable_shared_from_this<Battl
 	unsigned int getDistanceTravelled() const;
 	bool shouldPlaySoundNow();
 	unsigned int getWalkSoundIndex();
-	// Return true if retreated and we have to exit
+	// Returns true if retreated
 	bool getNewGoal(GameState &state);
 	bool calculateVelocityForLaunch(float distanceXY, float diffZ, float &velocityXY,
 	                                float &velocityZ);
@@ -414,9 +433,9 @@ class BattleUnit : public StateObject, public std::enable_shared_from_this<Battl
 	               float &velocityZ);
 	void launch(GameState &state, Vec3<float> targetPosition,
 	            BodyState bodyState = BodyState::Standing);
-	void startFalling();
+	void startFalling(GameState &state);
 	void startMoving(GameState &state);
-	void setPosition(GameState &state, const Vec3<float> &pos);
+	void setPosition(GameState &state, const Vec3<float> &pos, bool goal = false);
 
 	// Turning
 
@@ -426,6 +445,8 @@ class BattleUnit : public StateObject, public std::enable_shared_from_this<Battl
 	// Movement and turning
 
 	void resetGoal();
+	// Updates to do when unit reached goal
+	void onReachGoal(GameState & state);
 
 	// Missions
 
@@ -445,15 +466,23 @@ class BattleUnit : public StateObject, public std::enable_shared_from_this<Battl
 	// Attempt to give unit a new mission, replacing others, returns true if successful
 	bool setMission(GameState &state, BattleUnitMission *mission);
 
-	// TU functions
+	// TB / TU functions
 
+	void setReserveShotMode(ReserveShotMode mode);
+	void setReserveKneelMode(KneelingMode mode);
+	void refreshReserveCost();
 	// Wether unit can afford action
-	bool canAfford(GameState &state, int cost) const;
+	bool canAfford(GameState &state, int cost, bool ignoreKneelReserve = false, bool ignoreShootReserve = false) const;
 	// Returns if unit did spend (false if unsufficient TUs)
-	bool spendTU(GameState &state, int cost);
-	int getThrowCost();
-	int getMedikitCost();
-	int getMotionScannerCost();
+	bool spendTU(GameState &state, int cost, bool ignoreKneelReserve = false, bool ignoreShootReserve = false, bool allowInterrupt = false);
+	// Spend all tu
+	void spendRemainingTU(GameState &state, bool allowInterrupt = false);
+	int getThrowCost() const;
+	int getMedikitCost() const;
+	int getMotionScannerCost() const;
+	int getTeleporterCost() const;
+	// Do routine that must be done at unit's turn start
+	void beginTurn(GameState &state);
 
 	// AI execution
 
@@ -471,6 +500,8 @@ class BattleUnit : public StateObject, public std::enable_shared_from_this<Battl
 
 	void requestGiveWay(const BattleUnit &requestor, const std::list<Vec3<int>> &plannedPath,
 	                    Vec3<int> pos);
+	void applyEnzymeEffect(GameState &state);
+	void spawnEnzymeSmoke(GameState &state, Vec3<int> pos);
 
 	// Unit state queries
 
@@ -539,6 +570,8 @@ class BattleUnit : public StateObject, public std::enable_shared_from_this<Battl
 
 	// Main update function
 	void update(GameState &state, unsigned int ticks);
+	// Update function for TB
+	void updateTB(GameState &state);
 	// Updates unit regeneration, bleeding, debuffs and morale states
 	void updateStateAndStats(GameState &state, unsigned int ticks);
 	// Updates unit give way request and events
@@ -552,22 +585,20 @@ class BattleUnit : public StateObject, public std::enable_shared_from_this<Battl
 	// Updates unit's hands trainsition
 	void updateHands(GameState &state, unsigned int &handsTicksRemaining);
 	// Updates unit's movement if unit is falling
-	// Return true if retreated or destroyed and we must halt immediately
-	bool updateMovementFalling(GameState &state, unsigned int &moveTicksRemaining,
+	void updateMovementFalling(GameState &state, unsigned int &moveTicksRemaining,
 	                           bool &wasUsingLift);
-	// Return true if retreated or destroyed and we must halt immediately
-	bool updateMovementBrainsucker(GameState &state, unsigned int &moveTicksRemaining,
+	// Updates unit's movement if unit is sucking brain
+	void updateMovementBrainsucker(GameState &state, unsigned int &moveTicksRemaining,
 	                           bool &wasUsingLift);
-	// Return true if retreated or destroyed and we must halt immediately
-	bool updateMovementJumping(GameState &state, unsigned int &moveTicksRemaining,
+	// Updates unit's movement if unit is jumping
+	void updateMovementJumping(GameState &state, unsigned int &moveTicksRemaining,
 	                           bool &wasUsingLift);
 	// Updates unit's movement if unit is moving normally
-	// Return true if retreated or destroyed and we must halt immediately
-	bool updateMovementNormal(GameState &state, unsigned int &moveTicksRemaining,
+	void updateMovementNormal(GameState &state, unsigned int &moveTicksRemaining,
 	                          bool &wasUsingLift);
 	// Updates unit's movement
 	// Return true if retreated or destroyed and we must halt immediately
-	bool updateMovement(GameState &state, unsigned int &moveTicksRemaining, bool &wasUsingLift);
+	void updateMovement(GameState &state, unsigned int &moveTicksRemaining, bool &wasUsingLift);
 	// Updates unit's àôñøòï trainsition and acquires new target àôñøòï
 	void updateTurning(GameState &state, unsigned int &turnTicksRemaining, unsigned int const handsTicksRemaining);
 	// Updates unit's displayed item (which one will draw in unit's hands on screen)
@@ -608,7 +639,7 @@ class BattleUnit : public StateObject, public std::enable_shared_from_this<Battl
   private:
 	friend class Battle;
 
-	void startAttacking(GameState &state, WeaponStatus status);
+	bool startAttacking(GameState &state, WeaponStatus status);
 	bool startAttackPsiInternal(GameState &state, StateRef<BattleUnit> target, PsiStatus status,
 	                            StateRef<AEquipmentType> item);
 
@@ -625,15 +656,26 @@ class BattleUnit : public StateObject, public std::enable_shared_from_this<Battl
 
 	void calculateVisionToTerrain(GameState &state, Battle &battle, TileMap &map,
 	                              Vec3<float> eyesPos);
+	// Calculate unit's vision to LBs checking every one independently
+	// Figure out a center tile of a block and check if it's visible (no collision)
+	void calculateVisionToLosBlocks(GameState &state, Battle &battle, TileMap &map,
+	                              Vec3<float> eyesPos, std::set<int> &discoveredBlocks, std::set<int> &blocksToCheck);
+	// Calculate unit's vision to LBs using "shotgun" approach:
+	// Shoot 25 beams and include everything that was passed through into list of visible blocks
+	void calculateVisionToLosBlocksLazy(GameState &state, Battle &battle, TileMap &map,
+								  Vec3<float> eyesPos, std::set<int> &discoveredBlocks);
 	void calculateVisionToUnits(GameState &state, Battle &battle, TileMap &map,
 	                            Vec3<float> eyesPos);
+	bool calculateVisionToUnit(GameState &state, Battle &battle, TileMap &map,
+		Vec3<float> eyesPos, BattleUnit &u);
+
 	bool isWithinVision(Vec3<int> pos);
 
 	// Update unit's vision of other units and terrain
-	void refreshUnitVisibility(GameState &state, Vec3<float> oldPosition);
+	void refreshUnitVisibility(GameState &state);
 	// Update other units's vision of this unit
-	void refreshUnitVision(GameState &state, bool forceBlind = false);
+	void refreshUnitVision(GameState &state, bool forceBlind = false, StateRef<BattleUnit> targetUnit = StateRef<BattleUnit>());
 	// Update both this unit's vision and other unit's vision of this unit
-	void refreshUnitVisibilityAndVision(GameState &state, Vec3<float> oldPosition);
+	void refreshUnitVisibilityAndVision(GameState &state);
 };
 }
diff --git a/game/state/battle/battleunitmission.cpp b/game/state/battle/battleunitmission.cpp
index db111c156..33cc4280e 100644
--- a/game/state/battle/battleunitmission.cpp
+++ b/game/state/battle/battleunitmission.cpp
@@ -17,23 +17,24 @@
 namespace OpenApoc
 {
 
-BattleUnitTileHelper::BattleUnitTileHelper(TileMap &map, BattleUnitType type)
+BattleUnitTileHelper::BattleUnitTileHelper(TileMap &map, BattleUnitType type, bool allowJumping)
     : BattleUnitTileHelper(
           map, (type == BattleUnitType::LargeFlyer || type == BattleUnitType::LargeWalker),
-          (type == BattleUnitType::LargeFlyer || type == BattleUnitType::SmallFlyer),
+          (type == BattleUnitType::LargeFlyer || type == BattleUnitType::SmallFlyer), allowJumping,
           (type == BattleUnitType::LargeFlyer || type == BattleUnitType::LargeWalker) ? 70 : 32,
           nullptr)
 {
 }
 
-BattleUnitTileHelper::BattleUnitTileHelper(TileMap &map, bool large, bool flying, int maxHeight,
+BattleUnitTileHelper::BattleUnitTileHelper(TileMap &map, bool large, bool flying, bool allowJumping, int maxHeight,
                                            sp<TileObjectBattleUnit> tileObject)
     : map(map), large(large), flying(flying), maxHeight(maxHeight), tileObject(tileObject)
 {
+	this->allowJumping = allowJumping && !flying;
 }
 
 BattleUnitTileHelper::BattleUnitTileHelper(TileMap &map, BattleUnit &u)
-    : BattleUnitTileHelper(map, u.isLarge(), u.canFly(), u.agent->type->bodyType->maxHeight,
+    : BattleUnitTileHelper(map, u.isLarge(), u.canFly(), u.agent->isBodyStateAllowed(BodyState::Jumping), u.agent->type->bodyType->maxHeight,
                            u.tileObject)
 {
 }
@@ -1036,6 +1037,10 @@ BattleUnitMission *BattleUnitMission::gotoLocation(BattleUnit &u, Vec3<int> targ
 	mission->allowRunningAway = allowRunningAway;
 	mission->targetBodyState = u.target_body_state;
 	mission->targetFacing = u.goalFacing;
+	if (facingDelta > 4)
+	{
+		facingDelta -= 8;
+	}
 	mission->facingDelta = facingDelta;
 
 	return mission;
@@ -1056,11 +1061,11 @@ BattleUnitMission *BattleUnitMission::restartNextMission(BattleUnit &)
 	return mission;
 }
 
-BattleUnitMission *BattleUnitMission::acquireTU(BattleUnit &, unsigned int acquireTU)
+BattleUnitMission *BattleUnitMission::acquireTU(BattleUnit &, bool allowContinue)
 {
 	auto *mission = new BattleUnitMission();
 	mission->type = Type::AcquireTU;
-	mission->timeUnits = acquireTU;
+	mission->allowContinue = allowContinue;
 	return mission;
 }
 
@@ -1293,7 +1298,7 @@ BattleUnitMission *BattleUnitMission::jump(BattleUnit &u, Vec3<float> target, Bo
 	return mission;
 }
 
-bool BattleUnitMission::spendAgentTUs(GameState &state, BattleUnit &u, int cost, bool cancel)
+bool BattleUnitMission::spendAgentTUs(GameState &state, BattleUnit &u, int cost, bool cancel, bool ignoreKneelReserve, bool allowInterrupt)
 {
 	if (costPaidUpFront > 0)
 	{
@@ -1309,7 +1314,7 @@ bool BattleUnitMission::spendAgentTUs(GameState &state, BattleUnit &u, int cost,
 		}
 	}
 
-	if (u.spendTU(state, cost))
+	if (u.spendTU(state, cost, ignoreKneelReserve, false, allowInterrupt))
 	{
 		return true;
 	}
@@ -1319,7 +1324,7 @@ bool BattleUnitMission::spendAgentTUs(GameState &state, BattleUnit &u, int cost,
 	}
 	else
 	{
-		u.addMission(state, acquireTU(u, cost));
+		u.addMission(state, BattleUnitMission::Type::AcquireTU);
 	}
 	return false;
 }
@@ -1346,6 +1351,15 @@ bool BattleUnitMission::getNextDestination(GameState &state, BattleUnit &u, Vec3
 	switch (this->type)
 	{
 		case Type::GotoLocation:
+			if (state.current_battle->mode == Battle::Mode::TurnBased
+				&& ((!state.current_battle->interruptQueue.empty())
+					|| (u.owner == state.current_battle->currentActiveOrganisation && !state.current_battle->interruptUnits.empty())
+					|| (u.owner != state.current_battle->currentActiveOrganisation &&
+						state.current_battle->interruptUnits.find({ &state, u.id }) == state.current_battle->interruptUnits.end())))
+			{
+				u.addMission(state, BattleUnitMission::acquireTU(u, true));
+				return false;
+			}
 			return advanceAlongPath(state, u, dest);
 		case Type::Brainsuck:
 			return advanceBrainsucker(state, u, dest);
@@ -1391,6 +1405,15 @@ bool BattleUnitMission::getNextFacing(GameState &state, BattleUnit &u, Vec2<int>
 		case Type::ReachGoal:
 		case Type::Jump:
 		case Type::Brainsuck:
+			if (state.current_battle->mode == Battle::Mode::TurnBased
+				&& ((!state.current_battle->interruptQueue.empty())
+					|| (u.owner == state.current_battle->currentActiveOrganisation && !state.current_battle->interruptUnits.empty())
+					|| (u.owner != state.current_battle->currentActiveOrganisation &&
+						state.current_battle->interruptUnits.find({ &state, u.id }) == state.current_battle->interruptUnits.end())))
+			{
+				u.addMission(state, BattleUnitMission::acquireTU(u, true));
+				return false;
+			}
 			return advanceFacing(state, u, dest);
 		default:
 			return false;
@@ -1575,6 +1598,14 @@ void BattleUnitMission::update(GameState &state, BattleUnit &u, unsigned int tic
 		case Type::Teleport:
 			return;
 		case Type::Brainsuck:
+			// Unit fell down, cancel brainsucker
+			if (!targetUnit->isConscious())
+			{
+				cancelled = true;
+				u.resetGoal();
+				u.startFalling(state);
+				return;
+			}
 			// Do not get stuck during brainsuck, move!
 			if (!finished && u.current_movement_state == MovementState::None)
 			{
@@ -1611,7 +1642,7 @@ void BattleUnitMission::update(GameState &state, BattleUnit &u, unsigned int tic
 				}
 				brainsuckSoundsPlayed++;
 			}
-			if (brainsuckTicksAccumulated >= TICKS_TO_BRAINSUCK)
+			if (brainsuckTicksAccumulated >= TICKS_TO_BRAINSUCK && state.current_battle->interruptQueue.empty() && state.current_battle->interruptUnits.empty())
 			{
 				if (randBoundsExclusive(state.rng, 0, 100) < BRAINSUCK_CHANCE)
 				{
@@ -1650,11 +1681,6 @@ bool BattleUnitMission::isFinishedInternal(GameState &, BattleUnit &u)
 	switch (this->type)
 	{
 		case Type::AcquireTU:
-			// This mission is never finished. It stays indefinetly.
-			// When player ends his turn only then game manually checks
-			// wether agents have TUs to continue their actions and allows
-			// to do so by manually removing this mission from the queue
-			//return u.agent->modified_stats.time_units >= (int)timeUnits;
 			return false;
 		case Type::ReachGoal:
 			return u.atGoal || u.falling;
@@ -1730,8 +1756,7 @@ void BattleUnitMission::start(GameState &state, BattleUnit &u)
 					cancelled = true;
 					return;
 				}
-				// Teleportation cost is 55% TUs
-				int cost = u.agent->current_stats.time_units * 55 / 100;
+				int cost = u.getTeleporterCost();
 				if (!spendAgentTUs(state, u, cost, true))
 				{
 					return;
@@ -1769,7 +1794,7 @@ void BattleUnitMission::start(GameState &state, BattleUnit &u)
 		}
 		case Type::Brainsuck:
 		{
-			if (targetUnit->brainSucker)
+			if (targetUnit->brainSucker && targetUnit->brainSucker.id != u.id)
 			{
 				cancelled = true;
 				return;
@@ -2305,7 +2330,7 @@ bool BattleUnitMission::advanceFacing(GameState &state, BattleUnit &u, Vec2<int>
 	if (targetBodyState == BodyState::Throwing)
 	{
 		int cost = getBodyStateChangeCost(u, u.current_body_state, targetBodyState);
-		if (!spendAgentTUs(state, u, cost, true))
+		if (!spendAgentTUs(state, u, cost, true, true, true))
 		{
 			return false;
 		}
@@ -2315,7 +2340,7 @@ bool BattleUnitMission::advanceFacing(GameState &state, BattleUnit &u, Vec2<int>
 	dest = getFacingStep(u, targetFacing);
 
 	// Calculate and spend cost
-	int cost = freeTurn ? 0 : 1;
+	int cost = freeTurn ? 0 : getTurnCost(u);
 	if (!spendAgentTUs(state, u, cost, true))
 	{
 		return false;
@@ -2377,7 +2402,7 @@ bool BattleUnitMission::advanceBodyState(GameState &state, BattleUnit &u, BodySt
 	int cost =
 	    type == Type::ReachGoal ? 0 : getBodyStateChangeCost(u, u.target_body_state, targetState);
 	// If unsufficient TUs - cancel missions other than GotoLocation
-	if (!spendAgentTUs(state, u, cost, type != Type::GotoLocation))
+	if (!spendAgentTUs(state, u, cost, type != Type::GotoLocation, targetState == BodyState::Kneeling))
 	{
 		return false;
 	}
@@ -2387,7 +2412,12 @@ bool BattleUnitMission::advanceBodyState(GameState &state, BattleUnit &u, BodySt
 	return true;
 }
 
-int BattleUnitMission::getBodyStateChangeCost(BattleUnit &u, BodyState from, BodyState to)
+int BattleUnitMission::getTurnCost(BattleUnit & )
+{
+	return 1;
+}
+
+int BattleUnitMission::getBodyStateChangeCost(const BattleUnit &u, BodyState from, BodyState to)
 {
 	// If not within these conditions, it costs nothing!
 	switch (to)
@@ -2439,7 +2469,7 @@ UString BattleUnitMission::getName()
 	switch (this->type)
 	{
 		case Type::AcquireTU:
-			name = "AcquireTUs " + format(" %u", timeUnits);
+			name = "AcquireTUs";
 			break;
 		case Type::GotoLocation:
 			name = "GotoLocation " + format(" %s", targetLocation);
diff --git a/game/state/battle/battleunitmission.h b/game/state/battle/battleunitmission.h
index 9231a896d..52a14dd5b 100644
--- a/game/state/battle/battleunitmission.h
+++ b/game/state/battle/battleunitmission.h
@@ -26,9 +26,9 @@ class BattleUnitTileHelper : public CanEnterTileHelper
 
   public:
 	BattleUnitTileHelper(TileMap &map, BattleUnit &u);
-	BattleUnitTileHelper(TileMap &map, bool large, bool flying, int maxHeight,
+	BattleUnitTileHelper(TileMap &map, bool large, bool flying, bool allowJumping, int maxHeight,
 	                     sp<TileObjectBattleUnit> tileObject);
-	BattleUnitTileHelper(TileMap &map, BattleUnitType type);
+	BattleUnitTileHelper(TileMap &map, BattleUnitType type, bool allowJumping = false);
 
 	static float getDistanceStatic(Vec3<float> from, Vec3<float> to);
 	static float getDistanceStatic(Vec3<float> from, Vec3<float> toStart, Vec3<float> toEnd);
@@ -100,9 +100,10 @@ class BattleUnitMission
 	MovementState getNextMovementState(GameState &state, BattleUnit &u);
 
 	// Spend agent TUs or append AcquireTU mission
-	bool spendAgentTUs(GameState &state, BattleUnit &u, int cost, bool cancel = false);
+	bool spendAgentTUs(GameState &state, BattleUnit &u, int cost, bool cancel = false, bool ignoreKneelReserve = false, bool allowInterrupt = false);
 
-	static int getBodyStateChangeCost(BattleUnit &u, BodyState from, BodyState to);
+	static int getTurnCost(BattleUnit &u);
+	static int getBodyStateChangeCost(const BattleUnit &u, BodyState from, BodyState to);
 	static Vec2<int> getFacingStep(BattleUnit &u, Vec2<int> targetFacing, int facingDelta = 0);
 	// Used to determine target facings
 	static Vec2<int> getFacing(BattleUnit &u, Vec3<float> from, Vec3<float> to,
@@ -116,7 +117,7 @@ class BattleUnitMission
 	                                       bool demandGiveWay = false, bool allowSkipNodes = true,
 	                                       int giveWayAttempts = 20, bool allowRunningAway = false);
 	static BattleUnitMission *snooze(BattleUnit &u, unsigned int ticks);
-	static BattleUnitMission *acquireTU(BattleUnit &u, unsigned int tu);
+	static BattleUnitMission *acquireTU(BattleUnit &u, bool allowContinue = false);
 	static BattleUnitMission *changeStance(BattleUnit &u, BodyState state);
 	static BattleUnitMission *throwItem(BattleUnit &u, sp<AEquipment> item, Vec3<int> target);
 	static BattleUnitMission *dropItem(BattleUnit &u, sp<AEquipment> item);
@@ -170,7 +171,7 @@ class BattleUnitMission
 	unsigned int timeToSnooze = 0;
 
 	// AcquireTU
-	unsigned int timeUnits = 0;
+	bool allowContinue = false;
 
 	// ChangeBodyState
 	BodyState targetBodyState = BodyState::Downed;
@@ -184,6 +185,8 @@ class BattleUnitMission
 	unsigned int brainsuckTicksAccumulated = 0;
 	unsigned int brainsuckSoundsPlayed = 0;
 
+
+
 	// Mission cancelled (due to unsufficient TUs or something else failing)
 	bool cancelled = false;
 };
diff --git a/game/state/gamestate_serialize.xml b/game/state/gamestate_serialize.xml
index 2e4f1e214..309b1b32a 100644
--- a/game/state/gamestate_serialize.xml
+++ b/game/state/gamestate_serialize.xml
@@ -308,7 +308,7 @@
 		<member>velocityXY</member>
 		<member>velocityZ</member>
 		<member>timeToSnooze</member>
-		<member>timeUnits</member>
+		<member>allowContinue</member>
 		<member>targetBodyState</member>
 		<member>currentPlannedPath</member>
 		<member>allowRunningAway</member>
@@ -418,6 +418,8 @@
 		<member>currentPlayer</member>
 		<member>currentActiveOrganisation</member>
 		<member>currentTurn</member>
+		<member>ticksWithoutAction</member>
+		<member>turnEndAllowed</member>
 		<member>interruptQueue</member>
 		<member>interruptUnits</member>
 		<member>battleViewZLevel</member>
@@ -562,11 +564,15 @@
 		<member>moraleState</member>
 		<member>moraleStateTicksRemaining</member>
 		<member>moraleTicksAccumulated</member>
+		<member>initialTU</member>
+		<member>reserveShotCost</member>
 		<member>behavior_mode</member>
 		<member>fire_aiming_mode</member>
 		<member>fire_permission_mode</member>
 		<member>movement_mode</member>
 		<member>kneeling_mode</member>
+		<member>reserve_shot_mode</member>
+		<member>reserve_kneel_mode</member>
 		<member>body_animation_ticks_remaining</member>
 		<member>body_animation_ticks_total</member>
 		<member>body_animation_ticks_static</member>
@@ -597,6 +603,7 @@
 		<member>bounced</member>
 		<member>collisionIgnoredTicks</member>
 		<member>velocity</member>
+		<member>tilesMoved</member>
 		<member>giveWayRequestData</member>
 		<member>displayedItem</member>
 		<member>visibleUnits</member>
@@ -613,6 +620,7 @@
 		<member>ownerInvulnerableTicks</member>
 		<member>collisionIgnoredTicks</member>
 		<member>ticksUntilCollapse</member>
+		<member>owner</member>
 	</object>
 	<object>
 		<name>BattleHazard</name>
@@ -624,8 +632,9 @@
 		<member>age</member>
 		<member>frame</member>
 		<member>ticksUntilVisible</member>
-		<member>ticksUntilNextFrameChange</member>
-		<member>ticksUntilNextUpdate</member>
+		<member>frameChangeTicksAccumulated</member>
+		<member>nextUpdateTicksAccumulated</member>
+		<member>owner</member>
 	</object>
 	<object>
 		<name>BattleExplosion</name>
@@ -639,6 +648,7 @@
 		<member>damageType</member>
 		<member>depletionRate</member>
 		<member>ownerUnit</member>
+		<member>ownerOrganisation</member>
 		<member>affectedUnits</member>
 	</object>
 	<object>
@@ -656,6 +666,7 @@
 		<member>door</member>
 		<member>supportedItems</member>
 		<member>supportedParts</member>
+		<member>owner</member>
 	</object>
 	<object>
 		<name>BattleDoor</name>
@@ -1220,6 +1231,13 @@
 		<value>Snap</value>
 		<value>Auto</value>
 	</enum>
+	<enum>
+		<name>ReserveShotMode</name>
+		<value>Aimed</value>
+		<value>Snap</value>
+		<value>Auto</value>
+		<value>None</value>
+	</enum>
 	<enum>
 		<name>BattleUnit::FirePermissionMode</name>
 		<value>AtWill</value>
@@ -1236,6 +1254,7 @@
 		<value>None</value>
 		<value>Kneeling</value>
 	</enum>
+	
 	<enum>
 		<name>WeaponStatus</name>
 		<value>NotFiring</value>
@@ -1515,7 +1534,7 @@
 		<member>movement</member>
 	</object>
 	<object full="true">
-		<name>UnitAIList</name>
+		<name>UnitAIBlock</name>
 		<member>aiList</member>
 		<member>ticksLastThink</member>
 		<member>ticksUntilReThink</member>
diff --git a/game/state/tileview/collision.cpp b/game/state/tileview/collision.cpp
index 77bc47ca3..ac57dd4fa 100644
--- a/game/state/tileview/collision.cpp
+++ b/game/state/tileview/collision.cpp
@@ -15,7 +15,7 @@ namespace OpenApoc
 Collision TileMap::findCollision(Vec3<float> lineSegmentStart, Vec3<float> lineSegmentEnd,
                                  const std::set<TileObject::Type> validTypes,
                                  sp<TileObject> ignoredObject, bool useLOS, bool check_full_path,
-                                 unsigned maxRange) const
+                                 unsigned maxRange, bool recordPassedTiles) const
 {
 	bool typeChecking = validTypes.size() > 0;
 	bool rangeChecking = maxRange > 0.0f;
@@ -58,12 +58,20 @@ Collision TileMap::findCollision(Vec3<float> lineSegmentStart, Vec3<float> lineS
 			if (!lastT)
 			{
 				lastT = t;
+				if (recordPassedTiles)
+				{
+					c.passedTiles.push_back(tile);
+				}
 			}
 			else
 			{
 				if (t != lastT)
 				{
 					lastT = t;
+					if (recordPassedTiles)
+					{
+						c.passedTiles.push_back(tile);
+					}
 					auto vec = t->position;
 					// Apply vision blockage if we passed at least 1 tile
 					auto thisDistance =
diff --git a/game/state/tileview/collision.h b/game/state/tileview/collision.h
index 096112d31..ab87a2515 100644
--- a/game/state/tileview/collision.h
+++ b/game/state/tileview/collision.h
@@ -17,6 +17,7 @@ class Collision
 	sp<TileObject> obj;
 	sp<Projectile> projectile;
 	Vec3<float> position;
+	std::list<Vec3<int>> passedTiles;
 	bool outOfRange = false;
 	explicit operator bool() const { return obj != nullptr; }
 };
diff --git a/game/state/tileview/pathfinding.cpp b/game/state/tileview/pathfinding.cpp
index 5953c282c..8249f126e 100644
--- a/game/state/tileview/pathfinding.cpp
+++ b/game/state/tileview/pathfinding.cpp
@@ -244,7 +244,7 @@ std::list<Vec3<int>> TileMap::findShortestPath(Vec3<int> origin, Vec3<int> desti
 					float thisCost = 0.0f;
 					bool unused = false;
 					bool jumped = false;
-					if (!canEnterTile.canEnterTile(nodeToExpand->thisTile, tile, true, jumped,
+					if (!canEnterTile.canEnterTile(nodeToExpand->thisTile, tile, canEnterTile.allowJumping, jumped,
 					                               thisCost, unused, ignoreStaticUnits,
 					                               ignoreAllUnits))
 						continue;
diff --git a/game/state/tileview/tile.h b/game/state/tileview/tile.h
index 698cdcfae..b8a5461d2 100644
--- a/game/state/tileview/tile.h
+++ b/game/state/tileview/tile.h
@@ -199,6 +199,7 @@ class CanEnterTileHelper
 	// Value here defines how much, in percent, can resulting path afford to be unoptimal
 	// For example 1.05 means resulting path can be 5% longer than an optimal one
 	virtual float pathOverheadAlloawnce() const { return 1.0f; }
+	bool allowJumping = false;
 };
 
 class TileMap
@@ -270,7 +271,7 @@ class TileMap
 	Collision findCollision(Vec3<float> lineSegmentStart, Vec3<float> lineSegmentEnd,
 	                        const std::set<TileObject::Type> validTypes = {},
 	                        sp<TileObject> ignoredObject = nullptr, bool useLOS = false,
-	                        bool check_full_path = false, unsigned maxRange = 0) const;
+	                        bool check_full_path = false, unsigned maxRange = 0, bool recordPassedTiles = false) const;
 
 	bool checkThrowTrajectory(const sp<TileObject> thrower, Vec3<float> start, Vec3<int> end,
 	                          Vec3<float> targetVectorXY, float velocityXY, float velocityZ) const;
diff --git a/game/ui/CMakeLists.txt b/game/ui/CMakeLists.txt
index 057517298..00ebd32f5 100644
--- a/game/ui/CMakeLists.txt
+++ b/game/ui/CMakeLists.txt
@@ -13,6 +13,7 @@ set (GAMEUI_SOURCE_FILES
 	battle/battlebriefing.cpp
 	battle/battledebriefing.cpp
 	battle/battleprestart.cpp
+	battle/battleturnbasedconfirmbox.cpp
 	battle/battleview.cpp
 	base/basegraphics.cpp
 	base/basescreen.cpp
@@ -52,6 +53,7 @@ set (GAMEUI_HEADER_FILES
 	battle/battlebriefing.h
 	battle/battledebriefing.h
 	battle/battleprestart.h
+	battle/battleturnbasedconfirmbox.h
 	battle/battleview.h
 	base/basegraphics.h
 	base/basescreen.h
diff --git a/game/ui/battle/battleturnbasedconfirmbox.cpp b/game/ui/battle/battleturnbasedconfirmbox.cpp
new file mode 100644
index 000000000..19b3a4734
--- /dev/null
+++ b/game/ui/battle/battleturnbasedconfirmbox.cpp
@@ -0,0 +1,70 @@
+#include "game/ui/battle/battleturnbasedconfirmbox.h"
+#include "forms/form.h"
+#include "forms/label.h"
+#include "forms/textbutton.h"
+#include "forms/ui.h"
+#include "framework/event.h"
+#include "framework/font.h"
+#include "framework/framework.h"
+#include "framework/renderer.h"
+#include "library/strings_format.h"
+
+namespace OpenApoc
+{
+	BattleTurnBasedConfirmBox::BattleTurnBasedConfirmBox(const UString &text, 
+		std::function<void()> callbackYes, std::function<void()> callbackNo)
+		: Stage(), callbackYes(callbackYes), callbackNo(callbackNo), form(ui().getForm("battle/battle_tb_plan_popup"))
+	{
+		form->findControlTyped<Label>("MESSAGE")->setText(text);
+	}
+
+	BattleTurnBasedConfirmBox::~BattleTurnBasedConfirmBox() = default;
+
+	void BattleTurnBasedConfirmBox::begin() {}
+
+	void BattleTurnBasedConfirmBox::pause() {}
+
+	void BattleTurnBasedConfirmBox::resume() {}
+
+	void BattleTurnBasedConfirmBox::finish() {}
+
+	void BattleTurnBasedConfirmBox::eventOccurred(Event *e)
+	{
+		form->eventOccured(e);
+
+		if (e->type() == EVENT_FORM_INTERACTION)
+		{
+			if (e->forms().EventFlag == FormEventType::ButtonClick)
+			{
+				if (e->forms().RaisedBy->Name == "BUTTON_OK")
+				{
+					fw().stageQueueCommand({ StageCmd::Command::POP });
+					if (callbackYes)
+						callbackYes();
+					return;
+				}
+				else if (e->forms().RaisedBy->Name == "BUTTON_CANCEL")
+				{
+					fw().stageQueueCommand({ StageCmd::Command::POP });
+					if (callbackNo)
+						callbackNo();
+					return;
+				}
+			}
+		}
+	}
+
+	void BattleTurnBasedConfirmBox::update() { form->update(); }
+
+	void BattleTurnBasedConfirmBox::render()
+	{
+		fw().stageGetPrevious(this->shared_from_this())->render();
+		form->render();
+		fw().renderer->drawRect(form->Location, form->Size, Colour{ 48, 48, 52 });
+		fw().renderer->drawRect(form->Location + 2, form->Size - 2, Colour{ 96, 100, 104 });
+		fw().renderer->drawRect(form->Location + 1, form->Size - 2, Colour{ 236, 236, 236 });
+	}
+
+	bool BattleTurnBasedConfirmBox::isTransition() { return false; }
+
+}; // namespace OpenApoc
diff --git a/game/ui/battle/battleturnbasedconfirmbox.h b/game/ui/battle/battleturnbasedconfirmbox.h
new file mode 100644
index 000000000..c537f27be
--- /dev/null
+++ b/game/ui/battle/battleturnbasedconfirmbox.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "framework/stage.h"
+#include "library/sp.h"
+#include "library/strings.h"
+#include <functional>
+
+namespace OpenApoc
+{
+
+	class Form;
+
+	class BattleTurnBasedConfirmBox : public Stage
+	{
+	private:
+		sp<Form> form;
+		std::function<void()> callbackYes;
+		std::function<void()> callbackNo;
+
+	public:
+		enum class ButtonOptions
+		{
+			Ok,
+			YesNo
+		};
+
+		BattleTurnBasedConfirmBox(const UString &text, 
+			std::function<void()> callbackYes = std::function<void()>(),
+			std::function<void()> callbackNo = std::function<void()>());
+		~BattleTurnBasedConfirmBox() override;
+		// Stage control
+		void begin() override;
+		void pause() override;
+		void resume() override;
+		void finish() override;
+		void eventOccurred(Event *e) override;
+		void update() override;
+		void render() override;
+		bool isTransition() override;
+	};
+}; // namespace OpenApoc
diff --git a/game/ui/battle/battleview.cpp b/game/ui/battle/battleview.cpp
index 996afd494..871b5e792 100644
--- a/game/ui/battle/battleview.cpp
+++ b/game/ui/battle/battleview.cpp
@@ -1,4 +1,5 @@
 #include "game/ui/battle/battleview.h"
+#include "game/ui/battle/battleturnbasedconfirmbox.h"
 #include "forms/checkbox.h"
 #include "forms/form.h"
 #include "forms/graphic.h"
@@ -50,8 +51,9 @@ static const std::vector<UString> TAB_FORM_NAMES_RT = {
     "battle/battle_rt_tab1", "battle/battle_rt_tab2", "battle/battle_rt_tab3",
 };
 static const std::vector<UString> TAB_FORM_NAMES_TB = {
-    "battle/battle_tb_tab1", "battle/battle_tb_tab2", "battle/battle_tb_tab3", "battle/battle_tb_tab4", "battle/battle_tb_tab5"
+    "battle/battle_tb_tab1", "battle/battle_tb_tab2", "battle/battle_tb_tab3", "battle/battle_tb_tab4"
 };
+static const int TICKS_TRY_END_TURN = TICKS_PER_SECOND;
 static const std::set<BodyPart> bodyParts{BodyPart::Body, BodyPart::Helmet, BodyPart::LeftArm,
                                           BodyPart::Legs, BodyPart::RightArm};
 
@@ -66,7 +68,7 @@ BattleView::BattleView(sp<GameState> gameState)
       followAgent(false), palette(fw().data->loadPalette("xcom3/tacdata/tactical.pal")),
       selectionState(BattleSelectionState::Normal)
 {
-	this->pal = palette;
+	pal = palette;
 
 	for (int j = 0; j <= 15; j++)
 	{
@@ -127,7 +129,7 @@ BattleView::BattleView(sp<GameState> gameState)
 			return;
 		}
 		f->takesFocus = false;
-		this->uiTabsRT.push_back(f);
+		uiTabsRT.push_back(f);
 	}
 	for (auto &formName : TAB_FORM_NAMES_TB)
 	{
@@ -138,27 +140,36 @@ BattleView::BattleView(sp<GameState> gameState)
 			return;
 		}
 		f->takesFocus = false;
-		this->uiTabsTB.push_back(f);
+		uiTabsTB.push_back(f);
 	}
+	{
+		executePlanPopup = mksp<BattleTurnBasedConfirmBox>( tr("Execute remaining movement orders for this unit?"),
+			[this] {
+			unitPendingConfirmation->missions.pop_front();
+			unitPendingConfirmation = nullptr;
+		}, [this] {
+			unitPendingConfirmation = nullptr;
+		});
+	}
+
 
 	switch (battle.mode)
 	{
 		case Battle::Mode::RealTime:
-			this->activeTab = this->uiTabsRT[0];
-			this->mainTab = this->uiTabsRT[0];
-			this->psiTab = this->uiTabsRT[1];
-			this->primingTab = this->uiTabsRT[2];
+			activeTab = uiTabsRT[0];
+			mainTab = uiTabsRT[0];
+			psiTab = uiTabsRT[1];
+			primingTab = uiTabsRT[2];
 			baseForm->findControlTyped<RadioButton>("BUTTON_SPEED0")->setChecked(true);
 			updateSpeed = BattleUpdateSpeed::Pause;
 			lastSpeed = BattleUpdateSpeed::Speed1;
 			break;
 		case Battle::Mode::TurnBased:
-			this->activeTab = this->uiTabsTB[0];
-			this->mainTab = this->uiTabsTB[0];
-			this->psiTab = this->uiTabsTB[1];
-			this->primingTab = this->uiTabsTB[2];
-			this->notMyTurnTab = this->uiTabsTB[3];
-			this->executePlanTab = this->uiTabsTB[4];
+			activeTab = uiTabsTB[0];
+			mainTab = uiTabsTB[0];
+			psiTab = uiTabsTB[1];
+			primingTab = uiTabsTB[2];
+			notMyTurnTab = uiTabsTB[3];
 			baseForm->findControlTyped<RadioButton>("BUTTON_SPEED2")->setChecked(true);
 			updateSpeed = BattleUpdateSpeed::Speed2;
 			lastSpeed = BattleUpdateSpeed::Pause;
@@ -305,17 +316,17 @@ BattleView::BattleView(sp<GameState> gameState)
 	// Refresh base views
 	resume();
 
-	this->baseForm->findControl("BUTTON_FOLLOW_AGENT")
+	baseForm->findControl("BUTTON_FOLLOW_AGENT")
 	    ->addCallback(FormEventType::CheckBoxChange, [this](Event *e) {
 		    this->followAgent =
 		        std::dynamic_pointer_cast<CheckBox>(e->forms().RaisedBy)->isChecked();
 		});
-	this->baseForm->findControl("BUTTON_TOGGLE_STRATMAP")
+	baseForm->findControl("BUTTON_TOGGLE_STRATMAP")
 	    ->addCallback(FormEventType::CheckBoxChange, [this](Event *e) {
 		    bool strategy = std::dynamic_pointer_cast<CheckBox>(e->forms().RaisedBy)->isChecked();
 		    this->setViewMode(strategy ? TileViewMode::Strategy : TileViewMode::Isometric);
 		});
-	this->baseForm->findControl("BUTTON_LAYERING")
+	baseForm->findControl("BUTTON_LAYERING")
 	    ->addCallback(FormEventType::TriStateBoxChange, [this](Event *e) {
 		    int state = std::dynamic_pointer_cast<TriStateBox>(e->forms().RaisedBy)->getState();
 		    switch (state)
@@ -333,7 +344,7 @@ BattleView::BattleView(sp<GameState> gameState)
 
 		});
 
-	this->baseForm->findControl("BUTTON_CEASE_FIRE")
+	baseForm->findControl("BUTTON_CEASE_FIRE")
 	    ->addCallback(FormEventType::MouseClick, [this](Event *) {
 		    bool at_will = false;
 		    for (auto u : this->battle.battleViewSelectedUnits)
@@ -355,28 +366,28 @@ BattleView::BattleView(sp<GameState> gameState)
 			    }
 		    }
 		});
-	this->baseForm->findControl("BUTTON_AIMED")
+	baseForm->findControl("BUTTON_AIMED")
 	    ->addCallback(FormEventType::MouseClick, [this](Event *) {
 		    for (auto u : this->battle.battleViewSelectedUnits)
 		    {
 			    u->fire_aiming_mode = WeaponAimingMode::Aimed;
 		    }
 		});
-	this->baseForm->findControl("BUTTON_SNAP")
+	baseForm->findControl("BUTTON_SNAP")
 	    ->addCallback(FormEventType::MouseClick, [this](Event *) {
 		    for (auto u : this->battle.battleViewSelectedUnits)
 		    {
 			    u->fire_aiming_mode = WeaponAimingMode::Snap;
 		    }
 		});
-	this->baseForm->findControl("BUTTON_AUTO")
+	baseForm->findControl("BUTTON_AUTO")
 	    ->addCallback(FormEventType::MouseClick, [this](Event *) {
 		    for (auto u : this->battle.battleViewSelectedUnits)
 		    {
 			    u->fire_aiming_mode = WeaponAimingMode::Auto;
 		    }
 		});
-	this->baseForm->findControl("BUTTON_KNEEL")
+	baseForm->findControl("BUTTON_KNEEL")
 	    ->addCallback(FormEventType::MouseClick, [this](Event *) {
 		    bool not_kneeling = false;
 
@@ -400,42 +411,42 @@ BattleView::BattleView(sp<GameState> gameState)
 			    }
 		    }
 		});
-	this->baseForm->findControl("BUTTON_PRONE")
+	baseForm->findControl("BUTTON_PRONE")
 	    ->addCallback(FormEventType::MouseClick, [this](Event *) {
 		    for (auto u : this->battle.battleViewSelectedUnits)
 		    {
 			    u->setMovementMode(MovementMode::Prone);
 		    }
 		});
-	this->baseForm->findControl("BUTTON_WALK")
+	baseForm->findControl("BUTTON_WALK")
 	    ->addCallback(FormEventType::MouseClick, [this](Event *) {
 		    for (auto u : this->battle.battleViewSelectedUnits)
 		    {
 			    u->setMovementMode(MovementMode::Walking);
 		    }
 		});
-	this->baseForm->findControl("BUTTON_RUN")
+	baseForm->findControl("BUTTON_RUN")
 	    ->addCallback(FormEventType::MouseClick, [this](Event *) {
 		    for (auto u : this->battle.battleViewSelectedUnits)
 		    {
 			    u->setMovementMode(MovementMode::Running);
 		    }
 		});
-	this->baseForm->findControl("BUTTON_EVASIVE")
+	baseForm->findControl("BUTTON_EVASIVE")
 	    ->addCallback(FormEventType::MouseClick, [this](Event *) {
 		    for (auto u : this->battle.battleViewSelectedUnits)
 		    {
 			    u->behavior_mode = BattleUnit::BehaviorMode::Evasive;
 		    }
 		});
-	this->baseForm->findControl("BUTTON_NORMAL")
+	baseForm->findControl("BUTTON_NORMAL")
 	    ->addCallback(FormEventType::MouseClick, [this](Event *) {
 		    for (auto u : this->battle.battleViewSelectedUnits)
 		    {
 			    u->behavior_mode = BattleUnit::BehaviorMode::Normal;
 		    }
 		});
-	this->baseForm->findControl("BUTTON_AGGRESSIVE")
+	baseForm->findControl("BUTTON_AGGRESSIVE")
 	    ->addCallback(FormEventType::MouseClick, [this](Event *) {
 		    for (auto u : this->battle.battleViewSelectedUnits)
 		    {
@@ -443,100 +454,215 @@ BattleView::BattleView(sp<GameState> gameState)
 		    }
 		});
 
-	this->baseForm->findControl("BUTTON_LAYER_UP")
+	baseForm->findControl("BUTTON_RESERVE_AIMED")
+		->addCallback(FormEventType::MouseClick, [this](Event *) {
+		bool pushed = false;
+		for (auto u : this->battle.battleViewSelectedUnits)
+		{
+			if (u->reserve_shot_mode == ReserveShotMode::Aimed)
+			{
+				pushed = true;
+			}
+		}
+		for (auto u : this->battle.battleViewSelectedUnits)
+		{
+			u->setReserveShotMode(pushed ? ReserveShotMode::None : ReserveShotMode::Aimed);
+		}
+	});
+
+	baseForm->findControl("BUTTON_RESERVE_SNAP")
+		->addCallback(FormEventType::MouseClick, [this](Event *) {
+		bool pushed = false;
+		for (auto u : this->battle.battleViewSelectedUnits)
+		{
+			if (u->reserve_shot_mode == ReserveShotMode::Snap)
+			{
+				pushed = true;
+			}
+		}
+		for (auto u : this->battle.battleViewSelectedUnits)
+		{
+			u->setReserveShotMode(pushed ? ReserveShotMode::None : ReserveShotMode::Snap);
+		}
+	});
+
+	baseForm->findControl("BUTTON_RESERVE_AUTO")
+		->addCallback(FormEventType::MouseClick, [this](Event *) {
+		bool pushed = false;
+		for (auto u : this->battle.battleViewSelectedUnits)
+		{
+			if (u->reserve_shot_mode == ReserveShotMode::Auto)
+			{
+				pushed = true;
+			}
+		}
+		for (auto u : this->battle.battleViewSelectedUnits)
+		{
+			u->setReserveShotMode(pushed ? ReserveShotMode::None : ReserveShotMode::Auto);
+		}
+	});
+
+	baseForm->findControl("BUTTON_RESERVE_KNEEL")
+		->addCallback(FormEventType::MouseClick, [this](Event *) {
+		bool pushed = false;
+		for (auto u : this->battle.battleViewSelectedUnits)
+		{
+			if (u->reserve_kneel_mode == KneelingMode::Kneeling)
+			{
+				pushed = true;
+			}
+		}
+		for (auto u : this->battle.battleViewSelectedUnits)
+		{
+			u->setReserveKneelMode(pushed ? KneelingMode::None : KneelingMode::Kneeling);
+		}
+	});
+
+
+
+	baseForm->findControl("BUTTON_LAYER_UP")
 	    ->addCallback(FormEventType::ButtonClick, [this](Event *) {
 		    this->setZLevel(getZLevel() + 1);
 		    updateLayerButtons();
 		});
-	this->baseForm->findControl("BUTTON_LAYER_DOWN")
+	baseForm->findControl("BUTTON_LAYER_DOWN")
 	    ->addCallback(FormEventType::ButtonClick, [this](Event *) {
 		    this->setZLevel(getZLevel() - 1);
 		    updateLayerButtons();
 		});
 
-	this->baseForm->findControl("BUTTON_MOVE_GROUP")
+	baseForm->findControl("BUTTON_MOVE_GROUP")
 	    ->addCallback(FormEventType::ButtonClick,
 	                  [this](Event *) { this->battle.battleViewGroupMove = true; });
-	this->baseForm->findControl("BUTTON_MOVE_INDIVIDUALLY")
+	baseForm->findControl("BUTTON_MOVE_INDIVIDUALLY")
 	    ->addCallback(FormEventType::ButtonClick,
 	                  [this](Event *) { this->battle.battleViewGroupMove = false; });
 	if (battle.battleViewGroupMove)
 	{
-		this->baseForm->findControlTyped<RadioButton>("BUTTON_MOVE_GROUP")->setChecked(true);
+		baseForm->findControlTyped<RadioButton>("BUTTON_MOVE_GROUP")->setChecked(true);
 	}
 	else
 	{
-		this->baseForm->findControlTyped<RadioButton>("BUTTON_MOVE_INDIVIDUALLY")->setChecked(true);
+		baseForm->findControlTyped<RadioButton>("BUTTON_MOVE_INDIVIDUALLY")->setChecked(true);
 	}
 
-	this->uiTabsRT[0]
+	uiTabsRT[0]
 	    ->findControl("BUTTON_LAYER_1")
-	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { this->setZLevel(1); });
-	this->uiTabsRT[0]
+	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { setZLevel(1); });
+	uiTabsRT[0]
 	    ->findControl("BUTTON_LAYER_2")
-	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { this->setZLevel(2); });
-	this->uiTabsRT[0]
+	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { setZLevel(2); });
+	uiTabsRT[0]
 	    ->findControl("BUTTON_LAYER_3")
-	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { this->setZLevel(3); });
-	this->uiTabsRT[0]
+	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { setZLevel(3); });
+	uiTabsRT[0]
 	    ->findControl("BUTTON_LAYER_4")
-	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { this->setZLevel(4); });
-	this->uiTabsRT[0]
+	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { setZLevel(4); });
+	uiTabsRT[0]
 	    ->findControl("BUTTON_LAYER_5")
-	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { this->setZLevel(5); });
-	this->uiTabsRT[0]
+	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { setZLevel(5); });
+	uiTabsRT[0]
 	    ->findControl("BUTTON_LAYER_6")
-	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { this->setZLevel(6); });
-	this->uiTabsRT[0]
+	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { setZLevel(6); });
+	uiTabsRT[0]
 	    ->findControl("BUTTON_LAYER_7")
-	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { this->setZLevel(7); });
-	this->uiTabsRT[0]
+	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { setZLevel(7); });
+	uiTabsRT[0]
 	    ->findControl("BUTTON_LAYER_8")
-	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { this->setZLevel(8); });
-	this->uiTabsRT[0]
+	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { setZLevel(8); });
+	uiTabsRT[0]
 	    ->findControl("BUTTON_LAYER_9")
-	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { this->setZLevel(9); });
-	this->uiTabsTB[0]
+	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { setZLevel(9); });
+	uiTabsTB[0]
 	    ->findControl("BUTTON_LAYER_1")
-	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { this->setZLevel(1); });
-	this->uiTabsTB[0]
+	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { 
+		setZLevel(1); 
+		uiTabsTB[3]->findControlTyped<RadioButton>("BUTTON_LAYER_1")->setChecked(true);});
+	uiTabsTB[0]
 	    ->findControl("BUTTON_LAYER_2")
-	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { this->setZLevel(2); });
-	this->uiTabsTB[0]
+	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { 
+		setZLevel(2); 
+		uiTabsTB[3]->findControlTyped<RadioButton>("BUTTON_LAYER_2")->setChecked(true);});
+	uiTabsTB[0]
 	    ->findControl("BUTTON_LAYER_3")
-	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { this->setZLevel(3); });
-	this->uiTabsTB[0]
+	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { 
+		setZLevel(3);
+		uiTabsTB[3]->findControlTyped<RadioButton>("BUTTON_LAYER_3")->setChecked(true);});
+	uiTabsTB[0]
 	    ->findControl("BUTTON_LAYER_4")
-	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { this->setZLevel(4); });
-	this->uiTabsTB[0]
+	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { 
+		setZLevel(4); 
+		uiTabsTB[3]->findControlTyped<RadioButton>("BUTTON_LAYER_4")->setChecked(true);});
+	uiTabsTB[0]
 	    ->findControl("BUTTON_LAYER_5")
-	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { this->setZLevel(5); });
-	this->uiTabsTB[0]
+	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { 
+		setZLevel(5);
+		uiTabsTB[3]->findControlTyped<RadioButton>("BUTTON_LAYER_5")->setChecked(true);});
+	uiTabsTB[0]
 	    ->findControl("BUTTON_LAYER_6")
-	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { this->setZLevel(6); });
-	this->uiTabsTB[0]
+	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { 
+		setZLevel(6); 
+		uiTabsTB[3]->findControlTyped<RadioButton>("BUTTON_LAYER_6")->setChecked(true);});
+	uiTabsTB[0]
 	    ->findControl("BUTTON_LAYER_7")
-	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { this->setZLevel(7); });
-	this->uiTabsTB[0]
+	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { 
+		setZLevel(7);
+		uiTabsTB[3]->findControlTyped<RadioButton>("BUTTON_LAYER_7")->setChecked(true);});
+	uiTabsTB[0]
 	    ->findControl("BUTTON_LAYER_8")
-	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { this->setZLevel(8); });
-	this->uiTabsTB[0]
+	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { 
+		setZLevel(8);
+		uiTabsTB[3]->findControlTyped<RadioButton>("BUTTON_LAYER_8")->setChecked(true);});
+	uiTabsTB[0]
 	    ->findControl("BUTTON_LAYER_9")
-	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { this->setZLevel(9); });
-	this->baseForm->findControl("BUTTON_FOLLOW_AGENT")
-	    ->addCallback(FormEventType::CheckBoxChange, [this](Event *e) {
-		    this->followAgent =
-		        std::dynamic_pointer_cast<CheckBox>(e->forms().RaisedBy)->isChecked();
-		});
-
-	this->baseForm->findControl("BUTTON_SHOW_OPTIONS")
+	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) { 
+		setZLevel(9); 
+		uiTabsTB[3]->findControlTyped<RadioButton>("BUTTON_LAYER_9")->setChecked(true);});
+	uiTabsTB[3]
+		->findControl("BUTTON_LAYER_1")
+		->addCallback(FormEventType::CheckBoxSelected, [this](Event *) {uiTabsTB[0]
+			->findControlTyped<RadioButton>("BUTTON_LAYER_1")->setChecked(true); });
+	uiTabsTB[3]
+		->findControl("BUTTON_LAYER_2")
+		->addCallback(FormEventType::CheckBoxSelected, [this](Event *) {uiTabsTB[0]
+			->findControlTyped<RadioButton>("BUTTON_LAYER_2")->setChecked(true); });
+	uiTabsTB[3]
+		->findControl("BUTTON_LAYER_3")
+		->addCallback(FormEventType::CheckBoxSelected, [this](Event *) {uiTabsTB[0]
+			->findControlTyped<RadioButton>("BUTTON_LAYER_3")->setChecked(true); });
+	uiTabsTB[3]
+		->findControl("BUTTON_LAYER_4")
+		->addCallback(FormEventType::CheckBoxSelected, [this](Event *) {uiTabsTB[0]
+			->findControlTyped<RadioButton>("BUTTON_LAYER_4")->setChecked(true); });
+	uiTabsTB[3]
+		->findControl("BUTTON_LAYER_5")
+		->addCallback(FormEventType::CheckBoxSelected, [this](Event *) {uiTabsTB[0]
+			->findControlTyped<RadioButton>("BUTTON_LAYER_5")->setChecked(true); });
+	uiTabsTB[3]
+		->findControl("BUTTON_LAYER_6")
+		->addCallback(FormEventType::CheckBoxSelected, [this](Event *) {uiTabsTB[0]
+			->findControlTyped<RadioButton>("BUTTON_LAYER_6")->setChecked(true); });
+	uiTabsTB[3]
+		->findControl("BUTTON_LAYER_7")
+		->addCallback(FormEventType::CheckBoxSelected, [this](Event *) {uiTabsTB[0]
+			->findControlTyped<RadioButton>("BUTTON_LAYER_7")->setChecked(true); });
+	uiTabsTB[3]
+		->findControl("BUTTON_LAYER_8")
+		->addCallback(FormEventType::CheckBoxSelected, [this](Event *) {uiTabsTB[0]
+			->findControlTyped<RadioButton>("BUTTON_LAYER_8")->setChecked(true); });
+	uiTabsTB[3]
+		->findControl("BUTTON_LAYER_9")
+		->addCallback(FormEventType::CheckBoxSelected, [this](Event *) {uiTabsTB[0]
+			->findControlTyped<RadioButton>("BUTTON_LAYER_9")->setChecked(true); });
+
+	baseForm->findControl("BUTTON_SHOW_OPTIONS")
 	    ->addCallback(FormEventType::ButtonClick, [this](Event *) {
 		    fw().stageQueueCommand(
 		        {StageCmd::Command::PUSH, mksp<InGameOptions>(this->state->shared_from_this())});
 		});
-	this->baseForm->findControl("BUTTON_SHOW_LOG")
+	baseForm->findControl("BUTTON_SHOW_LOG")
 	    ->addCallback(FormEventType::ButtonClick, [this](Event *) { LogWarning("Show log"); });
-	this->baseForm->findControl("BUTTON_ZOOM_EVENT")
+	baseForm->findControl("BUTTON_ZOOM_EVENT")
 	    ->addCallback(FormEventType::ButtonClick, [this](Event *) { LogWarning("Zoom to event"); });
 
 	// FIXME: When clicking on items or weapons, activate them or go into fire / teleport mode
@@ -624,61 +750,58 @@ BattleView::BattleView(sp<GameState> gameState)
 		}
 		else
 		{
-			item->prime(false, delay * TICKS_PER_SECOND / 4, (range + 1) * 6);
+			if (this->battle.mode == Battle::Mode::TurnBased)
+			{
+				item->prime(false, delay * TICKS_PER_TURN, (range + 1) * 6);
+			}
+			else
+			{
+				item->prime(false, delay * TICKS_PER_SECOND / 4, (range + 1) * 6);
+			}
 		}
 		this->activeTab = this->mainTab;
 	};
 
-	std::function<void(FormsEvent * e)> updateDelay = [this, throwItem](Event *) {
-		int delay = this->primingTab->findControlTyped<ScrollBar>("DELAY_SLIDER")->getValue();
-		LogWarning("Delay %d", delay);
-		UString text;
-		if (delay == 0)
-			text = format(tr("Activates now."));
-		else
-			text = format(tr("Delay = %i"), (int)((float)delay / 4.0f));
-		this->primingTab->findControlTyped<Label>("DELAY_TEXT")->setText(text);
+	std::function<void(FormsEvent * e)> updateDelay = [this](Event *) {
+		this->refreshDelayText();
 	};
 
-	std::function<void(FormsEvent * e)> updateRange = [this, throwItem](Event *) {
-		int range = this->primingTab->findControlTyped<ScrollBar>("RANGE_SLIDER")->getValue();
-
-		UString text = format(tr("Range = %2.1fm."), ((float)(range + 1) * 1.5f));
-		this->primingTab->findControlTyped<Label>("RANGE_TEXT")->setText(text);
+	std::function<void(FormsEvent * e)> updateRange = [this](Event *) {
+		this->refreshRangeText();
 	};
 
 	// Priming controls
 
-	this->uiTabsRT[2]
+	uiTabsRT[2]
 	    ->findControlTyped<CheckBox>("HIDDEN_CHECK_RIGHT_HAND")
 	    ->setClickSound(nullptr);
-	this->uiTabsRT[2]->findControlTyped<CheckBox>("HIDDEN_CHECK_RIGHT_HAND")->Enabled = false;
-	this->uiTabsRT[2]
+	uiTabsRT[2]->findControlTyped<CheckBox>("HIDDEN_CHECK_RIGHT_HAND")->Enabled = false;
+	uiTabsRT[2]
 	    ->findControlTyped<GraphicButton>("BUTTON_CANCEL")
 	    ->addCallback(FormEventType::ButtonClick, cancelThrow);
-	this->uiTabsRT[2]
+	uiTabsRT[2]
 	    ->findControlTyped<GraphicButton>("BUTTON_OK")
 	    ->addCallback(FormEventType::ButtonClick, finishPriming);
-	this->uiTabsRT[2]
+	uiTabsRT[2]
 	    ->findControlTyped<ScrollBar>("DELAY_SLIDER")
 	    ->addCallback(FormEventType::ScrollBarChange, updateDelay);
-	this->uiTabsRT[2]
+	uiTabsRT[2]
 	    ->findControlTyped<ScrollBar>("RANGE_SLIDER")
 	    ->addCallback(FormEventType::ScrollBarChange, updateRange);
-	this->uiTabsRT[2]
+	uiTabsRT[2]
 	    ->findControlTyped<CheckBox>("HIDDEN_CHECK_RIGHT_HAND")
 	    ->setClickSound(nullptr);
-	this->uiTabsTB[2]->findControlTyped<CheckBox>("HIDDEN_CHECK_RIGHT_HAND")->Enabled = false;
-	this->uiTabsTB[2]
+	uiTabsTB[2]->findControlTyped<CheckBox>("HIDDEN_CHECK_RIGHT_HAND")->Enabled = false;
+	uiTabsTB[2]
 	    ->findControlTyped<GraphicButton>("BUTTON_CANCEL")
 	    ->addCallback(FormEventType::ButtonClick, cancelThrow);
-	this->uiTabsTB[2]
+	uiTabsTB[2]
 	    ->findControlTyped<GraphicButton>("BUTTON_OK")
 	    ->addCallback(FormEventType::ButtonClick, finishPriming);
-	this->uiTabsTB[2]
+	uiTabsTB[2]
 	    ->findControlTyped<ScrollBar>("DELAY_SLIDER")
 	    ->addCallback(FormEventType::ScrollBarChange, updateDelay);
-	this->uiTabsTB[2]
+	uiTabsTB[2]
 	    ->findControlTyped<ScrollBar>("RANGE_SLIDER")
 	    ->addCallback(FormEventType::ScrollBarChange, updateRange);
 
@@ -726,106 +849,111 @@ BattleView::BattleView(sp<GameState> gameState)
 
 	// Psi controls
 
-	this->uiTabsRT[1]
+	uiTabsRT[1]
 	    ->findControlTyped<GraphicButton>("BUTTON_CANCEL")
 	    ->addCallback(FormEventType::ButtonClick, cancelPsi);
-	this->uiTabsRT[1]
+	uiTabsRT[1]
 	    ->findControlTyped<RadioButton>("BUTTON_CONTROL")
 	    ->addCallback(FormEventType::MouseClick, psiControl);
-	this->uiTabsRT[1]
+	uiTabsRT[1]
 	    ->findControlTyped<RadioButton>("BUTTON_PANIC")
 	    ->addCallback(FormEventType::MouseClick, psiPanic);
-	this->uiTabsRT[1]
+	uiTabsRT[1]
 	    ->findControlTyped<RadioButton>("BUTTON_STUN")
 	    ->addCallback(FormEventType::MouseClick, psiStun);
-	this->uiTabsRT[1]
+	uiTabsRT[1]
 	    ->findControlTyped<RadioButton>("BUTTON_PROBE")
 	    ->addCallback(FormEventType::MouseClick, psiProbe);
-	this->uiTabsTB[1]
+	uiTabsTB[1]
 	    ->findControlTyped<GraphicButton>("BUTTON_CANCEL")
 	    ->addCallback(FormEventType::ButtonClick, cancelPsi);
-	this->uiTabsTB[1]
+	uiTabsTB[1]
 	    ->findControlTyped<RadioButton>("BUTTON_CONTROL")
 	    ->addCallback(FormEventType::MouseClick, psiControl);
-	this->uiTabsTB[1]
+	uiTabsTB[1]
 	    ->findControlTyped<RadioButton>("BUTTON_PANIC")
 	    ->addCallback(FormEventType::MouseClick, psiPanic);
-	this->uiTabsTB[1]
+	uiTabsTB[1]
 	    ->findControlTyped<RadioButton>("BUTTON_STUN")
 	    ->addCallback(FormEventType::MouseClick, psiStun);
-	this->uiTabsTB[1]
+	uiTabsTB[1]
 	    ->findControlTyped<RadioButton>("BUTTON_PROBE")
 	    ->addCallback(FormEventType::MouseClick, psiProbe);
 
 	// Hand controls
 
-	this->uiTabsRT[0]
+	uiTabsRT[0]
 	    ->findControlTyped<Graphic>("OVERLAY_RIGHT_HAND")
 	    ->addCallback(FormEventType::MouseDown, clickedRightHand);
-	this->uiTabsRT[0]
+	uiTabsRT[0]
 	    ->findControlTyped<Graphic>("OVERLAY_LEFT_HAND")
 	    ->addCallback(FormEventType::MouseDown, clickedLeftHand);
-	this->uiTabsTB[0]
+	uiTabsTB[0]
 	    ->findControlTyped<Graphic>("OVERLAY_RIGHT_HAND")
 	    ->addCallback(FormEventType::MouseDown, clickedRightHand);
-	this->uiTabsTB[0]
+	uiTabsTB[0]
 	    ->findControlTyped<Graphic>("OVERLAY_LEFT_HAND")
 	    ->addCallback(FormEventType::MouseDown, clickedLeftHand);
-	this->uiTabsRT[0]
+	uiTabsRT[0]
 	    ->findControlTyped<GraphicButton>("BUTTON_RIGHT_HAND_DROP")
 	    ->addCallback(FormEventType::MouseClick, dropRightHand);
-	this->uiTabsRT[0]
+	uiTabsRT[0]
 	    ->findControlTyped<GraphicButton>("BUTTON_LEFT_HAND_DROP")
 	    ->addCallback(FormEventType::MouseClick, dropLeftHand);
-	this->uiTabsTB[0]
+	uiTabsTB[0]
 	    ->findControlTyped<GraphicButton>("BUTTON_RIGHT_HAND_DROP")
 	    ->addCallback(FormEventType::MouseClick, dropRightHand);
-	this->uiTabsTB[0]
+	uiTabsTB[0]
 	    ->findControlTyped<GraphicButton>("BUTTON_LEFT_HAND_DROP")
 	    ->addCallback(FormEventType::MouseClick, dropLeftHand);
-	this->uiTabsRT[0]
+	uiTabsRT[0]
 	    ->findControlTyped<CheckBox>("BUTTON_RIGHT_HAND_THROW")
 	    ->addCallback(FormEventType::MouseClick, throwRightHand);
-	this->uiTabsRT[0]
+	uiTabsRT[0]
 	    ->findControlTyped<CheckBox>("BUTTON_LEFT_HAND_THROW")
 	    ->addCallback(FormEventType::MouseClick, throwLeftHand);
-	this->uiTabsTB[0]
+	uiTabsTB[0]
 	    ->findControlTyped<CheckBox>("BUTTON_RIGHT_HAND_THROW")
 	    ->addCallback(FormEventType::MouseClick, throwRightHand);
-	this->uiTabsTB[0]
+	uiTabsTB[0]
 	    ->findControlTyped<CheckBox>("BUTTON_LEFT_HAND_THROW")
 	    ->addCallback(FormEventType::MouseClick, throwLeftHand);
 
-	// We need this in TB because we will be able to allow pausing then
-	this->baseForm->findControl("BUTTON_SPEED0")
+	// We need these in TB because we will be able to allow pausing then
+
+	baseForm->findControl("BUTTON_SPEED0")
 	    ->addCallback(FormEventType::CheckBoxSelected, [this](Event *) {
 		    this->lastSpeed = this->updateSpeed;
 		    this->updateSpeed = BattleUpdateSpeed::Pause;
 		});
-	this->baseForm->findControl("BUTTON_SPEED1")
+	baseForm->findControl("BUTTON_SPEED1")
 	    ->addCallback(FormEventType::CheckBoxSelected,
 	                  [this](Event *) { this->updateSpeed = BattleUpdateSpeed::Speed1; });
-	this->baseForm->findControl("BUTTON_SPEED2")
+	baseForm->findControl("BUTTON_SPEED2")
 	    ->addCallback(FormEventType::CheckBoxSelected,
 	                  [this](Event *) { this->updateSpeed = BattleUpdateSpeed::Speed2; });
-	this->baseForm->findControl("BUTTON_SPEED3")
+	baseForm->findControl("BUTTON_SPEED3")
 	    ->addCallback(FormEventType::CheckBoxSelected,
 	                  [this](Event *) { this->updateSpeed = BattleUpdateSpeed::Speed3; });
 
 	switch (battle.mode)
 	{
 		case Battle::Mode::RealTime:
-			this->baseForm->findControl("BUTTON_ENDTURN")->setVisible(false);
+			baseForm->findControl("BUTTON_RESERVE_AIMED")->setVisible(false);
+			baseForm->findControl("BUTTON_RESERVE_SNAP")->setVisible(false);
+			baseForm->findControl("BUTTON_RESERVE_AUTO")->setVisible(false);
+			baseForm->findControl("BUTTON_RESERVE_KNEEL")->setVisible(false);
+			baseForm->findControl("BUTTON_ENDTURN")->setVisible(false);
 			break;
 		case Battle::Mode::TurnBased:
-			this->baseForm->findControl("BUTTON_SPEED0")->setVisible(false);
-			this->baseForm->findControl("BUTTON_SPEED1")->setVisible(false);
-			this->baseForm->findControl("BUTTON_SPEED2")->setVisible(false);
-			this->baseForm->findControl("BUTTON_SPEED3")->setVisible(false);
-			this->baseForm->findControl("CLOCK")->setVisible(false);
-			this->baseForm->findControl("BUTTON_ENDTURN")
+			baseForm->findControl("BUTTON_SPEED0")->setVisible(false);
+			baseForm->findControl("BUTTON_SPEED1")->setVisible(false);
+			baseForm->findControl("BUTTON_SPEED2")->setVisible(false);
+			baseForm->findControl("BUTTON_SPEED3")->setVisible(false);
+			baseForm->findControl("CLOCK")->setVisible(false);
+			baseForm->findControl("BUTTON_ENDTURN")
 			    ->addCallback(FormEventType::ButtonClick,
-			                  [this](Event *) { this->battle.endTurn(); });
+			                  [this](Event *) { endTurnRequested = true; });
 			break;
 	}
 
@@ -836,27 +964,25 @@ BattleView::~BattleView() = default;
 
 void BattleView::begin()
 {
-	this->uiTabsRT[0]->findControl("BUTTON_LAYER_1")->setVisible(maxZDraw >= 1);
-	this->uiTabsRT[0]->findControl("BUTTON_LAYER_2")->setVisible(maxZDraw >= 2);
-	this->uiTabsRT[0]->findControl("BUTTON_LAYER_3")->setVisible(maxZDraw >= 3);
-	this->uiTabsRT[0]->findControl("BUTTON_LAYER_4")->setVisible(maxZDraw >= 4);
-	this->uiTabsRT[0]->findControl("BUTTON_LAYER_5")->setVisible(maxZDraw >= 5);
-	this->uiTabsRT[0]->findControl("BUTTON_LAYER_6")->setVisible(maxZDraw >= 6);
-	this->uiTabsRT[0]->findControl("BUTTON_LAYER_7")->setVisible(maxZDraw >= 7);
-	this->uiTabsRT[0]->findControl("BUTTON_LAYER_8")->setVisible(maxZDraw >= 8);
-	this->uiTabsRT[0]->findControl("BUTTON_LAYER_9")->setVisible(maxZDraw >= 9);
-	this->uiTabsTB[0]->findControl("BUTTON_LAYER_1")->setVisible(maxZDraw >= 1);
-	this->uiTabsTB[0]->findControl("BUTTON_LAYER_2")->setVisible(maxZDraw >= 2);
-	this->uiTabsTB[0]->findControl("BUTTON_LAYER_3")->setVisible(maxZDraw >= 3);
-	this->uiTabsTB[0]->findControl("BUTTON_LAYER_4")->setVisible(maxZDraw >= 4);
-	this->uiTabsTB[0]->findControl("BUTTON_LAYER_5")->setVisible(maxZDraw >= 5);
-	this->uiTabsTB[0]->findControl("BUTTON_LAYER_6")->setVisible(maxZDraw >= 6);
-	this->uiTabsTB[0]->findControl("BUTTON_LAYER_7")->setVisible(maxZDraw >= 7);
-	this->uiTabsTB[0]->findControl("BUTTON_LAYER_8")->setVisible(maxZDraw >= 8);
-	this->uiTabsTB[0]->findControl("BUTTON_LAYER_9")->setVisible(maxZDraw >= 9);
+	uiTabsRT[0]->findControl("BUTTON_LAYER_1")->setVisible(maxZDraw >= 1);
+	uiTabsRT[0]->findControl("BUTTON_LAYER_2")->setVisible(maxZDraw >= 2);
+	uiTabsRT[0]->findControl("BUTTON_LAYER_3")->setVisible(maxZDraw >= 3);
+	uiTabsRT[0]->findControl("BUTTON_LAYER_4")->setVisible(maxZDraw >= 4);
+	uiTabsRT[0]->findControl("BUTTON_LAYER_5")->setVisible(maxZDraw >= 5);
+	uiTabsRT[0]->findControl("BUTTON_LAYER_6")->setVisible(maxZDraw >= 6);
+	uiTabsRT[0]->findControl("BUTTON_LAYER_7")->setVisible(maxZDraw >= 7);
+	uiTabsRT[0]->findControl("BUTTON_LAYER_8")->setVisible(maxZDraw >= 8);
+	uiTabsRT[0]->findControl("BUTTON_LAYER_9")->setVisible(maxZDraw >= 9);
+	uiTabsTB[0]->findControl("BUTTON_LAYER_1")->setVisible(maxZDraw >= 1);
+	uiTabsTB[0]->findControl("BUTTON_LAYER_2")->setVisible(maxZDraw >= 2);
+	uiTabsTB[0]->findControl("BUTTON_LAYER_3")->setVisible(maxZDraw >= 3);
+	uiTabsTB[0]->findControl("BUTTON_LAYER_4")->setVisible(maxZDraw >= 4);
+	uiTabsTB[0]->findControl("BUTTON_LAYER_5")->setVisible(maxZDraw >= 5);
+	uiTabsTB[0]->findControl("BUTTON_LAYER_6")->setVisible(maxZDraw >= 6);
+	uiTabsTB[0]->findControl("BUTTON_LAYER_7")->setVisible(maxZDraw >= 7);
+	uiTabsTB[0]->findControl("BUTTON_LAYER_8")->setVisible(maxZDraw >= 8);
+	uiTabsTB[0]->findControl("BUTTON_LAYER_9")->setVisible(maxZDraw >= 9);
 
-	if (battle.mode == Battle::Mode::TurnBased)
-		onNewTurn();
 }
 
 void BattleView::resume() {}
@@ -897,7 +1023,7 @@ void BattleView::render()
 	}
 
 	// If there's a modal dialog, darken the screen
-	if (fw().stageGetCurrent() != this->shared_from_this())
+	if (fw().stageGetCurrent() != shared_from_this())
 	{
 		fw().renderer->drawFilledRect({0, 0}, fw().displayGetSize(), Colour{0, 0, 0, 128});
 	}
@@ -928,25 +1054,50 @@ void BattleView::setUpdateSpeed(BattleUpdateSpeed updateSpeed)
 
 void BattleView::update()
 {
+	bool realTime = battle.mode == Battle::Mode::RealTime;
+
 	BattleTileView::update();
 	// FIXME: Is there a more efficient way? But TileView does not know about battle or state!
 	battle.battleViewScreenCenter = centerPos;
 
 	// Update turn based stuff
-	if (battle.mode == Battle::Mode::TurnBased)
+	if (!realTime)
 	{
-		bool notMyTurn = !battle.interruptUnits.empty() || battle.currentActiveOrganisation != battle.currentPlayer;
+		bool notMyTurn = endTurnRequested || battle.turnEndAllowed || !battle.interruptUnits.empty() || !battle.interruptQueue.empty() || battle.currentActiveOrganisation != battle.currentPlayer;
 		if (notMyTurn && activeTab != notMyTurnTab)
 		{
 			activeTab = notMyTurnTab;
 			lastSelectedUnits = battle.battleViewSelectedUnits;
-			// Do other stuff that should be done when control is taken away?
+			battle.battleViewSelectedUnits.clear();
+			updateTBButtons();
 		}
 		else if (!notMyTurn && activeTab == notMyTurnTab)
 		{
 			activeTab = mainTab;
 			battle.battleViewSelectedUnits = lastSelectedUnits;
-			// Do other stuff that should be done when control is regained?
+			updateTBButtons();
+		}
+
+		if (endTurnRequested && !unitPendingConfirmation && battle.ticksWithoutAction >= TICKS_TRY_END_TURN)
+		{
+			for (auto &u : battle.units)
+			{
+				if (u.second->owner != battle.currentActiveOrganisation || u.second->missions.empty() || u.second->missions.front()->type!= BattleUnitMission::Type::AcquireTU || !u.second->missions.front()->allowContinue || unitsSkipped.find(u.second) != unitsSkipped.end())
+				{
+					continue;
+				}
+				unitPendingConfirmation = u.second;
+				battle.ticksWithoutAction = 0;
+				unitsSkipped.insert(unitPendingConfirmation);
+				fw().stageQueueCommand({ StageCmd::Command::PUSH, executePlanPopup});
+				break;
+			}
+			if (!unitPendingConfirmation)
+			{
+				battle.turnEndAllowed = true;
+				endTurnRequested = false;
+				unitsSkipped.clear();
+			}
 		}
 	}
 
@@ -967,7 +1118,7 @@ void BattleView::update()
 		rightThrowDelay--;
 	}
 	// Update path preview in TB mode
-	if (battle.mode == Battle::Mode::TurnBased)
+	if (!realTime)
 	{
 		if (previewedPathCost == -1)
 		{
@@ -981,7 +1132,7 @@ void BattleView::update()
 	}
 
 	unsigned int ticks = 0;
-	switch (this->updateSpeed)
+	switch (updateSpeed)
 	{
 		case BattleUpdateSpeed::Pause:
 			ticks = 0;
@@ -998,7 +1149,7 @@ void BattleView::update()
 	}
 	while (ticks > 0)
 	{
-		this->state->update();
+		state->update();
 		ticks--;
 	}
 	if (battle.mode == Battle::Mode::RealTime)
@@ -1015,20 +1166,18 @@ void BattleView::update()
 		colorCurrent = clamp(colorCurrent, 0, 15);
 		colorForward = !colorForward;
 	}
-	this->pal = modPalette[colorCurrent];
+	pal = modPalette[colorCurrent];
 
 	// Update weapons if required
 
 	auto rightInfo = createItemOverlayInfo(true);
-	if (rightInfo != rightHandInfo &&
-	    (this->activeTab == uiTabsRT[0] || this->activeTab == uiTabsTB[0]))
+	if (rightInfo != rightHandInfo && activeTab == mainTab)
 	{
 		rightHandInfo = rightInfo;
 		updateItemInfo(true);
 	}
 	auto leftInfo = createItemOverlayInfo(false);
-	if (leftInfo != leftHandInfo &&
-	    (this->activeTab == uiTabsRT[0] || this->activeTab == uiTabsTB[0]))
+	if (leftInfo != leftHandInfo && activeTab == mainTab)
 	{
 		leftHandInfo = leftInfo;
 		updateItemInfo(false);
@@ -1040,7 +1189,7 @@ void BattleView::update()
 	{
 		f->Enabled = false;
 	}
-	if (leftHandInfo.selected || rightHandInfo.selected)
+	if ((leftHandInfo.selected || rightHandInfo.selected) && !battle.battleViewSelectedUnits.empty())
 	{
 		auto unit = battle.battleViewSelectedUnits.front();
 		for (int i = 0; i < 2; i++)
@@ -1062,11 +1211,18 @@ void BattleView::update()
 				{
 					motionScannerForms[right]->Enabled = true;
 
-					auto newMotionInfo = createMotionInfo(*item->battleScanner);
+					auto newMotionInfo = realTime ? createMotionInfo(*item->battleScanner) : createMotionInfo();
 					if (motionInfo != newMotionInfo)
 					{
 						motionInfo = newMotionInfo;
-						updateMotionInfo(right, *item->battleScanner);
+						if (realTime)
+						{
+							updateMotionInfo(right, *item->battleScanner);
+						}
+						else
+						{
+							updateMotionInfo(right,motionInfo.position);
+						}
 					}
 
 					break;
@@ -1097,7 +1253,7 @@ void BattleView::update()
 	}
 
 	// Update psi
-	if (this->activeTab == psiTab)
+	if (activeTab == psiTab)
 	{
 		auto newPsiInfo = createPsiInfo();
 		if (psiInfo != newPsiInfo)
@@ -1120,7 +1276,7 @@ void BattleView::update()
 
 	// If we have 'follow agent' enabled we clobber any other movement that may have occurred in
 	// this frame
-	if (this->followAgent)
+	if (followAgent)
 	{
 		if (battle.battleViewSelectedUnits.size() > 0)
 		{
@@ -1133,6 +1289,7 @@ void BattleView::updateSelectedUnits()
 {
 	if (activeTab == notMyTurnTab)
 	{
+		resetPathPreview();
 		return;
 	}
 	auto prevLSU = lastSelectedUnit;
@@ -1170,10 +1327,10 @@ void BattleView::updateSelectedUnits()
 		switch (battle.mode)
 		{
 			case Battle::Mode::RealTime:
-				this->activeTab = this->uiTabsRT[0];
+				activeTab = uiTabsRT[0];
 				break;
 			case Battle::Mode::TurnBased:
-				this->activeTab = this->uiTabsTB[0];
+				activeTab = uiTabsTB[0];
 				break;
 		}
 	}
@@ -1190,8 +1347,6 @@ void BattleView::updateSelectedUnits()
 
 void BattleView::updateSelectionMode()
 {
-	// FIXME: Add Psi in the mix
-	// FIXME: Change cursor
 	if (battle.battleViewSelectedUnits.size() == 0)
 	{
 		if (modifierLCtrl || modifierRCtrl)
@@ -1273,7 +1428,6 @@ void BattleView::updateSelectionMode()
 			break;
 	}
 	// Change cursor
-	bool psiCursor = false;
 	switch (selectionState)
 	{
 		case BattleSelectionState::FireAny:
@@ -1297,7 +1451,6 @@ void BattleView::updateSelectionMode()
 		case BattleSelectionState::PsiStun:
 		case BattleSelectionState::PsiProbe:
 			fw().getCursor().CurrentType = ApocCursor::CursorType::PsiTarget;
-			psiCursor = true;
 			break;
 		case BattleSelectionState::Normal:
 		case BattleSelectionState::NormalAlt:
@@ -1337,7 +1490,12 @@ void BattleView::updateSoldierButtons()
 	bool evasive = false;
 	bool normal = false;
 	bool aggressive = false;
-
+	bool reserve_aimed_set = false;
+	bool reserve_snap_set = false;
+	bool reserve_auto_set = false;
+	bool reserve_kneel_set = false;
+	bool reserve_shot_unset = false;
+	bool reserve_kneel_unset = false;
 	for (auto u : battle.battleViewSelectedUnits)
 	{
 		switch (u->fire_aiming_mode)
@@ -1392,31 +1550,128 @@ void BattleView::updateSoldierButtons()
 		{
 			not_kneeling = true;
 		}
+		switch (u->reserve_shot_mode)
+		{
+			case ReserveShotMode::Aimed:
+				reserve_aimed_set = true;
+				break;
+			case ReserveShotMode::Snap:
+				reserve_snap_set = true;
+				break;
+			case ReserveShotMode::Auto:
+				reserve_auto_set = true;
+				break;
+			case ReserveShotMode::None:
+				reserve_shot_unset = true;
+				break;
+		}
+		if (u->reserve_kneel_mode == KneelingMode::Kneeling)
+		{
+			reserve_kneel_set = true;
+		}
+		else
+		{
+			reserve_kneel_unset = true;
+		}
 	}
 
-	this->baseForm->findControlTyped<TriStateBox>("BUTTON_CEASE_FIRE")
+	baseForm->findControlTyped<TriStateBox>("BUTTON_CEASE_FIRE")
 	    ->setState(cease_fire && at_will ? 3 : (cease_fire ? 2 : 1));
-	this->baseForm->findControlTyped<CheckBox>("BUTTON_AIMED")->setChecked(aimed);
-	this->baseForm->findControlTyped<CheckBox>("BUTTON_SNAP")->setChecked(snap);
-	this->baseForm->findControlTyped<CheckBox>("BUTTON_AUTO")->setChecked(auto_fire);
-	this->baseForm->findControlTyped<TriStateBox>("BUTTON_KNEEL")
+	baseForm->findControlTyped<CheckBox>("BUTTON_AIMED")->setChecked(aimed);
+	baseForm->findControlTyped<CheckBox>("BUTTON_SNAP")->setChecked(snap);
+	baseForm->findControlTyped<CheckBox>("BUTTON_AUTO")->setChecked(auto_fire);
+	baseForm->findControlTyped<TriStateBox>("BUTTON_KNEEL")
 	    ->setState(kneeling && not_kneeling ? 3 : (kneeling ? 2 : 1));
-	this->baseForm->findControlTyped<CheckBox>("BUTTON_PRONE")->setChecked(prone);
-	this->baseForm->findControlTyped<CheckBox>("BUTTON_WALK")->setChecked(walk);
-	this->baseForm->findControlTyped<CheckBox>("BUTTON_RUN")->setChecked(run);
-	this->baseForm->findControlTyped<CheckBox>("BUTTON_EVASIVE")->setChecked(evasive);
-	this->baseForm->findControlTyped<CheckBox>("BUTTON_NORMAL")->setChecked(normal);
-	this->baseForm->findControlTyped<CheckBox>("BUTTON_AGGRESSIVE")->setChecked(aggressive);
+	baseForm->findControlTyped<CheckBox>("BUTTON_PRONE")->setChecked(prone);
+	baseForm->findControlTyped<CheckBox>("BUTTON_WALK")->setChecked(walk);
+	baseForm->findControlTyped<CheckBox>("BUTTON_RUN")->setChecked(run);
+	baseForm->findControlTyped<CheckBox>("BUTTON_EVASIVE")->setChecked(evasive);
+	baseForm->findControlTyped<CheckBox>("BUTTON_NORMAL")->setChecked(normal);
+	baseForm->findControlTyped<CheckBox>("BUTTON_AGGRESSIVE")->setChecked(aggressive);
+
+	baseForm->findControlTyped<TriStateBox>("BUTTON_RESERVE_AIMED")
+		->setState(reserve_aimed_set && reserve_shot_unset ? 3 : (reserve_aimed_set ? 2 : 1));
+	baseForm->findControlTyped<TriStateBox>("BUTTON_RESERVE_SNAP")
+		->setState(reserve_snap_set && reserve_shot_unset ? 3 : (reserve_snap_set ? 2 : 1));
+	baseForm->findControlTyped<TriStateBox>("BUTTON_RESERVE_AUTO")
+		->setState(reserve_auto_set && reserve_shot_unset ? 3 : (reserve_auto_set ? 2 : 1));
+	baseForm->findControlTyped<TriStateBox>("BUTTON_RESERVE_KNEEL")
+		->setState(reserve_kneel_set && reserve_kneel_unset ? 3 : (reserve_kneel_set ? 2 : 1));
 
 	bool throwing = !battle.battleViewSelectedUnits.empty() &&
 	                battle.battleViewSelectedUnits.front()->isThrowing();
 
-	this->mainTab->findControlTyped<CheckBox>("BUTTON_LEFT_HAND_THROW")
+	mainTab->findControlTyped<CheckBox>("BUTTON_LEFT_HAND_THROW")
 	    ->setChecked(selectionState == BattleSelectionState::ThrowLeft || leftThrowDelay > 0 ||
 	                 throwing);
-	this->mainTab->findControlTyped<CheckBox>("BUTTON_RIGHT_HAND_THROW")
+	mainTab->findControlTyped<CheckBox>("BUTTON_RIGHT_HAND_THROW")
 	    ->setChecked(selectionState == BattleSelectionState::ThrowRight || rightThrowDelay > 0 ||
 	                 throwing);
+
+
+}
+
+void BattleView::updateTBButtons()
+{
+	bool visible = activeTab != notMyTurnTab;
+	baseForm->findControlTyped<CheckBox>("BUTTON_FOLLOW_AGENT")->setVisible(visible);
+	baseForm->findControlTyped<GraphicButton>("BUTTON_SHOW_OPTIONS")->setVisible(visible);
+	baseForm->findControlTyped<TriStateBox>("BUTTON_CEASE_FIRE")->setVisible(visible);
+	baseForm->findControlTyped<CheckBox>("BUTTON_AIMED")->setVisible(visible);
+	baseForm->findControlTyped<CheckBox>("BUTTON_SNAP")->setVisible(visible);
+	baseForm->findControlTyped<CheckBox>("BUTTON_AUTO")->setVisible(visible);
+	baseForm->findControlTyped<TriStateBox>("BUTTON_KNEEL")->setVisible(visible);
+	baseForm->findControlTyped<CheckBox>("BUTTON_PRONE")->setVisible(visible);
+	baseForm->findControlTyped<CheckBox>("BUTTON_WALK")->setVisible(visible);
+	baseForm->findControlTyped<CheckBox>("BUTTON_RUN")->setVisible(visible);
+	baseForm->findControlTyped<CheckBox>("BUTTON_EVASIVE")->setVisible(visible);
+	baseForm->findControlTyped<CheckBox>("BUTTON_NORMAL")->setVisible(visible);
+	baseForm->findControlTyped<CheckBox>("BUTTON_AGGRESSIVE")->setVisible(visible);
+	baseForm->findControlTyped<TriStateBox>("BUTTON_RESERVE_AIMED")->setVisible(visible);
+	baseForm->findControlTyped<TriStateBox>("BUTTON_RESERVE_SNAP")->setVisible(visible);
+	baseForm->findControlTyped<TriStateBox>("BUTTON_RESERVE_AUTO")->setVisible(visible);
+	baseForm->findControlTyped<TriStateBox>("BUTTON_RESERVE_KNEEL")->setVisible(visible);
+	baseForm->findControlTyped<GraphicButton>("BUTTON_ENDTURN")->setVisible(visible);
+	baseForm->findControlTyped<RadioButton>("BUTTON_MOVE_GROUP")->setVisible(visible);
+	baseForm->findControlTyped<RadioButton>("BUTTON_MOVE_INDIVIDUALLY")->setVisible(visible);
+}
+
+void BattleView::refreshDelayText()
+{
+	int delay = primingTab->findControlTyped<ScrollBar>("DELAY_SLIDER")->getValue();
+	LogWarning("Delay %d", delay);
+	UString text;
+	if (delay == 0)
+	{
+		text = format(tr("Activates now."));
+	}
+	else
+	{
+		if (battle.mode == Battle::Mode::TurnBased)
+		{
+			if (delay == 1)
+			{
+				text = format(tr("Activates at end of turn."));
+			}
+			else
+			{
+				text = format("%s %d", tr("Turns before activation:"), delay - 1);
+			}
+		}
+		else
+		{
+			text = format(tr("Delay = %i"), (int)((float)delay / 4.0f));
+		}
+	}
+	primingTab->findControlTyped<Label>("DELAY_TEXT")->setText(text);
+}
+
+void BattleView::refreshRangeText()
+{
+	int range = primingTab->findControlTyped<ScrollBar>("RANGE_SLIDER")->getValue();
+
+	UString text = format(tr("Range = %2.1fm."), ((float)(range + 1) * 1.5f));
+	primingTab->findControlTyped<Label>("RANGE_TEXT")->setText(text);
 }
 
 void BattleView::orderJump(Vec3<int> target, BodyState bodyState)
@@ -1447,6 +1702,7 @@ void BattleView::orderMove(Vec3<int> target, bool strafe, bool demandGiveWay)
 	auto u = battle.battleViewSelectedUnits.front();
 	BattleUnit temp;
 	temp.agent = u->agent;
+	temp.position = u->position;
 	int facingDelta = strafe ? BattleUnitMission::getFacingDelta(
 	                               u->facing, BattleUnitMission::getFacing(temp, target))
 	                         : 0;
@@ -1565,7 +1821,7 @@ void BattleView::orderUse(bool right, bool automatic)
 				{
 					item->prime();
 				}
-				this->selectionState =
+				selectionState =
 				    right ? BattleSelectionState::ThrowRight : BattleSelectionState::ThrowLeft;
 			}
 			else
@@ -1574,9 +1830,12 @@ void BattleView::orderUse(bool right, bool automatic)
 				{
 					break;
 				}
-				this->activeTab = this->primingTab;
-				this->activeTab->findControlTyped<CheckBox>("HIDDEN_CHECK_RIGHT_HAND")
+				activeTab = primingTab;
+				refreshDelayText();
+				refreshRangeText();
+				activeTab->findControlTyped<CheckBox>("HIDDEN_CHECK_RIGHT_HAND")
 				    ->setChecked(right);
+				
 				bool range;
 				switch (item->type->trigger_type)
 				{
@@ -1587,19 +1846,19 @@ void BattleView::orderUse(bool right, bool automatic)
 					default:
 						range = false;
 				}
-				this->activeTab->findControl("RANGE_TEXT")->setVisible(range);
-				this->activeTab->findControl("RANGE_SLIDER")->setVisible(range);
+				activeTab->findControl("RANGE_TEXT")->setVisible(range);
+				activeTab->findControl("RANGE_SLIDER")->setVisible(range);
 			}
 			break;
 		case AEquipmentType::Type::MindBender:
 			// Mind bender does not care for automatic mode
 			selectionState = BattleSelectionState::Normal;
-			this->activeTab = this->psiTab;
-			this->activeTab->findControlTyped<RadioButton>("BUTTON_CONTROL")->setChecked(false);
-			this->activeTab->findControlTyped<RadioButton>("BUTTON_PANIC")->setChecked(false);
-			this->activeTab->findControlTyped<RadioButton>("BUTTON_STUN")->setChecked(false);
-			this->activeTab->findControlTyped<RadioButton>("BUTTON_PROBE")->setChecked(false);
-			this->activeTab->findControlTyped<CheckBox>("RIGHTHANDUSED")->setChecked(right);
+			activeTab = psiTab;
+			activeTab->findControlTyped<RadioButton>("BUTTON_CONTROL")->setChecked(false);
+			activeTab->findControlTyped<RadioButton>("BUTTON_PANIC")->setChecked(false);
+			activeTab->findControlTyped<RadioButton>("BUTTON_STUN")->setChecked(false);
+			activeTab->findControlTyped<RadioButton>("BUTTON_PROBE")->setChecked(false);
+			activeTab->findControlTyped<CheckBox>("RIGHTHANDUSED")->setChecked(right);
 			break;
 		case AEquipmentType::Type::Teleporter:
 			// Teleporter does not care for automatic mode
@@ -1776,20 +2035,75 @@ void BattleView::orderTeleport(Vec3<int> target, bool right)
 
 void BattleView::orderFire(Vec3<int> target, WeaponStatus status, bool modifier)
 {
-	// FIXME: If TB ensure enough TUs for turn and fire
 	for (auto unit : battle.battleViewSelectedUnits)
 	{
-		unit->startAttacking(*state, target, status, modifier);
+		if (!unit->startAttacking(*state, target, status, modifier))
+		{
+			LogWarning("Unsufficient TU to fire");
+		}
+	}
+}
+
+void BattleView::orderFire(StateRef<BattleUnit> shooter, Vec3<int> target, WeaponStatus status)
+{
+	if (!shooter->startAttacking(*state, target, status))
+	{
+		LogWarning("Unsufficient TU to fire");
 	}
 }
 
-void BattleView::orderFire(StateRef<BattleUnit> u, WeaponStatus status)
+void BattleView::orderFire(StateRef<BattleUnit> u, WeaponStatus status, bool forced)
 {
-	// FIXME: If TB ensure enough TUs for turn and fire
-	for (auto unit : battle.battleViewSelectedUnits)
+	if (battle.battleViewSelectedUnits.empty())
+	{
+		return;
+	}
+	bool noLOF = false;
+	if (status == WeaponStatus::FiringBothHands)
+	{
+		for (auto unit : battle.battleViewSelectedUnits)
+		{
+			if (unit->hasLineToUnit(u))
+			{
+				unit->startAttacking(*state, u, status);
+			}
+			else
+			{
+				if (forced)
+				{
+					orderFire(unit, u->position, status);
+				}
+				else
+				{
+					noLOF = true;
+				}
+			}
+		}
+	}
+	else
+	{
+		auto unit = battle.battleViewSelectedUnits.front();
+		if (unit->hasLineToUnit(u))
+		{
+			unit->startAttacking(*state, u, status);
+		}
+		else
+		{
+			if (forced)
+			{
+				orderFire(unit, u->position, status);
+			}
+			else
+			{
+				noLOF = true;
+			}
+		}
+	}
+	if (noLOF)
 	{
-		unit->startAttacking(*state, u, status);
+		LogWarning("No LOF to target!");
 	}
+	
 }
 
 void BattleView::orderFocus(StateRef<BattleUnit> u)
@@ -1824,11 +2138,11 @@ void BattleView::orderPsiAttack(StateRef<BattleUnit> u, PsiStatus status, bool r
 
 	if (unit->startAttackPsi(*state, u, status, item->type))
 	{
-		this->activeTab->findControlTyped<RadioButton>("BUTTON_CONTROL")->setChecked(false);
-		this->activeTab->findControlTyped<RadioButton>("BUTTON_PANIC")->setChecked(false);
-		this->activeTab->findControlTyped<RadioButton>("BUTTON_STUN")->setChecked(false);
-		this->activeTab->findControlTyped<RadioButton>("BUTTON_PROBE")->setChecked(false);
-		this->selectionState = BattleSelectionState::Normal;
+		activeTab->findControlTyped<RadioButton>("BUTTON_CONTROL")->setChecked(false);
+		activeTab->findControlTyped<RadioButton>("BUTTON_PANIC")->setChecked(false);
+		activeTab->findControlTyped<RadioButton>("BUTTON_STUN")->setChecked(false);
+		activeTab->findControlTyped<RadioButton>("BUTTON_PROBE")->setChecked(false);
+		selectionState = BattleSelectionState::Normal;
 	}
 }
 
@@ -1869,6 +2183,7 @@ void BattleView::eventOccurred(Event *e)
 	     e->keyboard().KeyCode == SDLK_LALT || e->keyboard().KeyCode == SDLK_RCTRL ||
 	     e->keyboard().KeyCode == SDLK_LCTRL || e->keyboard().KeyCode == SDLK_f ||
 	     e->keyboard().KeyCode == SDLK_r || e->keyboard().KeyCode == SDLK_a ||
+			e->keyboard().KeyCode == SDLK_e ||
 	     e->keyboard().KeyCode == SDLK_p || e->keyboard().KeyCode == SDLK_h ||
 	     e->keyboard().KeyCode == SDLK_k || e->keyboard().KeyCode == SDLK_q ||
 		  e->keyboard().KeyCode == SDLK_s || e->keyboard().KeyCode == SDLK_j))
@@ -1898,32 +2213,47 @@ void BattleView::eventOccurred(Event *e)
 				    {StageCmd::Command::PUSH, mksp<InGameOptions>(state->shared_from_this())});
 				return;
 			case SDLK_PAGEUP:
-				this->setZLevel(getZLevel() + 1);
+				setZLevel(getZLevel() + 1);
 				setSelectedTilePosition(
 				    {selectedTilePosition.x, selectedTilePosition.y, selectedTilePosition.z + 1});
 				updateLayerButtons();
 				break;
 			case SDLK_PAGEDOWN:
-				this->setZLevel(getZLevel() - 1);
+				setZLevel(getZLevel() - 1);
 				setSelectedTilePosition(
 				    {selectedTilePosition.x, selectedTilePosition.y, selectedTilePosition.z - 1});
 				updateLayerButtons();
 				break;
 			case SDLK_TAB:
-				this->baseForm->findControlTyped<CheckBox>("BUTTON_TOGGLE_STRATMAP")
+				baseForm->findControlTyped<CheckBox>("BUTTON_TOGGLE_STRATMAP")
 				    ->setChecked(
-				        !this->baseForm->findControlTyped<CheckBox>("BUTTON_TOGGLE_STRATMAP")
+				        !baseForm->findControlTyped<CheckBox>("BUTTON_TOGGLE_STRATMAP")
 				             ->isChecked());
 				break;
 			case SDLK_SPACE:
-				if (this->updateSpeed != BattleUpdateSpeed::Pause)
+				if (updateSpeed != BattleUpdateSpeed::Pause)
 					setUpdateSpeed(BattleUpdateSpeed::Pause);
 				else
-					setUpdateSpeed(this->lastSpeed);
+					setUpdateSpeed(lastSpeed);
+				break;
+			case SDLK_e:
+				if (battle.mode == Battle::Mode::TurnBased)
+				{
+					battle.interruptUnits.clear();
+					for (auto u : battle.units)
+					{
+						if (u.second->owner != battle.currentActiveOrganisation || !u.second->isConscious())
+						{
+							continue;
+						}
+						u.second->cancelMissions(*state);
+					}
+					battle.endTurn(*state);
+				}
 				break;
 			case SDLK_f:
 			{
-				auto t = this->getSelectedTilePosition();
+				auto t = getSelectedTilePosition();
 				auto &map = *battle.map;
 				auto tile = map.getTile(t);
 				for (auto &o : tile->ownedObjects)
@@ -2092,7 +2422,7 @@ void BattleView::eventOccurred(Event *e)
 			{
 				if (!battle.battleViewSelectedUnits.empty())
 				{
-					auto t = this->getSelectedTilePosition();
+					auto t = getSelectedTilePosition();
 					orderJump(t);
 				}
 				break;
@@ -2101,10 +2431,10 @@ void BattleView::eventOccurred(Event *e)
 	}
 	else if (e->type() == EVENT_MOUSE_MOVE)
 	{
-		Vec2<float> screenOffset = {this->getScreenOffset().x, this->getScreenOffset().y};
+		Vec2<float> screenOffset = {getScreenOffset().x, getScreenOffset().y};
 		// Offset by 4 since ingame 4 is the typical height of the ground, and game displays cursor
 		// on top of the ground
-		setSelectedTilePosition(this->screenToTileCoords(
+		setSelectedTilePosition(screenToTileCoords(
 		    Vec2<float>((float)e->mouse().X, (float)e->mouse().Y + 4) - screenOffset,
 		    (float)getZLevel() - 1.0f));
 	}
@@ -2138,517 +2468,528 @@ void BattleView::eventOccurred(Event *e)
 	// Exclude mouse down events that are over the form
 	else if (e->type() == EVENT_MOUSE_DOWN)
 	{
-		if (this->getViewMode() == TileViewMode::Strategy && e->type() == EVENT_MOUSE_DOWN &&
-		    Event::isPressed(e->mouse().Button, Event::MouseButton::Middle))
+		handleMouseDown(e);
+	}
+	else if (e->type() == EVENT_GAME_STATE)
+	{
+		auto gameEvent = dynamic_cast<GameEvent *>(e);
+		if (!gameEvent)
 		{
-			Vec2<float> screenOffset = {this->getScreenOffset().x, this->getScreenOffset().y};
-			auto clickTile = this->screenToTileCoords(
-			    Vec2<float>{e->mouse().X, e->mouse().Y} - screenOffset, 0.0f);
-			this->setScreenCenterTile({clickTile.x, clickTile.y});
+			LogError("Invalid game state event");
+			return;
 		}
-		else if (e->type() == EVENT_MOUSE_DOWN &&
-		         (Event::isPressed(e->mouse().Button, Event::MouseButton::Middle)))
+		/*if (!gameEvent->message().empty())
 		{
-			// CHEAT - move unit to mouse
-			if (!battle.battleViewSelectedUnits.empty())
-			{
-				selectionState = BattleSelectionState::TeleportLeft;
-			}
+		    state->logEvent(gameEvent);
+		    baseForm->findControlTyped<Ticker>("NEWS_TICKER")->addMessage(gameEvent->message());
+		    auto notification = mksp<NotificationScreen>(state, *this, gameEvent->message());
+		    stageCmd.cmd = StageCmd::Command::PUSH;
+		    stageCmd.nextStage = notification;
+		}*/
+		switch (gameEvent->type)
+		{
+			default:
+				break;
 		}
-		else if (e->type() == EVENT_MOUSE_DOWN &&
-		         (Event::isPressed(e->mouse().Button, Event::MouseButton::Left) ||
-		          Event::isPressed(e->mouse().Button, Event::MouseButton::Right)))
+	}
+	else
+	{
+		BattleTileView::eventOccurred(e);
+	}
+}
+
+void BattleView::handleMouseDown(Event * e)
+
+{
+	if (activeTab == notMyTurnTab)
+	{
+		return;
+	}
+
+	if (getViewMode() == TileViewMode::Strategy && e->type() == EVENT_MOUSE_DOWN &&
+		Event::isPressed(e->mouse().Button, Event::MouseButton::Middle))
+	{
+		Vec2<float> screenOffset = { getScreenOffset().x, getScreenOffset().y };
+		auto clickTile = screenToTileCoords(
+			Vec2<float>{e->mouse().X, e->mouse().Y} -screenOffset, 0.0f);
+		setScreenCenterTile({ clickTile.x, clickTile.y });
+	}
+	else if (e->type() == EVENT_MOUSE_DOWN &&
+		(Event::isPressed(e->mouse().Button, Event::MouseButton::Middle)))
+	{
+		// CHEAT - move unit to mouse
+		if (!battle.battleViewSelectedUnits.empty())
 		{
-			auto buttonPressed = Event::isPressed(e->mouse().Button, Event::MouseButton::Left)
-			                         ? Event::MouseButton::Left
-			                         : Event::MouseButton::Right;
+			selectionState = BattleSelectionState::TeleportLeft;
+		}
+	}
+	else if (e->type() == EVENT_MOUSE_DOWN &&
+		(Event::isPressed(e->mouse().Button, Event::MouseButton::Left) ||
+			Event::isPressed(e->mouse().Button, Event::MouseButton::Right)))
+	{
+		auto buttonPressed = Event::isPressed(e->mouse().Button, Event::MouseButton::Left)
+			? Event::MouseButton::Left
+			: Event::MouseButton::Right;
 
-			auto player = state->getPlayer();
-			// If a click has not been handled by a form it's in the map.
-			auto t = this->getSelectedTilePosition();
-			auto objsPresent = map.getTile(t.x, t.y, t.z)->getUnits(true);
-			auto unitPresent = objsPresent.empty() ? nullptr : objsPresent.front();
-			auto objsOccupying = map.getTile(t.x, t.y, t.z)->getUnits(true, true);
-			auto unitOccupying = objsOccupying.empty() ? nullptr : objsOccupying.front();
-			if (unitOccupying)
+		auto player = state->getPlayer();
+		// If a click has not been handled by a form it's in the map.
+		auto t = getSelectedTilePosition();
+		auto objsPresent = map.getTile(t.x, t.y, t.z)->getUnits(true);
+		auto unitPresent = objsPresent.empty() ? nullptr : objsPresent.front();
+		auto objsOccupying = map.getTile(t.x, t.y, t.z)->getUnits(true, true);
+		auto unitOccupying = objsOccupying.empty() ? nullptr : objsOccupying.front();
+		if (unitOccupying)
+		{
+			unitPresent = unitOccupying;
+		}
+		// Determine attack target
+		sp<BattleUnit> attackTarget = nullptr;
+		if (!attackTarget)
+		{
+			for (auto u : objsOccupying)
 			{
-				unitPresent = unitOccupying;
+				if (player->isRelatedTo(u->owner) == Organisation::Relation::Hostile &&
+					battle.visibleUnits[player].find({ &*state, u->id }) !=
+					battle.visibleUnits[player].end())
+				{
+					attackTarget = u;
+					break;
+				}
 			}
-			// Determine attack target
-			sp<BattleUnit> attackTarget = nullptr;
-			if (!attackTarget)
+		}
+		if (!attackTarget)
+		{
+			for (auto u : objsPresent)
 			{
-				for (auto u : objsOccupying)
+				if (player->isRelatedTo(u->owner) == Organisation::Relation::Hostile &&
+					battle.visibleUnits[player].find({ &*state, u->id }) !=
+					battle.visibleUnits[player].end())
 				{
-					if (player->isRelatedTo(u->owner) == Organisation::Relation::Hostile &&
-					    battle.visibleUnits[player].find({&*state, u->id}) !=
-					        battle.visibleUnits[player].end())
-					{
-						attackTarget = u;
-						break;
-					}
+					attackTarget = u;
+					break;
 				}
 			}
-			if (!attackTarget)
+		}
+		if (!attackTarget && unitPresent && (unitPresent->owner == player ||
+			battle.visibleUnits[player].find({ &*state, unitPresent->id }) !=
+			battle.visibleUnits[player].end()))
+		{
+			attackTarget = unitPresent;
+		}
+		// Determine selection/deselection target
+		sp<BattleUnit> selectionTarget = nullptr;
+		if (!selectionTarget)
+		{
+			for (auto u : objsOccupying)
 			{
-				for (auto u : objsPresent)
+				if (player == u->owner && u->moraleState == MoraleState::Normal)
 				{
-					if (player->isRelatedTo(u->owner) == Organisation::Relation::Hostile &&
-					    battle.visibleUnits[player].find({&*state, u->id}) !=
-					        battle.visibleUnits[player].end())
-					{
-						attackTarget = u;
-						break;
-					}
+					selectionTarget = u;
+					break;
 				}
 			}
-			if (!attackTarget && unitPresent && (unitPresent->owner == player ||
-			    battle.visibleUnits[player].find({&*state, unitPresent->id}) !=
-			        battle.visibleUnits[player].end()))
+		}
+		if (!selectionTarget)
+		{
+			for (auto u : objsPresent)
 			{
-				attackTarget = unitPresent;
+				if (player == u->owner && u->moraleState == MoraleState::Normal)
+				{
+					selectionTarget = u;
+					break;
+				}
 			}
-			// Determine selection/deselection target
-			sp<BattleUnit> selectionTarget = nullptr;
-			if (!selectionTarget)
+		}
+		// Determine course of action
+		LogWarning("Click at tile %d, %d, %d", t.x, t.y, t.z);
+		switch (selectionState)
+		{
+		case BattleSelectionState::Normal:
+		case BattleSelectionState::NormalAlt:
+			switch (buttonPressed)
 			{
-				for (auto u : objsOccupying)
+			case Event::MouseButton::Left:
+				// If selectable unit is present, priority is to move if not occupied
+				if (selectionTarget)
 				{
-					if (player == u->owner && u->moraleState == MoraleState::Normal)
+					// Move if units are selected and noone is occupying
+					if (!unitOccupying && battle.battleViewSelectedUnits.size() > 0)
 					{
-						selectionTarget = u;
-						break;
+						orderMove(t, selectionState == BattleSelectionState::NormalAlt);
+					}
+					// Select if friendly unit present under cursor
+					else
+					{
+						orderSelect({ &*state, selectionTarget->id });
 					}
 				}
-			}
-			if (!selectionTarget)
-			{
-				for (auto u : objsPresent)
+				// Otherwise move if not occupied
+				else if (!unitOccupying)
+				{
+					orderMove(t, selectionState == BattleSelectionState::NormalAlt);
+				}
+				break;
+			case Event::MouseButton::Right:
+				// Turn if no enemy unit present under cursor
+				// or if holding alt
+				if (!attackTarget ||
+					player->isRelatedTo(attackTarget->owner) !=
+					Organisation::Relation::Hostile ||
+					selectionState == BattleSelectionState::NormalAlt)
+				{
+					orderTurn(t);
+				}
+				// Focus fire RT / Fire TB
+				else
 				{
-					if (player == u->owner && u->moraleState == MoraleState::Normal)
+					switch (battle.mode)
 					{
-						selectionTarget = u;
+					case Battle::Mode::TurnBased:
+						if (attackTarget)
+						{
+							orderFire({ &*state, attackTarget->id }, WeaponStatus::FiringBothHands, modifierLShift || modifierRShift);
+						}
+						break;
+					case Battle::Mode::RealTime:
+						if (attackTarget->isConscious())
+						{
+							orderFocus({ &*state, attackTarget->id });
+						}
 						break;
 					}
 				}
+				break;
+			default:
+				LogError("Unhandled mouse button!");
+				break;
 			}
-			// Determine course of action
-			LogWarning("Click at tile %d, %d, %d", t.x, t.y, t.z);
-			switch (selectionState)
+			break;
+		case BattleSelectionState::NormalCtrl:
+		case BattleSelectionState::NormalCtrlAlt:
+			// Selection add/remove mode
+			switch (buttonPressed)
 			{
-				case BattleSelectionState::Normal:
-				case BattleSelectionState::NormalAlt:
-					switch (buttonPressed)
-					{
-						case Event::MouseButton::Left:
-							// If selectable unit is present, priority is to move if not occupied
-							if (selectionTarget)
-							{
-								// Move if units are selected and noone is occupying
-								if (!unitOccupying && battle.battleViewSelectedUnits.size() > 0)
-								{
-									orderMove(t, selectionState == BattleSelectionState::NormalAlt);
-								}
-								// Select if friendly unit present under cursor
-								else
-								{
-									orderSelect({&*state, selectionTarget->id});
-								}
-							}
-							// Otherwise move if not occupied
-							else if (!unitOccupying)
-							{
-								orderMove(t, selectionState == BattleSelectionState::NormalAlt);
-							}
-							break;
-						case Event::MouseButton::Right:
-							// Turn if no enemy unit present under cursor
-							// or if holding alt
-							if (!attackTarget ||
-							    player->isRelatedTo(attackTarget->owner) !=
-							        Organisation::Relation::Hostile ||
-							    selectionState == BattleSelectionState::NormalAlt)
-							{
-								orderTurn(t);
-							}
-							// Focus fire RT / Fire TB
-							else
-							{
-								switch (battle.mode)
-								{
-									case Battle::Mode::TurnBased:
-										if (attackTarget)
-										{
-											orderFire({&*state, attackTarget->id});
-										}
-										break;
-									case Battle::Mode::RealTime:
-										if (attackTarget->isConscious())
-										{
-											orderFocus({&*state, attackTarget->id});
-										}
-										break;
-								}
-							}
-							break;
-						default:
-							LogError("Unhandled mouse button!");
-							break;
-					}
-					break;
-				case BattleSelectionState::NormalCtrl:
-				case BattleSelectionState::NormalCtrlAlt:
-					// Selection add/remove mode
-					switch (buttonPressed)
-					{
-						// LMB = Add to selection
-						case Event::MouseButton::Left:
-							if (selectionTarget)
-							{
-								orderSelect({&*state, selectionTarget->id}, false, true);
-							}
-							// If none occupying - order move if additional modifiers held
-							else if (!unitOccupying &&
-							         selectionState != BattleSelectionState::NormalCtrl)
-							{
-								// Move pathing through
-								orderMove(t, false, true);
-							}
-							break;
-						// RMB = Remove from selection
-						case Event::MouseButton::Right:
-							if (selectionTarget)
-							{
-								orderSelect({&*state, selectionTarget->id}, true);
-							}
-							break;
-						default:
-							LogError("Unhandled mouse button!");
-							break;
-					}
-					// Debug section below
-					if (true)
+				// LMB = Add to selection
+			case Event::MouseButton::Left:
+				if (selectionTarget)
+				{
+					orderSelect({ &*state, selectionTarget->id }, false, true);
+				}
+				// If none occupying - order move if additional modifiers held
+				else if (!unitOccupying &&
+					selectionState != BattleSelectionState::NormalCtrl)
+				{
+					// Move pathing through
+					orderMove(t, false, true);
+				}
+				break;
+				// RMB = Remove from selection
+			case Event::MouseButton::Right:
+				if (selectionTarget)
+				{
+					orderSelect({ &*state, selectionTarget->id }, true);
+				}
+				break;
+			default:
+				LogError("Unhandled mouse button!");
+				break;
+			}
+			// Debug section below
+			if (true)
+			{
+				UString debug = "";
+				debug += format("\nDEBUG INFORMATION ABOUT TILE %d, %d, %d", t.x, t.y, t.z);
+				debug += format("\n LOS BLOCK %d", battle.getLosBlockID(t.x, t.y, t.z));
+				auto &map = *battle.map;
+				auto tile = map.getTile(t);
+				for (auto &o : tile->ownedObjects)
+				{
+					if (o->getType() == TileObject::Type::Ground ||
+						o->getType() == TileObject::Type::Feature ||
+						o->getType() == TileObject::Type::LeftWall ||
+						o->getType() == TileObject::Type::RightWall)
 					{
-						UString debug = "";
-						debug += format("\nDEBUG INFORMATION ABOUT TILE %d, %d, %d", t.x, t.y, t.z);
-						debug += format("\n LOS BLOCK %d", battle.getLosBlockID(t.x, t.y, t.z));
-						auto &map = *battle.map;
-						auto tile = map.getTile(t);
-						for (auto &o : tile->ownedObjects)
+						auto mp = std::static_pointer_cast<TileObjectBattleMapPart>(o)
+							->getOwner();
+						debug += format(
+							"\n[%s] SBT %d STATUS %s\nFIRE Res=%d Tim=%d Burned=%D",
+							mp->type.id, mp->type->getVanillaSupportedById(),
+							!mp->isAlive()
+							? "DEAD "
+							: (mp->damaged
+								? "DAMAGED"
+								: (mp->providesHardSupport ? "HARD " : "SOFT ")),
+							mp->type->fire_resist, mp->type->fire_burn_time,
+							mp->burnTicksAccumulated);
+						for (int x = t.x - 1; x <= t.x + 1; x++)
 						{
-							if (o->getType() == TileObject::Type::Ground ||
-							    o->getType() == TileObject::Type::Feature ||
-							    o->getType() == TileObject::Type::LeftWall ||
-							    o->getType() == TileObject::Type::RightWall)
+							for (int y = t.y - 1; y <= t.y + 1; y++)
 							{
-								auto mp = std::static_pointer_cast<TileObjectBattleMapPart>(o)
-								              ->getOwner();
-								debug += format(
-								    "\n[%s] SBT %d STATUS %s\nFIRE Res=%d Tim=%d Burned=%D",
-								    mp->type.id, mp->type->getVanillaSupportedById(),
-								    !mp->isAlive()
-								        ? "DEAD "
-								        : (mp->damaged
-								               ? "DAMAGED"
-								               : (mp->providesHardSupport ? "HARD " : "SOFT ")),
-								    mp->type->fire_resist, mp->type->fire_burn_time,
-								    mp->burnTicksAccumulated);
-								for (int x = t.x - 1; x <= t.x + 1; x++)
+								for (int z = t.z - 1; z <= t.z + 1; z++)
 								{
-									for (int y = t.y - 1; y <= t.y + 1; y++)
+									if (x < 0 || x >= map.size.x || y < 0 ||
+										y >= map.size.y || z < 0 || z >= map.size.z)
+									{
+										continue;
+									}
+									auto tile2 = map.getTile(x, y, z);
+									for (auto &o2 : tile2->ownedObjects)
 									{
-										for (int z = t.z - 1; z <= t.z + 1; z++)
+										if (o2->getType() == TileObject::Type::Ground ||
+											o2->getType() == TileObject::Type::Feature ||
+											o2->getType() == TileObject::Type::LeftWall ||
+											o2->getType() == TileObject::Type::RightWall)
 										{
-											if (x < 0 || x >= map.size.x || y < 0 ||
-											    y >= map.size.y || z < 0 || z >= map.size.z)
+											auto mp2 = std::static_pointer_cast<
+												TileObjectBattleMapPart>(o2)
+												->getOwner();
+											for (auto &p : mp2->supportedParts)
 											{
-												continue;
-											}
-											auto tile2 = map.getTile(x, y, z);
-											for (auto &o2 : tile2->ownedObjects)
-											{
-												if (o2->getType() == TileObject::Type::Ground ||
-												    o2->getType() == TileObject::Type::Feature ||
-												    o2->getType() == TileObject::Type::LeftWall ||
-												    o2->getType() == TileObject::Type::RightWall)
+												if (p.first == t &&
+													p.second == mp->type->type)
 												{
-													auto mp2 = std::static_pointer_cast<
-													               TileObjectBattleMapPart>(o2)
-													               ->getOwner();
-													for (auto &p : mp2->supportedParts)
-													{
-														if (p.first == t &&
-														    p.second == mp->type->type)
-														{
-															debug += format(
-															    "\nSupported by %s at %d %d %d",
-															    mp2->type.id, x - t.x, y - t.y,
-															    z - t.z);
-														}
-													}
+													debug += format(
+														"\nSupported by %s at %d %d %d",
+														mp2->type.id, x - t.x, y - t.y,
+														z - t.z);
 												}
 											}
 										}
 									}
 								}
 							}
-							if (o->getType() == TileObject::Type::Hazard)
-							{
-								auto h = std::static_pointer_cast<TileObjectBattleHazard>(o)
-								             ->getHazard();
-								debug += format("\nHazard %s %s Pow=%d Age=%d LT=%d  ",
-								                h->damageType.id, h->damageType->hazardType.id,
-								                h->power, h->age, h->lifetime);
-							}
 						}
-
-						auto uto = tile->getUnitIfPresent();
-						if (uto)
-						{
-							auto u = uto->getUnit();
-							debug += format("\nContains unit %s.", u->id.cStr());
-							debug += format("\nMorale state: %d", (int)u->moraleState);
-							debug += format("\nPosition: %f, %f, %f", u->position.x, u->position.y,
-							                u->position.z);
-							debug += format("\nGoal: %f, %f, %f", u->goalPosition.x,
-							                u->goalPosition.y, u->goalPosition.z);
-							debug += format("\nCurrent movement: %d, falling: %d",
-							                (int)u->current_movement_state, (int)u->falling);
-							debug += format("\nMissions [%d]:", (int)u->missions.size());
-							for (auto &m : u->missions)
-							{
-								debug += format("\n%s", m->getName());
-							}
-							debug += format("\nSeen units [%d]:", (int)u->visibleUnits.size());
-							for (auto &unit : u->visibleUnits)
-							{
-								debug += format("\n%s", unit.id);
-							}
-							/*	debug += format(
-							        "\nCurrent ai state:\n  %s\n  enSp %d enSpPr %d attPos %s "
-							        "lasSnEnPos %s",
-							        u->aiList.lastDecision.getName(), (int)u->aiState.enemySpotted,
-							        (int)u->aiState.enemySpottedPrevious,
-							   u->aiState.attackerPosition,
-							        u->aiList.lastSeenEnemyPosition);*/
-						}
-						LogWarning("%s", debug);
 					}
-					break;
-				case BattleSelectionState::FireAny:
-				case BattleSelectionState::FireLeft:
-				case BattleSelectionState::FireRight:
-					switch (buttonPressed)
+					if (o->getType() == TileObject::Type::Hazard)
 					{
-						case Event::MouseButton::Left:
-						{
-							WeaponStatus status = WeaponStatus::FiringBothHands;
-							switch (selectionState)
-							{
-								case BattleSelectionState::FireLeft:
-									status = WeaponStatus::FiringLeftHand;
-									break;
-								case BattleSelectionState::FireRight:
-									status = WeaponStatus::FiringRightHand;
-									break;
-								case BattleSelectionState::FireAny:
-								default:
-									// Do nothing
-									break;
-							}
-							bool modified = (modifierLAlt || modifierRAlt);
-							if (modified)
-							{
-								orderFire(t, status, modified);
-							}
-							else if (attackTarget)
-							{
-								orderFire({&*state, attackTarget->id}, status);
-							}
-							else
-							{
-								orderFire(t, status, modified);
-							}
-							break;
-						}
-						case Event::MouseButton::Right:
-						{
-							if (selectionState != BattleSelectionState::FireAny)
-							{
-								selectionState = BattleSelectionState::Normal;
-							}
-							break;
-						}
-						default:
-							LogError("Unhandled mouse button!");
-							break;
+						auto h = std::static_pointer_cast<TileObjectBattleHazard>(o)
+							->getHazard();
+						debug += format("\nHazard %s %s Pow=%d Age=%d LT=%d  ",
+							h->damageType.id, h->damageType->hazardType.id,
+							h->power, h->age, h->lifetime);
 					}
-					break;
-				case BattleSelectionState::ThrowRight:
-				case BattleSelectionState::ThrowLeft:
-					switch (buttonPressed)
+				}
+
+				auto uto = tile->getUnitIfPresent();
+				if (uto)
+				{
+					auto u = uto->getUnit();
+					debug += format("\nContains unit %s.", u->id.cStr());
+					debug += format("\nMorale state: %d", (int)u->moraleState);
+					debug += format("\nPosition: %f, %f, %f", u->position.x, u->position.y,
+						u->position.z);
+					debug += format("\nGoal: %f, %f, %f", u->goalPosition.x,
+						u->goalPosition.y, u->goalPosition.z);
+					debug += format("\nCurrent movement: %d, falling: %d",
+						(int)u->current_movement_state, (int)u->falling);
+					debug += format("\nMissions [%d]:", (int)u->missions.size());
+					for (auto &m : u->missions)
 					{
-						case Event::MouseButton::Left:
-						{
-							bool right = selectionState == BattleSelectionState::ThrowRight;
-							orderThrow(t, right);
-							break;
-						}
-						case Event::MouseButton::Right:
-						{
-							selectionState = BattleSelectionState::Normal;
-							break;
-						}
-						default:
-							LogError("Unhandled mouse button!");
-							break;
+						debug += format("\n%s", m->getName());
 					}
-					break;
-				case BattleSelectionState::TeleportLeft:
-				case BattleSelectionState::TeleportRight:
-					switch (buttonPressed)
+					debug += format("\nSeen units [%d]:", (int)u->visibleUnits.size());
+					for (auto &unit : u->visibleUnits)
 					{
-						case Event::MouseButton::Left:
-						{
-							bool right = selectionState == BattleSelectionState::TeleportRight;
-							orderTeleport(t, right);
-							break;
-						}
-						case Event::MouseButton::Right:
-						{
-							selectionState = BattleSelectionState::Normal;
-							break;
-						}
-						default:
-							LogError("Unhandled mouse button!");
-							break;
+						debug += format("\n%s", unit.id);
 					}
+					/*	debug += format(
+					"\nCurrent ai state:\n  %s\n  enSp %d enSpPr %d attPos %s "
+					"lasSnEnPos %s",
+					u->aiList.lastDecision.getName(), (int)u->aiState.enemySpotted,
+					(int)u->aiState.enemySpottedPrevious,
+					u->aiState.attackerPosition,
+					u->aiList.lastSeenEnemyPosition);*/
+				}
+				LogWarning("%s", debug);
+			}
+			break;
+		case BattleSelectionState::FireAny:
+		case BattleSelectionState::FireLeft:
+		case BattleSelectionState::FireRight:
+			switch (buttonPressed)
+			{
+			case Event::MouseButton::Left:
+			{
+				WeaponStatus status = WeaponStatus::FiringBothHands;
+				switch (selectionState)
+				{
+				case BattleSelectionState::FireLeft:
+					status = WeaponStatus::FiringLeftHand;
+					break;
+				case BattleSelectionState::FireRight:
+					status = WeaponStatus::FiringRightHand;
 					break;
-				case BattleSelectionState::PsiControl:
-				case BattleSelectionState::PsiPanic:
-				case BattleSelectionState::PsiStun:
-				case BattleSelectionState::PsiProbe:
-					switch (buttonPressed)
+				case BattleSelectionState::FireAny:
+				default:
+					// Do nothing
+					break;
+				}
+				bool modified = (modifierLAlt || modifierRAlt);
+				if (modified)
+				{
+					orderFire(t, status, modified);
+				}
+				else if (attackTarget)
+				{
+					orderFire({ &*state, attackTarget->id }, status, modifierRShift || modifierLShift);
+				}
+				else
+				{
+					orderFire(t, status, modified);
+				}
+				break;
+			}
+			case Event::MouseButton::Right:
+			{
+				if (selectionState != BattleSelectionState::FireAny)
+				{
+					selectionState = BattleSelectionState::Normal;
+				}
+				break;
+			}
+			default:
+				LogError("Unhandled mouse button!");
+				break;
+			}
+			break;
+		case BattleSelectionState::ThrowRight:
+		case BattleSelectionState::ThrowLeft:
+			switch (buttonPressed)
+			{
+			case Event::MouseButton::Left:
+			{
+				bool right = selectionState == BattleSelectionState::ThrowRight;
+				orderThrow(t, right);
+				break;
+			}
+			case Event::MouseButton::Right:
+			{
+				selectionState = BattleSelectionState::Normal;
+				break;
+			}
+			default:
+				LogError("Unhandled mouse button!");
+				break;
+			}
+			break;
+		case BattleSelectionState::TeleportLeft:
+		case BattleSelectionState::TeleportRight:
+			switch (buttonPressed)
+			{
+			case Event::MouseButton::Left:
+			{
+				bool right = selectionState == BattleSelectionState::TeleportRight;
+				orderTeleport(t, right);
+				break;
+			}
+			case Event::MouseButton::Right:
+			{
+				selectionState = BattleSelectionState::Normal;
+				break;
+			}
+			default:
+				LogError("Unhandled mouse button!");
+				break;
+			}
+			break;
+		case BattleSelectionState::PsiControl:
+		case BattleSelectionState::PsiPanic:
+		case BattleSelectionState::PsiStun:
+		case BattleSelectionState::PsiProbe:
+			switch (buttonPressed)
+			{
+			case Event::MouseButton::Left:
+			{
+				auto u = battle.battleViewSelectedUnits.front();
+				if (attackTarget && attackTarget != u.getSp())
+				{
+					bool right =
+						activeTab->findControlTyped<CheckBox>("RIGHTHANDUSED")
+						->isChecked();
+					switch (selectionState)
 					{
-						case Event::MouseButton::Left:
-						{
-							auto u = battle.battleViewSelectedUnits.front();
-							if (attackTarget && attackTarget != u.getSp())
-							{
-								bool right =
-								    this->activeTab->findControlTyped<CheckBox>("RIGHTHANDUSED")
-								        ->isChecked();
-								switch (selectionState)
-								{
-									case BattleSelectionState::PsiControl:
-										orderPsiAttack({&*state, attackTarget->id},
-										               PsiStatus::Control, right);
-										break;
-									case BattleSelectionState::PsiPanic:
-										orderPsiAttack({&*state, attackTarget->id},
-										               PsiStatus::Panic, right);
-										break;
-									case BattleSelectionState::PsiStun:
-										orderPsiAttack({&*state, attackTarget->id}, PsiStatus::Stun,
-										               right);
-										break;
-									case BattleSelectionState::PsiProbe:
-										orderPsiAttack({&*state, attackTarget->id},
-										               PsiStatus::Probe, right);
-										break;
-									default:
-										// Don't cry Travis
-										break;
-								}
-							}
-							break;
-						}
-						case Event::MouseButton::Right:
-						{
-							selectionState = BattleSelectionState::Normal;
-							if (this->activeTab != psiTab)
-							{
-								LogError("How come are we in psi mode but not in psi tab?");
-							}
-							else
-							{
-								this->activeTab->findControlTyped<RadioButton>("BUTTON_CONTROL")
-								    ->setChecked(false);
-								this->activeTab->findControlTyped<RadioButton>("BUTTON_PANIC")
-								    ->setChecked(false);
-								this->activeTab->findControlTyped<RadioButton>("BUTTON_STUN")
-								    ->setChecked(false);
-								this->activeTab->findControlTyped<RadioButton>("BUTTON_PROBE")
-								    ->setChecked(false);
-							}
-							break;
-						}
-						default:
-							LogError("Unhandled mouse button!");
-							break;
+					case BattleSelectionState::PsiControl:
+						orderPsiAttack({ &*state, attackTarget->id },
+							PsiStatus::Control, right);
+						break;
+					case BattleSelectionState::PsiPanic:
+						orderPsiAttack({ &*state, attackTarget->id },
+							PsiStatus::Panic, right);
+						break;
+					case BattleSelectionState::PsiStun:
+						orderPsiAttack({ &*state, attackTarget->id }, PsiStatus::Stun,
+							right);
+						break;
+					case BattleSelectionState::PsiProbe:
+						orderPsiAttack({ &*state, attackTarget->id },
+							PsiStatus::Probe, right);
+						break;
+					default:
+						// Don't cry Travis
+						break;
 					}
-					break;
+				}
+				break;
+			}
+			case Event::MouseButton::Right:
+			{
+				selectionState = BattleSelectionState::Normal;
+				if (activeTab != psiTab)
+				{
+					LogError("How come are we in psi mode but not in psi tab?");
+				}
+				else
+				{
+					activeTab->findControlTyped<RadioButton>("BUTTON_CONTROL")
+						->setChecked(false);
+					activeTab->findControlTyped<RadioButton>("BUTTON_PANIC")
+						->setChecked(false);
+					activeTab->findControlTyped<RadioButton>("BUTTON_STUN")
+						->setChecked(false);
+					activeTab->findControlTyped<RadioButton>("BUTTON_PROBE")
+						->setChecked(false);
+				}
+				break;
 			}
-		}
-	}
-	else if (e->type() == EVENT_GAME_STATE)
-	{
-		auto gameEvent = dynamic_cast<GameEvent *>(e);
-		if (!gameEvent)
-		{
-			LogError("Invalid game state event");
-			return;
-		}
-		/*if (!gameEvent->message().empty())
-		{
-		    state->logEvent(gameEvent);
-		    baseForm->findControlTyped<Ticker>("NEWS_TICKER")->addMessage(gameEvent->message());
-		    auto notification = mksp<NotificationScreen>(state, *this, gameEvent->message());
-		    stageCmd.cmd = StageCmd::Command::PUSH;
-		    stageCmd.nextStage = notification;
-		}*/
-		switch (gameEvent->type)
-		{
 			default:
+				LogError("Unhandled mouse button!");
 				break;
+			}
+			break;
 		}
 	}
-	else
-	{
-		BattleTileView::eventOccurred(e);
-	}
 }
 
 void BattleView::updateLayerButtons()
 {
-	switch (this->getZLevel())
+	switch (getZLevel())
 	{
 		case 1:
-			this->mainTab->findControlTyped<RadioButton>("BUTTON_LAYER_1")->setChecked(true);
+			mainTab->findControlTyped<RadioButton>("BUTTON_LAYER_1")->setChecked(true);
 			break;
 		case 2:
-			this->mainTab->findControlTyped<RadioButton>("BUTTON_LAYER_2")->setChecked(true);
+			mainTab->findControlTyped<RadioButton>("BUTTON_LAYER_2")->setChecked(true);
 			break;
 		case 3:
-			this->mainTab->findControlTyped<RadioButton>("BUTTON_LAYER_3")->setChecked(true);
+			mainTab->findControlTyped<RadioButton>("BUTTON_LAYER_3")->setChecked(true);
 			break;
 		case 4:
-			this->mainTab->findControlTyped<RadioButton>("BUTTON_LAYER_4")->setChecked(true);
+			mainTab->findControlTyped<RadioButton>("BUTTON_LAYER_4")->setChecked(true);
 			break;
 		case 5:
-			this->mainTab->findControlTyped<RadioButton>("BUTTON_LAYER_5")->setChecked(true);
+			mainTab->findControlTyped<RadioButton>("BUTTON_LAYER_5")->setChecked(true);
 			break;
 		case 6:
-			this->mainTab->findControlTyped<RadioButton>("BUTTON_LAYER_6")->setChecked(true);
+			mainTab->findControlTyped<RadioButton>("BUTTON_LAYER_6")->setChecked(true);
 			break;
 		case 7:
-			this->mainTab->findControlTyped<RadioButton>("BUTTON_LAYER_7")->setChecked(true);
+			mainTab->findControlTyped<RadioButton>("BUTTON_LAYER_7")->setChecked(true);
 			break;
 		case 8:
-			this->mainTab->findControlTyped<RadioButton>("BUTTON_LAYER_8")->setChecked(true);
+			mainTab->findControlTyped<RadioButton>("BUTTON_LAYER_8")->setChecked(true);
 			break;
 		case 9:
-			this->mainTab->findControlTyped<RadioButton>("BUTTON_LAYER_9")->setChecked(true);
+			mainTab->findControlTyped<RadioButton>("BUTTON_LAYER_9")->setChecked(true);
 			break;
 	}
 }
@@ -2670,35 +3011,35 @@ void BattleView::updateItemInfo(bool right)
 	// Item info
 	if (info.itemType)
 	{
-		this->activeTab->findControlTyped<Graphic>("IMAGE_" + name + "_HAND")
+		activeTab->findControlTyped<Graphic>("IMAGE_" + name + "_HAND")
 		    ->setImage(info.itemType->equipscreen_sprite);
 		if (info.damageType)
 		{
-			this->activeTab->findControlTyped<Graphic>("IMAGE_" + name + "_DAMAGETYPE")
+			activeTab->findControlTyped<Graphic>("IMAGE_" + name + "_DAMAGETYPE")
 			    ->setImage(info.damageType->icon_sprite);
 		}
 		else
 		{
-			this->activeTab->findControlTyped<Graphic>("IMAGE_" + name + "_DAMAGETYPE")
+			activeTab->findControlTyped<Graphic>("IMAGE_" + name + "_DAMAGETYPE")
 			    ->setImage(nullptr);
 		}
 	}
 	else
 	{
-		this->activeTab->findControlTyped<Graphic>("IMAGE_" + name + "_HAND")->setImage(nullptr);
-		this->activeTab->findControlTyped<Graphic>("IMAGE_" + name + "_DAMAGETYPE")
+		activeTab->findControlTyped<Graphic>("IMAGE_" + name + "_HAND")->setImage(nullptr);
+		activeTab->findControlTyped<Graphic>("IMAGE_" + name + "_DAMAGETYPE")
 		    ->setImage(nullptr);
 	}
 
 	// Selection bracket
 	if (info.selected)
 	{
-		this->activeTab->findControlTyped<Graphic>("IMAGE_" + name + "_HAND_SELECTED")
+		activeTab->findControlTyped<Graphic>("IMAGE_" + name + "_HAND_SELECTED")
 		    ->setImage(selectedItemOverlay);
 	}
 	else
 	{
-		this->activeTab->findControlTyped<Graphic>("IMAGE_" + name + "_HAND_SELECTED")
+		activeTab->findControlTyped<Graphic>("IMAGE_" + name + "_HAND_SELECTED")
 		    ->setImage(nullptr);
 	}
 
@@ -2755,34 +3096,34 @@ void BattleView::updateItemInfo(bool right)
 			}
 		}
 	}
-	this->activeTab->findControlTyped<Graphic>("OVERLAY_" + name + "_HAND")->setImage(overlay);
+	activeTab->findControlTyped<Graphic>("OVERLAY_" + name + "_HAND")->setImage(overlay);
 }
 
 void BattleView::updatePsiInfo()
 {
-	this->activeTab->findControlTyped<Graphic>("OVERLAY_CONTROL")
+	activeTab->findControlTyped<Graphic>("OVERLAY_CONTROL")
 	    ->setImage(psiInfo.status == PsiStatus::Control ? selectedPsiOverlay : nullptr);
-	this->activeTab->findControlTyped<Graphic>("OVERLAY_PANIC")
+	activeTab->findControlTyped<Graphic>("OVERLAY_PANIC")
 	    ->setImage(psiInfo.status == PsiStatus::Panic ? selectedPsiOverlay : nullptr);
-	this->activeTab->findControlTyped<Graphic>("OVERLAY_STUN")
+	activeTab->findControlTyped<Graphic>("OVERLAY_STUN")
 	    ->setImage(psiInfo.status == PsiStatus::Stun ? selectedPsiOverlay : nullptr);
-	this->activeTab->findControlTyped<Graphic>("OVERLAY_PROBE")
+	activeTab->findControlTyped<Graphic>("OVERLAY_PROBE")
 	    ->setImage(psiInfo.status == PsiStatus::Probe ? selectedPsiOverlay : nullptr);
 
-	this->activeTab->findControlTyped<Label>("PSI_ENERGY_LABEL")
+	activeTab->findControlTyped<Label>("PSI_ENERGY_LABEL")
 	    ->setText(format("%d", psiInfo.curEnergy));
-	this->activeTab->findControlTyped<Label>("PSI_ATTACK_LABEL")
+	activeTab->findControlTyped<Label>("PSI_ATTACK_LABEL")
 	    ->setText(format("%d", psiInfo.curAttack));
-	this->activeTab->findControlTyped<Label>("PSI_DEFENSE_LABEL")
+	activeTab->findControlTyped<Label>("PSI_DEFENSE_LABEL")
 	    ->setText(format("%d", psiInfo.curDefense));
 
 	// FIXME: Maybe pre-draw all 100 of them?
 
-	this->activeTab->findControlTyped<Graphic>("PSI_ENERGY_BAR")
+	activeTab->findControlTyped<Graphic>("PSI_ENERGY_BAR")
 	    ->setImage(drawPsiBar(psiInfo.curEnergy, psiInfo.maxEnergy));
-	this->activeTab->findControlTyped<Graphic>("PSI_ATTACK_BAR")
+	activeTab->findControlTyped<Graphic>("PSI_ATTACK_BAR")
 	    ->setImage(drawPsiBar(psiInfo.curAttack, psiInfo.maxAttack));
-	this->activeTab->findControlTyped<Graphic>("PSI_DEFENSE_BAR")
+	activeTab->findControlTyped<Graphic>("PSI_DEFENSE_BAR")
 	    ->setImage(drawPsiBar(psiInfo.curDefense, psiInfo.maxDefense));
 }
 
@@ -2792,6 +3133,12 @@ void BattleView::updateMotionInfo(bool right, BattleScanner &scanner)
 	motionScannerData[right]->setImage(drawMotionScanner(scanner));
 }
 
+void BattleView::updateMotionInfo(bool right, Vec2<int> position)
+{
+	motionScannerUnit[right]->setImage(motionScannerDirectionIcons[motionInfo.direction]);
+	motionScannerData[right]->setImage(drawMotionScanner(position));
+}
+
 sp<RGBImage> BattleView::drawPsiBar(int cur, int max)
 {
 	int width = 137;
@@ -2851,7 +3198,7 @@ sp<RGBImage> BattleView::drawMotionScanner(BattleScanner &scanner)
 	auto scannerDisplay = mksp<RGBImage>(Vec2<int>{MOTION_SCANNER_X * 2, MOTION_SCANNER_Y * 2});
 	{
 		RGBImageLock l(scannerDisplay);
-		// Content
+
 		for (int x = 0; x < MOTION_SCANNER_X; x++)
 		{
 			for (int y = 0; y < MOTION_SCANNER_Y; y++)
@@ -2859,7 +3206,60 @@ sp<RGBImage> BattleView::drawMotionScanner(BattleScanner &scanner)
 				auto &color = colors.at(std::min(15, scanner.movementTicks[y * MOTION_SCANNER_X + x] * 16 / (int)TICKS_SCANNER_REMAIN_LIT));
 				for (int i = 0;i <= 1;i++)
 				{
-					for (int j = 0;j <= 1;j++) 
+					for (int j = 0;j <= 1;j++)
+					{
+						l.set({ 2 * x + i, 2 * y + j }, color);
+					}
+				}
+			}
+		}
+	}
+	return scannerDisplay;
+}
+
+sp<RGBImage> BattleView::drawMotionScanner(Vec2<int> position)
+{
+	static const std::vector<Colour> colors =
+	{ { 0,0,0, },{ 16,16,16,255 },{ 32,32,32,255 },{ 48,48,48,255 },
+	{ 64,64,64,255 },{ 80,80,80,255 },{ 96,96,96,255 },{ 112,112,112,255 },
+	{ 128,128,128,255 },{ 144,144,144,255 },{ 160,160,160,255 },{ 176,176,176,255 },
+	{ 192,192,192,255 },{ 208,208,208,255 },{ 224,224,224,255 },{ 240,240,240,255 } };
+	static const Vec2<int> midPos = { MOTION_SCANNER_X / 2, MOTION_SCANNER_Y / 2 };
+	auto scannerDisplay = mksp<RGBImage>(Vec2<int>{MOTION_SCANNER_X * 2, MOTION_SCANNER_Y * 2});
+	{
+		RGBImageLock l(scannerDisplay);
+
+		auto movementTicks = std::vector<int>(MOTION_SCANNER_X * MOTION_SCANNER_Y);
+
+		for (auto &u : battle.units)
+		{
+			if (!u.second->isConscious() || u.second->tilesMoved == 0)
+			{
+				continue;
+			}
+			auto pos = Vec2<int>(u.second->position.x, u.second->position.y) - position + midPos;
+			if (pos.x < 0 || pos.y < 0 || pos.x >= MOTION_SCANNER_X || pos.y >= MOTION_SCANNER_Y)
+			{
+				continue;
+			}
+			if (movementTicks[pos.y * MOTION_SCANNER_X + pos.x] < u.second->tilesMoved)
+			{
+				movementTicks[pos.y * MOTION_SCANNER_X + pos.x] = u.second->tilesMoved;
+			}
+		}
+
+		for (int x = 0; x < MOTION_SCANNER_X; x++)
+		{
+			for (int y = 0; y < MOTION_SCANNER_Y; y++)
+			{
+				if (movementTicks[y * MOTION_SCANNER_X + x] > 0)
+				{
+					movementTicks[y * MOTION_SCANNER_X + x] = 5 + movementTicks[y * MOTION_SCANNER_X + x] * 2 / 3;
+				}
+				auto &color = colors.at(std::min(15, movementTicks[y * MOTION_SCANNER_X + x]));
+				for (int i = 0;i <= 1;i++)
+				{
+					for (int j = 0;j <= 1;j++)
 					{
 						l.set({ 2 * x + i, 2 * y + j }, color);
 					}
@@ -2992,6 +3392,25 @@ MotionScannerInfo BattleView::createMotionInfo(BattleScanner &scanner)
 	return a;
 }
 
+MotionScannerInfo BattleView::createMotionInfo()
+{
+	static const std::map<Vec2<int>, int> offset_dir_map = {
+		{ { 0, -1 }, 0 },{ { 1, -1 }, 1 },{ { 1, 0 }, 2 },{ { 1, 1 }, 3 },
+		{ { 0, 1 }, 4 },{ { -1, 1 }, 5 },{ { -1, 0 }, 6 },{ { -1, -1 }, 7 },
+	};
+
+	MotionScannerInfo a;
+
+	auto u = battle.battleViewSelectedUnits.front();
+	a.direction = offset_dir_map.at(u->facing);
+	a.id = u.id;
+	a.position = { u->position.x,u->position.y };
+	// Update every other second
+	a.version = state->gameTime.getTicks() / TICKS_PER_SECOND / 2;
+
+	return a;
+}
+
 bool AgentEquipmentInfo::operator==(const AgentEquipmentInfo &other) const
 {
 	return (this->accuracy == other.accuracy && this->curAmmo == other.curAmmo &&
@@ -3020,7 +3439,7 @@ bool AgentPsiInfo::operator!=(const AgentPsiInfo &other) const
 bool MotionScannerInfo::operator==(const MotionScannerInfo &other) const
 {
 	return (this->direction == other.direction && this->id == other.id &&
-		this->version == other.version);
+		this->version == other.version && this->position == other.position);
 }
 
 bool MotionScannerInfo::operator!=(const MotionScannerInfo &other) const
diff --git a/game/ui/battle/battleview.h b/game/ui/battle/battleview.h
index 20733e9f5..e15fa15b4 100644
--- a/game/ui/battle/battleview.h
+++ b/game/ui/battle/battleview.h
@@ -15,6 +15,7 @@ class Control;
 class AEquipment;
 class AEquipmentType;
 class Graphic;
+class BattleTurnBasedConfirmBox;
 
 enum class BattleUpdateSpeed
 {
@@ -81,6 +82,7 @@ class MotionScannerInfo
     int direction = 0;
 	UString id = "";
 	uint64_t version = 0;
+	Vec2<int> position;
 
 	bool operator==(const MotionScannerInfo &other) const;
 	bool operator!=(const MotionScannerInfo &other) const;
@@ -95,7 +97,8 @@ class BattleView : public BattleTileView
 	};
 	const Colour ammoColour = {158, 24, 12};
 
-	sp<Form> activeTab, mainTab, psiTab, primingTab, notMyTurnTab, executePlanTab, baseForm;
+	sp<Form> activeTab, mainTab, psiTab, primingTab, notMyTurnTab, baseForm;
+	sp<BattleTurnBasedConfirmBox> executePlanPopup;
 	std::vector<sp<Form>> uiTabsRT;
 	std::vector<sp<Form>> uiTabsTB;
 	BattleUpdateSpeed updateSpeed;
@@ -128,6 +131,10 @@ class BattleView : public BattleTileView
 	sp<Palette> palette;
 	std::vector<sp<Palette>> modPalette;
 
+	bool endTurnRequested = false;
+	sp<BattleUnit> unitPendingConfirmation;
+	std::set<sp<BattleUnit>> unitsSkipped;
+
 	BattleSelectionState selectionState;
 	bool modifierLShift = false;
 	bool modifierRShift = false;
@@ -143,15 +150,22 @@ class BattleView : public BattleTileView
 	void updateSelectedUnits();
 	void updateLayerButtons();
 	void updateSoldierButtons();
+	void updateTBButtons();
+
+	void refreshDelayText();
+	void refreshRangeText();
 
 	AgentEquipmentInfo createItemOverlayInfo(bool rightHand);
 	AgentPsiInfo createPsiInfo();
+	MotionScannerInfo createMotionInfo();
 	MotionScannerInfo createMotionInfo(BattleScanner &scanner);
 	void updateItemInfo(bool right);
 	void updatePsiInfo();
 	void updateMotionInfo(bool right, BattleScanner &scanner);
+	void updateMotionInfo(bool right, Vec2<int> position);
 	sp<RGBImage> drawPsiBar(int cur, int max);
 	sp<RGBImage> drawMotionScanner(BattleScanner &scanner);
+	sp<RGBImage> drawMotionScanner(Vec2<int> position);
 	sp<Image> selectedItemOverlay;
 	sp<Image> selectedPsiOverlay;
 	std::vector<sp<Image>> motionScannerDirectionIcons;
@@ -176,7 +190,8 @@ class BattleView : public BattleTileView
 	void orderSelect(StateRef<BattleUnit> u, bool inverse = false, bool additive = false);
 	void orderFire(Vec3<int> target, WeaponStatus status = WeaponStatus::FiringBothHands,
 	               bool modifier = false);
-	void orderFire(StateRef<BattleUnit> u, WeaponStatus status = WeaponStatus::FiringBothHands);
+	void orderFire(StateRef<BattleUnit> u, WeaponStatus status = WeaponStatus::FiringBothHands, bool forced = false);
+	void orderFire(StateRef<BattleUnit> shooter, Vec3<int> target, WeaponStatus status = WeaponStatus::FiringBothHands);
 	void orderFocus(StateRef<BattleUnit> u);
 	void orderHeal(BodyPart part);
 
@@ -189,6 +204,7 @@ class BattleView : public BattleTileView
 	void render() override;
 	void finish() override;
 	void eventOccurred(Event *e) override;
+	void handleMouseDown(Event *e);
 
 	void setUpdateSpeed(BattleUpdateSpeed updateSpeed);
 };
diff --git a/game/ui/gameui.vcxproj b/game/ui/gameui.vcxproj
index d1bbd56bc..3f94686f5 100644
--- a/game/ui/gameui.vcxproj
+++ b/game/ui/gameui.vcxproj
@@ -29,6 +29,7 @@
     <ClCompile Include="battle\battlebriefing.cpp" />
     <ClCompile Include="battle\battledebriefing.cpp" />
     <ClCompile Include="battle\battleprestart.cpp" />
+    <ClCompile Include="battle\battleturnbasedconfirmbox.cpp" />
     <ClCompile Include="battle\battleview.cpp" />
     <ClCompile Include="boot.cpp" />
     <ClCompile Include="city\basebuyscreen.cpp" />
@@ -68,6 +69,7 @@
     <ClInclude Include="battle\battlebriefing.h" />
     <ClInclude Include="battle\battledebriefing.h" />
     <ClInclude Include="battle\battleprestart.h" />
+    <ClInclude Include="battle\battleturnbasedconfirmbox.h" />
     <ClInclude Include="battle\battleview.h" />
     <ClInclude Include="boot.h" />
     <ClInclude Include="city\basebuyscreen.h" />
diff --git a/game/ui/gameui.vcxproj.filters b/game/ui/gameui.vcxproj.filters
index 30a74a48f..02c595af3 100644
--- a/game/ui/gameui.vcxproj.filters
+++ b/game/ui/gameui.vcxproj.filters
@@ -126,6 +126,9 @@
     <ClCompile Include="battle\battleprestart.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="battle\battleturnbasedconfirmbox.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="boot.h">
@@ -239,6 +242,9 @@
     <ClInclude Include="battle\battledebriefing.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="battle\battleturnbasedconfirmbox.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
diff --git a/game/ui/tileview/battletileview.cpp b/game/ui/tileview/battletileview.cpp
index 882f93088..be15db159 100644
--- a/game/ui/tileview/battletileview.cpp
+++ b/game/ui/tileview/battletileview.cpp
@@ -201,7 +201,7 @@ BattleTileView::BattleTileView(TileMap &map, Vec3<int> isoTileSize, Vec2<int> st
 
 	auto font = ui().getFont("smallset");
 
-	for (int i = 0; i <= 99; i++)
+	for (int i = 0; i <= 255; i++)
 	{
 		tuIndicators.push_back(font->getString(format("%d", i)));
 	}
@@ -989,6 +989,28 @@ void BattleTileView::render()
 				}
 			}
 
+			if (revealWholeMap)
+			{
+				static const Vec2<float> offset = { -13.0f, -19.0f };
+				static const Vec2<float> offsetTU = { 13.0f, -5.0f };
+
+				for (auto &u : battle.units)
+				{
+					if (!u.second->isConscious())
+					{
+						continue;
+					}
+					Vec2<float> pos =
+						tileToOffsetScreenCoords(
+							u.second->getPosition() +
+							Vec3<float>{0.0f, 0.0f,
+							(u.second->getCurrentHeight() - 4.0f) * 1.5f / 40.0f}) + offset;
+
+					auto &img = tuIndicators[u.second->agent->modified_stats.time_units];
+					r.draw(img, pos + offsetTU - Vec2<float>{img->size.x / 2, img->size.y / 2});
+				}
+			}
+
 			// Draw unit focus arrows
 			if (!unitsToDrawFocusArrows.empty())
 			{
@@ -1296,6 +1318,7 @@ void BattleTileView::updatePathPreview()
 		LogError("Trying to update path preview with no unit selected!?");
 		return;
 	}
+
 	if (!lastSelectedUnit->canMove())
 		return;
 	auto &map = lastSelectedUnit->tileObject->map;
diff --git a/tools/extractors/docs/tb.txt b/tools/extractors/docs/tb.txt
index 6ec9cfbda..bbfe15067 100644
--- a/tools/extractors/docs/tb.txt
+++ b/tools/extractors/docs/tb.txt
@@ -1,28 +1,20 @@
-Turn Based:
+What do we want:
+- Vanilla experience 100% sans bugs and inconviniences
 
-- There is currentActiveOrg, one that is taking its turn
-- There is a list of interruptUnits - units that are currently interrupting current org's turn
-- TacticalAI decides for other orgs when to give up it's turn. Player decides for players.
+What do we need still:
+- A system for moving camera to events in battle (callback?)
+- When enemy spotted for the first time we pause mission and give event
+- When no action visible to player happens for 1 second hide behind screen
+- When screen is shown fast forward updates and cull walking sounds
+- When action first visible to player move camera to center on action and remove screen
+- When interrupting center on the first interrupting unit
+- When unit accepts interrupt set it's focus unit, change default ai so that it can only attack focus unit if interrupting, clear focus unit when clearing interrupt units
+- (this is wrong!) When unit accepts interrupt check it's behavior and movement, if aggressive or can't move, ensure it has lof to triggering unit, and in range, and can afford an attack, otherwise order turn and do not accept
+- Instead, we should think() and only give interrupt if decision was made
+- MDGA! decisions!
 
-When not our turn:
-
-- No AI functions
-- No advancement available in missions
-- No control available
-
-When our interrupt:
-
-- Only LowMorale, Default, Behavior AI functions, and only up to a TU limit (if TU lower than limit then no function)
-- LowBehavior AI additionally wastes all remaining TUs of a unit if no TU
-- When unit on interrupt not active for more than a second it is removed from interrupt units list
-- When interrupt units list is clear interrupt is over and control resumes for currentActiveOrg
-
-Interrupt triggers:
-
-- After morale checks are done at the beginning of the turn, each lowmorale unit makes a notification and is given interrupt
-- Units from active org are not given chance to interrupt (except condition above)
-- When we change position, give interrupt chance to every unit that sees us
-- When unit is hit, give interrupt chance to that unit
-- Interrupt chance includes RemainingTU * Reaction value. Unit only accepts interrupt if it's value is greater, and only up to TU value that still makes it greater.
-  Ex: 40/80 TU 20R unit fires at 20/60 40R unit. Value 10 vs 13,333 allows interrupt, but only up to 10 which is 15 TU. 
-  Therefore unit's interrupt TUs limit is 15. When unit' TUs go below this level his interrupt will end.
+Proper handling of decisions:
+- Decision is something unit is doing currently
+- What does AI do?
+	LowMoraleAI: simply does it's thing, cares not for what was going on before
+	DefaultAI: turns to attacker, start firing on enemy if not firing, prefer focus enemy
\ No newline at end of file
diff --git a/tools/extractors/extract_agent_types.cpp b/tools/extractors/extract_agent_types.cpp
index 95a81a5ff..794ac6316 100644
--- a/tools/extractors/extract_agent_types.cpp
+++ b/tools/extractors/extract_agent_types.cpp
@@ -1347,18 +1347,16 @@ void InitialGameStateExtractor::extractAgentBodyTypes(GameState &state) const
 
 			// Skeletoid and Anthropod are both humanoids
 			case UNIT_TYPE_SKELETOID:
-			// Other humans
+				// Skeletoid only differs from other humanods by having built-in flight capabilities
+				a->allowed_body_states.insert(BodyState::Flying);
+				// Other humans
 			case UNIT_TYPE_ANTHROPOD:
 				height = 32;
 				idx = 5;
-				// Skeletoid only differs from other humanods by having built-in flight capabilities
-				if (i == UNIT_TYPE_SKELETOID)
-				{
-					a->allowed_body_states.insert(BodyState::Flying);
-				}
 				a->allowed_movement_states.insert(MovementState::Normal);
 				a->allowed_movement_states.insert(MovementState::Running);
 				a->allowed_movement_states.insert(MovementState::Strafing);
+				a->allowed_movement_states.insert(MovementState::Reverse);
 				a->allowed_fire_movement_states.insert(MovementState::None);
 				a->allowed_fire_movement_states.insert(MovementState::Normal);
 				a->allowed_body_states.insert(BodyState::Standing);
diff --git a/tools/extractors/extract_unit_animation_pack_bsk.cpp b/tools/extractors/extract_unit_animation_pack_bsk.cpp
index 672c3f1c9..9a5ef632d 100644
--- a/tools/extractors/extract_unit_animation_pack_bsk.cpp
+++ b/tools/extractors/extract_unit_animation_pack_bsk.cpp
@@ -58,6 +58,9 @@ void InitialGameStateExtractor::extractAnimationPackBsk(sp<BattleUnitAnimationPa
 				p->standart_animations[{ItemWieldMode::None, HandState::AtEase, MovementState::None,
 				                        BodyState::Jumping}][{x, y}] =
 				    getAnimationEntry(dataAD, dataUA, dataUF, 3, {x, y}, 100, 9, false);
+				p->standart_animations[{ItemWieldMode::None, HandState::AtEase, MovementState::Normal,
+				                        BodyState::Jumping}][{x, y}] =
+				    getAnimationEntry(dataAD, dataUA, dataUF, 3, {x, y}, 100, 9, false);
 
 				// Sucking state: 4
 				p->standart_animations[{ItemWieldMode::None, HandState::AtEase,
@@ -78,6 +81,10 @@ void InitialGameStateExtractor::extractAnimationPackBsk(sp<BattleUnitAnimationPa
 				                          MovementState::None, BodyState::Standing,
 				                          BodyState::Jumping}][{x, y}] =
 				    getAnimationEntry(dataAD, dataUA, dataUF, 3, {x, y});
+				p->body_state_animations[{ItemWieldMode::None, HandState::AtEase,
+				                          MovementState::Normal, BodyState::Standing,
+				                          BodyState::Jumping}][{x, y}] =
+				    getAnimationEntry(dataAD, dataUA, dataUF, 3, {x, y});
 			}
 		}
 	}