From 1a03890095ce78fb0eae0249822c6960217e00ba Mon Sep 17 00:00:00 2001
From: davpapp <david.papp@students.olin.edu>
Date: Thu, 15 Feb 2018 06:27:12 -0500
Subject: [PATCH] Refactoring. Starting work with OpenCV

---
 bin/Cursor.class               | Bin 7025 -> 7551 bytes
 bin/CursorDataFileParser.class | Bin 3297 -> 3299 bytes
 bin/CursorPath.class           | Bin 5642 -> 5737 bytes
 bin/CursorPathTest.class       | Bin 3602 -> 4044 bytes
 bin/CursorPoint.class          | Bin 1908 -> 1881 bytes
 bin/CursorPointTest.class      | Bin 2209 -> 2620 bytes
 bin/CursorTest.class           | Bin 3116 -> 3376 bytes
 bin/OpenCVTest.class           | Bin 0 -> 576 bytes
 bin/main.class                 | Bin 1094 -> 463 bytes
 src/Cursor.java                |  53 ++++++++++-----------
 src/CursorDataFileParser.java  |  10 ++--
 src/CursorPath.java            |  52 ++++++++++++--------
 src/CursorPathTest.java        |  84 +++++++++++++++++----------------
 src/CursorPoint.java           |  14 +++---
 src/CursorPointTest.java       |  31 +++++++++---
 src/CursorTest.java            |  28 +++++++----
 src/OpenCVTest.java            |  11 +++++
 src/main.java                  |   4 +-
 18 files changed, 172 insertions(+), 115 deletions(-)
 create mode 100644 bin/OpenCVTest.class
 create mode 100644 src/OpenCVTest.java

diff --git a/bin/Cursor.class b/bin/Cursor.class
index b72457658e1ff804222e7828215b400b993b882e..8dcf495416d22c5e3ffa0c0ceaa10079c9ed4581 100644
GIT binary patch
literal 7551
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
Ax&QzG

