From bbb2fdefb9a8789dd09414d192463fe268db9534 Mon Sep 17 00:00:00 2001 From: Tomasz Adamczyk Date: Mon, 31 May 2021 17:10:14 +0200 Subject: [PATCH] clean --- .idea/{SmartTractor.iml => SmartCart.iml} | 0 .idea/modules.xml | 2 +- .idea/workspace.xml | 94 +++++++++-- __pycache__/astar.cpython-37.pyc | Bin 5291 -> 5282 bytes __pycache__/cart.cpython-37.pyc | Bin 0 -> 8708 bytes __pycache__/definitions.cpython-37.pyc | Bin 3703 -> 3663 bytes __pycache__/graph.cpython-37.pyc | Bin 4392 -> 4383 bytes __pycache__/map.cpython-37.pyc | Bin 5718 -> 5683 bytes __pycache__/neuralnetwork.cpython-37.pyc | Bin 0 -> 4442 bytes __pycache__/plant.cpython-37.pyc | Bin 2940 -> 2722 bytes __pycache__/tractor.cpython-37.pyc | Bin 8835 -> 0 bytes __pycache__/treelearn.cpython-37.pyc | Bin 1404 -> 1384 bytes astar.py | 82 +++++----- tractor.py => cart.py | 154 +++++++++--------- definitions.py | 84 +++++----- graph.py | 58 +++---- map.py | 24 +-- neuralnetwork.py | 110 +++++++++++++ plant.py | 81 +++++---- py.py | 29 ++-- resources/{ => decision_tree}/data.csv | 0 resources/{ => decision_tree}/mytree.png | Bin resources/{ => decision_tree}/tree.pkl | Bin resources/{ => images}/beetroots_stage_0.png | Bin resources/{ => images}/beetroots_stage_1.png | Bin resources/{ => images}/beetroots_stage_2.png | Bin resources/{ => images}/beetroots_stage_3.png | Bin resources/{ => images}/carrots_stage_0.png | Bin resources/{ => images}/carrots_stage_1.png | Bin resources/{ => images}/carrots_stage_2.png | Bin resources/{ => images}/carrots_stage_3.png | Bin resources/{ => images}/dirt.png | Bin resources/{ => images}/farmland_dry.png | Bin resources/{ => images}/farmland_wet.png | Bin resources/{ => images}/flower_dandelion.png | Bin .../minecart_command_block_east.png | Bin .../minecart_command_block_north.png | Bin .../minecart_command_block_south.png | Bin .../minecart_command_block_west.png | Bin resources/{ => images}/potatoes_stage_0.png | Bin resources/{ => images}/potatoes_stage_1.png | Bin resources/{ => images}/potatoes_stage_2.png | Bin resources/{ => images}/potatoes_stage_3.png | Bin resources/{ => images}/rail_normal.png | Bin resources/{ => images}/sponge.png | Bin resources/{ => images}/wheat_stage_0.png | Bin resources/{ => images}/wheat_stage_1.png | Bin resources/{ => images}/wheat_stage_2.png | Bin resources/{ => images}/wheat_stage_3.png | Bin resources/{ => images}/wheat_stage_4.png | Bin resources/{ => images}/wheat_stage_5.png | Bin resources/{ => images}/wheat_stage_6.png | Bin resources/{ => images}/wheat_stage_7.png | Bin treelearn.py | 20 +-- 54 files changed, 460 insertions(+), 278 deletions(-) rename .idea/{SmartTractor.iml => SmartCart.iml} (100%) create mode 100644 __pycache__/cart.cpython-37.pyc create mode 100644 __pycache__/neuralnetwork.cpython-37.pyc delete mode 100644 __pycache__/tractor.cpython-37.pyc rename tractor.py => cart.py (76%) create mode 100644 neuralnetwork.py rename resources/{ => decision_tree}/data.csv (100%) rename resources/{ => decision_tree}/mytree.png (100%) rename resources/{ => decision_tree}/tree.pkl (100%) rename resources/{ => images}/beetroots_stage_0.png (100%) rename resources/{ => images}/beetroots_stage_1.png (100%) rename resources/{ => images}/beetroots_stage_2.png (100%) rename resources/{ => images}/beetroots_stage_3.png (100%) rename resources/{ => images}/carrots_stage_0.png (100%) rename resources/{ => images}/carrots_stage_1.png (100%) rename resources/{ => images}/carrots_stage_2.png (100%) rename resources/{ => images}/carrots_stage_3.png (100%) rename resources/{ => images}/dirt.png (100%) rename resources/{ => images}/farmland_dry.png (100%) rename resources/{ => images}/farmland_wet.png (100%) rename resources/{ => images}/flower_dandelion.png (100%) rename resources/{ => images}/minecart_command_block_east.png (100%) rename resources/{ => images}/minecart_command_block_north.png (100%) rename resources/{ => images}/minecart_command_block_south.png (100%) rename resources/{ => images}/minecart_command_block_west.png (100%) rename resources/{ => images}/potatoes_stage_0.png (100%) rename resources/{ => images}/potatoes_stage_1.png (100%) rename resources/{ => images}/potatoes_stage_2.png (100%) rename resources/{ => images}/potatoes_stage_3.png (100%) rename resources/{ => images}/rail_normal.png (100%) rename resources/{ => images}/sponge.png (100%) rename resources/{ => images}/wheat_stage_0.png (100%) rename resources/{ => images}/wheat_stage_1.png (100%) rename resources/{ => images}/wheat_stage_2.png (100%) rename resources/{ => images}/wheat_stage_3.png (100%) rename resources/{ => images}/wheat_stage_4.png (100%) rename resources/{ => images}/wheat_stage_5.png (100%) rename resources/{ => images}/wheat_stage_6.png (100%) rename resources/{ => images}/wheat_stage_7.png (100%) diff --git a/.idea/SmartTractor.iml b/.idea/SmartCart.iml similarity index 100% rename from .idea/SmartTractor.iml rename to .idea/SmartCart.iml diff --git a/.idea/modules.xml b/.idea/modules.xml index 477f5bd..6d43d3d 100644 --- a/.idea/modules.xml +++ b/.idea/modules.xml @@ -2,7 +2,7 @@ - + \ No newline at end of file diff --git a/.idea/workspace.xml b/.idea/workspace.xml index fd9d236..300aef3 100644 --- a/.idea/workspace.xml +++ b/.idea/workspace.xml @@ -2,8 +2,49 @@ + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + + - + + - + + - + + - + + @@ -184,10 +252,15 @@ - + - + + + + + + @@ -201,6 +274,7 @@ - + + \ No newline at end of file diff --git a/__pycache__/astar.cpython-37.pyc b/__pycache__/astar.cpython-37.pyc index 287907e3762868b0ef0cc78c817e7bdd7a9c4a60..540fd4810b13389963b86578601056c5dc617dce 100644 GIT binary patch delta 466 zcmXw#Jx{|h5QghCG%1Z~X)0O}lzs|@0a#iP2nLuL7+4Te8d4*I+9tZBe2pL`CghEg z35f|6iC=*D1uPbbU%}2f61M#4^!m=ed!MaGi*8dop1}3<``USbp%Eb){F*GOI}Svn zH}a9@)5dCEq)*royfE@yD+zO$&wn!WS#sRQFjV9N1Zw=&xSL#)N-9<=L{*?Mddh7p zO_6effDO7L8Tf%vT|c;l24;y&0Nx<7`~DdVdD3h*g&GcB7piy(H3|70lqKp2p+>A9 z@I&*0Z1PWYm$dj*=9D`|ArBS2@8J3GsKTq%F2VvzP(%m~*cpS6Sqjwo11-)LV#ON%=` zFdR4X{6T2<&_P(iT0WKAOTjWm9v|d3OBNNnA24ttA3)j(>k<~S5XZY|ZBpCVlvYH=uhvR~Qt={cQPG3oK~N9`L1K(s4YW;|q<(-W@gkmN z-@uCpPg37Oe1!$UlMf&W9-V2>J^XfN_rLRJW*^KaQ(xEh-WaZ*`px0zvmP?GBCc6g z-38kTJ?Ol!*OVAG>T^;%@$5#(gAg>-M@V5LQ>VNQZVl(MNG^% zjNm4&j6p-P`U1v(s*?Ch-{qF*B#DTzah6b^EFKMONG5IH=dEKHzzeAYKjRQ^Q-Mh_ zk{j)lX&>BHXf?ev9;}MBTtBOH_Hys+Kqef|zl1bCgDHYe$abrQQD5?}!To|8bW2!v zqv4(NV=HJoj;X>V%J(xk1lMZ?Rs;K!iI6vaahu;!Wr9>2;v>J@xzDUBgIymP_dOq` z$*fGMAjEgydQeK34mSP)&_tuMGZe)M a1;QACCLERhH;w#i;;68wDq4@GYQw)U+Ih|Z diff --git a/__pycache__/cart.cpython-37.pyc b/__pycache__/cart.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..70275bfdfa576371df0fd679314d9699ea55dcea GIT binary patch literal 8708 zcmb_hO>7&-72aL$@=w&iEK$Ff?ZgQa$BC0PKaQJ5mT60=EEy6VwS<8U!=YkX6zL3U zTM{UsNQ_*XgV9sb0)^B=ffhLxxiu(yDbRa!+G|g~7e&!izxQUiyIlQL4oYI@?aaKH z`R2VhZ{Eya?e0z+_}%)~Hy{7~UBmbXW!k?OUOvFnIEzFW!mJuaMa`ml!w{B;JvKz_ z3#(`ebH&KnPr+v_mMLxj{67ATl8R9@g+biHdTbP9A|`B5TR0*P>WG9$g2qKkq(Kv+ zOJqQkqFeNUrbMsk15Jy5F#y^n2E`C)Mw}AEpxt6bWI=nxs2Bt772{$8v`Hm`i%SrOo<-TGOqsxs6Ii zG`zlYy;`l5n-$^Sua;`fhL;lS5(Vq^nwMUy$mV)=eWxNld+kA`>UBLTH7nAsRvsc_ zZh7W*F6G&cN_9<=?xanLLrI*H1SLsIXbzH$=l6!pfc)q3?BzSR8x`5OQ>bs28avZ7 zqO@7w+1|KwYrA~6BsXu#`aR%i+*#R#Fi0SG%1AEW-}aKOyIxywx-JdZ=tE+d@s9sa zH#NA}<|~`TgC9`>%A$M`FD>I9Om$RIYt$G~Z!!PPrZhR4PqbuQ$CokVvBU z>&;TL?m3U{R!YsB$wC0>LeD%+m2@NPjeJ^Zx}|E>ji`Vs8>C*t+?in1M=+L|34BC- zdmx$8BwCn+(y~TjF$&MFl{PC;EQ35mrz!NJqc)CgfTNSCOv0ldQD2Zf$dEM>iYr+2 z9XMi28bjdmoQI|AgM(-qB$>{E`oZ3b<`Aa;i&`a3T#^w<8dMG-feOjAj?iSbt)S@I z8AO{l=*d8Y(0P>e|6i8bLwX2CICB6&XMKmFj0{a zHVNAQkDJ8ys|R|gxow|(5I+LA(|pHFgs%huePAifd}@ zC0f?LX&O)BwQpOAz2v^Jm%<3Kjih|6^J!sfj$eg1OmKXs^If{dcfd#Q)`pEbV=trg zcGjRCG;OO>JcO8l5UL(^QMv~@vXj=EmVE2*|XOxaLC!Wc9X57u)$-> zhZwm}#P@L&+OT!LUm(!erG&_0MAY{Har(Kmuqj9Kt^E@{Cb-AHaoeQdBjx)Ajtl6K zN~1lZ?9d*6iyl)vk1=kW);(I1^8F(1mqvR8=b=5`LXQq(?BTXuK1Ry-i!Q%3+9Nm* z>+y;CScG4_Ui9Vkw+uMxC` zeQAy?Yen$|_=s;**@+%89gIw4jIc!kV?2a0$r#Cw1B)Syp%Szm!!xciehb+Qv;Nd< z+G`-dNE}(#v*J5B#&L}?R{JD`F%68i{5XQKqXhUS@JupBsv(SRJ5iirIVz4UTaMy8 zImSti(W?D9gs}@49cf1}c9a0$6rR(Jk!lEI+wv4=7^C9IvMnmUlVd#XV;l=%Bztt^ zR{=(#8Pa9O-t@kK{2AC`z>^m2>Ci%1S4>+!BkWt}+MJl_uo`KNPi zjanWx+9%pxf-EN?r#etf>9R12fam+6AfI-Q?Mn(u;SjF`N{mv+c({n!b~Aw91JRMEHACPh54I# zIYoo@6PWcz5X%cm$BAM;A?qkFo|>ImUOw1&f4kW4xj1}l3BxYsqc8^i@_=`6buK?s zh~Vv2g+7D&(0O@qiEQu00}Kca-r zm-0DEIPO1BZyZSLb1JjHL#2@;LGN8GoNC3Tu{SHV=Fh;>po<>^DoUDZ{Uo8bw7H`W zUXdn#Xioz4h4>p}5OZ5wpSLXeC8kW`q{#Nmrn!g9c|?iUZmflCc8IM=VrwBzrl^#2 zwiY6Z%=ATOx`@?wt85=g-5pmdd#K^~6~#FR2v@CohjSg?{# zU)SYJNOKt_BxkGJNR~XlU>Nc}N+LQKjtJCM zPVMJlZIBP5wKM>A46`!QSTRZbRhl$+#@V6|@59$k$0hDp=#y@_n&v$+Y?$-C7~ZiL zAaynjd6qtzXbzI|Rd6JTBTG7TZ{^{5+oTfYDpO%ffxQG;MF4ih{WmlN^1E$%IT};b76;gNkLyn z5$ImO77mmY*NRFk?l@c1FHc`$m$l<;ProvKi3p0Q2D$6dAze#K(xD`WsvHyPOkSfT zPYJuI>-2Vmk~t(f6Q2+2;=qOdP(-F~<3YLnJ2X(5uwH}~&g0S4+EI7VhqXFf9TI(o z*24te^?JbPtXOSX*Wr{X-@$vFM4v?qH(q;7*Wr{a3++1ks)IV5NO_HsDr$J=KDk|t ztsbAqQh~WEQL+1GQL&Wx0)(Zc1f<+ar~hDQ^hXkh`ZSfnRvSD!DRvL!y$+u|#Z?3p zuGf+Sg1+(@HC#PV34>KjG`6VRWDe}O0CE&LxpXU1Z& zP<<=}Lv4u1Vxi6PFL=UO`omawXYKHkbm7Tizy(CXxB-F~kYZ=r$1SO%>I6YcjXoCh zO$hN}2SYthLd*vm;){j&Z055yA83fr4)Hn6=V(6A5Fc)$cw7V^!o*nxyD0}9*jYPr zc1Moywlt^1?c#op+66gk7v!j2JD0$_x}Cw^i+8?PX$La=af?n5(Jx$GLG;PtIeQ0h zihcLY&86Fm1$XJXyOPgeTY;aSopTF6y_M%k+v{bf>-puv`~r>=%N*=@DOGwqzrcqA zuaEPq20Bz>^tlTvUz;eefkaU~e`m=nZDUrPAs!LwJ92#0t6 z0Z94N=ZWt;C3H0|uTb&Nt@M)ZSo6O*KT)^< literal 0 HcmV?d00001 diff --git a/__pycache__/definitions.cpython-37.pyc b/__pycache__/definitions.cpython-37.pyc index 12d2ce0b7f8ff6a6b6aa27a9a875c6da6b80f04f..7c199b81bde350c6db648f8ed02684d6b8dfbc1e 100644 GIT binary patch delta 1106 zcmZ{i&rcIU6vua$-EFDeQlLZK31cQkO4-!v!;@%kJ)q^JvB%Yidhh@0_oi{Eq9`ZE`z}#~$p)EhoYWk2;C!Jyy(4Q!s^1;Y6T{lWV11h;bpC zvlJ&6pj?=7VVeu%HWa}w6zRe;>c$PIhX}p69Yt{v_2CZGk8h&^_#w27#aMC7E{+j4 zjzen#N}xfaCITFZg8@$9&=4AibVFM;$*PieRg!cXsT(gs$4fCbWwR+V+9;VOO(q+| zBD#YmG;WS#Ily68kVALte7dO51oN3Ng(};dB{}!eO~FY9PTCDE#mV(hZi;bJHfJeL zu9tGtjGMMO(~_KEl!7x1oUuVmadLf>%P=lua~ZOMdt@84WE*qjK5x$Ben^W!egIa) zI3I(3F%Em84DZA!pMW#+`b=KG$ZH7vQXHBj8Rn!YpM-U(yJ^@QA|H!K4=`Wi21nqH z)bBs?SImRG=ar}C!RYq0jV<^jox*EZ2Q0XDqXPN2KhLcYu)-rNBuF@NrgTouX-}loe@V>o>Tt)nkCCST>&llgP zy{q77|2f-16EK4&cR2_{MCbHyfFWxnz;FyiA*Qnj!l|e;2cAcSbby<)}J9aAR zGLhVCuFHXp+z=nKHw>FFZNjz*BtQ~P!7RE4Db#Vn9O7YKpGWQhgM=Uh>7hYEV^GE% zl(7fV#`)tyhRd2RYdhLF-L&Br{<)66U_)9t;fw(n&4G)yqm9#r4Yy>vCEL-)=^}>9 znJ#Cz4n4jcIf48Tjv9E`#LMC3|BB+!FIH9I@xe5rdzSxOQ4k##tm3BVbOw6 zByY-1a(B1LUEd~mw@UIIlz_V^3HQ(}+(#*RK>CNs1ts!_*7P+rhYPMCZn@le%avr) z_|TQcUrG8%QWk$BX`FZC-y|*K>wFqFNh+FwvY3N@7@eJ@>b)hP~Zne`fW=%!N>0RljkH10(5ysmke2YXF`sn21Zd6odU8~f#n@YK^H8tghwxcQ_oBNpcPK$PsNwA*8C2y!RHF``x z_132V}(qH2|D1r)VEW_8l$j#BL>%!q$@!(!YDzq~Vn zNeed0nxZzV%5$ZP8)H9xOXM`#bosM^%Tiv@+OPJHTWx$K?cz&m6@QnKnD@u=g(Ut3 D)!`zJ diff --git a/__pycache__/graph.cpython-37.pyc b/__pycache__/graph.cpython-37.pyc index 91db8daef8260d345084d292f02025e751574d72..d9bc7b6f50730b0d0d740fd8068320de6c24e9f5 100644 GIT binary patch delta 473 zcmYjOJxjwt81A((jZJbE{2HtjGZc$ODC!`BL&d?ZPL44oSFNPEdEVoF-jC;AgXh5S`F^dWpU0o~(~md5htQtvqfP4|0x`Wq z53|!3e1dM39Wh3-L{%7N%8DtwhE*+7E`wnv!V#Si-u9I}(BTtmU(WsqPC^la+&GSfJrZf85hhLKedM^^k)gn0~rX2rCz;nKn$xKqz_R zcU!QgQ^9yt^fXey8ng@ABb7U)1Xvu61j>fkT8%9a9`bCJgi-f`=VEiU;wKiM4c@4z?zK&8D6N{Rsh& zdK0g*AEV^x#s44*CM{E2c;Nl|CVi5}+H=imJ5Da8p4az_)3+C=jnJ+*KpW;E_yMOd zxkdN0V&CZ;%dF2B3A-?_+R_9vCJ>QE8pnk*q~P<9R45SBFbT5uJl$rD34RmI}F zP}#$_^6t|xaghcmLxu~Qv4I!S5kJT7-{6u&{C_6C%HpKBY)T^<1;LKED{iCuq?GTV zn^;0-7-g`cO%^q(3JnKmd+MBL1Y6{a4JeSV%&OZ^=YhIzRTQKV(k_W_4A%6pq=z$c z3){(hkB``ZV0XGplEKh*@nx6MkyvnA>rIs#R${TLzoj+iG=8O$A2-EEaVuk5JXfpet7{%o#;WF^iAn{QpVLIeG0X^{F$#U~QFLH=mDNA3YCh0HG9b zMgx9hn-xn-Nb&Km#^*~>v!5>%+{5h?5j@Bh-Mu`^?H2RLM@*H;qS4ST>ZUUmHfV;J zF4k=-6enY*i6i_wg?v%8{9|z`UZYtH3v?#Xxd>NSOk&Y_k&sbD`9(NpRvK)Q{WX+7 z?nVEut}M;LvNW$4{vJ-&`FCZXA^_xLkq#8+>yiGF<-ZFgSetB(wL^c3y-dtG%sL^` zCBd82VTC2+uDe9luWB*~3IYrRMgXILBp@X*OM6?G4^9(+Nx&4qn_#_7b#HVAu_>G8 zx1rdmAypBc!I)ZvP}|kh*+uGl1`JY2PR0UZ&LYlFJj35Y&G7|LwPhl&B)D8Ayj6=e zt$^I%%wwIFrLJ>Ri-tBp3&@}ReQ1-PYD3CT-~3+dK`wvMOnw!aR0gD#CHPY$>8q<5 IzmBec14rMbLI3~& delta 641 zcmZ{iOH1oO6vyw}N^I5CM-ywS=+%WUs#q5yQZB|CZ3Qzm8I2o>wLU0TD?=8#a^v2` z!G+)8Zl&Pf&mg!M5c~q}MFgE=P!xN!_>r0aW9Ed^Qg^B7oT@hclF!rb+2-up$doFMuTe-QnM0mPuh0vqY(AzTe3Mi8TjsDx;7n8EVY^0L%nJOvN2 z1et*6STZq*a(mXWZOR;P(WY+TnSwE`D>;p7M}f*THNVOk@U%qyFUqZM&NSGU=mMN; zo$Wc)BJ+8h1%*p+t)-QM+~q6qs0|SYx^4k&xIN_zz3SeM?`@a)PRTD<4}*JmGTX>9 zYJ0NB%)U=x8ghbVtg$fFTi@X^bDgc)CJzooXZ)wrqBhHk)4u;GA0_po4qcVeI>~q8 zGg)T<*L2voYlEt!V_`q|P0~XBc!RvsPYz*U8H19ZX~vJli-;<`>T$Ty6QP-K67Kc2 EH%Ga)w*UYD diff --git a/__pycache__/neuralnetwork.cpython-37.pyc b/__pycache__/neuralnetwork.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2b3ea84f5fc46611a8f6bd1832321fba09ba998a GIT binary patch literal 4442 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 V;a=s=+@q)`f68Bi=hlip{U4A)zIXrt literal 0 HcmV?d00001 diff --git a/__pycache__/plant.cpython-37.pyc b/__pycache__/plant.cpython-37.pyc index 363305ffbc2995707d2f0f4bd4e008ba4954122a..e47b153fede71fcfa128d42171813be71aa60665 100644 GIT binary patch delta 792 zcmb7?&ubGw6vyA2o!w2dn;&h`q_HYmYjr^j1#dkFM!YCmh|rU^(Om=9Htl3fqwJD{ zR}Y2x2NKU-N(3)@@#x8uhxO{EM^AzX`rf9NRs``a@57t-zBBV?W`9&(PUf%Wa#KO{lZ?pfViknz-x`1~)`ap8#`b_$$)p(>i^z-voF1eC0#Ykctu|_7xgfE$2mtEtMiOG Yz2sE&tTXLSxp~F^xF=Le-*gs!0pFUamButPscG|QZbnFCh9F%F zfx8t+x|V|UTlfXUaU-tm&Yc@U&$&sk35dPn{ASL7&ir%EotdM#U-Q=eL?TLHefrjX zel7LEnxXWb$k7#Jix*2?gP&~DFH|g*RsUdvm`KlqpuA}Ump-h*=PK%%)6v-3<%hpQqltE>+qKm zpZ248bA}vJnZ+Q}F~b&`cg~opaOd|?KJCfDKl-K^(bGTuuF`za~V$g>Cno! z*3p;D{V`65mC-i)&PX5RHaFphF_9i zg>w}+J}yt>H=#yluX3B{u=3aX#OKK4*b)}mh+E=zbS-Yh7dd{0HsdMLjIRCx Dn}Otl diff --git a/__pycache__/tractor.cpython-37.pyc b/__pycache__/tractor.cpython-37.pyc deleted file mode 100644 index d816ea1dcc2b6c0e02eb42d1229c68e40a61ebbf..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8835 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 I?5ui_@% delta 648 zcmY*WyKWOf6rDT!^sZlV>_j-irr0P-frFr;L!l1^2+#^CES^zt;_R+w2ME@zQn*Hn zH9xRhP#{DD4F$hILA&AuC=n$}!AwvrxY9i{_uSXf%n$F}Ywk809#ZzrfBW>Ky=cDQ z)RDHDa##6X<=IaK934V|36#KY$nVfUTuO3qjZ!WO~cxfo4J={h1s*prYGhk-p{nIe@5#$Y#{GgThRRjBp|1I diff --git a/astar.py b/astar.py index a2c022e..01190dc 100644 --- a/astar.py +++ b/astar.py @@ -1,7 +1,7 @@ from operator import itemgetter +import cart import copy -import tractor -class Istate: #stan początkowy traktora (strona, w którą patrzy, miejsce, w którym się on znajduje) +class Istate: #stan początkowy wózka (strona, w którą patrzy, miejsce, w którym się on znajduje) def __init__(self, direction, x, y): self.direction = direction self.x = x @@ -51,51 +51,15 @@ def cost(map, node): #funkcja kosztu : ile kosztuje przejechanie przez dane pole cost = cost + map.get_field_cost(int(node.get_x()), int(node.get_y())) + 1 node = node.get_parent() return cost -def heuristic(node, goaltest): #funkcja heurestyki : oszacowuje koszt osiągnięcia stanu końcowego (droga) - return abs(node.get_x() - goaltest[0]) + abs(node.get_y() - goaltest[1]) def f(map, node, goaltest): #funkcja zwracająca sumę funkcji kosztu oraz heurestyki return cost(map, node) + heuristic(node, goaltest) -def goal_test(elem, goaltest): #funkcja sprawdzająca czy położenie traktora równa się położeniu punktu docelowego, jeśli tak zwraca prawdę, w przeciwnym wypadku fałsz +def goal_test(elem, goaltest): #funkcja sprawdzająca czy położenie wózka równa się położeniu punktu docelowego, jeśli tak zwraca prawdę, w przeciwnym wypadku fałsz if elem.get_x() == goaltest[0] and elem.get_y() == goaltest[1]: return True else: return False -def print_moves(elem): #zwraca listę ruchów jakie należy wykonać by dotrzeć do punktu docelowego - moves_list = [] - while (elem.get_parent() != None): - moves_list.append(elem.get_action()) - elem = elem.get_parent() - moves_list.reverse() - return moves_list -def succ(elem): #funkcja następnika, przypisuje jakie akcje są możliwe do wykonania na danym polu oraz jaki będzie stan (kierunek, położenie) po wykonaniu tej akcji - actions_list = [] - temp = copy.copy(elem.get_direction()) - if temp == 1: - temp = 4 - else: - temp = temp - 1 - actions_list.append(("rotate_left", (temp, elem.get_x(), elem.get_y()))) - temp = copy.copy(elem.get_direction()) - if temp == 4: - temp = 1 - else: - temp = temp + 1 - actions_list.append(("rotate_right", (temp, elem.get_x(), elem.get_y()))) - temp_move_south = elem.get_y() + 1 - temp_move_west = elem.get_x() - 1 - temp_move_east = elem.get_x() + 1 - temp_move_north = elem.get_y() - 1 - if tractor.Tractor.is_move_allowed_succ(elem) == "x + 1": - actions_list.append(("move", (elem.get_direction(), temp_move_east, elem.get_y()))) - elif tractor.Tractor.is_move_allowed_succ(elem) == "y - 1": - actions_list.append(("move", (elem.get_direction(), elem.get_x(), temp_move_north))) - elif tractor.Tractor.is_move_allowed_succ(elem) == "y + 1": - actions_list.append(("move", (elem.get_direction(), elem.get_x(), temp_move_south))) - elif tractor.Tractor.is_move_allowed_succ(elem) == "x - 1": - actions_list.append(("move", (elem.get_direction(), temp_move_west, elem.get_y()))) - return actions_list def graphsearch(fringe, explored, istate, succ, goaltest, f, map): #przeszukiwanie grafu wszerz - node = Node(None, istate.get_direction(), None, istate.get_x(), istate.get_y()) #wierzchołek początkowy, stworzony ze stanu początkowego traktora + node = Node(None, istate.get_direction(), None, istate.get_x(), istate.get_y()) #wierzchołek początkowy, stworzony ze stanu początkowego wózka fringe.append((node, 0)) #wierzchołki do odwiedzenia z priorytetem while True: if not fringe: @@ -128,4 +92,40 @@ def graphsearch(fringe, explored, istate, succ, goaltest, f, map): #przeszukiwan fringe.pop(i + 1) fringe = sorted(fringe, key=itemgetter(1)) #sortowanie fringe'a według priorytetu break - i = i + 1 \ No newline at end of file + i = i + 1 +def heuristic(node, goaltest): #funkcja heurestyki : oszacowuje koszt osiągnięcia stanu końcowego (droga) + return abs(node.get_x() - goaltest[0]) + abs(node.get_y() - goaltest[1]) +def print_moves(elem): #zwraca listę ruchów jakie należy wykonać by dotrzeć do punktu docelowego + moves_list = [] + while (elem.get_parent() != None): + moves_list.append(elem.get_action()) + elem = elem.get_parent() + moves_list.reverse() + return moves_list +def succ(elem): #funkcja następnika, przypisuje jakie akcje są możliwe do wykonania na danym polu oraz jaki będzie stan (kierunek, położenie) po wykonaniu tej akcji + actions_list = [] + temp = copy.copy(elem.get_direction()) + if temp == 1: + temp = 4 + else: + temp = temp - 1 + actions_list.append(("rotate_left", (temp, elem.get_x(), elem.get_y()))) + temp = copy.copy(elem.get_direction()) + if temp == 4: + temp = 1 + else: + temp = temp + 1 + actions_list.append(("rotate_right", (temp, elem.get_x(), elem.get_y()))) + temp_move_south = elem.get_y() + 1 + temp_move_west = elem.get_x() - 1 + temp_move_east = elem.get_x() + 1 + temp_move_north = elem.get_y() - 1 + if cart.Cart.is_move_allowed_succ(elem) == "x + 1": + actions_list.append(("move", (elem.get_direction(), temp_move_east, elem.get_y()))) + elif cart.Cart.is_move_allowed_succ(elem) == "y - 1": + actions_list.append(("move", (elem.get_direction(), elem.get_x(), temp_move_north))) + elif cart.Cart.is_move_allowed_succ(elem) == "y + 1": + actions_list.append(("move", (elem.get_direction(), elem.get_x(), temp_move_south))) + elif cart.Cart.is_move_allowed_succ(elem) == "x - 1": + actions_list.append(("move", (elem.get_direction(), temp_move_west, elem.get_y()))) + return actions_list \ No newline at end of file diff --git a/tractor.py b/cart.py similarity index 76% rename from tractor.py rename to cart.py index 163485e..22accce 100644 --- a/tractor.py +++ b/cart.py @@ -1,6 +1,6 @@ import definitions import random -class Tractor: +class Cart: def __init__(self, amount_of_seeds, collected_plants, direction, fertilizer, fuel, water_level, x, y): self.amount_of_seeds = amount_of_seeds #amount_of_seeds to słownik, przechowuje informacje o posiadanej ilości ziaren dla danej rośliny self.collected_plants = collected_plants #collected_plants to słownik, przechowuje informacje o zebranych plonach @@ -48,50 +48,12 @@ class Tractor: return self.y def set_y(self, y): self.y = y - def move(self): - if self.direction == definitions.TRACTOR_DIRECTION_EAST: - self.x = self.x + definitions.BLOCK_SIZE - elif self.direction == definitions.TRACTOR_DIRECTION_NORTH: - self.y = self.y - definitions.BLOCK_SIZE - elif self.direction == definitions.TRACTOR_DIRECTION_SOUTH: - self.y = self.y + definitions.BLOCK_SIZE - elif self.direction == definitions.TRACTOR_DIRECTION_WEST: - self.x = self.x - definitions.BLOCK_SIZE - def rotate_left(self): - if self.direction == 1: - self.direction = 4 - else: - self.direction = self.direction - 1 - def rotate_right(self): - if self.direction == 4: - self.direction = 1 - else: - self.direction = self.direction + 1 - def station_restore(self, station1): #aktualizuje stan stacji pod względem oddanych plonów oraz uzupełnia zapasy traktora - station1.set_collected_plants("beetroot", station1.get_collected_plants("beetroot") + self.get_collected_plants("beetroot")) - self.set_collected_plants("beetroot", 0) - station1.set_collected_plants("carrot", station1.get_collected_plants("carrot") + self.get_collected_plants("carrot")) - self.set_collected_plants("carrot", 0) - station1.set_collected_plants("potato", station1.get_collected_plants("potato") + self.get_collected_plants("potato")) - self.set_collected_plants("potato", 0) - station1.set_collected_plants("wheat", station1.get_collected_plants("wheat") + self.get_collected_plants("wheat")) - self.set_collected_plants("wheat", 0) - self.set_amount_of_seeds("beetroot", definitions.TRACTOR_AMOUNT_OF_SEEDS_EACH_TYPE) - self.set_amount_of_seeds("carrot", definitions.TRACTOR_AMOUNT_OF_SEEDS_EACH_TYPE) - self.set_amount_of_seeds("potato", definitions.TRACTOR_AMOUNT_OF_SEEDS_EACH_TYPE) - self.set_amount_of_seeds("wheat", definitions.TRACTOR_AMOUNT_OF_SEEDS_EACH_TYPE) - self.set_fertilizer("beetroot", definitions.TRACTOR_FERTILIZER) - self.set_fertilizer("carrot", definitions.TRACTOR_FERTILIZER) - self.set_fertilizer("potato", definitions.TRACTOR_FERTILIZER) - self.set_fertilizer("wheat", definitions.TRACTOR_FERTILIZER) - self.set_fuel(definitions.TRACTOR_FUEL) - self.set_water_level(definitions.TRACTOR_WATER_LEVEL) - def do_work(self, map1, station1, tractor1_rect): #jaką pracę traktor ma wykonać na danym polu, na którym aktualnie przebywa (zmienia stan logiczny danego pola) + def do_work(self, map1, station1, cart_rect): #jaką pracę wózek ma wykonać na danym polu, na którym aktualnie przebywa (zmienia stan logiczny danego pola) loop = True if self.get_all_amount_of_seeds() == 0: loop = False - x = int(tractor1_rect.x / definitions.BLOCK_SIZE) - y = int(tractor1_rect.y / definitions.BLOCK_SIZE) + x = int(cart_rect.x / definitions.BLOCK_SIZE) + y = int(cart_rect.y / definitions.BLOCK_SIZE) field = map1.get_fields()[x][y] if x == 0 and y == 0: self.station_restore(station1) @@ -139,54 +101,31 @@ class Tractor: self.set_fertilizer("wheat", (self.get_fertilizer("wheat") - 1)) field.get_soil().set_is_fertilized(True) field.get_plant().set_state(field.get_plant().get_state() + definitions.WHEAT_GROW_TIME) - elif field.get_plant().get_name() == "beetroot" and field.get_plant().get_state() == definitions.BEETROOTS_MAXIMUM_STATE and self.get_all_collected_plants() < definitions.TRACTOR_MAXIMUM_COLLECTED_PLANTS: + elif field.get_plant().get_name() == "beetroot" and field.get_plant().get_state() == definitions.BEETROOTS_MAXIMUM_STATE and self.get_all_collected_plants() < definitions.CART_MAXIMUM_COLLECTED_PLANTS: field.get_plant().set_state(0) field.get_soil().set_is_fertilized(False) field.get_soil().set_water_level(False) field.get_soil().set_state(False) self.set_collected_plants("beetroot", self.get_collected_plants("beetroot") + 1) - elif field.get_plant().get_name() == "carrot" and field.get_plant().get_state() == definitions.CARROTS_MAXIMUM_STATE and self.get_all_collected_plants() < definitions.TRACTOR_MAXIMUM_COLLECTED_PLANTS: + elif field.get_plant().get_name() == "carrot" and field.get_plant().get_state() == definitions.CARROTS_MAXIMUM_STATE and self.get_all_collected_plants() < definitions.CART_MAXIMUM_COLLECTED_PLANTS: field.get_plant().set_state(0) field.get_soil().set_is_fertilized(False) field.get_soil().set_water_level(False) field.get_soil().set_state(False) self.set_collected_plants("carrot", self.get_collected_plants("carrot") + 1) - elif field.get_plant().get_name() == "potato" and field.get_plant().get_state() == definitions.POTATOES_MAXIMUM_STATE and self.get_all_collected_plants() < definitions.TRACTOR_MAXIMUM_COLLECTED_PLANTS: + elif field.get_plant().get_name() == "potato" and field.get_plant().get_state() == definitions.POTATOES_MAXIMUM_STATE and self.get_all_collected_plants() < definitions.CART_MAXIMUM_COLLECTED_PLANTS: field.get_plant().set_state(0) field.get_soil().set_is_fertilized(False) field.get_soil().set_water_level(False) field.get_soil().set_state(False) self.set_collected_plants("potato", self.get_collected_plants("potato") + 1) - elif field.get_plant().get_name() == "wheat" and field.get_plant().get_state() == definitions.WHEAT_MAXIMUM_STATE and self.get_all_collected_plants() < definitions.TRACTOR_MAXIMUM_COLLECTED_PLANTS: + elif field.get_plant().get_name() == "wheat" and field.get_plant().get_state() == definitions.WHEAT_MAXIMUM_STATE and self.get_all_collected_plants() < definitions.CART_MAXIMUM_COLLECTED_PLANTS: field.get_plant().set_state(0) field.get_soil().set_is_fertilized(False) field.get_soil().set_water_level(False) field.get_soil().set_state(False) self.set_collected_plants("wheat", self.get_collected_plants("wheat") + 1) - def is_move_allowed(self, tractor1_rect): #sprawdza czy dany ruch, który chce wykonać traktor jest możliwy, zwraca prawdę lub fałsz - if self.direction == definitions.TRACTOR_DIRECTION_EAST and tractor1_rect.x + definitions.BLOCK_SIZE < definitions.WIDTH: - return True - elif self.direction == definitions.TRACTOR_DIRECTION_NORTH and tractor1_rect.y - definitions.BLOCK_SIZE >= 0: - return True - elif self.direction == definitions.TRACTOR_DIRECTION_SOUTH and tractor1_rect.y + definitions.BLOCK_SIZE < definitions.HEIGHT: - return True - elif self.direction == definitions.TRACTOR_DIRECTION_WEST and tractor1_rect.x - definitions.BLOCK_SIZE >= 0: - return True - else: - return False - @staticmethod - def is_move_allowed_succ(node): #sprawdza czy dany ruch, który chce wykonać traktor jest możliwy, zwraca pozycje po wykonaniu ruchu, wersja node - if node.get_direction() == definitions.TRACTOR_DIRECTION_EAST and node.get_x() * definitions.BLOCK_SIZE + definitions.BLOCK_SIZE < definitions.WIDTH: - return "x + 1" - elif node.get_direction() == definitions.TRACTOR_DIRECTION_NORTH and node.get_y() * definitions.BLOCK_SIZE - definitions.BLOCK_SIZE >= 0: - return "y - 1" - elif node.get_direction() == definitions.TRACTOR_DIRECTION_SOUTH and node.get_y() * definitions.BLOCK_SIZE + definitions.BLOCK_SIZE < definitions.HEIGHT: - return "y + 1" - elif node.get_direction() == definitions.TRACTOR_DIRECTION_WEST and node.get_x() * definitions.BLOCK_SIZE - definitions.BLOCK_SIZE >= 0: - return "x - 1" - else: - return False - def handle_movement(self, move, tractor1_rect): #odpowiada za poruszanie się traktora po mapie + def handle_movement(self, move, cart_rect): #odpowiada za poruszanie się wózka po mapie if self.get_fuel() > 0: if move == "move": self.move() @@ -195,16 +134,16 @@ class Tractor: elif move == "rotate_right": self.rotate_right() self.set_fuel(self.get_fuel() - 1) - tractor1_rect.x = self.get_x() - tractor1_rect.y = self.get_y() - def handle_random_movement(self, tractor1_rect): #odpowiada za losowe poruszanie się traktora po mapie + cart_rect.x = self.get_x() + cart_rect.y = self.get_y() + def handle_movement_random(self, cart_rect): #odpowiada za losowe poruszanie się wózka po mapie loop = True while loop and self.get_fuel() > 0: random1 = random.randint(1, 3) - if random1 == 1 and self.is_move_allowed(tractor1_rect) is True: + if random1 == 1 and self.is_move_allowed(cart_rect) is True: self.move() - tractor1_rect.x = self.get_x() - tractor1_rect.y = self.get_y() + cart_rect.x = self.get_x() + cart_rect.y = self.get_y() loop = False elif random1 == 2: self.rotate_left() @@ -212,4 +151,65 @@ class Tractor: elif random1 == 3: self.rotate_right() loop = False - self.set_fuel(self.get_fuel() - 1) \ No newline at end of file + self.set_fuel(self.get_fuel() - 1) + def is_move_allowed(self, cart_rect): #sprawdza czy dany ruch, który chce wykonać wózek jest możliwy, zwraca prawdę lub fałsz + if self.direction == definitions.CART_DIRECTION_EAST and cart_rect.x + definitions.BLOCK_SIZE < definitions.WIDTH: + return True + elif self.direction == definitions.CART_DIRECTION_NORTH and cart_rect.y - definitions.BLOCK_SIZE >= 0: + return True + elif self.direction == definitions.CART_DIRECTION_SOUTH and cart_rect.y + definitions.BLOCK_SIZE < definitions.HEIGHT: + return True + elif self.direction == definitions.CART_DIRECTION_WEST and cart_rect.x - definitions.BLOCK_SIZE >= 0: + return True + else: + return False + @staticmethod + def is_move_allowed_succ(node): #sprawdza czy dany ruch, który chce wykonać wózek jest możliwy, zwraca pozycje po wykonaniu ruchu, wersja node + if node.get_direction() == definitions.CART_DIRECTION_EAST and node.get_x() * definitions.BLOCK_SIZE + definitions.BLOCK_SIZE < definitions.WIDTH: + return "x + 1" + elif node.get_direction() == definitions.CART_DIRECTION_NORTH and node.get_y() * definitions.BLOCK_SIZE - definitions.BLOCK_SIZE >= 0: + return "y - 1" + elif node.get_direction() == definitions.CART_DIRECTION_SOUTH and node.get_y() * definitions.BLOCK_SIZE + definitions.BLOCK_SIZE < definitions.HEIGHT: + return "y + 1" + elif node.get_direction() == definitions.CART_DIRECTION_WEST and node.get_x() * definitions.BLOCK_SIZE - definitions.BLOCK_SIZE >= 0: + return "x - 1" + else: + return False + def move(self): + if self.direction == definitions.CART_DIRECTION_EAST: + self.x = self.x + definitions.BLOCK_SIZE + elif self.direction == definitions.CART_DIRECTION_NORTH: + self.y = self.y - definitions.BLOCK_SIZE + elif self.direction == definitions.CART_DIRECTION_SOUTH: + self.y = self.y + definitions.BLOCK_SIZE + elif self.direction == definitions.CART_DIRECTION_WEST: + self.x = self.x - definitions.BLOCK_SIZE + def rotate_left(self): + if self.direction == 1: + self.direction = 4 + else: + self.direction = self.direction - 1 + def rotate_right(self): + if self.direction == 4: + self.direction = 1 + else: + self.direction = self.direction + 1 + def station_restore(self, station1): #aktualizuje stan stacji pod względem oddanych plonów oraz uzupełnia zapasy wózka + station1.set_collected_plants("beetroot", station1.get_collected_plants("beetroot") + self.get_collected_plants("beetroot")) + self.set_collected_plants("beetroot", 0) + station1.set_collected_plants("carrot", station1.get_collected_plants("carrot") + self.get_collected_plants("carrot")) + self.set_collected_plants("carrot", 0) + station1.set_collected_plants("potato", station1.get_collected_plants("potato") + self.get_collected_plants("potato")) + self.set_collected_plants("potato", 0) + station1.set_collected_plants("wheat", station1.get_collected_plants("wheat") + self.get_collected_plants("wheat")) + self.set_collected_plants("wheat", 0) + self.set_amount_of_seeds("beetroot", definitions.CART_AMOUNT_OF_SEEDS_EACH_TYPE) + self.set_amount_of_seeds("carrot", definitions.CART_AMOUNT_OF_SEEDS_EACH_TYPE) + self.set_amount_of_seeds("potato", definitions.CART_AMOUNT_OF_SEEDS_EACH_TYPE) + self.set_amount_of_seeds("wheat", definitions.CART_AMOUNT_OF_SEEDS_EACH_TYPE) + self.set_fertilizer("beetroot", definitions.CART_FERTILIZER) + self.set_fertilizer("carrot", definitions.CART_FERTILIZER) + self.set_fertilizer("potato", definitions.CART_FERTILIZER) + self.set_fertilizer("wheat", definitions.CART_FERTILIZER) + self.set_fuel(definitions.CART_FUEL) + self.set_water_level(definitions.CART_WATER_LEVEL) \ No newline at end of file diff --git a/definitions.py b/definitions.py index 5225869..bafcd24 100644 --- a/definitions.py +++ b/definitions.py @@ -6,35 +6,52 @@ BEETROOTS_ADULT_COST = 4 BEETROOTS_GROW_COST = 10 BEETROOTS_GROW_TIME = 5 BEETROOTS_MAXIMUM_STATE = BEETROOTS_GROW_TIME * 3 + 1 -BEETROOTS_STAGE_0 = pygame.image.load(os.path.join('resources', 'beetroots_stage_0.png')) +BEETROOTS_STAGE_0 = pygame.image.load(os.path.join('resources/images', 'beetroots_stage_0.png')) BEETROOTS_STAGE_0 = pygame.transform.scale(BEETROOTS_STAGE_0, (BLOCK_SIZE, BLOCK_SIZE)) -BEETROOTS_STAGE_1 = pygame.image.load(os.path.join('resources', 'beetroots_stage_1.png')) +BEETROOTS_STAGE_1 = pygame.image.load(os.path.join('resources/images', 'beetroots_stage_1.png')) BEETROOTS_STAGE_1 = pygame.transform.scale(BEETROOTS_STAGE_1, (BLOCK_SIZE, BLOCK_SIZE)) -BEETROOTS_STAGE_2 = pygame.image.load(os.path.join('resources', 'beetroots_stage_2.png')) +BEETROOTS_STAGE_2 = pygame.image.load(os.path.join('resources/images', 'beetroots_stage_2.png')) BEETROOTS_STAGE_2 = pygame.transform.scale(BEETROOTS_STAGE_2, (BLOCK_SIZE, BLOCK_SIZE)) -BEETROOTS_STAGE_3 = pygame.image.load(os.path.join('resources', 'beetroots_stage_3.png')) +BEETROOTS_STAGE_3 = pygame.image.load(os.path.join('resources/images', 'beetroots_stage_3.png')) BEETROOTS_STAGE_3 = pygame.transform.scale(BEETROOTS_STAGE_3, (BLOCK_SIZE, BLOCK_SIZE)) CARROTS_ADULT_COST = 4 CARROTS_GROW_COST = 10 CARROTS_GROW_TIME = 5 CARROTS_MAXIMUM_STATE = CARROTS_GROW_TIME * 3 + 1 -CARROTS_STAGE_0 = pygame.image.load(os.path.join('resources', 'carrots_stage_0.png')) +CARROTS_STAGE_0 = pygame.image.load(os.path.join('resources/images', 'carrots_stage_0.png')) CARROTS_STAGE_0 = pygame.transform.scale(CARROTS_STAGE_0, (BLOCK_SIZE, BLOCK_SIZE)) -CARROTS_STAGE_1 = pygame.image.load(os.path.join('resources', 'carrots_stage_1.png')) +CARROTS_STAGE_1 = pygame.image.load(os.path.join('resources/images', 'carrots_stage_1.png')) CARROTS_STAGE_1 = pygame.transform.scale(CARROTS_STAGE_1, (BLOCK_SIZE, BLOCK_SIZE)) -CARROTS_STAGE_2 = pygame.image.load(os.path.join('resources', 'carrots_stage_2.png')) +CARROTS_STAGE_2 = pygame.image.load(os.path.join('resources/images', 'carrots_stage_2.png')) CARROTS_STAGE_2 = pygame.transform.scale(CARROTS_STAGE_2, (BLOCK_SIZE, BLOCK_SIZE)) -CARROTS_STAGE_3 = pygame.image.load(os.path.join('resources', 'carrots_stage_3.png')) +CARROTS_STAGE_3 = pygame.image.load(os.path.join('resources/images', 'carrots_stage_3.png')) CARROTS_STAGE_3 = pygame.transform.scale(CARROTS_STAGE_3, (BLOCK_SIZE, BLOCK_SIZE)) -DIRT = pygame.image.load(os.path.join('resources', 'dirt.png')) +CART_DIRECTION_EAST_TEXTURE = pygame.image.load(os.path.join('resources/images', 'minecart_command_block_east.png')) +CART_DIRECTION_EAST_TEXTURE = pygame.transform.scale(CART_DIRECTION_EAST_TEXTURE, (BLOCK_SIZE, BLOCK_SIZE)) +CART_DIRECTION_NORTH_TEXTURE = pygame.image.load(os.path.join('resources/images', 'minecart_command_block_north.png')) +CART_DIRECTION_NORTH_TEXTURE = pygame.transform.scale(CART_DIRECTION_NORTH_TEXTURE, (BLOCK_SIZE, BLOCK_SIZE)) +CART_DIRECTION_SOUTH_TEXTURE = pygame.image.load(os.path.join('resources/images', 'minecart_command_block_south.png')) +CART_DIRECTION_SOUTH_TEXTURE = pygame.transform.scale(CART_DIRECTION_SOUTH_TEXTURE, (BLOCK_SIZE, BLOCK_SIZE)) +CART_DIRECTION_WEST_TEXTURE = pygame.image.load(os.path.join('resources/images', 'minecart_command_block_west.png')) +CART_DIRECTION_WEST_TEXTURE = pygame.transform.scale(CART_DIRECTION_WEST_TEXTURE, (BLOCK_SIZE, BLOCK_SIZE)) +CART_DIRECTION_EAST = 2 +CART_DIRECTION_NORTH = 1 +CART_DIRECTION_SOUTH = 3 +CART_DIRECTION_WEST = 4 +CART_FERTILIZER = 2 +CART_FUEL = 200 +CART_AMOUNT_OF_SEEDS_EACH_TYPE = 20 +CART_MAXIMUM_COLLECTED_PLANTS = 80 +CART_WATER_LEVEL = 40 +DIRT = pygame.image.load(os.path.join('resources/images', 'dirt.png')) DIRT = pygame.transform.scale(DIRT, (BLOCK_SIZE, BLOCK_SIZE)) DIRT_COST = 2 HEIGHT_AMOUNT, WIDTH_AMOUNT = 10, 10 HEIGHT, WIDTH = BLOCK_SIZE * HEIGHT_AMOUNT, BLOCK_SIZE * WIDTH_AMOUNT -FARMLAND_DRY = pygame.image.load(os.path.join('resources', 'farmland_dry.png')) +FARMLAND_DRY = pygame.image.load(os.path.join('resources/images', 'farmland_dry.png')) FARMLAND_DRY = pygame.transform.scale(FARMLAND_DRY, (BLOCK_SIZE, BLOCK_SIZE)) FARMLAND_DRY_COST = 3 -FARMLAND_WET = pygame.image.load(os.path.join('resources', 'farmland_wet.png')) +FARMLAND_WET = pygame.image.load(os.path.join('resources/images', 'farmland_wet.png')) FARMLAND_WET = pygame.transform.scale(FARMLAND_WET, (BLOCK_SIZE, BLOCK_SIZE)) FARMLAND_WET_COST = 1 FPS = 1 @@ -42,54 +59,37 @@ POTATOES_ADULT_COST = 4 POTATOES_GROW_COST = 10 POTATOES_GROW_TIME = 5 POTATOES_MAXIMUM_STATE = POTATOES_GROW_TIME * 3 + 1 -POTATOES_STAGE_0 = pygame.image.load(os.path.join('resources', 'potatoes_stage_0.png')) +POTATOES_STAGE_0 = pygame.image.load(os.path.join('resources/images', 'potatoes_stage_0.png')) POTATOES_STAGE_0 = pygame.transform.scale(POTATOES_STAGE_0, (BLOCK_SIZE, BLOCK_SIZE)) -POTATOES_STAGE_1 = pygame.image.load(os.path.join('resources', 'potatoes_stage_1.png')) +POTATOES_STAGE_1 = pygame.image.load(os.path.join('resources/images', 'potatoes_stage_1.png')) POTATOES_STAGE_1 = pygame.transform.scale(POTATOES_STAGE_1, (BLOCK_SIZE, BLOCK_SIZE)) -POTATOES_STAGE_2 = pygame.image.load(os.path.join('resources', 'potatoes_stage_2.png')) +POTATOES_STAGE_2 = pygame.image.load(os.path.join('resources/images', 'potatoes_stage_2.png')) POTATOES_STAGE_2 = pygame.transform.scale(POTATOES_STAGE_2, (BLOCK_SIZE, BLOCK_SIZE)) -POTATOES_STAGE_3 = pygame.image.load(os.path.join('resources', 'potatoes_stage_3.png')) +POTATOES_STAGE_3 = pygame.image.load(os.path.join('resources/images', 'potatoes_stage_3.png')) POTATOES_STAGE_3 = pygame.transform.scale(POTATOES_STAGE_3, (BLOCK_SIZE, BLOCK_SIZE)) -SPONGE = pygame.image.load(os.path.join('resources', 'sponge.png')) +SPONGE = pygame.image.load(os.path.join('resources/images', 'sponge.png')) SPONGE = pygame.transform.scale(SPONGE, (BLOCK_SIZE, BLOCK_SIZE)) -STATION = pygame.image.load(os.path.join('resources', 'rail_normal.png')) +STATION = pygame.image.load(os.path.join('resources/images', 'rail_normal.png')) STATION = pygame.transform.scale(STATION, (BLOCK_SIZE, BLOCK_SIZE)) STATION_COST = 5 -TRACTOR_DIRECTION_EAST_TEXTURE = pygame.image.load(os.path.join('resources', 'minecart_command_block_east.png')) -TRACTOR_DIRECTION_EAST_TEXTURE = pygame.transform.scale(TRACTOR_DIRECTION_EAST_TEXTURE, (BLOCK_SIZE, BLOCK_SIZE)) -TRACTOR_DIRECTION_NORTH_TEXTURE = pygame.image.load(os.path.join('resources', 'minecart_command_block_north.png')) -TRACTOR_DIRECTION_NORTH_TEXTURE = pygame.transform.scale(TRACTOR_DIRECTION_NORTH_TEXTURE, (BLOCK_SIZE, BLOCK_SIZE)) -TRACTOR_DIRECTION_SOUTH_TEXTURE = pygame.image.load(os.path.join('resources', 'minecart_command_block_south.png')) -TRACTOR_DIRECTION_SOUTH_TEXTURE = pygame.transform.scale(TRACTOR_DIRECTION_SOUTH_TEXTURE, (BLOCK_SIZE, BLOCK_SIZE)) -TRACTOR_DIRECTION_WEST_TEXTURE = pygame.image.load(os.path.join('resources', 'minecart_command_block_west.png')) -TRACTOR_DIRECTION_WEST_TEXTURE = pygame.transform.scale(TRACTOR_DIRECTION_WEST_TEXTURE, (BLOCK_SIZE, BLOCK_SIZE)) -TRACTOR_DIRECTION_EAST = 2 -TRACTOR_DIRECTION_NORTH = 1 -TRACTOR_DIRECTION_SOUTH = 3 -TRACTOR_DIRECTION_WEST = 4 -TRACTOR_FERTILIZER = 2 -TRACTOR_FUEL = 200 -TRACTOR_AMOUNT_OF_SEEDS_EACH_TYPE = 20 -TRACTOR_MAXIMUM_COLLECTED_PLANTS = 80 -TRACTOR_WATER_LEVEL = 40 WHEAT_ADULT_COST = 4 WHEAT_GROW_COST = 10 WHEAT_GROW_TIME = 5 WHEAT_MAXIMUM_STATE = WHEAT_GROW_TIME * 7 + 1 -WHEAT_STAGE_0 = pygame.image.load(os.path.join('resources', 'wheat_stage_0.png')) +WHEAT_STAGE_0 = pygame.image.load(os.path.join('resources/images', 'wheat_stage_0.png')) WHEAT_STAGE_0 = pygame.transform.scale(WHEAT_STAGE_0, (BLOCK_SIZE, BLOCK_SIZE)) -WHEAT_STAGE_1 = pygame.image.load(os.path.join('resources', 'wheat_stage_1.png')) +WHEAT_STAGE_1 = pygame.image.load(os.path.join('resources/images', 'wheat_stage_1.png')) WHEAT_STAGE_1 = pygame.transform.scale(WHEAT_STAGE_1, (BLOCK_SIZE, BLOCK_SIZE)) -WHEAT_STAGE_2 = pygame.image.load(os.path.join('resources', 'wheat_stage_2.png')) +WHEAT_STAGE_2 = pygame.image.load(os.path.join('resources/images', 'wheat_stage_2.png')) WHEAT_STAGE_2 = pygame.transform.scale(WHEAT_STAGE_2, (BLOCK_SIZE, BLOCK_SIZE)) -WHEAT_STAGE_3 = pygame.image.load(os.path.join('resources', 'wheat_stage_3.png')) +WHEAT_STAGE_3 = pygame.image.load(os.path.join('resources/images', 'wheat_stage_3.png')) WHEAT_STAGE_3 = pygame.transform.scale(WHEAT_STAGE_3, (BLOCK_SIZE, BLOCK_SIZE)) -WHEAT_STAGE_4 = pygame.image.load(os.path.join('resources', 'wheat_stage_4.png')) +WHEAT_STAGE_4 = pygame.image.load(os.path.join('resources/images', 'wheat_stage_4.png')) WHEAT_STAGE_4 = pygame.transform.scale(WHEAT_STAGE_4, (BLOCK_SIZE, BLOCK_SIZE)) -WHEAT_STAGE_5 = pygame.image.load(os.path.join('resources', 'wheat_stage_5.png')) +WHEAT_STAGE_5 = pygame.image.load(os.path.join('resources/images', 'wheat_stage_5.png')) WHEAT_STAGE_5 = pygame.transform.scale(WHEAT_STAGE_5, (BLOCK_SIZE, BLOCK_SIZE)) -WHEAT_STAGE_6 = pygame.image.load(os.path.join('resources', 'wheat_stage_6.png')) +WHEAT_STAGE_6 = pygame.image.load(os.path.join('resources/images', 'wheat_stage_6.png')) WHEAT_STAGE_6 = pygame.transform.scale(WHEAT_STAGE_6, (BLOCK_SIZE, BLOCK_SIZE)) -WHEAT_STAGE_7 = pygame.image.load(os.path.join('resources', 'wheat_stage_7.png')) +WHEAT_STAGE_7 = pygame.image.load(os.path.join('resources/images', 'wheat_stage_7.png')) WHEAT_STAGE_7 = pygame.transform.scale(WHEAT_STAGE_7, (BLOCK_SIZE, BLOCK_SIZE)) WINDOW = pygame.display.set_mode((WIDTH, HEIGHT)) \ No newline at end of file diff --git a/graph.py b/graph.py index 1f81e00..27c23c5 100644 --- a/graph.py +++ b/graph.py @@ -1,6 +1,6 @@ +import cart import copy -import tractor -class Istate: #stan początkowy traktora (strona, w którą patrzy, miejsce, w którym się on znajduje) +class Istate: #stan początkowy wózka (strona, w którą patrzy, miejsce, w którym się on znajduje) def __init__(self, direction, x, y): self.direction = direction self.x = x @@ -44,11 +44,32 @@ class Node: #wierzchołek grafu return self.y def set_y(self, y): self.y = y -def goal_test(elem, goaltest): #funkcja sprawdzająca czy położenie traktora równa się położeniu punktu docelowego, jeśli tak zwraca prawdę, w przeciwnym wypadku fałsz +def goal_test(elem, goaltest): #funkcja sprawdzająca czy położenie wózka równa się położeniu punktu docelowego, jeśli tak zwraca prawdę, w przeciwnym wypadku fałsz if elem.get_x() == goaltest[0] and elem.get_y() == goaltest[1]: return True else: return False +def graphsearch(fringe, explored, istate, succ, goaltest): #przeszukiwanie grafu wszerz + node = Node(None, istate.get_direction(), None, istate.get_x(), istate.get_y()) #wierzchołek początkowy, stworzony ze stanu początkowego wózka + fringe.append(node) #wierzchołki do odwiedzenia + while True: + if not fringe: + return False + elem = fringe.pop(0) #zdejmujemy wierzchołek z kolejki fringe i rozpatrujemy go + temp = copy.copy(elem) + if goal_test(elem, goaltest) is True: #jeżeli osiągniemy cel w trakcie przeszukiwania grafu wszerz (wjedziemy na pole docelowe) : zwracamy listę ruchów, po których wykonaniu dotrzemy na miejsce + return print_moves(elem) + explored.append(elem) #dodajemy wierzchołek do listy wierzchołków odwiedzonych + for (action, state) in succ(temp): #iterujemy po wszystkich możliwych akcjach i stanach otrzymanych dla danego wierzchołka grafu + fringe_tuple = [] + explored_tuple = [] + for x in fringe: + fringe_tuple.append((x.get_direction(), x.get_x(), x.get_y())) + for x in explored: + explored_tuple.append((x.get_direction(), x.get_x(), x.get_y())) + if state not in fringe_tuple and state not in explored_tuple: #jeżeli stan nie znajduje się na fringe oraz nie znajduje się w liście wierzchołków odwiedzonych + x = Node(action, state[0], elem, state[1], state[2]) #stworzenie nowego wierzchołka, którego rodzicem jest elem + fringe.append(x) #dodanie wierzchołka na fringe def print_moves(elem): #zwraca listę ruchów jakie należy wykonać by dotrzeć do punktu docelowego moves_list = [] while (elem.get_parent() != None): @@ -74,33 +95,12 @@ def succ(elem): #funkcja następnika, przypisuje jakie akcje są możliwe do wyk temp_move_west = elem.get_x() - 1 temp_move_east = elem.get_x() + 1 temp_move_north = elem.get_y() - 1 - if tractor.Tractor.is_move_allowed_succ(elem) == "x + 1": + if cart.Cart.is_move_allowed_succ(elem) == "x + 1": actions_list.append(("move", (elem.get_direction(), temp_move_east, elem.get_y()))) - elif tractor.Tractor.is_move_allowed_succ(elem) == "y - 1": + elif cart.Cart.is_move_allowed_succ(elem) == "y - 1": actions_list.append(("move", (elem.get_direction(), elem.get_x(), temp_move_north))) - elif tractor.Tractor.is_move_allowed_succ(elem) == "y + 1": + elif cart.Cart.is_move_allowed_succ(elem) == "y + 1": actions_list.append(("move", (elem.get_direction(), elem.get_x(), temp_move_south))) - elif tractor.Tractor.is_move_allowed_succ(elem) == "x - 1": + elif cart.Cart.is_move_allowed_succ(elem) == "x - 1": actions_list.append(("move", (elem.get_direction(), temp_move_west, elem.get_y()))) - return actions_list -def graphsearch(fringe, explored, istate, succ, goaltest): #przeszukiwanie grafu wszerz - node = Node(None, istate.get_direction(), None, istate.get_x(), istate.get_y()) #wierzchołek początkowy, stworzony ze stanu początkowego traktora - fringe.append(node) #wierzchołki do odwiedzenia - while True: - if not fringe: - return False - elem = fringe.pop(0) #zdejmujemy wierzchołek z kolejki fringe i rozpatrujemy go - temp = copy.copy(elem) - if goal_test(elem, goaltest) is True: #jeżeli osiągniemy cel w trakcie przeszukiwania grafu wszerz (wjedziemy na pole docelowe) : zwracamy listę ruchów, po których wykonaniu dotrzemy na miejsce - return print_moves(elem) - explored.append(elem) #dodajemy wierzchołek do listy wierzchołków odwiedzonych - for (action, state) in succ(temp): #iterujemy po wszystkich możliwych akcjach i stanach otrzymanych dla danego wierzchołka grafu - fringe_tuple = [] - explored_tuple = [] - for x in fringe: - fringe_tuple.append((x.get_direction(), x.get_x(), x.get_y())) - for x in explored: - explored_tuple.append((x.get_direction(), x.get_x(), x.get_y())) - if state not in fringe_tuple and state not in explored_tuple: #jeżeli stan nie znajduje się na fringe oraz nie znajduje się w liście wierzchołków odwiedzonych - x = Node(action, state[0], elem, state[1], state[2]) #stworzenie nowego wierzchołka, którego rodzicem jest elem - fringe.append(x) #dodanie wierzchołka na fringe \ No newline at end of file + return actions_list \ No newline at end of file diff --git a/map.py b/map.py index 422643d..0936c39 100644 --- a/map.py +++ b/map.py @@ -23,6 +23,17 @@ class Map: temp_field = field.Field(temp_plant, temp_rect, temp_soil) temp_map_field.append(temp_field) self.fields.append(temp_map_field) + def draw_window(self, cart, cart_rect): #rysuje mapę + self.fill_map() + if cart.get_direction() == definitions.CART_DIRECTION_EAST: + definitions.WINDOW.blit(definitions.CART_DIRECTION_EAST_TEXTURE, (cart_rect.x, cart_rect.y)) + elif cart.get_direction() == definitions.CART_DIRECTION_NORTH: + definitions.WINDOW.blit(definitions.CART_DIRECTION_NORTH_TEXTURE, (cart_rect.x, cart_rect.y)) + elif cart.get_direction() == definitions.CART_DIRECTION_SOUTH: + definitions.WINDOW.blit(definitions.CART_DIRECTION_SOUTH_TEXTURE, (cart_rect.x, cart_rect.y)) + elif cart.get_direction() == definitions.CART_DIRECTION_WEST: + definitions.WINDOW.blit(definitions.CART_DIRECTION_WEST_TEXTURE, (cart_rect.x, cart_rect.y)) + pygame.display.update() def fill_map(self): #wypełnia mapę teksturami na podstawie logicznego stanu pól for i in range(definitions.WIDTH_AMOUNT): for j in range(definitions.HEIGHT_AMOUNT): @@ -106,15 +117,4 @@ class Map: elif field.get_soil().get_state() is True and field.get_soil().get_water_level() is False: return definitions.FARMLAND_DRY_COST elif field.get_soil().get_state() is True and field.get_soil().get_water_level() is True: - return definitions.FARMLAND_WET_COST - def draw_window(self, tractor1, tractor1_rect): #rysuje mapę - self.fill_map() - if tractor1.get_direction() == definitions.TRACTOR_DIRECTION_EAST: - definitions.WINDOW.blit(definitions.TRACTOR_DIRECTION_EAST_TEXTURE, (tractor1_rect.x, tractor1_rect.y)) - elif tractor1.get_direction() == definitions.TRACTOR_DIRECTION_NORTH: - definitions.WINDOW.blit(definitions.TRACTOR_DIRECTION_NORTH_TEXTURE, (tractor1_rect.x, tractor1_rect.y)) - elif tractor1.get_direction() == definitions.TRACTOR_DIRECTION_SOUTH: - definitions.WINDOW.blit(definitions.TRACTOR_DIRECTION_SOUTH_TEXTURE, (tractor1_rect.x, tractor1_rect.y)) - elif tractor1.get_direction() == definitions.TRACTOR_DIRECTION_WEST: - definitions.WINDOW.blit(definitions.TRACTOR_DIRECTION_WEST_TEXTURE, (tractor1_rect.x, tractor1_rect.y)) - pygame.display.update() \ No newline at end of file + return definitions.FARMLAND_WET_COST \ No newline at end of file diff --git a/neuralnetwork.py b/neuralnetwork.py new file mode 100644 index 0000000..9660659 --- /dev/null +++ b/neuralnetwork.py @@ -0,0 +1,110 @@ +from PIL import Image +from torch.autograd import Variable +from torch.optim import Adam +from torch.utils.data import DataLoader +from torchvision.transforms import transforms +import glob +import numpy as np +import os +import pathlib +import torch +import torch.nn as nn +import torchvision +class ConvNet(nn.Module): + def __init__(self, num_classes=6): + super(ConvNet, self).__init__() + self.conv1 = nn.Conv2d(in_channels=3, out_channels=12, kernel_size=3, stride=1, padding=1) + self.bn1 = nn.BatchNorm2d(num_features=12) + self.relu1 = nn.ReLU() + self.pool = nn.MaxPool2d(kernel_size=2) + self.conv2 = nn.Conv2d(in_channels=12, out_channels=20, kernel_size=3, stride=1, padding=1) + self.relu2 = nn.ReLU() + self.conv3 = nn.Conv2d(in_channels=20, out_channels=32, kernel_size=3, stride=1, padding=1) + self.bn3 = nn.BatchNorm2d(num_features=32) + self.relu3 = nn.ReLU() + self.fc = nn.Linear(in_features=75 * 75 * 32, out_features=num_classes) + def forward(self, input): + output = self.conv1(input) + output = self.bn1(output) + output = self.relu1(output) + output = self.pool(output) + output = self.conv2(output) + output = self.relu2(output) + output = self.conv3(output) + output = self.bn3(output) + output = self.relu3(output) + output = output.view(-1, 32 * 75 * 75) + output = self.fc(output) + return output +def create_neural_network(): + device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + transformer = transforms.Compose([transforms.Resize((150, 150)), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])]) + train_path = os.path.join('resources/neural_network/train/') + test_path = os.path.join('resources/neural_network/test/') + pred_path = os.path.join('resources/neural_network/pred/') + train_loader = DataLoader(torchvision.datasets.ImageFolder(train_path, transform=transformer), batch_size=64, shuffle=True) + test_loader = DataLoader(torchvision.datasets.ImageFolder(test_path, transform=transformer), batch_size=32, shuffle=True) + root = pathlib.Path(train_path) + classes = sorted([j.name.split('/')[-1] for j in root.iterdir()]) + if os.path.exists("resources/neural_network/checkpoint.model"): + checkpoint = torch.load(os.path.join('resources/neural_network', 'checkpoint.model')) + model = ConvNet(num_classes=6) + model.load_state_dict(checkpoint) + model.eval() + transformer1 = transforms.Compose([transforms.Resize((150, 150)), transforms.ToTensor(), transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])]) + images_path = glob.glob(pred_path+'/*.jpg') + pred_dict = {} + for i in images_path: + pred_dict[i[i.rfind('/') + 1:]] = prediction1(i, transformer1, model, classes) + print(pred_dict) + else: + model = ConvNet(num_classes=6).to(device) + optimizer = Adam(model.parameters(), lr=0.001, weight_decay=0.0001) + loss_function = nn.CrossEntropyLoss() + num_epochs = 10 + train_count = len(glob.glob(train_path + '/**/*.jpg')) + test_count = len(glob.glob(test_path + '/**/*.jpg')) + best_accuracy = 0.0 + for epoch in range(num_epochs): + model.train() + train_accuracy = 0.0 + train_loss = 0.0 + for i, (images, labels) in enumerate(train_loader): + if torch.cuda.is_available(): + images = Variable(images.cuda()) + labels = Variable(labels.cuda()) + optimizer.zero_grad() + outputs = model(images) + loss = loss_function(outputs, labels) + loss.backward() + optimizer.step() + train_loss += loss.cpu().data * images.size(0) + _, prediction = torch.max(outputs.data, 1) + train_accuracy += int(torch.sum(prediction == labels.data)) + train_accuracy = train_accuracy / train_count + train_loss = train_loss / train_count + model.eval() + test_accuracy = 0.0 + for i, (images, labels) in enumerate(test_loader): + if torch.cuda.is_available(): + images = Variable(images.cuda()) + labels = Variable(labels.cuda()) + outputs = model(images) + _, prediction = torch.max(outputs.data, 1) + test_accuracy += int(torch.sum(prediction == labels.data)) + test_accuracy = test_accuracy / test_count + print('Epoch: ' + str(epoch) + ' Train Loss: ' + str(train_loss) + ' Train Accuracy: ' + str(train_accuracy) + ' Test Accuracy: ' + str(test_accuracy)) + if test_accuracy > best_accuracy: + torch.save(model.state_dict(), 'resources/neural_network/checkpoint.model') + best_accuracy = test_accuracy +def prediction1(img_path, transformer, model, classes): + image = Image.open(img_path) + image_tensor = transformer(image).float() + image_tensor = image_tensor.unsqueeze_(0) + if torch.cuda.is_available(): + image_tensor.cuda() + input = Variable(image_tensor) + output = model(input) + index = output.data.numpy().argmax() + pred = classes[index] + return pred \ No newline at end of file diff --git a/plant.py b/plant.py index dca31b2..6a5e1b4 100644 --- a/plant.py +++ b/plant.py @@ -12,6 +12,44 @@ class Plant: def set_state(self, state): self.state = state @staticmethod + def get_mature_plant(map1, cart): #pobiera współrzędne jakiejś dojrzałej rośliny + x = -1 + y = -1 + for i in range(definitions.WIDTH_AMOUNT): + for j in range(definitions.HEIGHT_AMOUNT): + field = map1.get_fields()[i][j] + if field.get_plant().get_name() == "beetroot" and field.get_plant().get_state() == definitions.BEETROOTS_MAXIMUM_STATE: + x = i + y = j + elif field.get_plant().get_name() == "carrot" and field.get_plant().get_state() == definitions.CARROTS_MAXIMUM_STATE: + x = i + y = j + elif field.get_plant().get_name() == "potato" and field.get_plant().get_state() == definitions.POTATOES_MAXIMUM_STATE: + x = i + y = j + + elif field.get_plant().get_name() == "wheat" and field.get_plant().get_state() == definitions.WHEAT_MAXIMUM_STATE: + x = i + y = j + if x == -1 and y == -1: + return False + else: + return x, y + @staticmethod + def grow_plants( + map1): #metoda statyczna, która zwiększa pole state (etap rozwoju rośliny) dla danej rośliny na danym polu o 1 + for i in range(definitions.WIDTH_AMOUNT): + for j in range(definitions.HEIGHT_AMOUNT): + field = map1.get_fields()[i][j] + if field.get_plant().get_name() == "beetroot" and field.get_plant().get_state() > 0 and field.get_plant().get_state() < definitions.BEETROOTS_MAXIMUM_STATE: + field.get_plant().set_state(field.get_plant().get_state() + 1) + elif field.get_plant().get_name() == "carrot" and field.get_plant().get_state() > 0 and field.get_plant().get_state() < definitions.CARROTS_MAXIMUM_STATE: + field.get_plant().set_state(field.get_plant().get_state() + 1) + elif field.get_plant().get_name() == "potato" and field.get_plant().get_state() > 0 and field.get_plant().get_state() < definitions.POTATOES_MAXIMUM_STATE: + field.get_plant().set_state(field.get_plant().get_state() + 1) + elif field.get_plant().get_name() == "wheat" and field.get_plant().get_state() > 0 and field.get_plant().get_state() < definitions.WHEAT_MAXIMUM_STATE: + field.get_plant().set_state(field.get_plant().get_state() + 1) + @staticmethod def if_any_mature_plant(map1): #sprawdza czy na polu występuje choć jedna dojrzała roślina, jeśli tak zwraca prawdę, w przeciwnym razie zwraca fałsz for i in range(definitions.WIDTH_AMOUNT): for j in range(definitions.HEIGHT_AMOUNT): @@ -24,45 +62,4 @@ class Plant: return True elif field.get_plant().get_name() == "wheat" and field.get_plant().get_state() == definitions.WHEAT_MAXIMUM_STATE: return True - return False - @staticmethod - def get_closest_mature_plant(map1, tractor1): #TO DO, pobiera współrzędne najbliższej dojrzałej rośliny od miejsca, w którym znajduje się traktor - x = -1 - y = -1 - min = definitions.WIDTH_AMOUNT + definitions.HEIGHT_AMOUNT + 1 - for i in range(definitions.WIDTH_AMOUNT): - for j in range(definitions.HEIGHT_AMOUNT): - field = map1.get_fields()[i][j] - if field.get_plant().get_name() == "beetroot" and field.get_plant().get_state() == definitions.BEETROOTS_MAXIMUM_STATE: #and abs(tractor1.get_x() - i) + abs(tractor1.get_y() - j) < min: - x = i - y = j - min = abs(tractor1.get_x() - i) + abs(tractor1.get_y() - j) - elif field.get_plant().get_name() == "carrot" and field.get_plant().get_state() == definitions.CARROTS_MAXIMUM_STATE: #and abs(tractor1.get_x() - i) + abs(tractor1.get_y() - j) < min: - x = i - y = j - min = abs(tractor1.get_x() - i) + abs(tractor1.get_y() - j) - elif field.get_plant().get_name() == "potato" and field.get_plant().get_state() == definitions.POTATOES_MAXIMUM_STATE: #and abs(tractor1.get_x() - i) + abs(tractor1.get_y() - j) < min: - x = i - y = j - min = abs(tractor1.get_x() - i) + abs(tractor1.get_y() - j) - elif field.get_plant().get_name() == "wheat" and field.get_plant().get_state() == definitions.WHEAT_MAXIMUM_STATE: #and abs(tractor1.get_x() - i) + abs(tractor1.get_y() - j) < min: - x = i - y = j - min = abs(tractor1.get_x() - i) + abs(tractor1.get_y() - j) - if x == -1 and y == -1: - return False - else: - return x, y - @staticmethod - def grow_plants(map1): #metoda statyczna, która zwiększa pole state (etap rozwoju rośliny) dla danej rośliny na danym polu o 1 - for i in range(definitions.WIDTH_AMOUNT): - for j in range(definitions.HEIGHT_AMOUNT): - field = map1.get_fields()[i][j] - if field.get_plant().get_name() == "beetroot" and field.get_plant().get_state() > 0 and field.get_plant().get_state() < definitions.BEETROOTS_MAXIMUM_STATE: - field.get_plant().set_state(field.get_plant().get_state() + 1) - elif field.get_plant().get_name() == "carrot" and field.get_plant().get_state() > 0 and field.get_plant().get_state() < definitions.CARROTS_MAXIMUM_STATE: - field.get_plant().set_state(field.get_plant().get_state() + 1) - elif field.get_plant().get_name() == "potato" and field.get_plant().get_state() > 0 and field.get_plant().get_state() < definitions.POTATOES_MAXIMUM_STATE: - field.get_plant().set_state(field.get_plant().get_state() + 1) - elif field.get_plant().get_name() == "wheat" and field.get_plant().get_state() > 0 and field.get_plant().get_state() < definitions.WHEAT_MAXIMUM_STATE: - field.get_plant().set_state(field.get_plant().get_state() + 1) \ No newline at end of file + return False \ No newline at end of file diff --git a/py.py b/py.py index 0220af9..e3b3590 100644 --- a/py.py +++ b/py.py @@ -1,47 +1,48 @@ import astar +import cart import definitions import graph import map +import neuralnetwork import plant import pygame import station import treelearn -import tractor -pygame.display.set_caption("Smart Tractor") +pygame.display.set_caption("Smart Cart") def main(): #tworzenie podstawowych obiektów map1 = map.Map([]) map1.create_base_map() move_list = [] - amount_of_seeds_dict = {"beetroot": definitions.TRACTOR_AMOUNT_OF_SEEDS_EACH_TYPE, "carrot": definitions.TRACTOR_AMOUNT_OF_SEEDS_EACH_TYPE, "potato": definitions.TRACTOR_AMOUNT_OF_SEEDS_EACH_TYPE, "wheat": definitions.TRACTOR_AMOUNT_OF_SEEDS_EACH_TYPE} + amount_of_seeds_dict = {"beetroot": definitions.CART_AMOUNT_OF_SEEDS_EACH_TYPE, "carrot": definitions.CART_AMOUNT_OF_SEEDS_EACH_TYPE, "potato": definitions.CART_AMOUNT_OF_SEEDS_EACH_TYPE, "wheat": definitions.CART_AMOUNT_OF_SEEDS_EACH_TYPE} collected_plants_dict = {"beetroot": 0, "carrot": 0, "potato": 0, "wheat": 0} - fertilizer_dict = {"beetroot": definitions.TRACTOR_FERTILIZER, "carrot": definitions.TRACTOR_FERTILIZER, "potato": definitions.TRACTOR_FERTILIZER, "wheat": definitions.TRACTOR_FERTILIZER} + fertilizer_dict = {"beetroot": definitions.CART_FERTILIZER, "carrot": definitions.CART_FERTILIZER, "potato": definitions.CART_FERTILIZER, "wheat": definitions.CART_FERTILIZER} station1 = station.Station(collected_plants_dict) - tractor1 = tractor.Tractor(amount_of_seeds_dict, collected_plants_dict, definitions.TRACTOR_DIRECTION_NORTH, fertilizer_dict, definitions.TRACTOR_FUEL, definitions.TRACTOR_WATER_LEVEL, 0, 0) - tractor1_rect = pygame.Rect(tractor1.get_x(), tractor1.get_y(), definitions.BLOCK_SIZE, definitions.BLOCK_SIZE) + cart1 = cart.Cart(amount_of_seeds_dict, collected_plants_dict, definitions.CART_DIRECTION_NORTH, fertilizer_dict, definitions.CART_FUEL, definitions.CART_WATER_LEVEL, 0, 0) + cart1_rect = pygame.Rect(cart1.get_x(), cart1.get_y(), definitions.BLOCK_SIZE, definitions.BLOCK_SIZE) clock = pygame.time.Clock() tree = treelearn.treelearn() #tworzenie drzewa decyzyjnego decision = [0] #początkowa decyzja o braku powrotu do stacji (0) + #neuralnetwork.create_neural_network() run = True while run: #pętla główna programu clock.tick(definitions.FPS) for event in pygame.event.get(): if event.type == pygame.QUIT: run = False - map1.draw_window(tractor1, tractor1_rect) + map1.draw_window(cart1, cart1_rect) if not move_list and plant.Plant.if_any_mature_plant(map1) is True: #jeżeli są jakieś ruchy do wykonania w move_list oraz istnieje jakaś dojrzała roślina - istate = graph.Istate(tractor1.get_direction(), tractor1.get_x() / definitions.BLOCK_SIZE, tractor1.get_y() / definitions.BLOCK_SIZE) #stan początkowy traktora (jego orientacja oraz jego aktualne współrzędne) - #move_list = (graph.graphsearch([], [], istate, graph.succ, plant.Plant.get_closest_mature_plant(map1, tractor1))) #lista z ruchami, które należy po kolei wykonać, graph + istate = graph.Istate(cart1.get_direction(), cart1.get_x() / definitions.BLOCK_SIZE, cart1.get_y() / definitions.BLOCK_SIZE) #stan początkowy wózka (jego orientacja oraz jego aktualne współrzędne) if decision == [0]: #jeżeli decyzja jest 0 (brak powrotu do stacji) to uprawiaj pole - move_list = (astar.graphsearch([], [], istate, graph.succ, plant.Plant.get_closest_mature_plant(map1, istate), astar.f, map1)) #lista z ruchami, które należy po kolei wykonać, astar + move_list = (astar.graphsearch([], [], istate, graph.succ, plant.Plant.get_mature_plant(map1, istate), astar.f, map1)) #lista z ruchami, które należy po kolei wykonać, astar else: #jeżeli decyzja jest 1 (powrót do stacji) to wróć do stacji uzupełnić zapasy move_list = (graph.graphsearch([], [], istate, graph.succ, (0, 0))) #lista z ruchami, które należy po kolei wykonać, graphsearch elif move_list: #jeżeli move_list nie jest pusta - tractor1.handle_movement(move_list.pop(0), tractor1_rect) #wykonaj kolejny ruch oraz zdejmij ten ruch z początku listy + cart1.handle_movement(move_list.pop(0), cart1_rect) #wykonaj kolejny ruch oraz zdejmij ten ruch z początku listy else: - tractor1.handle_random_movement(tractor1_rect) #wykonuj losowe ruchy - tractor1.do_work(map1, station1, tractor1_rect) #wykonaj pracę na danym polu - decision = treelearn.make_decision(tree, tractor1.get_all_amount_of_seeds(), tractor1.get_all_collected_plants(), tractor1.get_all_fertilizer(), tractor1.get_fuel(), tractor1.get_water_level()) #podejmij decyzję czy wracać do stacji (0 : NIE, 1 : TAK) + cart1.handle_movement_random(cart1_rect) #wykonuj losowe ruchy + cart1.do_work(map1, station1, cart1_rect) #wykonaj pracę na danym polu + decision = treelearn.make_decision(tree, cart1.get_all_amount_of_seeds(), cart1.get_all_collected_plants(), cart1.get_all_fertilizer(), cart1.get_fuel(), cart1.get_water_level()) #podejmij decyzję czy wracać do stacji (0 : NIE, 1 : TAK) plant.Plant.grow_plants(map1) #zwiększ poziom dojrzałości roślin pygame.quit() if __name__ == "__main__": diff --git a/resources/data.csv b/resources/decision_tree/data.csv similarity index 100% rename from resources/data.csv rename to resources/decision_tree/data.csv diff --git a/resources/mytree.png b/resources/decision_tree/mytree.png similarity index 100% rename from resources/mytree.png rename to resources/decision_tree/mytree.png diff --git a/resources/tree.pkl b/resources/decision_tree/tree.pkl similarity index 100% rename from resources/tree.pkl rename to resources/decision_tree/tree.pkl diff --git a/resources/beetroots_stage_0.png b/resources/images/beetroots_stage_0.png similarity index 100% rename from resources/beetroots_stage_0.png rename to resources/images/beetroots_stage_0.png diff --git a/resources/beetroots_stage_1.png b/resources/images/beetroots_stage_1.png similarity index 100% rename from resources/beetroots_stage_1.png rename to resources/images/beetroots_stage_1.png diff --git a/resources/beetroots_stage_2.png b/resources/images/beetroots_stage_2.png similarity index 100% rename from resources/beetroots_stage_2.png rename to resources/images/beetroots_stage_2.png diff --git a/resources/beetroots_stage_3.png b/resources/images/beetroots_stage_3.png similarity index 100% rename from resources/beetroots_stage_3.png rename to resources/images/beetroots_stage_3.png diff --git a/resources/carrots_stage_0.png b/resources/images/carrots_stage_0.png similarity index 100% rename from resources/carrots_stage_0.png rename to resources/images/carrots_stage_0.png diff --git a/resources/carrots_stage_1.png b/resources/images/carrots_stage_1.png similarity index 100% rename from resources/carrots_stage_1.png rename to resources/images/carrots_stage_1.png diff --git a/resources/carrots_stage_2.png b/resources/images/carrots_stage_2.png similarity index 100% rename from resources/carrots_stage_2.png rename to resources/images/carrots_stage_2.png diff --git a/resources/carrots_stage_3.png b/resources/images/carrots_stage_3.png similarity index 100% rename from resources/carrots_stage_3.png rename to resources/images/carrots_stage_3.png diff --git a/resources/dirt.png b/resources/images/dirt.png similarity index 100% rename from resources/dirt.png rename to resources/images/dirt.png diff --git a/resources/farmland_dry.png b/resources/images/farmland_dry.png similarity index 100% rename from resources/farmland_dry.png rename to resources/images/farmland_dry.png diff --git a/resources/farmland_wet.png b/resources/images/farmland_wet.png similarity index 100% rename from resources/farmland_wet.png rename to resources/images/farmland_wet.png diff --git a/resources/flower_dandelion.png b/resources/images/flower_dandelion.png similarity index 100% rename from resources/flower_dandelion.png rename to resources/images/flower_dandelion.png diff --git a/resources/minecart_command_block_east.png b/resources/images/minecart_command_block_east.png similarity index 100% rename from resources/minecart_command_block_east.png rename to resources/images/minecart_command_block_east.png diff --git a/resources/minecart_command_block_north.png b/resources/images/minecart_command_block_north.png similarity index 100% rename from resources/minecart_command_block_north.png rename to resources/images/minecart_command_block_north.png diff --git a/resources/minecart_command_block_south.png b/resources/images/minecart_command_block_south.png similarity index 100% rename from resources/minecart_command_block_south.png rename to resources/images/minecart_command_block_south.png diff --git a/resources/minecart_command_block_west.png b/resources/images/minecart_command_block_west.png similarity index 100% rename from resources/minecart_command_block_west.png rename to resources/images/minecart_command_block_west.png diff --git a/resources/potatoes_stage_0.png b/resources/images/potatoes_stage_0.png similarity index 100% rename from resources/potatoes_stage_0.png rename to resources/images/potatoes_stage_0.png diff --git a/resources/potatoes_stage_1.png b/resources/images/potatoes_stage_1.png similarity index 100% rename from resources/potatoes_stage_1.png rename to resources/images/potatoes_stage_1.png diff --git a/resources/potatoes_stage_2.png b/resources/images/potatoes_stage_2.png similarity index 100% rename from resources/potatoes_stage_2.png rename to resources/images/potatoes_stage_2.png diff --git a/resources/potatoes_stage_3.png b/resources/images/potatoes_stage_3.png similarity index 100% rename from resources/potatoes_stage_3.png rename to resources/images/potatoes_stage_3.png diff --git a/resources/rail_normal.png b/resources/images/rail_normal.png similarity index 100% rename from resources/rail_normal.png rename to resources/images/rail_normal.png diff --git a/resources/sponge.png b/resources/images/sponge.png similarity index 100% rename from resources/sponge.png rename to resources/images/sponge.png diff --git a/resources/wheat_stage_0.png b/resources/images/wheat_stage_0.png similarity index 100% rename from resources/wheat_stage_0.png rename to resources/images/wheat_stage_0.png diff --git a/resources/wheat_stage_1.png b/resources/images/wheat_stage_1.png similarity index 100% rename from resources/wheat_stage_1.png rename to resources/images/wheat_stage_1.png diff --git a/resources/wheat_stage_2.png b/resources/images/wheat_stage_2.png similarity index 100% rename from resources/wheat_stage_2.png rename to resources/images/wheat_stage_2.png diff --git a/resources/wheat_stage_3.png b/resources/images/wheat_stage_3.png similarity index 100% rename from resources/wheat_stage_3.png rename to resources/images/wheat_stage_3.png diff --git a/resources/wheat_stage_4.png b/resources/images/wheat_stage_4.png similarity index 100% rename from resources/wheat_stage_4.png rename to resources/images/wheat_stage_4.png diff --git a/resources/wheat_stage_5.png b/resources/images/wheat_stage_5.png similarity index 100% rename from resources/wheat_stage_5.png rename to resources/images/wheat_stage_5.png diff --git a/resources/wheat_stage_6.png b/resources/images/wheat_stage_6.png similarity index 100% rename from resources/wheat_stage_6.png rename to resources/images/wheat_stage_6.png diff --git a/resources/wheat_stage_7.png b/resources/images/wheat_stage_7.png similarity index 100% rename from resources/wheat_stage_7.png rename to resources/images/wheat_stage_7.png diff --git a/treelearn.py b/treelearn.py index 0168fc8..249d7bf 100644 --- a/treelearn.py +++ b/treelearn.py @@ -6,24 +6,24 @@ import pickle import pydotplus from sklearn import tree from sklearn.tree import DecisionTreeClassifier +def make_decision(tree, amount_of_seeds, collected_plants, fertilizer, fuel, water_level): #zwraca decyzję o powrocie do stacji (0 : NIE, 1 : TAK) + decision = tree.predict([[amount_of_seeds, collected_plants, fertilizer, fuel, water_level]]) #podejmij decyzję na podstawie aktualnych parametrów wózka o powrocie do stacji lub nie + return decision def treelearn(): #zwraca utworzone drzewo decyzyjne - if os.path.exists("resources/tree.pkl"): #jeżeli drzewo jest zapisane w pliku to odczytaj - dtree = pickle.load(open(os.path.join('resources', "tree.pkl"), "rb")) + if os.path.exists("resources/decision_tree/tree.pkl"): #jeżeli drzewo jest zapisane w pliku to odczytaj + dtree = pickle.load(open(os.path.join('resources/decision_tree', "tree.pkl"), "rb")) else: #w przeciwnym razie utwórz drzewo od początku i zapisz do pliku - df = pandas.read_csv(os.path.join('resources', 'data.csv')) #czytanie danych do nauki drzewa z pliku .csv + df = pandas.read_csv(os.path.join('resources/decision_tree', 'data.csv')) #czytanie danych do nauki drzewa z pliku .csv features = ['amount of seeds', 'collected plants', 'fertilizer', 'fuel', 'water level'] x = df[features] #wczytanie atrybutów, z których ma się uczyć drzewo y = df['back to station'] #podjęte decyzje dtree = DecisionTreeClassifier() #klasyfikuje drzewo dtree = dtree.fit(x, y) #uczy drzewo - pickle.dump(dtree, open(os.path.join('resources', "tree.pkl"), "wb")) + pickle.dump(dtree, open(os.path.join('resources/decision_tree', "tree.pkl"), "wb")) data = tree.export_graphviz(dtree, out_file=None, feature_names=features) graph = pydotplus.graph_from_dot_data(data) - graph.write_png(os.path.join('resources', 'mytree.png')) - img = pltimg.imread(os.path.join('resources', 'mytree.png')) + graph.write_png(os.path.join('resources/decision_tree', 'mytree.png')) + img = pltimg.imread(os.path.join('resources/decision_tree', 'mytree.png')) imgplot = plt.imshow(img) plt.show() #wyświetl drzewo decyzyjne - return dtree -def make_decision(tree, amount_of_seeds, collected_plants, fertilizer, fuel, water_level): #zwraca decyzję o powrocie do stacji (0 : NIE, 1 : TAK) - decision = tree.predict([[amount_of_seeds, collected_plants, fertilizer, fuel, water_level]]) #podejmij decyzję na podstawie aktualnych parametrów traktora o powrocie do stacji lub nie - return decision \ No newline at end of file + return dtree \ No newline at end of file