literal 7025
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
JL?&gb`9CYKeLnyI

diff --git a/bin/CursorDataFileParser.class b/bin/CursorDataFileParser.class
index a9a600ba041fb89ac0461866692945398a693c19..4b5ec1dda2f423faf50625363cfbe0bd10b6120f 100644
GIT binary patch
delta 33
ocmaDT`B-wpKUNXp<kF&|)Vvbs(xT%0qJaF&yprP00&ExA0PpGzZvX%Q

delta 31
mcmaDX`A~AhKUN{Z<kF&|)Vvbs(xT%0qJYGbjLkx97uf*QqYQlj

diff --git a/bin/CursorPath.class b/bin/CursorPath.class
index 8acdb98c170caa005d43decafcb2828fdd4f7284..3baaaf1aa3f69f730988d4711cfb8fa0af657d19 100644
GIT binary patch
literal 5737
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

literal 5642
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

diff --git a/bin/CursorPathTest.class b/bin/CursorPathTest.class
index ff407ad82629069a8c7e424863476c2ad5521223..09bb02e57cfca7090f13aa325702f85d6b1076d6 100644
GIT binary patch
literal 4044
zcmai0S#uoK75-Y9p0-A9S+*8yBmuU(jWz}xB!fnlEqiP{L5q<FVGP8yXIfI*qv@fi
z1s2&8f^inI2V&wRBypUO4H6>@s7g_J%xfO=3-X$(JS7$9JGWc2U{}Rub@$wR&iTHx
z+;i?<|NFt80gT`S0}UElj<0%U*E?<b%UQeZ8;EFVy<ojyB@0$@DLH%of}Qg<H0LT}
zWepuuN@CS_3du>&v(~1ZvY*n>H18}GEq~RsHSD>Y%=lClE;T`o=(tmK{0R+>iT(u*
zk>hUOj-e4-O*A2<VcV2bv}aaV&f8wrI$xmO9aC=3DlAx@BfrDNh`;QRS8I)V@rD4~
ze7>uo6pGKS7JX;MUU13|Eld`Ru5bB{TjXBvl<O@eFRYRipC!k)y`)uglFC>N8ahqv
z6khE@+p!AHOLo<G69wWXbVOt5!950gHMHF&QYP-jeHylidCPY_noacAgew!Sr<$=F
zdkpl^>#CW}T@!n;k0C4CmzbdTO$#+?OBpzzAyy?A!+!Le7!VKI@=m!_u-3v|*D3mC
z@o>n*Fz#n4>H|0LTb^H@^k+S1$tg0fiJDla`WHm?0TU03>aeJuDCV8wQjPUYu}b8W
zRX%HbZrUaR(fovoheWfp9yHCevWhuYgoaTQheV{UUL?D0`&RU5)9!y~)5BdNm@+Yr
z!*|%43$x5BsiU6mUx*(0=c4*2>XRmpiF!vp&OD2b{)j}{#0g<yDhao=mSr_bsvb3Q
z3K<Q?vQ?f@Sz%S5Wd?GU!$YmwxM|qRz~(MaTP0P=24<MbAWmt^w@x|*`?TeiZEp)s
zYdD!)c313VzGRh3Njq0?N@aWaMc2DnE?GG{$-=hFIjdw(W|G2fk=o^C6+Fwe`~6FP
z4AYpC12#`L6G7prvYGci`lzxwjVDYj;7JX;mu$as$Y&R;Ni3iA+!bM{VdrM`-O&=-
z1NeGpn4B;Q_3J4q(5Fp2gJ&s1Tvc`TWhAB7zZpZR+Ef$H!7}h1yHrR{mQ9>TPJ?!d
ze;E<6O)RPvR@^c!7;rS~y8CgTEHmP&C78H~0yAi-m8`c)XCsNT(yQ87n-r?6aptp*
zn)p*P@x1ucPJiw=6hf?Q!WUwCJ~$4`c)`SrAaOH*J@NdiRbY406Pb)4Z?`{wwgl(X
zCO(7DGNZ()CTa5ssScZo5$^LQz90?22pd2QU&6}<zRX!r?fcW52PVFPSBSd2R&v>4
z^h7${pJpoxGAa|JYP{9HRN|np^P5Y;=&L5ahObkjj*&XCicVUfUo-Jd1;cVL9+cF4
zTfF~H2uOEzU(PtwNbqJW=Q9|}hCsY-;tl*zLpLGR3Agjdc_M4eR0<|tsTi_WRraQd
zA4zq$)p0u=w!t3!*u+mHnvpVFJWX&Ia@x27M%HB#JZUI|t3BIcXp|M&t``YcJL?D7
zT4{5L?X4LBl>=9qn4-;*89nlkcm8!{;V+tum|vTC8^2*J>4Y5ROgKeqX8_~oNThym
z;tvw3IAx`o-8E2)46o~DT_tdAjlGinL_}+x+)=j_I@J|aYNj~HK-tIEvTlL1jjfv_
zo^`_}%Xzn1BU}s8$Qy%S6^zZht6t6yI!ap=Qnf89P3&U#ZRF)e;~%Fi-v+-Lum#P0
z^TNOt`AYJwWCm`*d{>FI@F@zQ$~HdDKme`S&R@U|DmS2wUn14cw;1{xA`0*f4Rs9M
zMAtgHr*Gic(EHe>;Unyy8eB(WVDJ_O<&l)fL3xY}47TIpb&S=%C)ROvfC|T{ep18L
z+aC(IMhLf2Y~{0sc&&(&(>>(UM;-^zfgyBquy)}Q?o6T^8T4X?a!>LeA-;5yIdCTQ
zCC<CuC-E4)nBwYoG~A|8qru+>XA~wV%qt9kii5L+7v;7OG5yqz*;{ygN*HF}LsvC!
zEh+}Psno|f?Ww_R3o&C1{uw+)qYZL<2#tGuOS*b#@$B@_O?>JqTKLLeg%P=dNaF^U
zsu2iK_A{{uSlS7NvMbOJQD`ajOs5MgC=yM4Waj>Zod(Vw6?|SnLi{X$34ROl-RVXm
zdmC8&xL<=r9Afl`YY<y1h%FVwCafvM2Dz$)2sfFpC=teq@X}#%b4IYnBE#$WTs*?Z
zFujgP_{d-8XI?(@`O6#l;%lRNhu&Mqr;mjUJU~7V(x-#u@DM9tgjpZu^AJ*aSaF;P
zFe@C#D;y8uGII1<v?V@`lo?XIBeY=PRqpEC=S?c~;5t1J)DiN&k`WKaBFY6lu2-qc
zca{4$9*HKpq8s>DHI&_oQi{gMSyzWyb`yj+LI;l4P#&pJ-Yij_?tT~FBc*0uONDZT
zx_cF6ofZsypSvo=v>MdxEy~Eb9~?}q;|F7rgarBu>5%u;F<pLL9gD{GbzF-_`3Pei
zoU?#vng&jg%%eOzr+C&f1b?iC=wOBDU>IA%;irnIL3(ddIzrtJ{EXyuT4=$~`4z=4
zNKDRSuy?((cU?Kbdt=~)CY32}&9G1Wl5R{3`I#Z1F2!?Ayb$J%qxuc>4R`44_|-=^
z#}bZ5YJO1SWnJsgMdhvAf0u+rR6hx7X@<F-Wo@5kH+dZQVGjE+&mJ<z8{iW){z^C5
zPF?Z|{oR6-%F707Pbx1PX(Oe)jIa+3;<u`nHvJ8xuG6bPO6p3^X1Da8eTcIE7}&4=
z_ZaA5BfgirylIC?eVdw+)ILe-?^F%`-&}Swy3+RyoF&Vrc~+ibhkLfhufB?3eU&`+
z;hiv#J$P5;acd=y?Tp<Y>+%@vNgji}Adi2-&5*Z8Y2n?|f1pdxy>Sh#^0D;#n|Et*
xGGc(|7!*s99AJ>BS|Qnk_ef2KR1enqCC#e`xA>*2VDjj89+lCy!HovI|39NAcBKFS

literal 3602
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
TjNq5e3<k+S!>`Dq4Zr>mT(CPD

diff --git a/bin/CursorPoint.class b/bin/CursorPoint.class
index 8607e7a4f20ab8c50c44ec30e0f770012e976853..630dceb796ff934f57861f28730689a7216ebe88 100644
GIT binary patch
delta 644
zcmZXQPj3=Y6vfYD7^u?;D2P<FmfBhdiXDntm1?aNYpp0KZ7u$v&<RdUA%RiTjXT4R
zq`s9)KY=kZw6Tc`mu|Xp;l}s{+_^U1H=1a4^K#~Q?mh3!`|kVfQ$GH9_a4A0JlIq|
zL_$^5&RH$ns8`I{W@Ek3w5nE}LDDwAr4I$jU3g^L#ve<;VGOAl<{386H2$1D?N6x~
zN1ApjjTVDj%f)kI>ZD4Sr1?SD>XGxf;KdZf-c{p?q1TLhRWEI{Y;#@3G%oU2uIS<n
zL-;S(Zd&zf_OVr4F`GTO#L!c0SamxS)f8lLS;ZdAF@&`IzdMuhB{4Ct;wtj|fRylG
zXJAReih|wX1u5NEVo>7A=!#i0HZoCRE~;3<E&fs(9xUUI7q=OLPPWz1i&Vxg*-g`+
z!gn#pzet|~XW#~-hx8@h!r!K2AK!IH=q((GF#5=37(|55Uef<Bw6}4T56L6aF^urM
zJkDbLnXL83X_Y!7fl>ZO9wYiy)|Qhv?$9xe{toQG1DS%SV%yN27HgzVh$`*1YDZx4
z;cp8p1_)O=6Yd?ba(~E8Ah?AXf9OdKOgQ0T#BiEICFt-|Uyt*PXOZErJp)u@*OOwC
vFTDHpb34eE1Gz2Ciu^9F1g>>a5H|>Y^Op{i?qZ>fWj^Cgc<)hD7w-QA*a?rz

delta 644
zcmXYt%Wo1<6vn?h!vIbvjG%EysfKDT1BLQvtCeb7?NGI%R$CwVDkBi=3lcz0H*VQA
zsW)-qpJ5u>w5AIaH|~w`A8=>l!nN^Sn8m&G-S2+qcg~%kzP~>8+rNV&028ox)Gvd2
zwbHUyn=QLms?0a)n+(Uz{M_qCv))*&uhv>qJHIj^_L9L%!R1$#mdzlWQA@=D&TAOv
zV{C!N_&fIYbVkD%#_76LZ!)+{tCzZ<;UdO)Kw3L9gR36QQj0bFjh)=EYt`h^R<l*v
z)Nl=R{G$|h<roZJl#QSl*QsfDhHThWVd18RV_4w7rGBr4yoTGj!*w|pSY%*v5x6hB
zC58n5Bc0?cawzzKL5;@4<;sS=l?{u`BMpyH;P2%j_ftIg;2Hlc2jv&U{ULuJ$ioGR
zeoip93w?xExlPJX%3tP3uKw()-ZcyaDMmpI(xL%y7UyX1BX5!*jJ`fmD(dz2K8Cng
z8I~h3d0I)cC@(2y--uHhr-?r(qvU>7%-K;SyTB9@4saW8C<L62>?7Uft&^JQ;@7L&
z!WIX;E$lQ;xD7((+^Lz#F3Lazmk1%#Nk^8Hm~RS~9ej@9;?e#?u!7(SaA*%vzUxj|
zSKxDUMdw|aPnbT0RS3-Q;fBa}a4T@PgL|S*=;fY1LAry79X#QtC+1n977~j80pVDF
AhyVZp

diff --git a/bin/CursorPointTest.class b/bin/CursorPointTest.class
index dc274bfa31fbf537a187eb24d52e5448d474b52c..c9a74ab0bbda8fb03922ff7ac8313682e9c05084 100644
GIT binary patch
delta 1455
zcmZvcUu;uV9LK-6_fNZWg?20Jx>eX_%UZgU$)vKvD6kGTL>Ti@U;$=bx=}Z$ww<CR
zR(&x+B9MzAA(4#mVDQ0&xC{a)@d@?8_+WhSP2!V0_-6c<#qYWI+BU|Ap8GxLd+$BJ
z@8|wbuler<yx*+c`2xTe%w6=J54Khc<w~|#uH@&Z3VTW~zjUxvoGH#<{A4z=cBb$@
zjs!Ut&w9~;$K42<Z%WbBI;@wV=gZ|nsWSZPLVm6+L5*dz@tn5vT%vvF1OKmDrakrW
zQFting@mY%4d^iqsWaSxxQ>lTNbuUv8>NMU1SK{R&zbk7!O0d;pK+>C$=8eX!jAzR
zX@n#+v&jG0TIT1==dW+L`jeJ<_}wo*Xj30*neRWnm$>`&B`xzu*I!09*(O2aHqx~D
zr_`g3>ez>8%pTWJ_>hiqJV)m=f1^#@=&+8Qwep7ffh(<@&~cLYe(N$N&3r*V?8WbJ
zLnY96%`fFG`&TEH(Rv&08^tw%&H%cX5xI?+v(Q^#=(X<HR9{G13w^Z(b6n{@G>A1g
z03Rk<%PVNcJ7~cwZugYEDRex>*($t_&FClGR?N}shYL}h;8*U4%<);Is1)A$w3*k|
zHg)l7H)rpQqN{h|Kj!nw@-4KaRWXq{6BA9u*~&NpY-72$8f2Ze%7m1E<*txw%he&x
z7B~5N7rY!(R*69t*~aohEUcX+bznEbIEZy99>IF#(TQ1f;WczK;}bZGh?R51uCtc&
z?OM)-TF&WO&YY8TH%2kU#40z~jx3eNLWV_l^GBtxx@Q?9X@wtSzYuCNfCEBkT(N{Z
zq%2|V3f73LaRqMWV<<8|V@Tz?XAyoO3?Eh9(rEdbg-2!h^hVDuJnK0sqw4#+!4#xq
zi_~Vu1Y!&xN08?tf&`N2WvC=F*n|=E;dwlXGlX!Np*|x5(G278a9pZEy5T?y;v)xA
z1Q#4gNxX-s-3=+c<xt9C!J#z5{yD-|yK&S^YW>nNGRsvbmT^3-lFp<M8hPb~Af^DO
zgz{Km1Tev+5tv0~a*>Xp(&$)B&McxiB$)W|TLY7jhrs+RhHyPgRoW}}8|*qVyScU!
z!vK+`*<9NgbUSun5PLa}5!?iJp~QAO$Fw(?^8tn}Y{$_=Y+u!|eO|+M)4>+Sb%8Bq
z9U{|dt{rSnySetVRqf^)!)XWG1m;m7Ko0>va;IeRR~PXNNc+r_o?!1ZW_U=!6L5-3
Uwp5Wy#ZhV*QXB0TDP5TT2i*7(%K!iX

delta 1107
zcmY+D%TE(g6vn@4r!#G-p@S7@MR~PS`XCmh3Mda-K#(XzP(e_LsfNfSX-k5^NZe>*
zNEBybLSn?YFz!T2V~olY;?jkGfLj;tT$#r24il(Ndi(W!ckVgoch7wGywaTC@}Ir}
zXvXzb=M&AHO=Ysl=}dNN?q;edJwLnp?oLPX?bLrU3GU!PVj-QGPY=#d&t=={lS-$D
zhw!6x_~Ji*RV1QLNT_t73f20WRHf7+pu(?rNP((jsFUEF%4AaM>~MM^B|#33)n8UR
zSHix|ZSA-ILpq~pEdiy)g;uobFD(gwmkVc+kRUDc+vk9WZWnrt$X!NwhIC8MTUwQi
zE)4RScB?Mg^zYUYr(}l;8!LOJ$K>YmP&kr9sRup}Dsnjb5jCN3)QAKNB3{`Dh4w>{
z-A$4GNYvcauou$b%QZv2D8?w<m|>0gQG!(*L=n@U*ewDs9N@nqJi>9r$fy+e&`4!L
z0JCVKvhp$}xIYG&JDc@MrF%J^!>Lx8*-r~$i+a#5gu;j+RIj{=&NUQ^-{cxp`3+<%
zyYt!@x35DJBI%~uw-j3L65&xL-L67U6`t`NRkGjxx4_(BSyni?HnJU{jO~<j^}-Jy
zqBx8=D$s!=IEPA1at4-AjpwMr2h{3wYFT2p^)kFLTleFs*?N><c3Y1VUoRopc+vt-
zib3HzgFY%1{rZmDB%LRmL%L?~S{}&ZLaU89hJ;WE=#miR;=zbec7uc<BtR4rGBDg&
zrz0>FItGNLb(DAo1Py-*Ab9O0q~(W&Yu{X^o!=_3_Zh{F3$G)iAQ{#3nnS$cFxnAe
ze^HKW1I9QEY4){39&brvn+(LzjKjfoXK!e}m_t*BjlH3HEy%@<snJbz?RadW>%{{T
z-5?fCbYqyq6(+M2;zLK=DqhhoM@#agkuqdVozF}OUg%ZMv&1rdEOV53gt|s$LqD|@
MQaSB$N((0b0ghwA=Kufz

diff --git a/bin/CursorTest.class b/bin/CursorTest.class
index c5850dcb35e6b3f6cbc1583f708c80ae223cc1ca..dee61fce8b8019bcd06929f97fbc18a9f7442e53 100644
GIT binary patch
literal 3376
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
LI_e*^{)hhq`BuIc

literal 3116
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

diff --git a/bin/OpenCVTest.class b/bin/OpenCVTest.class
new file mode 100644
index 0000000000000000000000000000000000000000..33d43cbccbbdcffdabb25b69146310c85ee175d3
GIT binary patch
literal 576
zcmZ`$Jx>Bb5Pi$naVH9*pmt{m6jIrUu_0Qa6d;MQT8<4aId(653yJ^9#)?D}?fp^4
zIYPKbn%SLsv+wP^`T70$0&s~l2N?#h9|_eR4Ml7n<QOV5zU1wYt7*GGo{7LR6t1O`
z_J$$bXpR_iT|E&VvT#etqrgz^NhKZ@^RX~PJ`M##wWk9fj<}IYzA5JHi;Njcy;QM7
zY;!IZL%s3bOO*%KNHy&=M-C2&KLu`$(WZzahPOv$M6AQ5nD~L7M>6DAYUM{pljJ<U
z@;$e!jqn4ml(zm@_}hM~eeN$ezw_LCZg+Os*GTN@Ac5tO@STsh5*{k3C2rLjYK{K}
zr9}+%!UW<@CI*&Mk1mqwaSpPd)&^wgMz&LQC~MQn=*+iPD88>@k75E-5qlI%n|lfS
nl({%SnJUTS7EvaB-X|(g)#?hz-;`yLGB|673{@FU*4XJEK6{B6

literal 0
HcmV?d00001

diff --git a/bin/main.class b/bin/main.class
index e1f966c89b717780c504900c62e6978bd93f08ec..8317e8f62e53f58b6c02c476d25133054b1f002b 100644
GIT binary patch
delta 81
zcmX@cah{p$)W2Q(7#J8#8Kfq1eVsgkNq#aXbG4Z^P>2zPHv$PJ1}-4U1{RQH;0CgJ
RAd(DX4B{X~3=&{fk^sN63gQ3&

literal 1094
zcmZuv?M@Rx6g^W~wp|t}l-42@D=3z)R#e1LM3E0I7BFdpQGYG%3JcraX1hi4O?(1>
z>klxJ_yE3zFM^(Fp_GJ8c4qFKJNMjs?)h{2>o<TIyjI{7@K<!xR^S&1@9776#?tMb
z%;xr<QSt;j=S|!676dv{V_S?}a>|B^4umuW&?(T9H*I61UfDL>qP}ez0)2U>q+46M
zYfAgf>GyWc8nfjkR#qUE`jEc>D|oJH?_?!_y7IYXR6WzNYYKV=qKzp1lb2b1TWsAa
zhzJZ_B*@vG;kxyzXO!Dwq5_ddjOk=@n{5}@S;<n}tvRlW7(xne5V+|m>a~3p1JZd@
zAe6HY4BK<uLlp^x<dW2ITQ=TVua<R>TqH1};STPS3$xaWU#(kKgS7V{+{2iH)FpZg
zhc(ZrXc)%?qntXKjy4Hlt#8PNM@|gAk_}=?V6c@o`H^|k$(2ggJ0xZ4bXr9Q(+cjl
z_1gAc!vj1NP^vPeWfLWJ74Nd+84ZsyE0A<Zf5rS_l$Twnx@cKBR?5a&HOT4Zn`~wC
zEib1Rps3_mR*}V11@o6$F7C3SvW5jb6A08S!>CeEskMfzba#jHh+H8GGF@tnN+5WS
z%4s!ya#{k~nO|DeR>(Xbnm|`ufdbtHPcQAS>(w(=ss*R+mW)+X>NX^$nU;FtfH{;#
zD?Xm6bFK>Q40pjjFn)~ScOHCDxyoxWpo^>44B*~PE5wLv{Cju~GG!Qj=x?Mtrsb!1
z?gX)S$B5@oFu;9q{R9c_LmN{^xW#|?D|&xmv~ThV>B$K?9`)nNPt1M$_m{6b8u+8c
z0nvj*4HGxcHGy7?5N!exOe2a})*$N}Z=&Kk7HI`3j~7^C&0*dwV}-TGF^pBbWbRjt
W=z;GPaRo620}2vxhUVz@VeLQRF7)^S

diff --git a/src/Cursor.java b/src/Cursor.java
index 1d70c4d..78b00bd 100644
--- a/src/Cursor.java
+++ b/src/Cursor.java
@@ -18,14 +18,10 @@ import java.util.regex.Pattern;
 
 public class Cursor {
 	
-	public static final int NUMBER_OF_DISTANCES = 1000;
+	public static final int NUMBER_OF_DISTANCES = 2203; // For 1080p screen
 	public static final int MINIMUM_CLICK_LENGTH = 120;
 	public static final int MAXIMUM_CLICK_LENGTH = 240;
 	
-	public static final int GAME_WINDOW_OFFSET_WIDTH = 100; // top left corner of main game screen, from top left corner of screen
-	public static final int GAME_WINDOW_OFFSET_HEIGHT = 81;
-	
-	
 	private Robot robot;
 	private Randomizer randomizer;
 	private Random random;
@@ -96,38 +92,39 @@ public class Cursor {
 		leftClickCursor();
 	}
 	
+	public void moveAndRightClickAtCoordinates(Point goalPoint) throws InterruptedException {
+		moveCursorToCoordinates(goalPoint);
+		rightClickCursor();
+	}
+	
 	public Point moveAndLeftClickAtCoordinatesWithRandomness(Point goalPoint, int xTolerance, int yTolerance) throws InterruptedException {
 		Point randomizedGoalPoint = randomizePoint(goalPoint, xTolerance, yTolerance);
 		moveCursorToCoordinates(randomizedGoalPoint);
 		leftClickCursor();
-		return randomizedGoalPoint; // Return the point in case we need precise movement afterwards
-	}
-	
-	public void moveAndRightClickAtCoordinates(Point goalPoint) throws InterruptedException {
-		moveCursorToCoordinates(goalPoint);
-		rightClickCursor();
+		return randomizedGoalPoint; // Return the point we moved to in case we need precise movement afterwards
 	}
 	
 	public Point moveAndRightlickAtCoordinatesWithRandomness(Point goalPoint, int xTolerance, int yTolerance) throws InterruptedException {
 		Point randomizedGoalPoint = randomizePoint(goalPoint, xTolerance, yTolerance);
 		moveCursorToCoordinates(randomizedGoalPoint);
 		rightClickCursor();
-		return randomizedGoalPoint; // Return the point in case we need precise movement afterwards
+		return randomizedGoalPoint; // Return the point we moved to in case we need precise movement afterwards
 	}
 
 	public void moveCursorToCoordinates(Point goalPoint) throws InterruptedException {
 		Point startingPoint = getCurrentCursorPoint();
 		int distanceToMoveCursor = getDistanceBetweenPoints(startingPoint, goalPoint);
+		double angleToRotateCursorPathTo = getThetaBetweenPoints(startingPoint, goalPoint);
+		System.out.println("R:" + distanceToMoveCursor + ", theta:" + angleToRotateCursorPathTo);
 		if (distanceToMoveCursor == 0) { 
 			return;
 		}
-		double angleToMoveCursor = getThetaBetweenPoints(startingPoint, goalPoint);
 		
-		CursorPath cursorPathToFollow = chooseCursorPathToFollowBasedOnDistance(distanceToMoveCursor);
-		
-		double angleToTranslatePathBy = angleToMoveCursor - cursorPathToFollow.getCursorPathTheta();
-		
-		followCursorPath(startingCursorPoint, angleToTranslatePathBy, cursorPathToFollow);
+		CursorPath cursorPathWithDistanceSet = chooseCursorPathToFollowBasedOnDistance(distanceToMoveCursor);
+		CursorPath cursorPathWithDistanceAndAngleSet = cursorPathWithDistanceSet.getRotatedCopyOfCursorPath(angleToRotateCursorPathTo);
+		System.out.println("Rotated the points: ");
+		//cursorPathWithDistanceAndAngleSet.displayCursorPoints();
+		followCursorPath(cursorPathWithDistanceAndAngleSet, startingPoint);
 	}
 	
 	public int getDistanceBetweenPoints(Point startingPoint, Point goalPoint) {
@@ -135,14 +132,14 @@ public class Cursor {
 	}
 	
 	public double getThetaBetweenPoints(Point startingPoint, Point goalPoint) {
-		return Math.atan2(goalPoint.x - startingPoint.x, goalPoint.y - startingPoint.y);
+		return Math.atan2((goalPoint.x - startingPoint.x), (goalPoint.y - startingPoint.y));
 	}
 
-	private void followCursorPath(Point startingCursorPoint, double angleToTranslatePathBy, CursorPath cursorPathToFollow) throws InterruptedException {
-		for (CursorPoint untranslatedCursorPoint : cursorPathToFollow.getCursorPathPoints()) {
-			Point translatedPointToClick = translatePoint(startingCursorPoint, angleToTranslatePathBy, untranslatedCursorPoint);
+	private void followCursorPath(CursorPath cursorPathToFollow, Point startingPoint) throws InterruptedException {
+		for (CursorPoint cursorPoint : cursorPathToFollow.getCursorPathPoints()) {
+			Point translatedPointToClick = new Point(cursorPoint.x + startingPoint.x, cursorPoint.y + startingPoint.y);
 			robotMouseMove(translatedPointToClick);
-			Thread.sleep(untranslatedCursorPoint.delay);
+			Thread.sleep(cursorPoint.delay);
 		}
 	}
 	
@@ -153,11 +150,13 @@ public class Cursor {
 	private CursorPath chooseCursorPathToFollowBasedOnDistance(int distanceToMoveCursor) {		
 		int newDistanceToMoveCursor = findNearestPathLengthThatExists(distanceToMoveCursor);
 		double scaleToFactorBy = getScaleToFactorBy(newDistanceToMoveCursor, distanceToMoveCursor);
-		
+		System.out.println("new distance to follow cursor is: " + newDistanceToMoveCursor);
 		ArrayList<CursorPath> cursorPathsWithSameDistance = cursorPathsByDistance.get(newDistanceToMoveCursor);
 		int indexOfRandomPathToFollow = random.nextInt(cursorPathsWithSameDistance.size());
-		ArrayList<CursorPoint> scaledCursorPath = cursorPathsWithSameDistance.get(indexOfRandomPathToFollow).getScaledCopyOfCursorPath(scaleToFactorBy);
-		return scaledCursorPath;
+		//CursorPath scaledCursorPath = cursorPathsWithSameDistance.get(indexOfRandomPathToFollow).getScaledCopyOfCursorPath(scaleToFactorBy);
+		//System.out.println("Chose the following path: ");
+		//scaledCursorPath.displayCursorPoints();
+		return cursorPathsByDistance.get(newDistanceToMoveCursor).get(indexOfRandomPathToFollow);//scaledCursorPath;
 	}
 	
 	private int findNearestPathLengthThatExists(int distanceToMoveCursor) {
@@ -188,7 +187,7 @@ public class Cursor {
 	}
 	
 	public void displayCursorPaths() {
-		for (int i = 0; i < 200; i++) {
+		for (int i = 0; i < 1000; i++) {
 			System.out.println("There are " + cursorPathsByDistance.get(i).size() + " paths of size " + i);
 		}
 		System.out.println("--------------");
diff --git a/src/CursorDataFileParser.java b/src/CursorDataFileParser.java
index 06f9868..0ca8650 100644
--- a/src/CursorDataFileParser.java
+++ b/src/CursorDataFileParser.java
@@ -26,8 +26,8 @@ public class CursorDataFileParser {
 			String line;
 			CursorPoint lastCursorPoint = new CursorPoint(0, 0, 0);
 			int numberOfRepeats = 0;
-			ArrayList<CursorPoint> currentCursorPath = new ArrayList<CursorPoint>();
-			currentCursorPath.add(lastCursorPoint);
+			ArrayList<CursorPoint> currentCursorPoints = new ArrayList<CursorPoint>();
+			currentCursorPoints.add(lastCursorPoint);
 
 			while ((line = bufferedReader.readLine()) != null) {
 				if (lineMatchesPattern(line)) {
@@ -35,14 +35,14 @@ public class CursorDataFileParser {
 					if (cursorPointsHaveEqualCoordinates(newCursorPoint, lastCursorPoint)) {
 						numberOfRepeats++;
 						if (numberOfRepeats == 20) {
-							CursorPath newCursorPath = new CursorPath(currentCursorPath);
+							CursorPath newCursorPath = new CursorPath(currentCursorPoints);
 							cursorPaths.add(newCursorPath);
-							currentCursorPath.clear();
+							currentCursorPoints.clear();
 						}
 					}
 					else {
 						numberOfRepeats = 0;
-						currentCursorPath.add(newCursorPoint);
+						currentCursorPoints.add(newCursorPoint);
 						lastCursorPoint = newCursorPoint;
 					}
 				}
diff --git a/src/CursorPath.java b/src/CursorPath.java
index 3c02b2f..9a11b00 100644
--- a/src/CursorPath.java
+++ b/src/CursorPath.java
@@ -19,22 +19,32 @@ public class CursorPath {
 		this.timespan = calculateCursorPathTimespan();
 	}
 	
+	public CursorPath(ArrayList<CursorPoint> cursorPoints, boolean setInitializiationOff)
+	{
+		this.cursorPoints = cursorPoints;
+		this.distance = calculateCursorPathDistance();
+		this.theta = calculateCursorPathTheta();
+		this.timespan = calculateCursorPathTimespan();
+	}
+	
 	private ArrayList<CursorPoint> initializePathOfCursorPoints(ArrayList<CursorPoint> cursorPoints) {
 		CursorPoint startingCursorPoint = cursorPoints.get(0);
-		ArrayList<CursorPoint> translatedCursorPoints = getTranslatedCopyOfCursorPath(cursorPoints, startingCursorPoint);
-		ArrayList<CursorPoint> normalizedDelayCursorPoints = getNormalizedDelayCopyOfCursorPath(translatedCursorPoints);
+		ArrayList<CursorPoint> translatedCursorPoints = getTranslatedListOfCursorPoints(cursorPoints, startingCursorPoint);
+		ArrayList<CursorPoint> normalizedDelayCursorPoints = getNormalizedDelayListOfCursorPoints(translatedCursorPoints);
 		return normalizedDelayCursorPoints;
 	}
 	
-	private CursorPath getTranslatedCopyOfCursorPath(ArrayList<CursorPoint> cursorPoints, CursorPoint cursorPointToTranslateBy) {
-		ArrayList<CursorPoint> offsetCursorPath = new ArrayList<CursorPoint>();
+	// util
+	private ArrayList<CursorPoint> getTranslatedListOfCursorPoints(ArrayList<CursorPoint> cursorPoints, CursorPoint cursorPointToTranslateBy) {
+		ArrayList<CursorPoint> translatedCursorPath = new ArrayList<CursorPoint>();
 		for (CursorPoint cursorPoint : cursorPoints) {
-			offsetCursorPath.add(cursorPoint.getCursorPointTranslatedBy(cursorPointToTranslateBy));
+			translatedCursorPath.add(cursorPoint.getCursorPointTranslatedBy(cursorPointToTranslateBy));
 		}
-		return new CursorPath(offsetCursorPath);
+		return translatedCursorPath;
 	}
 	
-	private CursorPath getNormalizedDelayCopyOfCursorPath(ArrayList<CursorPoint> cursorPoints) {
+	//util
+	private ArrayList<CursorPoint> getNormalizedDelayListOfCursorPoints(ArrayList<CursorPoint> cursorPoints) {
 		ArrayList<CursorPoint> normalizedDelayCursorPoints = new ArrayList<CursorPoint>();
 		for (int i = 0; i < cursorPoints.size() - 1; i++) {
 			CursorPoint cursorPoint = cursorPoints.get(i);
@@ -42,24 +52,27 @@ public class CursorPath {
 			normalizedDelayCursorPoints.add(cursorPoint.getCursorPointWithNewDelay(nextCursorPoint.delay - cursorPoint.delay));
 		}
 		normalizedDelayCursorPoints.add(cursorPoints.get(cursorPoints.size() - 1).getCursorPointWithNewDelay(0));
-		return new CursorPath(normalizedDelayCursorPoints);
+		return normalizedDelayCursorPoints;
 	}
 
-	
-	public CursorPath getScaledCopyOfCursorPath(ArrayList<CursorPoint> cursorPoints, double factorToScaleBy) {
+	//util
+	public CursorPath getScaledCopyOfCursorPath(double factorToScaleBy) {
 		ArrayList<CursorPoint> scaledCursorPath = new ArrayList<CursorPoint>();
-		for (CursorPoint cursorPoint : cursorPoints) {
+		for (CursorPoint cursorPoint : this.cursorPoints) {
 			scaledCursorPath.add(cursorPoint.getCursorPointScaledBy(factorToScaleBy));
 		}
-		return new CursorPath(scaledCursorPath);
+		return new CursorPath(scaledCursorPath, true);
 	}
 	
-	public CursorPath getRotatedCopyOfCursorPath(ArrayList<CursorPoint> cursorPoints, double angleToRotateBy) {
+	//util
+	public CursorPath getRotatedCopyOfCursorPath(double angleToRotateTo) {
 		ArrayList<CursorPoint> rotatedCursorPath = new ArrayList<CursorPoint>();
-		for (CursorPoint cursorPoint : cursorPoints) {
+		double angleToRotateBy = this.theta - angleToRotateTo;
+		System.out.println("Rotating points by: " + angleToRotateBy);
+		for (CursorPoint cursorPoint : this.cursorPoints) {
 			rotatedCursorPath.add(cursorPoint.getCursorPointRotatedBy(angleToRotateBy));
 		}
-		return new CursorPath(rotatedCursorPath);
+		return new CursorPath(rotatedCursorPath, true);
 	}
 	
 	private int calculateCursorPathTimespan() {
@@ -71,12 +84,11 @@ public class CursorPath {
 	}
 	
 	private int calculateCursorPathDistance() {
-		return (int) (getStartingCursorPoint().getDistanceFrom(getEndingCursorPoint()));
+		return (int) (getEndingCursorPoint().getDistanceFromOrigin());
 	}
 	
 	private double calculateCursorPathTheta() {
-		CursorPoint endingCursorPoint = getEndingCursorPoint();
-		return Math.atan2(endingCursorPoint.y, endingCursorPoint.x);
+		return getEndingCursorPoint().getThetaFromOrigin();
 	}
 	
 	public CursorPoint getStartingCursorPoint() {
@@ -102,7 +114,7 @@ public class CursorPath {
 	}
 	
 	private boolean isCursorPathNumPointsReasonable() {
-		return (this.cursorPoints.size() > 0 && this.cursorPoints.size() < 50);
+		return (this.cursorPoints.size() > 0 && this.cursorPoints.size() < 80);
 	}
 	
 	public ArrayList<CursorPoint> getCursorPathPoints() {
@@ -122,7 +134,7 @@ public class CursorPath {
 		for (CursorPoint p : this.cursorPoints) {
 			p.display();
 		}
-		System.out.println("Number of points:" + this.cursorPoints.size() + ", Timespan:" + this.timespan);
+		System.out.println("Number of points:" + this.cursorPoints.size() + ", Timespan:" + this.timespan + ", Distance: " + this.distance + ", Theta: " + this.theta);
 		System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~ End of Path ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
 	}
 }
\ No newline at end of file
diff --git a/src/CursorPathTest.java b/src/CursorPathTest.java
index 36138b6..db8aa39 100644
--- a/src/CursorPathTest.java
+++ b/src/CursorPathTest.java
@@ -10,21 +10,30 @@ class CursorPathTest {
 	
 	
 	@Test
-	void testCursorPathOffset() {
+	void testCursorPaths() {
 		initializeCursorPath();
 		
 		for (CursorPath cursorPath : cursorPaths) {
+			cursorPath.displayCursorPoints();
+			
 			testCursorPathStartsAtOrigin(cursorPath);
 			testEndingCursorPointInCursorPathHasZeroDelay(cursorPath);
 			testCursorPathDistance(cursorPath);
 			testCursorPathTheta(cursorPath);
-			//testCursorPathLocations(cursorPath);
+			
 			testCursorPathRotation(cursorPath, Math.PI);
+			testCursorPathRotation(cursorPath, 7 / 4 * Math.PI);
 			testCursorPathScaling(cursorPath, 1.15);
-			cursorPath.displayCursorPoints();
+			
+			testCopyTime(cursorPath);
 		}
 	}
-
+	
+	private void initializeCursorPath() {
+		CursorDataFileParser cursorDataFileParser = new CursorDataFileParser("/home/dpapp/eclipse-workspace/RunescapeAI/testfiles/cursorPathTest.txt");
+		this.cursorPaths = cursorDataFileParser.getArrayListOfCursorPathsFromFile();
+	}
+	
 	private void testCursorPathStartsAtOrigin(CursorPath cursorPath) {
 		CursorPoint startingCursorPoint = cursorPath.getStartingCursorPoint();
 		assertTrue(startingCursorPoint.x == 0 && startingCursorPoint.y == 0);
@@ -32,63 +41,58 @@ class CursorPathTest {
 	
 	private void testEndingCursorPointInCursorPathHasZeroDelay(CursorPath cursorPath) {
 		CursorPoint endingCursorPoint = cursorPath.getEndingCursorPoint();
-		assertEquals(endingCursorPoint.delay, 0);
+		assertEquals(0, endingCursorPoint.delay);
 	}
 	
 	private void testCursorPathDistance(CursorPath cursorPath) {
-		int distance = cursorPath.getCursorPathDistance();
+		int cursorPathDistance = cursorPath.getCursorPathDistance();
 		CursorPoint startingCursorPoint = cursorPath.getStartingCursorPoint();
 		CursorPoint endingCursorPoint = cursorPath.getEndingCursorPoint();
 		
-		int actualDistance = (int) Math.hypot(startingCursorPoint.x - endingCursorPoint.x, startingCursorPoint.y - endingCursorPoint.y);
-		assertEquals(distance, actualDistance);
+		startingCursorPoint.display();
+		endingCursorPoint.display();
+		int expectedDistance = (int) Math.hypot(startingCursorPoint.x - endingCursorPoint.x, startingCursorPoint.y - endingCursorPoint.y);
+		assertEquals(expectedDistance, cursorPathDistance);
 	}
 	
 	private void testCursorPathTheta(CursorPath cursorPath) {
 		double theta = cursorPath.getCursorPathTheta();
+		CursorPoint startingCursorPoint = cursorPath.getStartingCursorPoint();
 		CursorPoint endingCursorPoint = cursorPath.getEndingCursorPoint();
-		double actualTheta = Math.atan2(endingCursorPoint.y, endingCursorPoint.x);
+		double actualTheta = Math.atan2(endingCursorPoint.x - startingCursorPoint.x, endingCursorPoint.y - startingCursorPoint.y);
 		assertEquals(theta, actualTheta);
 	}
-	/*private void testCursorPathLocations(CursorPath cursorPath) {
 	
-	}*/
 	
-	void testCursorPathRotation(CursorPath cursorPath, double angleToRotateBy) {
+	void testCursorPathRotation(CursorPath cursorPath, double angleToRotateTo) {
+		CursorPath rotatedCursorPath = cursorPath.getRotatedCopyOfCursorPath(angleToRotateTo);
+		assertEquals(angleToRotateTo, rotatedCursorPath.getCursorPathTheta());
+		
 		ArrayList<CursorPoint> cursorPoints = cursorPath.getCursorPathPoints();
-		ArrayList<CursorPoint> rotatedCursorPoints = cursorPath.getRotatedCopyOfCursorPath(angleToRotateBy);
+		ArrayList<CursorPoint> rotatedCursorPoints = rotatedCursorPath.getCursorPathPoints();
 		assertEquals(cursorPoints.size(), rotatedCursorPoints.size());
-		for (int i = 1; i < cursorPoints.size(); i++) {
-			double originalThetaOfCursorPoint = cursorPoints.get(i).getTheta();
-			double rotatedThetaOfCursorPoint = rotatedCursorPoints.get(i).getTheta();
-			System.out.println((originalThetaOfCursorPoint + angleToRotateBy) % (Math.PI) + "," + rotatedThetaOfCursorPoint);
-			//assertInRangeByAbsoluteValue(originalThetaOfCursorPoint + angleToRotateBy, rotatedThetaOfCursorPoint, 3);
-		}
-	}
-	
-	void testCursorPathScaling(CursorPath cursorPath, double factorToScaleBy) {
-		ArrayList<CursorPoint> cursorPoints = cursorPath.getCursorPathPoints();
-		ArrayList<CursorPoint> scaledCursorPoints = cursorPath.getScaledCopyOfCursorPath(factorToScaleBy);
-		assertEquals(cursorPoints.size(), scaledCursorPoints.size());
-		CursorPoint startingPoint = cursorPoints.get(0);
-		for (int i = 0; i < cursorPoints.size(); i++) {
-			double originalDistanceOfCursorPoint = cursorPoints.get(i).getDistanceFrom(startingPoint);
-			double scaledDistanceOfCursorPoint = scaledCursorPoints.get(i).getDistanceFrom(startingPoint);
-			assertInRangeByAbsoluteValue(originalDistanceOfCursorPoint * factorToScaleBy, scaledDistanceOfCursorPoint, 3);
-		}
-	}
-	
-	void initializeCursorPath() {
-		CursorDataFileParser cursorDataFileParser = new CursorDataFileParser("/home/dpapp/eclipse-workspace/RunescapeAI/testfiles/cursorPathTest.txt");
-		this.cursorPaths = cursorDataFileParser.getArrayListOfCursorPathsFromFile();
 
 	}
 	
-	void assertInRangeByRatio(double expected, double actual, double toleranceRatio) {
-		assertTrue((actual <= (expected * (1.0 + toleranceRatio))) && (actual >= (expected * (1.0 - toleranceRatio))));
+	void testCopyTime(CursorPath cursorPath) {
+		CursorPath rotatedCursorPath = cursorPath.getRotatedCopyOfCursorPath(2.3 / 9.0 * Math.PI);
+		ArrayList<CursorPoint> cursorPoints = cursorPath.getCursorPathPoints();
+		ArrayList<CursorPoint> rotatedCursorPoints = rotatedCursorPath.getCursorPathPoints();
+		assertEquals(cursorPoints.size(), rotatedCursorPoints.size());
+		for (int i = 0; i < cursorPoints.size(); i++) {
+			assertEquals(cursorPoints.get(i).delay, rotatedCursorPoints.get(i).delay);
+		}
+	}
+
+	void testCursorPathScaling(CursorPath cursorPath, double factorToScaleBy) {
+		CursorPath scaledCursorPath = cursorPath.getScaledCopyOfCursorPath(factorToScaleBy);
+
+		ArrayList<CursorPoint> cursorPoints = cursorPath.getCursorPathPoints();
+		ArrayList<CursorPoint> scaledCursorPoints = scaledCursorPath.getCursorPathPoints();
+		assertEquals(cursorPoints.size(), scaledCursorPoints.size());
 	}
 	
-	void assertInRangeByAbsoluteValue(double valueToTest, double expectation, double toleranceAbsolute) {
-		assertTrue((valueToTest <= (expectation + toleranceAbsolute)) && (valueToTest >= (expectation * (1 - toleranceAbsolute))));
+	void assertInRangeByTolerance(double expected, double actual, double tolerance) {
+		assertTrue((actual <= (expected + tolerance)) && (actual >= (expected - tolerance)));
 	}
 }
diff --git a/src/CursorPoint.java b/src/CursorPoint.java
index b6cc908..4a57d96 100644
--- a/src/CursorPoint.java
+++ b/src/CursorPoint.java
@@ -12,26 +12,26 @@ public class CursorPoint {
 		this.delay = delay;
 	}
 	
-	public double getDistanceFrom(CursorPoint b) {
-		return Math.hypot(this.x - b.x, this.y - b.y);
+	public double getDistanceFromOrigin() {
+		return Math.hypot(this.x, this.y);
 	}
 	
-	public double getTheta() {
-		return Math.atan2(this.y, this.x);
+	public double getThetaFromOrigin() {
+		return Math.atan2(this.x, this.y);
 	}
 	
 	public CursorPoint getCursorPointTranslatedBy(CursorPoint startingCursorPoint) {
-		return new CursorPoint(this.x - startingCursorPoint.x, this.y - startingCursorPoint.y, this.delay - startingCursorPoint.delay);
+		return new CursorPoint(x - startingCursorPoint.x, y - startingCursorPoint.y, delay - startingCursorPoint.delay);
 	}
 	
 	public CursorPoint getCursorPointScaledBy(double scaleFactor) {
-		return (new CursorPoint((int) (this.x * scaleFactor), (int) (this.y * scaleFactor), (int) (this.delay * scaleFactor)));
+		return (new CursorPoint((int) (this.x * scaleFactor), (int) (this.y * scaleFactor), (int) (delay * scaleFactor)));
 	}
 	
 	public CursorPoint getCursorPointRotatedBy(double angleOfRotation) {
 		int rotatedX = (int) (Math.cos(angleOfRotation) * this.x - Math.sin(angleOfRotation) * this.y);
 		int rotatedY = (int) (Math.sin(angleOfRotation) * this.x + Math.cos(angleOfRotation) * this.y);
-		return (new CursorPoint(rotatedX, rotatedY, this.delay));
+		return (new CursorPoint(rotatedX, rotatedY, delay));
 	}
 	
 	public CursorPoint getCursorPointWithNewDelay(int delay) {
diff --git a/src/CursorPointTest.java b/src/CursorPointTest.java
index 45d19e4..29063d8 100644
--- a/src/CursorPointTest.java
+++ b/src/CursorPointTest.java
@@ -5,17 +5,34 @@ import org.junit.jupiter.api.Test;
 class CursorPointTest {
 	
 	@Test
-	void testDistanceFrom() {
+	void testDistanceFromOrigin() {
 		CursorPoint a = new CursorPoint(0, 0, 0);
 		CursorPoint b = new CursorPoint(3, 4, 0);
 		CursorPoint c = new CursorPoint(500, 750, 0);
 		CursorPoint d = new CursorPoint(284, 848, 0);
 		
-		assertTrue(withinRangeByRatio(a.getDistanceFrom(b), 5, 0.0001));
-		assertTrue(withinRangeByRatio(a.getDistanceFrom(c), 901.387818866, 0.0001));
-		assertTrue(withinRangeByRatio(a.getDistanceFrom(d), 894.293016857, 0.0001));
-		assertTrue(withinRangeByRatio(b.getDistanceFrom(c), 896.395560007, 0.0001));
-		assertTrue(withinRangeByRatio(c.getDistanceFrom(d), 237.191905427, 0.0001));
+		assertEquals(0, a.getDistanceFromOrigin());
+		assertTrue(withinRangeByRatio(a.getDistanceFromOrigin(), 901.387818866, 0.0001));
+		assertTrue(withinRangeByRatio(a.getDistanceFromOrigin(), 894.293016857, 0.0001));
+		assertTrue(withinRangeByRatio(b.getDistanceFromOrigin(), 896.395560007, 0.0001));
+		assertTrue(withinRangeByRatio(c.getDistanceFromOrigin(), 237.191905427, 0.0001));
+	}
+	
+	@Test
+	void testThetaFromOrigin() {
+		CursorPoint a = new CursorPoint(0, 0, 0);
+		CursorPoint b = new CursorPoint(3, 4, 0);
+		CursorPoint c = new CursorPoint(500, 750, 0);
+		CursorPoint d = new CursorPoint(284, 848, 0);
+		CursorPoint e = new CursorPoint(10, 0, 0);
+		CursorPoint f = new CursorPoint(0, 10, 0);
+		
+		assertEquals(0, a.getThetaFromOrigin());
+		assertEquals(0.6435011087932844, b.getThetaFromOrigin());
+		assertEquals(0.5880026035475675, c.getThetaFromOrigin());
+		assertEquals(0.32316498061040844, d.getThetaFromOrigin());
+		assertEquals(1.5707963267948966, e.getThetaFromOrigin());
+		assertEquals(0.0, f.getThetaFromOrigin());
 	}
 	
 	@Test
@@ -51,6 +68,8 @@ class CursorPointTest {
 		assertTrue(h.x == -428 && h.y == -321);
 	}
 	
+	
+	
 	boolean withinRangeByRatio(double actual, double expectation, double toleranceRatio) {
 		return ((actual <= (expectation * (1 + toleranceRatio))) && (actual >= (expectation * (1 - toleranceRatio))));
 	}
diff --git a/src/CursorTest.java b/src/CursorTest.java
index 185c0ce..9d85629 100644
--- a/src/CursorTest.java
+++ b/src/CursorTest.java
@@ -12,23 +12,28 @@ class CursorTest {
 	
 	void initialize() throws AWTException {
 		cursor = new Cursor();
-		cursorTolerance = 3;
+		cursorTolerance = 5;
 	}
 	
 	@Test
 	void testMoveCursorToCoordinatesHelper() throws InterruptedException, AWTException {
 		initialize();
+		cursor.displayCursorPaths();
+		
+		testThetaBetweenPoints();
 		testMoveCursorToCoordinates();
-		testRightClickCursor();
+		//testRightClickCursor();
 	}
 	
-	@Test
 	void testThetaBetweenPoints() {
 		Point a = new Point(0, 0);
 		Point b = new Point(10, 0);
 		Point c = new Point(10, 10);
 		Point d = new Point(20, 10);
-		assertEquals(cursor.getThetaBetweenPoints(a, b), 0);
+		assertEquals(degreesToRadians(90), cursor.getThetaBetweenPoints(a, b));
+		assertEquals(degreesToRadians(45), cursor.getThetaBetweenPoints(a, c));
+		assertEquals(1.1071487177940904, cursor.getThetaBetweenPoints(a, d));
+		assertEquals(degreesToRadians(45), cursor.getThetaBetweenPoints(b, d));
 	}
 	
 	void testMoveCursorToCoordinates() throws InterruptedException {
@@ -52,7 +57,7 @@ class CursorTest {
 		testMoveCursorToCoordinates(a, g);
 	}
 	
-	void testRightClickCursor() throws InterruptedException {
+	/*void testRightClickCursor() throws InterruptedException {
 		Point a = new Point(375, 600);
 		Point b = new Point(952, 603);
 		Point c = new Point(1025, 133);
@@ -61,21 +66,24 @@ class CursorTest {
 		testMoveAndRightClickCursor(b, c);
 		testMoveAndRightClickCursor(c, d);
 		testMoveAndRightClickCursor(d, a);
-	}
+	}*/
 	
-	void testMoveAndRightClickCursor(Point a, Point b) throws InterruptedException {
+	/*void testMoveAndRightClickCursor(Point a, Point b) throws InterruptedException {
 		cursor.robotMouseMove(a);
 		cursor.moveAndRightClickAtCoordinates(b);
 		Point point = cursor.getCurrentCursorPoint();
+		System.out.println("Cursor ended up on " + point.x + "," + point.y);
 		verifyCursorIsInCorrectPlace(point, b);
 		// Way to verify that context menu is open?
-	}
+	}*/
 	
 	void testMoveCursorToCoordinates(Point a, Point b) throws InterruptedException {
 		cursor.robotMouseMove(a);
 		cursor.moveCursorToCoordinates(b);
 		Point point = cursor.getCurrentCursorPoint();
+		System.out.println("Cursor ended up on " + point.x + "," + point.y);
 		verifyCursorIsInCorrectPlace(point, b);
+		Thread.sleep(500);
 	}
 	
 	void verifyCursorIsInCorrectPlace(Point actualPoint, Point expectedPoint) {
@@ -90,6 +98,10 @@ class CursorTest {
 	void assertInRangeByAbsoluteValue(double valueToTest, double expectation, double toleranceAbsolute) {
 		assertTrue((valueToTest <= (expectation + toleranceAbsolute)) && (valueToTest >= (expectation * (1 - toleranceAbsolute))));
 	}
+	
+	private double degreesToRadians(double degrees) {
+		return degrees * Math.PI / 180.0;
+	}
 
 }
  
\ No newline at end of file
diff --git a/src/OpenCVTest.java b/src/OpenCVTest.java
new file mode 100644
index 0000000..adfa1c5
--- /dev/null
+++ b/src/OpenCVTest.java
@@ -0,0 +1,11 @@
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+
+public class OpenCVTest {
+   public static void main( String[] args ) {
+      System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+      Mat mat = Mat.eye(3, 3, CvType.CV_8UC1);
+      System.out.println("mat = " + mat.dump());
+   }
+}
\ No newline at end of file
diff --git a/src/main.java b/src/main.java
index e5ea76b..4978077 100644
--- a/src/main.java
+++ b/src/main.java
@@ -8,7 +8,7 @@ public class main {
 
 	public static void main(String[] args) throws AWTException, InterruptedException, IOException {
 		
-		Cursor cursor = new Cursor();
+		/*Cursor cursor = new Cursor();
 		CursorTask cursorTask = new CursorTask();
 		Inventory inventory = new Inventory();
 		
@@ -19,7 +19,7 @@ public class main {
 				cursorTask.optimizedDropAllItemsInInventory(cursor, inventory);
 			}
 			Thread.sleep(100);
-		}		
+		}		*/
 		//cursor.moveCursorToCoordinates(new Point(620, 420));
 		
 	}