From 0fa26f2acaf994d6c7e6110ef082c05f6bbcdf3e Mon Sep 17 00:00:00 2001
From: YuyoungRhee <bbclara@naver.com>
Date: Sat, 22 Mar 2025 13:53:23 +0900
Subject: [PATCH 01/18] =?UTF-8?q?docs(README):=20=EA=B5=AC=ED=98=84?=
 =?UTF-8?q?=ED=95=A0=20=EA=B8=B0=EB=8A=A5=20=EB=AA=A9=EB=A1=9D=20=EC=9E=90?=
 =?UTF-8?q?=EC=84=B1?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md |  39 +++++++++++++++++++++++++++++++++++++++
 img.png   | Bin 0 -> 16693 bytes
 2 files changed, 39 insertions(+)
 create mode 100644 img.png

diff --git a/README.md b/README.md
index 8102f91c870..0b927ebdfd2 100644
--- a/README.md
+++ b/README.md
@@ -5,3 +5,42 @@
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+## 구현할 기능 목록
+### 게임 진행
+- 백이 먼저 시작한다.
+- move 기물 시작위치 목적지 로 움직일 수 있다.
+  - ex) move P a2 a3
+  ![img.png](img.png)
+### 게임 종료
+- 자신의 킹이 상대의 기물 한개 이상에 의해 공격받고 있을 때 그 상태를 "체크"라고 한다.
+- 만약 체크를 막거나 피할 수 없는 상황이 된다면 자신은 체크메이트당한 것이며 경기는 체크메이트를 당한 선수의 패배로 끝난다.
+
+### 기물 행마법 / 기물 잡는 법
+#### 킹 (K, k)
+- 상하좌우, 대각선 방향으로 각각 1칸씩만 움직일 수 있다. 1 1경기마다 각 선수는 단 1번 "캐슬링"이라는 특별 행마를 할 수 있다.
+#### 퀸 (Q, q)
+- 상하좌우, 대각선 방향으로 기물이 없는 칸에 한해서 칸수의 제한 없이 움직일 수 있다.
+#### 룩 (R, r)
+- 상하좌우 방향으로 기물이 없는 칸에 한해서 칸수의 제한 없이 움직일 수 있다. 룩은 캐슬링을 할 때 따라 움직인다.
+#### 비숍 (B, b)
+- 대각선 방향으로 기물이 없는 칸에 한해서 칸수의 제한 없이 움직일 수 있다.
+#### 나이트 (N, n)
+- 수직 방향으로 한칸 움직인 후 수평 방향으로 두칸 움직이거나 수직 방향으로 두칸 움직인 후 수평 방향으로 한칸 움직인다.
+- 나이트는 유일하게 다른 기물을 넘어다닐 수 있다.
+#### 폰 (P, p)
+- 행마법과 기물을 잡는 법이 다른 유일한 기물이다.
+- 바로 앞의 칸이 비어 있다면 앞으로 한 칸 전진할 수 있다.(바로 앞에 상대의 기물이 있어도 잡을 수 없다.)
+- 경기중 단 한번도 움직이지 않은 폰은 바로 앞의 두칸이 비어 있을 때 두칸 전진할 수 있다.(한칸만 전진해도 된다.)
+- 폰은 앞쪽으로만 움직이며 절대 뒤쪽으로 행마하지 않는다.
+- 폰은 대각선 방향으로 바로 앞에 위치한 기물을 잡을 수 있다.(대각선 방향으로 바로 앞에 위치한 칸이 비어 있더라도 그곳으로 전진할 수 없다.)
+
+#### 기타
+- 폰을 제외한 기물들은 행마법과 기물 잡는 법이 동일하다.
+- 앙파상은 고려하지 않는다.
+
+
+### 고려할 수 있는 규칙들 (현재 적용 X)
+- 캐슬링
+- 프로모션
+- 앙파상
\ No newline at end of file
diff --git a/img.png b/img.png
new file mode 100644
index 0000000000000000000000000000000000000000..ad6824ae94c465f5ce452befb01cbc752fe4a0d5
GIT binary patch
literal 16693
zcmdVCc{r5q|2N)7A*m!~ZIjA&7em&uM2j#8MW_@R+ihns(}p6Z#ZuNm82fD*`%;Oy
zON?b~V=H1XhA;-hnBO@qclsXp_c%V!@%=r|@jQRjk;-+>bzSHAe!sT2M=-;)yxc<E
z8#Zj<J%8?u$%YLZ;oz6=Hcs$2kDqMJ*swu!_52yFOMW)gfkg|m?zI`#id^7K`A`5}
zeKG0TyLW>DGmZI$=`ZXH+AgOW^FQygx}ikBd}E4tqn1|K!-pJOwis(_X5D*n!=q(+
zl$khlz7#)0`fJgrR%v>|q54##=aFH1Rs0Dwr2A_8($F{owZ@!5bwF9mMh|vs$1Dt8
zg~i6im>`iF19d3zgAbnQss}SZ*M~BA_{7vSw;jA`d`IZu18F|k;RjDfH^Lw6EK<{q
zXhq%S=H~WlDM(`pZG>w{NHko!bm<G-`{rI9Q%g(j;NW1_y3lMiT4&AI&@i%ZCM8=+
zI#;dBCMH}MqxjhOYb|r@vC~JQ!osDD_S_V6Bjn~flS-BYE>t4~F0bq}+OtDcMY{&E
zn7Q$Os0jk0Qkod+w{k>6V!}>FUVc9PH3@<BKYZ$en$uqs8@?3MME`hUPk4D2Ev8<C
z@M#_?a#^YHpxUm9pe|fE(dp6}wL?rJx6x{tPSR``8R3>uP4TarldcTH=POK6pL$I#
zaaH=xB$<7^Bo+|udtNOZ_gUog>=us16a;U4yBXy8Cp+|Ffk9vM%TCz5;pj<g!*duc
z_IA)h@#vPZ&2FtvK9_uIDxmRkTf;`GkRu^xstNcveP2m93OvvlUK)M9bIH$nyZ*(C
z($*Ev&N*f|5?}cXs|3=p0xK`Ck1-RT{Hcq6>abecuRg2sv8k!U*UNiSDTOz_beu^E
zv_3H65*;{yRM(~)<G{Fb<qG4nSM9Ve9&i5VpW7fVZ6W!#b@_z8+c?y6szZJ7tL)t1
zIHjJ>obKC8eKW>6rJ`9^ntX^Urb;UAb5Wv_g(`PLx1(Y?`9!stoYm=#-7!K+PP&vX
zx1!;jWBf1i<+o=|;KULMoNM<ZlK1!pRbS?{hBtrPmHW#F51RB9XpM{!Q@sNiel$Nw
zm$}!M@xnVZc7w>pP7XiD<12`|IXa~uCn>7pK@4Ly^~tSyZ1SdbhT3GAS)ko$<&O~U
zp8{PD47-%rk!2&UKOf7>3Lt1G_^cigI_>wO&&k#+&^Z{(BZ78XeRZ68o@${n%~=b1
z?0Q7viaYXj@m_eXnQfs5WWj7(5>z~;TL!x7_gL>KU!x|0d;gp3lZWOOEu5qhluT|6
zn^{&mOVrq89!%W9z2mgPD%q{CFdW|Pbf&L#=8}A<Fs)N5d?KPUf+l+50H0oW?TRLq
zU}%kK?fvUdb;^wr7X5>;7p-UZjvF+@zU|p9VyeMbl_19BL1c1ELf$7weI?f(_fzx!
ze;OtVFLVY+F3!q8oV;s~?wl<RfB5*7(xgJFKhNIms&pxC>Hv)d{?FR<1f3x$DsGkH
zP(Ln*3JTT`lee+`Y6x~2BO<OtDLlr+@eaBsyJ#<5R#nw%$TcI|>P85n;$D@@N(*DJ
zTq`ASmCP6Dbh?H)y@KeQRS`txv0fikpcE6ba&tdY18goK6tVPMGqsx?hrbwMQ&Y9Y
z69R991}AourQEG<o%N~Aa(yJM=&H39sd7#LEoSWRuN<7LS|BSOu~{Q6Kk%=Yx-P^*
zMc=_q>P?lYvhN(~-_nBp2!lb0WYxMEUHpNJjCA9}kP#?y_|;%YOZS#TgNpjGc^LZS
zju&WU4W$z&#M)jR@1S)j6rkEF?1|NKX=!#epMcz!r^eh=zOxbOyLqNxBwXQvh(A#4
zxUsbKV4}B59Ou~mQpIaptIU;S?Y)l#v7RPPX-oUS|6pcQhGBfl*R=zmTEC2qnMgr|
zSAD3AOhMi?6_&5D@wGD1<Za}Z<jfEQ%l35rS%i<}BVTTaYnRF=C!$(RiB%carrw@d
z86+7rwcuAQ=RMPDF(f<FgR^qMzt(B)i|D?yA70CIeP?0;*O~1@4<4B=9BIT|e1{*%
zh74uTmsRyqY`yX!@WI&beCv+Br_A`d_n8WF^~UDXF3Mmdis=_<FdfGq`c4F%IdZGN
z)*!w#u%LU``CeSC-O}qXw(>-sv(;(7eg_<g`F??FRpj1HXmm=g`$$NV45x=)UNRKR
z{|cG5*K5w}$)I`Q>g?vkO5V6FfqKn-Vd7Vnj0Gbk;P!v}9_Y@u?LL<ADx-a%>h1tC
z-#IvLakNMv2W!_YHmT;*jFlSi*k7FY(zpsUW)xJ8NmBDx!61{a8kJOeQFQ0)E@PFP
z_4GJ-Q4U9Nl%7r@Y-pq(8s6!Mx&C=}dS!M)XZC<5OSM&!*R5C}r)zwaqgMVsfzUyD
z;X(|aHVGV+?pjutJ26-nsNbK-x>h6Gyfk1gI9$ko)T&UAirCpC=~|W)MALCugFpj5
z@ra{54nFB4MCZZey;hGOTT}RuP%%F-+;EyyYbV%gEO=cbGZAc#jc{nAu;<8_45Im&
zxaL<KN#x{UhK`^U2I<t(N3$QgOEiv%kULP&?Q%}ufsnG5gXMp1FLp^jr&n27!G85j
z(A%#vk|<ZNH-femHHte01O<&Rd2PozcNjx4PU&mSeb1q1gO<)+i`6(iSf}=UOtlhh
z5?Hrb&4M#(E@~p`xgFji+8WmFM7(IU*ZFRooe@&S@AA+_CAZ!f2JgO$;t^u{)|GV=
zbQ1f#I<#z|godt8HE}?o1b>Gwp?4VmBhQ1Otg0ZgYY@j5@rMr|S7RIsTDmz?FGEbv
z8P=Ykjg{+|Ru7nXEM%7ySHa0RG#rM1lWeLX>J>tt8Yn1}*lf4?lt}W<Rjx25bnTV>
z1Ick8`wZ}u7jM?@Ti#L|u$Yg8E!Kmh#}!%U+O#GE<KKkb`zAT;!{6mD4T>XvB7w1c
z_ydfMvK2z$@iNx6CI;|Lb$ZPsBk3}0@3y0SNZwl;l1Ir7M@yaY4#h(7$nGHjjMo-g
z8t$9aI}nN?A^3MJpNO{7#E&DN-76Z&t4vLN9~wW#AZ|yu?cJs<#>0XhbRMcxbdeY1
zL#;-{atI=89?CX0Or-B$%T<F0mR)b0B)Jl%jk+tQ0`qvU@Ikc4M?VA)F(Tr#Jj-kl
zy%8wvmyVao6Arr+tuNWcY=CJ0JyT(yyIQ<+^)RVAp`qC9fXiNt-nP!m+vVksZ@7Ks
zzhaDPp$Bovt0XI}>nYiPlM+U7GGsp&iq^)0N0sQlIBsW+HR&NAK4<9KYMq#^4onc{
zZ?jvy#Q<hqSWqqHHQI^@Bh@}g^_4Epf05XPJ#siqj4WA+9=Inq`mQ5A$mtjyZ&Fs+
z*BYD`eq5fhjp@OP>+5lOh>zY|YK!hrrfcHKXIAgxF1ZuhJuMRXbse8}i3J$<?KOQ{
zD2l{aHe&2wp=t!v!%7SK_k|6r#oiN)$b2HfpC{!taRl)~=wjVy1A8@OOW3RVA>@TO
z;gaPM10nZn#dIbP4t0nxj`TOW>Zs+vIy^Mtu7VdEUrKm*6&jCxUpU`C>Y2LK=;(y5
z`Q+9(9xh7A9k5m?;7qBVBR57A7W7{ZTSjUGAKR%DYgCwDER}Hrt3%ZCZws2*OY`jF
z2)nErt{r3GBV5IsXe{ZD7*}L4*CfE5?nFy1_o%2Fl6y9bCi4p_wwS^C{HN!XjT83V
zq!tPm-Q1)*b9D!nxf`>W1AA*De0~E2Q+iZWh6fhEmHjn}6RW!se&r5HO_LX!#|3NJ
zL>&9}b@E2I@g2*(7)3tVX1LQPV$lYiKl^LC!yU^#m>3Rh^Jd~5Qrrfdw5E#~`)lU@
zf0n@U!K&5_PtKs+L@+U1zAuZDwoS3uSs1FA9AWXllf+u1baYHiPFdF`U|9A}1eEcK
z_5T&)!xXp`J3KOBe<92WwK>uPyUc51+HsrK!^Lph<(f4)Sj;D?>aNY&*wSsmiIw<q
z3o=c@MCY+JaXwh4ta^01Xi3&{=rWOF%b*BMwzuz&OC7{|R~dRudhN8X++)NqiPCPi
zEKL_ydY1i02&Vt@CSxSA{#l1L)=oig_b0Fc=xi+i_}^`I#PTarajXXITP|6Bi{*3M
zAO&e(M#-jlS@qkq?YC%@g1Yt*yg-!S!U<4+?-(YjSvSXThM)iO6r1L@K&&cItc@Jr
zJeASNaCT#Lt7Be}w-3@&4_GX)Z>MY~UOj*Qq(Pio1cE+c6ie*9!y+vf)LzNWoU$me
z?y%q@FKz(u>ib*ycD?<AzK?{ITy%4~0&`+jQ|)dnobhWR&*!|PX>28eCX?CaqH02A
zL}cma&}n5BgP7(axAapB>i^}b@e@T<s{$KNFzQeRx-xxUm~JN}OujmzBhRYrqXQ8!
zaahi%;C$H(F`_GP=v=@e^V|$dAq+Hl!$QFkZ21SJt;A<Pcfu$aJjpnjmnYNQMWwxG
z_Bl<b!OW>P&77*z=HN+oa?4p6FFuQ1wmU*Td}t!No6<h}Jd?&ysEeE(n^2K^2o1d4
z=_UHx%Mg!=X&*1-&+@Iii=cmuDas0<Pp6R<gealmW^xh%cjLM*YHJhPS;if-5lO?z
zhMA(GQ<bp+Mg**+QQ{7)(}ADc-T#5*{uO$F_-(BJ*vC41Q&dke8erJi8#iv`FqikB
zVe|2~930vLW>6Om;>%JvYy)+3%u)KAIr+@$Tn(;&CTCY{+OYnGdOs?f1Gjjo&RAY(
zjegFuW=xg2v+(-JUWM!Jmp%{(N>+?deql+`(dl>ABK4~0HFz(bGfF-genZYC*Br(E
zSU=8N5@u|ve*b53OGi{zhvREZ3L>NiIb#2zxjCBong{Rpx{mONpn!nMmEL-|eS7`}
z+>w9o>3*D@sz29D>(S9$HX8Y^N2wnqvB}MS!shFbg&;PW(EcGw7(TS=*PB{UgF%h%
zRE9-}j{kglza8WM1C`>xUBa3lMsB>lCr_X1%)9XH(Vh>g{Y5R=qWLK;XixDf4rYR=
z85hKMJbNDsqgs4BP=d%eJiso!vb;E<OwXyikpwPYNd4u8Z)H&ku8*#H(lBBxhV_5K
z6{-lMWmN1bzEvCCoK~$Liv2RS|AgU=qJmc)d+Gvq>AEFZfN!&%>XIAR8g@T%zSMIi
zI^zM1G-0sk*2FA+<iobUeEft+0A|E<82NS=<mr`9imt-Lo`<f_>;~n1_?79UguUn0
zu6S1-%WA|#f_`<c^YPt+z^-(A-s-eutQD*_x=1ET`Hbreoi~$RJuXvw-|5SvPZ2u!
zAyw{?10icy{(Na-<npRx=&>g#__O7w2vp*TSEPFDtg>;;UQ1=w+#BpWd~_SqR<zKw
zB4ae*K4zO9%Q-oo*mNRxZ}w$8m*3=pFMX1Of3-mV5FTF8s%3uJ+yNHaQwkS~c6iX?
z7N~03u(VmUV52-yF@K|{nrsNE5#psG>DL<}*Vy9Tw=<c)+S!p(h$oEt^$NmP4r|JA
z|JbaWE(SkJkp5=k8V@Y|N8J>HS@Hj94DB0mtWCt!AG?Z^*!8msC}>jaHsFr^*t{EY
zke`K{7q%kzYY9FW*z9Ikw6r?!Z)A6#?>%O0|K!`Z+Dd1=Cn+u68u1obPtW;r#)2@Y
zxY?6&)7fi_W*<I$$lmSr>tH!{>NK0%-@FOCF^rPVn>ryOA!#vDAcckrN=+14R~Zf<
zXc>*oR;I-<F5WVhWo+8fir%`z#L+RUFMiWMwN^hzZ1UN&-If(_UWjx5a8`P=6|SRn
zhuEomMa9KA2}_9JN=@eVii(Ooz7x9}-n}!qIHg+|sC>68zfZG(n5_fI;ez;dpy}@)
zY+L553=>*%Orr-VqWE~`?RTn&qvM0^VO4|G<>i<0$L8xoBmB@BtA4pQR_?VnD864E
zwq!D8%rAm8I+1o3ee4KLx-)C&LCb>&my{>GM+GJwMs7vwgreIi-oot_^SdrtHVbe5
zbu;tZ7fcVc5|sJ&(|6P?zQJF*-2AFLngE*@CXbF953SvIoLV|Bwy<^GlNTncO{ja&
z_SK{ut@-?!oD<l!=&YgBTvz8iguYZ|b2u#W(MBR<-_O@yt<(H`aCJ3sQt6Y75X9%6
z4X1l;<4Ys3!cdhjx^iJk=Xs`~1;YYef>i%?PYN@zV%!Q{90PdvD;{HGG0B?zz<Y5h
zx0OiiOPNT!O0VOC6oC!wZ3y-RKqGMu*yZatrfaS;&!Znbht6_2wn!0I8~2yFnNoZb
zZ#RA<ROhGv$=<Br@k+azPBYSVuqYbd>8dF>GF)wlu=Wp*8#;F4s2+s?eR_G|>|7G>
zZ`bGH=DFP)7F{ydhx=eY6H__I4Z#;r&dqr+-N-X$0_+QaLsd8h0?d=IGdHfr8#!RA
zp~b9b@9giLT7P~A?))8+i_TV!9~(b?Bb>$YZ@|m(4hi+Iz)J{2xBXY(#ffDK{__ae
zmDB(AB}n?5-XHTv_hc)cnE8`pqFO!P=*TdmI_tHSB3mL;u?EQ$p0K_inPY(qUMKYV
zI<{tbPASrkKn-<7bB}Vju(4=(%GeLsd(40<<FDxC@`%0=fPn`pUz6-+ViS&Km&a<#
zaS+x1Zhw5+`_>NgV3LL9v4)wokVD<54Eub~T&WAq89e!7nMGC(19(?02_*t-s#NZn
z$NiNamt!{uq%ZLGUKpMD>}pqbP^`O|Uzm0}(T>k6(C{5~DeOXLE=iePi9uO529@|6
z&S-=$x8u2)uV8b|Ni3>G|5BN8A;bJbCGp}>M3Wk~c^M{9>XubXQwHp1<qI|AvPN)S
zj4kmoYt>hN;bW_^k1#jGUL-x#H4VxwTLqB5-_`f{uAk8U+7?uE-c`;*84bw`&j^<T
zra0t;&Kj%6)TqJcRd@@!%L_hVeo|R8;w}554qK_&NPe%w|6qEe3l==ZcTTUj<0711
zi-0Fs>du=;;6iG=Et~ybhgSpNciG9^e7_}ZutEg3BJrzC{;I^_NUUxDw@M5S3Uu?o
zRbpwNjQwjR=7Fuq|LYRmr-=;>4VO$zE^=^iTmovau5J?Nrghj`5G%zilMYHW^%zSD
z)x2EkFwX_oQ=t#*#+{_dBYeMvDzL(Xqy8KXTdSPMMQ>b(q&Ok>6OxmSfQpCVgNhm0
zH5$AUt@5E1_`fAd5rrmt!igoiR+FlqWFov4lY+ARDfFl(PcAoqT#wq7u)R${oim{#
zB5qHX?9VpJGN*DXEY5R?9j(>SW`4#NDqL%YeXyuw5uj_B$B+AnRYM0X>m22yW1`A~
z_<kK_X(P}cq~y-%8YeOgZUd=|_T@c4gSjYK;yAxZteVlhaQ=Lr{V;_CzLpVx{5Uc9
zma0nNmtztV5*=@JLXV$N2?1T<xRg{Al~-!>FSrGOu}!#5X`sNu)PU{E{@sX}NHJBz
zEJsH#iz{)lv1Gb>zM8gmYW{|&PX)0+kfqIH-HF*QX9p<WLhbkDYTFN3)a0*!-uy&9
z0pjzcC~fP?#nd-CXJI*tqPRS&ice=tQCZ83`{*us?WPAO7FY~)ca~{)l9$GzXVd)^
zI;uX?85Xt$XRS(Iy9?ZFkFUFPGz==8j@A&<K`m2q6l@K=Iy&S*i=`;6QlAnFJ^7eU
zYeyc=uT*R2IS>V9Tcrv*+ni1SeZJl8lDWAa(8ly<suxq%G|20kXVV<#!qOvCtX-^F
zRD66+GAlYZc7p3GG^$YTcs_#t81<ATBy>^3c7623OUA}2LkZBc>f?EzX>ZP^ZS>~-
zi5<Xek$>A{k>8~+3KS!fankCX<$@G$(&X||1zaQHGY34<p|iu`W9rdntB%4E$?-{?
zQ_1ZK4@90%kjmGNH}EdA^|<+7WqJ8SS;?y@oS^4_G0LDM>ni(Bt1XOo#xnSXQpJy%
zGd~ixV*Sk%pFY(}YkZsuTm$2@j67@#<9?T0|5fVQ^K4-9gGu|}iyL`FHQLH&8c$D*
zPLs*9xu2nM?JEp8A7*rAcnj`zA|{`6*RH2gf%6&2j!D|O?mEf~kEB)ytteWT@6-i^
z>X@V?{&0JO5zO=PDFSAhH#{sGd1^U%-G^V^1i?SIEhWxBScEQbUzq1ucM2`A$x52m
z4UIdzeiFt11GV8lTY@f6M0?2Q@T-_46T6~Cbqo7yTMvZf#o1eb&dD@=-z?9#=`LKw
zVRkbqlSg>0wU^yL211sO*ke(qf;Y+Egq*;@M6vGx|Iv8!{P?W3D#2PqGAuv2h~5J@
z?5T!nn`IBp=KIwpZoG*sx~cknQNc^vf!WjQl|hjo<lpAyNULA8K35C$n`SnQmNPkM
zogi`seQK&7iJmzFn*=bwwy|XdjrUd!4E?!ODn;_R$AEL$H((s=gS<s8w8(E62=$fS
zZDgJ(dm;NIHqA#m{hGHEzL=9@Qs&$6-eLSaG9hW8XYbJP$&fetN7=fOpJKfvjo({%
zQlyHPIeQ?9jq)+NBj1=y{zp&Mg&*B4Dm~bIu+ie=H@)g(j6V>m>P8z|3I300?V6%B
zp8JEb5tCQz3lHJy{S%wIAlGU^m(jNBZe8AscHj%Vrh<3Xspk9$>nrE{I9t9CE)4!9
z;S>3A^_F3gGTvF`H-uPcb^20;2s9Z$_-+5zINJY*5dK$h`tMo7rfuF@S{nrf1hTlj
zgHdbob<=@){{;{V?k!4Y%|@}}>&5~Hiv5GZp?$G?cYZ6dByN9PI<H{ge?}-z2<pyl
zUFBoVI@mJv8()Cay_k&#AKEXR?d?G8MWoMk<#*SS18bxT*xqRS-Q*qZpn$Z00i3%r
zSD7~Pv6pSU96x@X3)Zdq4|>}UAtV4;dS)Pi-Wh^anFrgHagl+fC@K@3YOVFv5esQW
zbEnu1g4RTUn)>_u<2t;5hx#^y@2ho0RlG9?pi}86*2)mAkF6GkaZ_{W7YJkg#A16w
z`o{YqCQB9blYBioPX%Sip?jQ&kbf9ec4(Z1c)oR&9$T5n>+@+%sXsgM=}mo<4<!cQ
zt3cjNl%Ub8W;$5QeNMzmYe{%-#^xHjUJ%26)`ZvF?D9JN56DdWv)wA<yR=YDJOzjs
zp75b8VK#&KuIR`i-hr;m0UxUd{^#u$G7o5N!9_(yw-@4O#>ERdGwz4(pg{YX0lz9z
zx)~otM?{og|1fl4x<iMu^5Xd1XcIBV7d1KHwsWA$x8TDgIkEse5>=3!J4HZ8?}1lW
zEsPrgBOpE0EI03$tOckRJd*i^93TO|*K`buxRl?jp^c+JGW27Ia}v!0f>of<WJTxx
ziw6&;2stHb&3CK#OlWzMWi}8YJAdMQ@UXhEayF0C%yR0|r>2}EymfUsr~_rmlZv;s
zxh(Qu=rj+VM)YrilTvvT)x6_|<s`?^<j(w|7jNGZ%$6J1Q3i0SyvL6s(z^$-nY^RP
zM#{h^LryQYjk`zt#K{JI^*C#38P`~8++m&_L(H(2tkJL*XlL;K!dx-t>O>JjHlN7p
zb6^9cH8xusGxeHp6JN|mJ$-6CN_bU1$BjeIL!n{5^J4~KReOwH`c7X8SNJB+eiLS8
zn&pWieed<fWBGT}jC`ved)H3)0%Bx`wT7nI4DeN|1<CwF0dRmtRjK8zvV!)QRrSvT
zmc~?DPephq$-J;Cm+{x%u0Ov4_a9R7|KvRX4@(AAC+K?L4Q>V^SL0ZoQ=8uj1FjT+
zyD85bN|V0ejo(%F?x8iGUM#eNJ*;ds>wkoSioIil@-?#rY>Ec%&yw#_zdtheXW5>k
z{lRViT$)_&@{sTdYv7ruPDj>>pRMb!)05ju<Oq)1HOrr#aJ9hjg~8s^r|mkWCO}yi
zVD%LddrXWhB0GTk{;JV_fo?i-LA5wIcK`{$T1H#~ouV&EdCl3`ZgkdRwA7TtE#>3*
zVH)Q3Jd2y*pR)_Q41a4OP+M7U>n?rHI$}B7nesT=L0&DV(7TaPmPqajyr4DN@(!?z
z;r&v{e=D|JRu;3EYr~nhEP*OrrCgii8Of$ipQ^4~p=&S&_|{+-eOmUts_?PSeZ*?R
zdJ1IP>Ga-Ln9ts_R^4~}gPwGAxmfG4lqs8Za}(2JH4^|k(zw14u2GoC=1CTFh2DsS
zmcp$n8j?%P+n|!}-!D(rFBJ<osDBhjYZ<*mlKWTQ`JV~?>v$(%!~cn=00obqV{k3>
z@EyzDKTd7YMGSp9Ya>xtH&~<k<S#cMmwY!)R7RTC&_RAsSyB>Zn53e6c+fw2hltu4
zKuBB*vbL|2iwj`#EkKB&_4Y3-_)mIOMknRB`P8-mc>_pF6G{{!PLjFET9hjZ96iBX
zHt+o#4H1CTeL7-hCQxgmGXU0GRX&Y+72*BuyJMrGS|49YHYO;o7~@+89Dyisr!wTH
z5)mT@o4;`8ZS)y<Z>4&~>a{&M$Dx<co;@FhQ6$jMGqaFs_Iq}F!~kHatsj#IO4Uyb
zrKnn~SzoOGZ$6C-J`Ev*vuM%Gz1+?xiPf$i<QCCM64Rh2>1{zkF=2zI_5Gh>8E`qK
z$dQRvS=XQMje6l1ZJ4+tbu5qcKE?hq8CCeCl0I(G+pEk*<Zg7)b4}*CsX(wO``swv
z2V_ncAycUvzoP_Me-ttIg&id+2~mN_G}nj9S8Fy?+Cf$Ta41H}%?a)>Py*+7?PA;=
zmh5n7kA8QiOeuHWV>kDPRcVANA>ZzS59IR)C-J6@zqrisp(5b@xdI?I5_L*mK8J}-
zI*avJtnu#Kk!@PXg}Y?2(MI2~EnA%(=%}$N+ZFV+?M3GO4Qx^Ihc4c!)qKw3)~&WX
zS~^*v#2TrOvXImW1`*@#sp3KN!!^AZOR>M>>ES^u={K_^$<%B=H3KMSVj`6ua>w$U
zF9m$6qU`%5Gd(@M^z<x8FRNyZFY7OhW~`Mdu$M<i$rdLk7B<3LAh&!Qcn0hBsxvdE
zR{yI(B1|M$TAI_J7;fdDJdzucLA<zZ1}y00Y<DCR`WunO6<1fQ)f^dawmFQoPUi6X
z{ofHbSnDK}y0MSj;4|yK?bKaT>;`WEVb#{3ulT=Z;r|)ZUMIQ!uM_>>mLL&eEDx3t
zbM1hkcvRQIfuvN$=5$b#CO}ob7klv)D6x#RuSF|8GUH0#DXL`*Q*KLzL6<2-FZk!%
zybE<<{NK^-mo%rJ==Mx*yn)diRn2!f0mwv!^d24te7ki|>6g(vl^Dzu*Wek8ts}ls
z0O?2HN*FMFN%k?ZFHam$E7T%XCXAG(_gz=*Z*(>w`xuj6%D`9hyoJjIvfKx_*KE*0
z<GyQ{$X`}pT7~Y7Au2!h0LoFh%%ie_fpGl9-BYa-sjuShT3Q>(I$P!Dx7ZEjpEiG$
z-xz4NmiD@3zZAjV&zzqYktmO>rRJ9NYoV~J{D5|h+v-{zTOjJGq}wZf)48PPS7m>C
zu7OH;U+?cqO`wu9rEqbDdAcU<bq=?opadw_ZK|=x4@tc(5D_Vp)~_nDc}}mZHU6eN
zD9uj^&5P3;-TxWE^{o}~hop@0_pzIT`|QW)9|ps{Wb{|h-QW5b7qa%|H$8r7Sp-8r
z`@dNX{9SL<(6olZFrLVP{lByVg`pIBr)i5McDeb2zWxHr!NI}wy!%OkoP>e^2I7~3
z<T#ijd*VbYkk3E7f1d(G;ahH57Jt=fH@m&I9jd-1#fxw{4Prd8dJ+4LPM$36yur&>
zRQ~}!kG*c(IAoA?3Rt4kMj+d!D`k<N0*)B^azJpLL%WoDUPd=X;Z;Gc&6%pjDYI*Q
zX_3~Irf|!+wfl)fn}1y@4}lHm=E1#8tfXTGnVjvB)>V!ZbJ1*F*|OH7v%@Sr8)&;q
zL1WGg*8xrhZG0DVb)LYs7LfC4_(+T8vEM<V#eo*xGp(wJp|2=P&p<5e9&&k9Fizbe
zDb9Lv#j}|-V9S0ql+~jkLy2$!`7QAYoYJJJ-;zJmiA>q}k8%KzGp@;G4P>8EO68@b
z;yL;DYaJfke}!stiVSSoy7zO@ISVS@_w||`7s{Nn{`zaOuHknH+&abv<PXIoh4e*L
zeKW;s7$$F{rPhEenp#HfIsZK4Vw$0KKzrXzkfzeJXV{%iL?qvj@(Ny!y?$>?#k^o^
z6}XWuV9|o4M^56BhfRu4kU{~r{9L$gb_OLYD~qUCvz$N>Y}Ls%UQz$4V*7{0J+(L5
zf6IpPiDgrFogZW}AIRDoVtvf1yWq%TAh9Xfb%}7R@aKvjor{l+jqLz+eEdEdi0vCx
zhW7jt+ASA=w6m2@w2QyLy85ci^avh3;e2@?bEK2BM+}+&!2!wsK>2RtUwuLDv9!c#
zQH-05H=Ur7Y=na=VSs&Zd_HSsy~hDqgx=D}mpd6NIc}}*-Y3KUJhzPsl2P8&ws;0j
z{EY8(f0oa3{b8aAH1SJ%WLAegj8dA2_0RDk=FDs$Rk_t6JF+zlH~qGOlog*lbb^+O
zl^I=_;Ch~6V&dTu4ShcRK?=O6jj_?ux@E5Ely0-Kn78X8_jU;0rzmA&V!~^2dLXk_
z#TIxcTGX&u?Gp}doqXDLJO1I{mT|t=WW0$5fdf~t{tExkfp)odpdG#v!M1Ec0Mxo+
zU>jpZs~X_+aodJRLX)OEXTPiJFUh_?RrO;=d}-Gp?>)X@)Q2R6Zr~g&uDH{hm`*ek
zO(tj%9>YfM0}ltH1S;^gvQsHv?3^YTDV<)-uR@f{luA$6SRt|vU<s`Qe~TZR825#*
zRG<gKh{zg&)fya#Lq#JH#fkW2A=76nO4BNMXMK3zt!&SFu*|0m7q|v=I5^B$1~M6)
z+liCE;rKK~l%dv8kFwop?{)%w?bu(QjVveE?TJ?N$2qdT_X(nf-7$49VP?)aFiP05
zqd>2`A6$g1Hh!c^<vSB;kADLc9W7gQ3Qu3mxEaTHf5Ja8q}!>#`%md(O6CQgy_K9F
zDfg=lZ&QRAge!u_ZcwFbfO-S$V6J-D{39y+Pvy_hc^yBD;Wvb{OUjQt`xW1jw?J)y
zEzEP})ZJ8H*{wt**FXDfokjcqqcQLsURb}xrXAkK#s{NgVzRrVP2AlJ`({|I^@2DL
z-~b#Xm||H;$pdbl8WvvyV6{UE5J)u0(-{dXxulGb?>k|#`7^Y2ne^e8+HlMNeq8gH
zmP9mWL0GX3s5mBidLiBK3oNkVVPO;6mlSX_J<%keac%XXsk7d~3h9ucJkvUhg=@bF
zwj@X))8n%esdX@Dt4VklH7oQK<m7DjR->Rhm9JjC2toUyIr)O(ftHV3r4XYr?#1R_
zR1yw8D6)=jNMiLbT%cWKL|b}04y|oQ9A7p^sCZL)L+x9Va!}M&F$<fNmL@`XlPHM0
zEQr5rz}t3NJoxHKUMTpjJvH$Y)v_XL_MLU=&dUr~oSxWE2hQ$o678kJ%_Y@SSmnkZ
zi04@7Bc9sTIFj#VMz?vk&9>iDH<2|rjd-|ESQ}ip(A6Xkf-91tB!N2n?rHIH(0Mur
zgI3hn(<*5<Sk<t^m)u-wAzIg;HReI&mI3(Dn&{>25Z0Pe=#I9Wg6_0iQs(BxUp{lM
zyJNs~CeOIK%GRu`oh23-Y`t*tB9X8uu^>P(88bGd>OQvzC`m8&f?#17>nisf{5<@h
zxEXkD4$aHU%WT!I=8OBu>1T8tLSJg08)DRUUq?Gj>-m_1XO~Ej#3v7c=*7nagKn*(
zhiY2Q`+z~+1_+2rT80d05al*G_WH}8Q`r*QE_fGfdZ3D!rEkO#XHg1>=~i-+Ac+j1
zMW~85^*mHm?P~MxZNF$GuoLFx)sc;htW|U!tR`etd2%Dk#AgAtr;fy`&H~eb2XO@(
zlrJ!Vk={BjPHzQ-%Mm!yl|X!hX}^tz5AIv{R3x#zADUwM_jCo^j-4aknkc2JF1(7h
zIFW6&X?7a~KlFE<g}M2dc_(yg6Bbyr-{B2-=_2tHUQr`xbyeFHXPXp7o^_X0!WwKQ
znmJEt{#0uIhe&??$^0L>f>0f%=b9PL*lr;Nm%n;CZ15ENUgx8?TQgjOv+w^UEfbZ5
z<tMRoEt0d#ZVs@o&mI9|H3j5ZI$*5gPetEqV*_mdhuRH-FlmzV-yyWbdxu<gI*47S
zVX68cuM^&Js55#-K|pfrm7e_<da53zDiP9N$jnnID;!?X&)cH=)lAuGowf*5FGsQk
z;|5vLhbN4r5bGN3oZcR_^Ls>c^d09<xISAYcqIS?B%k_DJi*~@N=TU?5L7Dyn?I1|
zE1R~n7B^zGr_aPfqc&*xC4?a2OcC@B$Co7^gm--cSLU`_<^uT{%Kk{U_q}r8?}9q+
zX^XVbj3OJi-%9Gs`U%`)2U_Ox0tLRA(_f3y^YDWO6(<qBv64A#ULZ}}ZXiH8z0rvJ
zCog1X>O|L@O`>u#x3RILiV(3<xTOR!@S6F_HBG$JYauvK_Z?-i*bvfNc0fmgD3ww9
z%~fxOSs|uoJ(V@71^;T~{vN6M-=g0&Z^H8M@MHl|CM;Zy#dr2seNA89;eFn{kY0j$
zz2X!U!bm~X(`a5KX1$GyuZDISH84VIok9+9s4A$V$JAC6=rkYuqXLLGq_bF_apJ^*
z$*y80CV|CNic=?h@|LYoP5?g7UWc7J9orArW6-G=*{RHIvnmaC<&g!l?+r+mPc6N-
z8jy^gAdv%cY75awW=VKc2jf9q-i&qnV;zJYNSI#^oFwA5%B)TbXAfcbH#As3)3LsE
z>D>GG@AvE$x-dFAN_6|QGw$TP{5lZ^h_Y&F8vG)u_MK(NrB@S@j8}jIDOj}};b)z0
z#CikNp>Ln`drn2Uv?Mq8@x7KUD}r!~JB)^(rY2BpJy#w1G^sMb7}J0Es=y<uTAb83
zg}&Ul?hclBKv>Qnpf))p$pmAlFskGThy#HP(y%1|uiISagsk{e%vD6y5ed_SHIxPX
z-^o1i{F0J)Icw{9O&|yp=Jr~<o%1B{;(#FdE5RZ<N#^>$RyG#J1)bzT$s5|aSWlig
zUh8ft8dY7KmPY}BlQ0m!2GztD0MJA;$&3DaFI29a;Jetz7(t4pgMkVF!hq$-&e+wL
zQGR4s{6Nq<h5O8RtTx{KO*ICgaEu`)cFUyph0~??Q%hws#zmW?osSEo>$Z=8*@cDT
zys!YSJ*aDWl|3?9Y+uo5ksIMB86!pp=raUafr>cQB97s)qN=U=UG<d{`-a;-WqGE8
z4Eqfq5Pk=OZ@I_q8XR8iuys=G8IY0@v1^uhvdZayLJy%z=DwbzTD(Th>IsaL9wGZt
zKTNw=ysUck489$V?rE=a{Wiu2=Kr>0cQNF4vN*D8S0%E>N4LXxP8>g;l6q)u%Y&7f
z6f!#HxQt9EO0{@?5w<Yv{&%0Wl2SKy5!NZN*Idj=uBm|+CfumH^eLr&&t9<|xy+qz
z1mL5v2R^K;kfLCgPdor0nT%Q69NKDCKbQf|wzI0-EWN^iK0~7mgbe0QuDPfat9LD5
zla`e&on%k*2`}vpQuGy5N6^lp3Fd#f^ds~ASaUso<}aQ-yRaann07yuk7BE8D~!F`
zM=0g5JVzxYB#2D*RH*U_ow~PU)eFWVWw`GZ5YSMkUnLjKL*!I6N?Q`RGQgl!TW5~N
z!beggbH&+Qhf2x<(><Bx<@!<4(YKnpK5iYv9ISVI6KmUc|K3(appvNxZHI5IBCKNP
zMKIO@f?&tw=Oal-`eXE>n~jYaz-Sp1CD+!x602V$eZ3q!gs=XO0fS519Zq+vCHY(@
zw-^tAfJjG7o)>xAx~zN4DGhpid;2l^A@P8hj6=^75~k>t>{*jHZw`X|if|>88KU9l
z&l(#WyW)N@>x5Iv7_ZNW-tLIiuXgZ`e13>iZ)Bwp>iIolbSvlf{gVglhf-49>h$jm
z^njRpr(ORlQ&H;4XFuWm%N3U5Px3kyr-<p2)V{?ufvtzpca4U3%~Tul#+P7XTvS`j
zLE^%_xa->}pIiNh-p-&P{1*}un3d@uBz?twb(S7pm!LU-pr=^CJ3B{&)m;yblF3zI
z@@96euh<s~25+>i1FcNi15xc!j<l}UvH_cw)DBqagGr{!Em9^MVFmT`3eP6l>@J*b
z>9EB5+sRt|P4g=j2llj(@A0HT(dAvd`xMTg<y*^+SIdXis6Sf+6L=-?g)(?x?08Or
zV23a;!|xwxZT*^DM+sGjt3}+d&uI2i{><HM^)-FX8z>nY8%Very@*6j5Nt{B&~g|D
zxNoowg~BO{s{8ccqgv#mp|u;tl|3%H)NP4V@D_r&b=nZPHwT@XR|I31nXP~Qkv&vi
zk#yi|`_p;vyAS1V3Z|xJ`P4MBt=@%!{tTI+4ghsKo^z1FY#10+1mbnw>Vg@9mDaY0
zUs(Sv@uWqWmZ@d6mvS`cQcn*1wJn)P#;Tq=<!V|~*`8-PFN$*+df6_2Y7;W`Yclj}
z-e-lY*O`BnTyleI_%rC@x%SuRe-87>Zeu&iBS$ZGIgMBEz&CBrynpXFwJYzA&A4A*
zI=0Us>HJI|>#*6SOXDX`bp;;eqCJi);}!RHQT0k8kWpG$@Ui5msEg#5v#sn{5CHWH
zYd*-K@JOvMg%EgGm|=pNF6dXTVEnDxC8pqVda12NO~Pxujc&u?xIY|E;AV);)CKm*
z@td>A@!1?^BDhC`E(XoVpwFVyfJcsl`!_}7VDno0cI`T^6H=4rV69f{+F8o)J=K2S
zb%1;IIrRcIv@KKKAxG5O|K3+=XOOj`fl&Px5ur7#xs-R`GL^JoBqy}GFgI6przJyK
zW7obKkgIK%@XmZUk`=f+Svw-GlzT}Cf)19mU%mD`b`OyD&JF}Dq))4_jED1}EDt;p
zykSv2;I|1dUF&W4#{&%x4D&RCVLr!qRWnfQqr=n&-y~5LU*7;`cneOiS^pG!JmSYR
zA8jx+E%!3X!(N7XH5s|t@yXjiPJfY3&&X(NG_WE*>gYXzg$k*gi@#WP(%2AE!xS?}
zQW*&2_kaB<1>wWG+<e*EXu$tyllXm}FOTDl9>2@6=#&ZIQLiVvH26vs778v<9WV~W
z>O9w>mRF73uN(AZC_Lx1-wH5cs>hGNk3)O)azm_&!0(g9h*;%mO3-^>U~@MY+Uqg*
zz`aE(F=O*SM=<o74+~{#0Ch+PReTi=Iy6)h5IY#eIvk`5=V8wn>a)k>!1zL!t*Y13
z!&=B#=&`#Rj!W0BRt8Ey%;kv>|K?#h0l~9VGR$c&Wi?4K+KEM<l-HCKP0w_|GUL<5
z6=&m6m~O0pU^NPFl%TD?LhE*FR}-^|dkMf2C`Aa(vScZ%lrG=;$rm}+WhaAXN4pt^
z${dD}-l6SLD!!Ca_FyZ9ZdZM>JHHRpExjD`Jo#hkOpn=6SjLr23!hRB(_~H#wRoEg
z3h2ehYE1d{T+#F`E*h^lw!`MDXf5%}t67a2o$UETLt}r-*)t{`dtI`0DRg3KkYLc(
z*L;|zdxGb%%7b;)YfZieYQ@u?Rds_%JG_yJ?-8Fs^D8=ufu?B6*QaS+n$5G9{ob}$
zo2kMFi)3oDWIsGUARgM%T|2(iGi-#O4L*GG<m_=`_0{^Om^%#Rk>>}cS4CX<SJg$K
z?k3RI&sTU0>Npu^K0~2%+EHtdT^?87Vj=r>sOyPYVdM_wFKzg8YX>s5#sx21BeP7o
zJLr?Y^x)jZYW9${CRFV7xw7_-g|!-iPoarm=Ce#*o*la=@m|@%&8410*kwg`(|WU+
z+3PAM=%yObXol%tS{}K7JS%H*$Mmy7SKz)C-H3?8$GWd520uthpMs(^AC`#@IqKox
zS-MXtv&Z-fkb&M~D0wx-Ag@NqQH>P;$LZ-3UDTUmMx#9^%2HfLq{f06<fWyXpIvVA
zoW45xVhYTRGMzdUN2u=v`D%s7M$4q&T_42XICqvFHb~T{58I#PRHsn|^}nk4I4?Ul
zROlehqhYB~BB#zeCst~?VjJKUOQ@$WIIz34k?6v)mk^Zp*oWvdHG?yZeHrt(zXQPB
z-X*(}A2$FGO>f)5rp-j~0|WexQpO}PtEj;nxx2Kt^>&zI#i7Vt_IGP<I~aiAhOE7T
kE^TFf5?5s{vo`d4oEF8MgP#UJ4q?N2UBff^+Sl&=f7Ry|6951J

literal 0
HcmV?d00001


From b1b53a495f56ad7fffbc9397b6414dfbc8db6a1a Mon Sep 17 00:00:00 2001
From: YuyoungRhee <bbclara@naver.com>
Date: Sat, 22 Mar 2025 14:31:01 +0900
Subject: [PATCH 02/18] =?UTF-8?q?feat(Knight):=20=EB=A7=90=EC=9D=98=20?=
 =?UTF-8?q?=EC=9D=B4=EB=8F=99=EA=B0=80=EB=8A=A5=20=EC=97=AC=EB=B6=80=20?=
 =?UTF-8?q?=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Piece 추상클래스를 상속받는 형태로 구현
---
 src/main/java/chess/piece/Knight.java | 44 ++++++++++++++++++++++++++-
 src/main/java/chess/piece/Piece.java  | 12 ++++++++
 2 files changed, 55 insertions(+), 1 deletion(-)
 create mode 100644 src/main/java/chess/piece/Piece.java

diff --git a/src/main/java/chess/piece/Knight.java b/src/main/java/chess/piece/Knight.java
index 2ee7c47a3bc..94f9e2df032 100644
--- a/src/main/java/chess/piece/Knight.java
+++ b/src/main/java/chess/piece/Knight.java
@@ -1,5 +1,47 @@
 package chess.piece;
 
-public class Knight {
+import static chess.Movement.DOWN_DOWN_LEFT;
+import static chess.Movement.DOWN_DOWN_RIGHT;
+import static chess.Movement.LEFT_LEFT_DOWN;
+import static chess.Movement.LEFT_LEFT_UP;
+import static chess.Movement.RIGHT_RIGHT_DOWN;
+import static chess.Movement.RIGHT_RIGHT_UP;
+import static chess.Movement.UP_UP_LEFT;
+import static chess.Movement.UP_UP_RIGHT;
 
+import chess.Movement;
+import chess.Position;
+import java.util.List;
+
+public class Knight extends Piece{
+    private final static List<Movement> knightMovement =
+            List.of(LEFT_LEFT_UP,
+                    LEFT_LEFT_DOWN,
+                    RIGHT_RIGHT_UP,
+                    RIGHT_RIGHT_DOWN,
+                    DOWN_DOWN_LEFT,
+                    DOWN_DOWN_RIGHT,
+                    UP_UP_LEFT,
+                    UP_UP_RIGHT
+            );
+
+    private final List<Movement> availableMovement;
+
+    public Knight() {
+        this.availableMovement = knightMovement;
+    }
+
+    public boolean canMove(Position start, Position target) {
+        for (Movement movement : availableMovement) {
+            if(!start.canMove(movement)) {
+                continue;
+            }
+
+            Position moved = start.move(movement);
+            if(moved.equals(target)) {
+                return true;
+            }
+        }
+        return false;
+    }
 }
diff --git a/src/main/java/chess/piece/Piece.java b/src/main/java/chess/piece/Piece.java
new file mode 100644
index 00000000000..561c174eb0d
--- /dev/null
+++ b/src/main/java/chess/piece/Piece.java
@@ -0,0 +1,12 @@
+package chess.piece;
+
+import chess.Position;
+
+public abstract class Piece {
+
+    Piece() {
+    }
+
+    public abstract boolean canMove(Position start, Position target);
+
+}

From 59aa50b8701ff792ca8a039bc2363c26ab5f132b Mon Sep 17 00:00:00 2001
From: YuyoungRhee <bbclara@naver.com>
Date: Sat, 22 Mar 2025 14:46:17 +0900
Subject: [PATCH 03/18] =?UTF-8?q?feat(Rook):=20=EB=A3=A9=20=EC=9D=B4?=
 =?UTF-8?q?=EB=8F=99=EA=B0=80=EB=8A=A5=EC=97=AC=EB=B6=80=20=EA=B5=AC?=
 =?UTF-8?q?=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 룩은 직선만 이동 가능
---
 src/main/java/chess/Column.java         | 27 +++++++++----
 src/main/java/chess/Position.java       | 12 ++++++
 src/main/java/chess/Row.java            | 26 +++++++++----
 src/main/java/chess/piece/Rook.java     | 25 ++++++++++++-
 src/test/java/chess/piece/RookTest.java | 50 +++++++++++++++++++++++++
 5 files changed, 123 insertions(+), 17 deletions(-)
 create mode 100644 src/test/java/chess/piece/RookTest.java

diff --git a/src/main/java/chess/Column.java b/src/main/java/chess/Column.java
index b64b4dc77a3..54d249337f3 100644
--- a/src/main/java/chess/Column.java
+++ b/src/main/java/chess/Column.java
@@ -2,14 +2,20 @@
 
 public enum Column {
 
-    A,
-    B,
-    C,
-    D,
-    E,
-    F,
-    G,
-    H;
+    A(1),
+    B(2),
+    C(3),
+    D(4),
+    E(5),
+    F(6),
+    G(7),
+    H(8);
+
+    private final int value;
+
+    Column(int value) {
+        this.value = value;
+    }
 
     public boolean isFarLeft() {
         return ordinal() == 0;
@@ -50,4 +56,9 @@ public Column moveRight(final int step) {
 
         throw new IllegalStateException("움직일 수 없는 위치입니다.");
     }
+
+    public int intValue() {
+        return value;
+    };
+
 }
diff --git a/src/main/java/chess/Position.java b/src/main/java/chess/Position.java
index 3ebeb0ea185..dea8744e22c 100644
--- a/src/main/java/chess/Position.java
+++ b/src/main/java/chess/Position.java
@@ -167,4 +167,16 @@ public Position moveHorizontal(final int step) {
         }
         return this;
     }
+
+    public boolean onStraight(Position other) {
+        return this.row() == other.row() || this.column == other.column;
+    }
+
+    public boolean onSameRow(Position other) {
+        return this.row == other.row();
+    }
+
+    public boolean onSameColumn(Position other) {
+        return this.column == other.column;
+    }
 }
diff --git a/src/main/java/chess/Row.java b/src/main/java/chess/Row.java
index 126ed048daa..fbc8e07c35f 100644
--- a/src/main/java/chess/Row.java
+++ b/src/main/java/chess/Row.java
@@ -2,14 +2,20 @@
 
 public enum Row {
 
-    EIGHT,
-    SEVEN,
-    SIX,
-    FIVE,
-    FOUR,
-    THREE,
-    TWO,
-    ONE;
+    EIGHT(8),
+    SEVEN(7),
+    SIX(6),
+    FIVE(5),
+    FOUR(4),
+    THREE(3),
+    TWO(2),
+    ONE(1);
+
+    private final int value;
+
+    Row(int value) {
+        this.value = value;
+    }
 
     public boolean isTop() {
         return ordinal() == 0;
@@ -50,4 +56,8 @@ public Row moveDown(final int step) {
 
         throw new IllegalStateException("움직일 수 없는 위치입니다.");
     }
+
+    public int intValue() {
+        return value;
+    };
 }
diff --git a/src/main/java/chess/piece/Rook.java b/src/main/java/chess/piece/Rook.java
index 7ed4d08bf03..b4a2447485c 100644
--- a/src/main/java/chess/piece/Rook.java
+++ b/src/main/java/chess/piece/Rook.java
@@ -1,5 +1,28 @@
 package chess.piece;
 
-public class Rook {
+import chess.Movement;
+import chess.Position;
+import chess.Row;
+import java.util.List;
+
+public class Rook extends Piece {
+
+    @Override
+    public boolean canMove(Position start, Position target) {
+        if (!start.onStraight(target)) {
+            return false;
+        }
+
+        if (start.onSameRow(target)) {
+            int step = target.row().intValue() - start.row().intValue();
+            return start.canMoveUp(step);
+        }
+
+        if (start.onSameColumn(target)) {
+            int step = target.column().intValue() - start.column().intValue();
+            return start.canMoveRight(step);
+        }
+        return false;
+    }
 
 }
diff --git a/src/test/java/chess/piece/RookTest.java b/src/test/java/chess/piece/RookTest.java
new file mode 100644
index 00000000000..073f71a409d
--- /dev/null
+++ b/src/test/java/chess/piece/RookTest.java
@@ -0,0 +1,50 @@
+package chess.piece;
+
+import static chess.Fixtures.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class RookTest {
+
+    @DisplayName("룩은 세로로 움직일 수 잇다.")
+    @Test
+    void Rook_canMove_Straight_Row() {
+        // given
+        Rook rook = new Rook();
+
+        // when
+        boolean canMove = rook.canMove(A1, A8);
+
+        // then
+        assertThat(canMove).isTrue();
+    }
+
+    @DisplayName("룩은 가로로 움직일 수 잇다.")
+    @Test
+    void Rook_canMove_Straight_Column() {
+        // given
+        Rook rook = new Rook();
+
+        // when
+        boolean canMove = rook.canMove(A1, H1);
+
+        // then
+        assertThat(canMove).isTrue();
+    }
+
+    @DisplayName("룩은 직선이 아니면 움직일 수 없다.")
+    @Test
+    void Rook_cannotMove_when_notStraight() {
+        // given
+        Rook rook = new Rook();
+
+        // when
+        boolean canMove = rook.canMove(A1, B2);
+
+        // then
+        assertThat(canMove).isFalse();
+    }
+
+}
\ No newline at end of file

From 174082f1de274e015501e0eb33ae35f33d778ab8 Mon Sep 17 00:00:00 2001
From: YuyoungRhee <bbclara@naver.com>
Date: Sat, 22 Mar 2025 14:58:10 +0900
Subject: [PATCH 04/18] =?UTF-8?q?feat(King):=20=ED=82=B9=20=EC=9D=B4?=
 =?UTF-8?q?=EB=8F=99=EA=B0=80=EB=8A=A5=EC=97=AC=EB=B6=80=20=EA=B5=AC?=
 =?UTF-8?q?=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 킹은 주변 한 칸으로 이동 가능
---
 src/main/java/chess/piece/King.java       | 32 ++++++++++++++++
 src/test/java/chess/piece/KingTest.java   | 46 +++++++++++++++++++++++
 src/test/java/chess/piece/KnightTest.java | 40 ++++++++++++++++++++
 3 files changed, 118 insertions(+)
 create mode 100644 src/test/java/chess/piece/KingTest.java
 create mode 100644 src/test/java/chess/piece/KnightTest.java

diff --git a/src/main/java/chess/piece/King.java b/src/main/java/chess/piece/King.java
index d64210cad13..1a7a446d01e 100644
--- a/src/main/java/chess/piece/King.java
+++ b/src/main/java/chess/piece/King.java
@@ -1,5 +1,37 @@
 package chess.piece;
 
+import chess.Movement;
+import chess.Position;
+import java.util.List;
+
 public class King {
+    private final static List<Movement> kingMovement =
+            List.of(Movement.UP,
+                    Movement.DOWN,
+                    Movement.LEFT,
+                    Movement.RIGHT,
+                    Movement.LEFT_UP,
+                    Movement.RIGHT_UP,
+                    Movement.LEFT_DOWN,
+                    Movement.RIGHT_DOWN);
+
+    private final List<Movement> availableMovement;
+
+    public King() {
+        this.availableMovement = kingMovement;
+    }
+
+    public boolean canMove(Position start, Position target) {
+        for (Movement movement : availableMovement) {
+            if(!start.canMove(movement)) {
+                continue;
+            }
 
+            Position moved = start.move(movement);
+            if(moved.equals(target)) {
+                return true;
+            }
+        }
+        return false;
+    }
 }
diff --git a/src/test/java/chess/piece/KingTest.java b/src/test/java/chess/piece/KingTest.java
new file mode 100644
index 00000000000..d55a6c9d527
--- /dev/null
+++ b/src/test/java/chess/piece/KingTest.java
@@ -0,0 +1,46 @@
+package chess.piece;
+
+import static chess.Fixtures.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import chess.Position;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class KingTest {
+
+    //B2에서 킹이 이동가능한 방향
+    static Stream<Position> provideKingMovesTo() {
+        return Stream.of(A2, C2, B3, B1, A3, A1, C3, C1);
+    }
+
+    @DisplayName("킹은 왼쪽 한칸으로 움직일 수 있다.")
+    @ParameterizedTest
+    @MethodSource("provideKingMovesTo")
+    void King_canMove_Left(Position target) {
+        // given
+        King king = new King();
+
+        // when
+        boolean canMove = king.canMove(B2, target);
+
+        // then
+        assertThat(canMove).isTrue();
+    }
+
+    @DisplayName("킹이 이동할 수 없는 칸이면 false")
+    @Test
+    void King_cannotMove() {
+        King king = new King();
+
+        // when
+        boolean canMove = king.canMove(B2, D2);
+
+        // then
+        assertThat(canMove).isFalse();
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/chess/piece/KnightTest.java b/src/test/java/chess/piece/KnightTest.java
new file mode 100644
index 00000000000..29832c28cde
--- /dev/null
+++ b/src/test/java/chess/piece/KnightTest.java
@@ -0,0 +1,40 @@
+package chess.piece;
+
+import static chess.Fixtures.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class KnightTest {
+
+    @DisplayName("말은 수평한칸, 수직두칸 이동할 수 있다.")
+    @Test
+    void Horse_canMoveTest() {
+        // given
+        Piece knight = new Knight();
+
+        // when
+        boolean canMove = knight.canMove(B1, C3);
+        boolean canMove2 = knight.canMove(B1, A3);
+
+        // then
+        assertThat(canMove).isTrue();
+        assertThat(canMove2).isTrue();
+    }
+
+    @DisplayName("말이 이동불가능한 경로로는 갈 수 없다.")
+    @Test
+    void Horse_canMove_False() {
+        // given
+        Piece knight = new Knight();
+
+        // when
+        boolean canMove = knight.canMove(B1, C2);
+
+        // then
+        assertThat(canMove).isFalse();
+    }
+
+}
\ No newline at end of file

From 5727250fd00c45e02a2b3f6328b57afa6b3fe262 Mon Sep 17 00:00:00 2001
From: YuyoungRhee <bbclara@naver.com>
Date: Sat, 22 Mar 2025 15:04:34 +0900
Subject: [PATCH 05/18] =?UTF-8?q?feat(Bishop):=20=EB=B9=84=EC=88=8D=20?=
 =?UTF-8?q?=EC=9D=B4=EB=8F=99=EA=B0=80=EB=8A=A5=20=EC=97=AC=EB=B6=80=20?=
 =?UTF-8?q?=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 비숍은 대각선으로 이동 가능
---
 src/main/java/chess/Position.java         |  7 +++++
 src/main/java/chess/piece/Bishop.java     | 10 ++++++-
 src/test/java/chess/piece/BishopTest.java | 36 +++++++++++++++++++++++
 3 files changed, 52 insertions(+), 1 deletion(-)
 create mode 100644 src/test/java/chess/piece/BishopTest.java

diff --git a/src/main/java/chess/Position.java b/src/main/java/chess/Position.java
index dea8744e22c..a6941162956 100644
--- a/src/main/java/chess/Position.java
+++ b/src/main/java/chess/Position.java
@@ -179,4 +179,11 @@ public boolean onSameRow(Position other) {
     public boolean onSameColumn(Position other) {
         return this.column == other.column;
     }
+
+    public boolean onDiagonal(Position other) {
+        int rowDiff = Math.abs(this.row().intValue() - other.row().intValue());
+        int colDiff = Math.abs(this.column.intValue() - other.column.intValue());
+
+        return rowDiff == colDiff;
+    }
 }
diff --git a/src/main/java/chess/piece/Bishop.java b/src/main/java/chess/piece/Bishop.java
index b14ab70f981..df890932eef 100644
--- a/src/main/java/chess/piece/Bishop.java
+++ b/src/main/java/chess/piece/Bishop.java
@@ -1,5 +1,13 @@
 package chess.piece;
 
-public class Bishop {
+import chess.Movement;
+import chess.Position;
+import java.util.List;
 
+public class Bishop extends Piece{
+
+    @Override
+    public boolean canMove(Position start, Position target) {
+        return start.onDiagonal(target);
+    }
 }
diff --git a/src/test/java/chess/piece/BishopTest.java b/src/test/java/chess/piece/BishopTest.java
new file mode 100644
index 00000000000..ce904f362dd
--- /dev/null
+++ b/src/test/java/chess/piece/BishopTest.java
@@ -0,0 +1,36 @@
+package chess.piece;
+
+import static chess.Fixtures.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class BishopTest {
+
+    @DisplayName("비숍은 대각선으로 갈 수 있다.")
+    @Test
+    void Bishop_canMove_diagonal() {
+        // given
+        Bishop bishop = new Bishop();
+
+        // when
+        boolean canMove = bishop.canMove(A1, B2);
+
+        // then
+        assertThat(canMove).isTrue();
+    }
+
+    @DisplayName("비숍은 직선으로 갈 수 없다.")
+    @Test
+    void Bishop_cannotMove_Straight() {
+        // given
+        Bishop bishop = new Bishop();
+
+        // when
+        boolean canMove = bishop.canMove(A1, A2);
+
+        // then
+        assertThat(canMove).isFalse();
+    }
+}
\ No newline at end of file

From 3cb4db9ba461b445360f5807a21a997a4e0801b2 Mon Sep 17 00:00:00 2001
From: YuyoungRhee <bbclara@naver.com>
Date: Sat, 22 Mar 2025 15:09:13 +0900
Subject: [PATCH 06/18] =?UTF-8?q?feat(Queen):=20=ED=80=B8=20=EC=9D=B4?=
 =?UTF-8?q?=EB=8F=99=EA=B0=80=EB=8A=A5=20=EC=97=AC=EB=B6=80=20=EA=B5=AC?=
 =?UTF-8?q?=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 퀸은 직선이나 대각선으로 이동 가능
---
 src/main/java/chess/piece/Queen.java     | 11 +++++-
 src/test/java/chess/piece/QueenTest.java | 50 ++++++++++++++++++++++++
 2 files changed, 60 insertions(+), 1 deletion(-)
 create mode 100644 src/test/java/chess/piece/QueenTest.java

diff --git a/src/main/java/chess/piece/Queen.java b/src/main/java/chess/piece/Queen.java
index 9b547261c4b..5ef74b467d6 100644
--- a/src/main/java/chess/piece/Queen.java
+++ b/src/main/java/chess/piece/Queen.java
@@ -1,5 +1,14 @@
 package chess.piece;
 
-public class Queen {
+import chess.Movement;
+import chess.Position;
+import java.util.List;
+
+public class Queen extends Piece{
+
+    @Override
+    public boolean canMove(Position start, Position target) {
+        return start.onStraight(target) || start.onDiagonal(target);
+    }
 
 }
diff --git a/src/test/java/chess/piece/QueenTest.java b/src/test/java/chess/piece/QueenTest.java
new file mode 100644
index 00000000000..580af961d6e
--- /dev/null
+++ b/src/test/java/chess/piece/QueenTest.java
@@ -0,0 +1,50 @@
+package chess.piece;
+
+import static chess.Fixtures.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class QueenTest {
+
+    @DisplayName("퀸은 대각선으로 이동 가능")
+    @Test
+    void Queen_canMove_diagonal() {
+        // given
+        Queen queen = new Queen();
+
+        // when
+        boolean canMove = queen.canMove(A1, C3);
+
+        // then
+        assertThat(canMove).isTrue();
+    }
+
+    @DisplayName("퀸은 직선으로 이동 가능")
+    @Test
+    void Queen_canMove_Straight() {
+        // given
+        Queen queen = new Queen();
+
+        // when
+        boolean canMove = queen.canMove(A1, A3);
+
+        // then
+        assertThat(canMove).isTrue();
+    }
+
+    @DisplayName("퀸은 직선이나 대각선이 아닌 곳으로는 이동 불가능")
+    @Test
+    void Queen_cannotMove() {
+        // given
+        Queen queen = new Queen();
+
+        // when
+        boolean canMove = queen.canMove(A1, B3);
+
+        // then
+        assertThat(canMove).isFalse();
+    }
+
+}
\ No newline at end of file

From 97755527a0f339d4f50a41fd9e78baf00a9e489e Mon Sep 17 00:00:00 2001
From: YuyoungRhee <bbclara@naver.com>
Date: Sat, 22 Mar 2025 15:14:38 +0900
Subject: [PATCH 07/18] =?UTF-8?q?refactor:=20=EB=A3=A9=20=EC=9D=B4?=
 =?UTF-8?q?=EB=8F=99=EA=B0=80=EB=8A=A5=20=EC=97=AC=EB=B6=80=20=EA=B8=B0?=
 =?UTF-8?q?=EB=8A=A5=20=EA=B0=84=EC=86=8C=ED=99=94?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 굳이 하나씩 이동하면서 확인할 필요가 없으므로 직선상에 있는지만 확인하도록 변경
---
 src/main/java/chess/piece/Rook.java | 16 ++++------------
 1 file changed, 4 insertions(+), 12 deletions(-)

diff --git a/src/main/java/chess/piece/Rook.java b/src/main/java/chess/piece/Rook.java
index b4a2447485c..37e8dbf42c1 100644
--- a/src/main/java/chess/piece/Rook.java
+++ b/src/main/java/chess/piece/Rook.java
@@ -9,20 +9,12 @@ public class Rook extends Piece {
 
     @Override
     public boolean canMove(Position start, Position target) {
-        if (!start.onStraight(target)) {
-            return false;
-        }
+        return start.onStraight(target);
+    }
 
-        if (start.onSameRow(target)) {
-            int step = target.row().intValue() - start.row().intValue();
-            return start.canMoveUp(step);
-        }
+    @Override
+    public List<Position> findAllRouteToTarget(Position start, Position target) {
 
-        if (start.onSameColumn(target)) {
-            int step = target.column().intValue() - start.column().intValue();
-            return start.canMoveRight(step);
-        }
-        return false;
     }
 
 }

From 65c6b8bca794390dd3b056c89e98a2e64694b62b Mon Sep 17 00:00:00 2001
From: YuyoungRhee <bbclara@naver.com>
Date: Sat, 22 Mar 2025 15:54:38 +0900
Subject: [PATCH 08/18] =?UTF-8?q?feat(piece):=20=EC=9D=B4=EB=8F=99=20?=
 =?UTF-8?q?=EA=B2=BD=EB=A1=9C=20=EC=82=AC=EC=9D=B4=EC=97=90=20=EC=9E=88?=
 =?UTF-8?q?=EB=8A=94=20=EB=AA=A8=EB=93=A0=20=EC=A2=8C=ED=91=9C=20=EB=B0=98?=
 =?UTF-8?q?=ED=99=98=20=EA=B8=B0=EB=8A=A5=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 폰 제외 모든 기물들의 이동 경로 사이에 있는 좌표들을 반환하는 기능 구현
---
 src/main/java/chess/Column.java           |  9 ++++++
 src/main/java/chess/Position.java         |  8 +++++
 src/main/java/chess/Row.java              |  9 ++++++
 src/main/java/chess/piece/Bishop.java     | 17 +++++++++++
 src/main/java/chess/piece/King.java       |  7 ++++-
 src/main/java/chess/piece/Knight.java     | 12 ++++++++
 src/main/java/chess/piece/Piece.java      |  2 ++
 src/main/java/chess/piece/Queen.java      | 36 ++++++++++++++++++++++-
 src/main/java/chess/piece/Rook.java       | 24 +++++++++++++--
 src/test/java/chess/piece/BishopTest.java | 15 ++++++++++
 src/test/java/chess/piece/QueenTest.java  | 15 ++++++++++
 src/test/java/chess/piece/RookTest.java   | 18 ++++++++++++
 12 files changed, 168 insertions(+), 4 deletions(-)

diff --git a/src/main/java/chess/Column.java b/src/main/java/chess/Column.java
index 54d249337f3..1ebd6088592 100644
--- a/src/main/java/chess/Column.java
+++ b/src/main/java/chess/Column.java
@@ -1,5 +1,7 @@
 package chess;
 
+import java.util.Arrays;
+
 public enum Column {
 
     A(1),
@@ -17,6 +19,13 @@ public enum Column {
         this.value = value;
     }
 
+    public static Column from(int value) {
+        return Arrays.stream(Column.values())
+                .filter(col -> col.value == value)
+                .findAny()
+                .orElseThrow();
+    }
+
     public boolean isFarLeft() {
         return ordinal() == 0;
     }
diff --git a/src/main/java/chess/Position.java b/src/main/java/chess/Position.java
index a6941162956..5b792096495 100644
--- a/src/main/java/chess/Position.java
+++ b/src/main/java/chess/Position.java
@@ -186,4 +186,12 @@ public boolean onDiagonal(Position other) {
 
         return rowDiff == colDiff;
     }
+
+    public int rowValue() {
+        return this.row().intValue();
+    }
+
+    public int colValue() {
+        return this.column.intValue();
+    }
 }
diff --git a/src/main/java/chess/Row.java b/src/main/java/chess/Row.java
index fbc8e07c35f..0339d40782b 100644
--- a/src/main/java/chess/Row.java
+++ b/src/main/java/chess/Row.java
@@ -1,5 +1,7 @@
 package chess;
 
+import java.util.Arrays;
+
 public enum Row {
 
     EIGHT(8),
@@ -17,6 +19,13 @@ public enum Row {
         this.value = value;
     }
 
+    public static Row from(int value) {
+        return Arrays.stream(Row.values())
+                .filter(row -> row.value == value)
+                .findAny()
+                .orElseThrow();
+    }
+
     public boolean isTop() {
         return ordinal() == 0;
     }
diff --git a/src/main/java/chess/piece/Bishop.java b/src/main/java/chess/piece/Bishop.java
index df890932eef..ab2e0053bcd 100644
--- a/src/main/java/chess/piece/Bishop.java
+++ b/src/main/java/chess/piece/Bishop.java
@@ -2,6 +2,7 @@
 
 import chess.Movement;
 import chess.Position;
+import java.util.ArrayList;
 import java.util.List;
 
 public class Bishop extends Piece{
@@ -10,4 +11,20 @@ public class Bishop extends Piece{
     public boolean canMove(Position start, Position target) {
         return start.onDiagonal(target);
     }
+
+    @Override
+    public List<Position> findAllRouteToTarget(Position start, Position target) {
+        List<Position> positions = new ArrayList<>();
+
+        Position current = start;
+        int rowStep = (target.rowValue() - start.rowValue()) / Math.abs(target.rowValue() - start.rowValue());
+        int colStep = (target.colValue() - start.colValue()) / Math.abs(target.colValue() - start.colValue());
+
+        while (!current.equals(target)) {
+            current = current.moveVertical(rowStep).moveHorizontal(colStep);
+            positions.add(current);
+        }
+
+        return positions;
+    }
 }
diff --git a/src/main/java/chess/piece/King.java b/src/main/java/chess/piece/King.java
index 1a7a446d01e..a3e5f5b2fbd 100644
--- a/src/main/java/chess/piece/King.java
+++ b/src/main/java/chess/piece/King.java
@@ -4,7 +4,7 @@
 import chess.Position;
 import java.util.List;
 
-public class King {
+public class King extends Piece{
     private final static List<Movement> kingMovement =
             List.of(Movement.UP,
                     Movement.DOWN,
@@ -34,4 +34,9 @@ public boolean canMove(Position start, Position target) {
         }
         return false;
     }
+
+    @Override
+    public List<Position> findAllRouteToTarget(Position start, Position target) {
+        return List.of(target);
+    }
 }
diff --git a/src/main/java/chess/piece/Knight.java b/src/main/java/chess/piece/Knight.java
index 94f9e2df032..402a4f466e8 100644
--- a/src/main/java/chess/piece/Knight.java
+++ b/src/main/java/chess/piece/Knight.java
@@ -9,8 +9,11 @@
 import static chess.Movement.UP_UP_LEFT;
 import static chess.Movement.UP_UP_RIGHT;
 
+import chess.Column;
 import chess.Movement;
 import chess.Position;
+import chess.Row;
+import java.util.ArrayList;
 import java.util.List;
 
 public class Knight extends Piece{
@@ -44,4 +47,13 @@ public boolean canMove(Position start, Position target) {
         }
         return false;
     }
+
+    @Override
+    public List<Position> findAllRouteToTarget(Position start, Position target) {
+        Row row = Row.from((start.rowValue() + target.rowValue()) / 2);
+        Column column = Column.from((start.colValue() + target.colValue()) / 2);
+
+        Position position = new Position(row, column);
+        return List.of(position);
+    }
 }
diff --git a/src/main/java/chess/piece/Piece.java b/src/main/java/chess/piece/Piece.java
index 561c174eb0d..6e3e91b8627 100644
--- a/src/main/java/chess/piece/Piece.java
+++ b/src/main/java/chess/piece/Piece.java
@@ -1,6 +1,7 @@
 package chess.piece;
 
 import chess.Position;
+import java.util.List;
 
 public abstract class Piece {
 
@@ -9,4 +10,5 @@ public abstract class Piece {
 
     public abstract boolean canMove(Position start, Position target);
 
+    public abstract List<Position> findAllRouteToTarget(Position start, Position target);
 }
diff --git a/src/main/java/chess/piece/Queen.java b/src/main/java/chess/piece/Queen.java
index 5ef74b467d6..9c25ab28721 100644
--- a/src/main/java/chess/piece/Queen.java
+++ b/src/main/java/chess/piece/Queen.java
@@ -2,13 +2,47 @@
 
 import chess.Movement;
 import chess.Position;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
-public class Queen extends Piece{
+public class Queen extends Piece {
 
     @Override
     public boolean canMove(Position start, Position target) {
         return start.onStraight(target) || start.onDiagonal(target);
     }
 
+    @Override
+    public List<Position> findAllRouteToTarget(Position start, Position target) {
+        List<Position> positions = new ArrayList<>();
+        Position current = start;
+
+        if (start.onSameColumn(target)) {
+            int oneStep = (target.rowValue() - start.rowValue()) / Math.abs(target.rowValue() - start.rowValue());
+            while (!current.equals(target)) {
+                current = current.moveVertical(oneStep);
+                positions.add(current);
+            }
+        }
+        if (start.onSameRow(target)) {
+            int oneStep = (target.colValue() - start.colValue()) / Math.abs(target.colValue() - start.colValue());
+            while (!current.equals(target)) {
+                current = current.moveHorizontal(oneStep);
+                positions.add(current);
+            }
+        }
+        if (start.onDiagonal(target)) {
+            int rowStep = (target.rowValue() - start.rowValue()) / Math.abs(target.rowValue() - start.rowValue());
+            int colStep = (target.colValue() - start.colValue()) / Math.abs(target.colValue() - start.colValue());
+
+            while (!current.equals(target)) {
+                current = current.moveVertical(rowStep).moveHorizontal(colStep);
+                positions.add(current);
+            }
+        }
+
+        return positions;
+    }
+
 }
diff --git a/src/main/java/chess/piece/Rook.java b/src/main/java/chess/piece/Rook.java
index 37e8dbf42c1..5df98f00652 100644
--- a/src/main/java/chess/piece/Rook.java
+++ b/src/main/java/chess/piece/Rook.java
@@ -1,8 +1,7 @@
 package chess.piece;
 
-import chess.Movement;
 import chess.Position;
-import chess.Row;
+import java.util.ArrayList;
 import java.util.List;
 
 public class Rook extends Piece {
@@ -14,7 +13,28 @@ public boolean canMove(Position start, Position target) {
 
     @Override
     public List<Position> findAllRouteToTarget(Position start, Position target) {
+        List<Position> positions = new ArrayList<>();
 
+        Position current = new Position(start.row(), start.column());
+
+        while (!current.equals(target)) {
+            if (start.onSameRow(target)) {
+                if (current.column().intValue() < target.column().intValue()) {
+                    current = current.moveRight();
+                } else {
+                    current = current.moveLeft();
+                }
+            }
+            if (start.onSameColumn(target)) {
+                if (current.row().intValue() < target.row().intValue()) {
+                    current = current.moveUp();
+                } else {
+                    current = current.moveDown();
+                }
+            }
+            positions.add(current);
+        }
+        return positions;
     }
 
 }
diff --git a/src/test/java/chess/piece/BishopTest.java b/src/test/java/chess/piece/BishopTest.java
index ce904f362dd..33e5a391153 100644
--- a/src/test/java/chess/piece/BishopTest.java
+++ b/src/test/java/chess/piece/BishopTest.java
@@ -3,6 +3,8 @@
 import static chess.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
+import chess.Position;
+import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
@@ -33,4 +35,17 @@ void Bishop_cannotMove_Straight() {
         // then
         assertThat(canMove).isFalse();
     }
+
+    @DisplayName("이동경로 사이에 있는 모든 좌표 반환")
+    @Test
+    void Bishop_findAllRoute() {
+        // given
+        Bishop bishop = new Bishop();
+
+        // when
+        List<Position> routes = bishop.findAllRouteToTarget(A1, D4);
+
+        // then
+        assertThat(routes).hasSize(3);
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/chess/piece/QueenTest.java b/src/test/java/chess/piece/QueenTest.java
index 580af961d6e..a8c5e9a3592 100644
--- a/src/test/java/chess/piece/QueenTest.java
+++ b/src/test/java/chess/piece/QueenTest.java
@@ -3,6 +3,8 @@
 import static chess.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
+import chess.Position;
+import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
@@ -47,4 +49,17 @@ void Queen_cannotMove() {
         assertThat(canMove).isFalse();
     }
 
+    @DisplayName("퀸의 이동경로에 있는 모든 좌표 반환")
+    @Test
+    void Queen_findAllRoute() {
+        // given
+        Queen queen = new Queen();
+
+        // when
+        List<Position> routes = queen.findAllRouteToTarget(D4, G7);
+
+        // then
+        assertThat(routes).hasSize(3);
+    }
+
 }
\ No newline at end of file
diff --git a/src/test/java/chess/piece/RookTest.java b/src/test/java/chess/piece/RookTest.java
index 073f71a409d..81212a282b7 100644
--- a/src/test/java/chess/piece/RookTest.java
+++ b/src/test/java/chess/piece/RookTest.java
@@ -3,6 +3,8 @@
 import static chess.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
+import chess.Position;
+import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
@@ -47,4 +49,20 @@ void Rook_cannotMove_when_notStraight() {
         assertThat(canMove).isFalse();
     }
 
+    @DisplayName("룩 이동 경로의 위치를 모두 반환한다.")
+    @Test
+    void Rook_findAllRoute() {
+        // given
+        Rook rook = new Rook();
+
+        // when
+        List<Position> routes = rook.findAllRouteToTarget(A1, A4);
+
+        // then
+        assertThat(routes).hasSize(3);
+        assertThat(routes.get(0)).isEqualTo(A2);
+        assertThat(routes.get(1)).isEqualTo(A3);
+        assertThat(routes.get(2)).isEqualTo(A4);
+    }
+
 }
\ No newline at end of file

From 2c0ae37181ce7e014b8bc045bd5e78309f1a0809 Mon Sep 17 00:00:00 2001
From: YuyoungRhee <bbclara@naver.com>
Date: Sat, 22 Mar 2025 15:57:20 +0900
Subject: [PATCH 09/18] =?UTF-8?q?refactor(piece):=20canMove=20->=20availab?=
 =?UTF-8?q?lePath=20=EB=A9=94=EC=84=9C=EB=93=9C=EB=AA=85=20=EB=B3=80?=
 =?UTF-8?q?=EA=B2=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/chess/piece/Bishop.java     | 2 +-
 src/main/java/chess/piece/King.java       | 2 +-
 src/main/java/chess/piece/Knight.java     | 2 +-
 src/main/java/chess/piece/Piece.java      | 2 +-
 src/main/java/chess/piece/Queen.java      | 2 +-
 src/main/java/chess/piece/Rook.java       | 2 +-
 src/test/java/chess/piece/BishopTest.java | 4 ++--
 src/test/java/chess/piece/KingTest.java   | 4 ++--
 src/test/java/chess/piece/KnightTest.java | 7 +++----
 src/test/java/chess/piece/QueenTest.java  | 6 +++---
 src/test/java/chess/piece/RookTest.java   | 6 +++---
 11 files changed, 19 insertions(+), 20 deletions(-)

diff --git a/src/main/java/chess/piece/Bishop.java b/src/main/java/chess/piece/Bishop.java
index ab2e0053bcd..2a73d0cdf14 100644
--- a/src/main/java/chess/piece/Bishop.java
+++ b/src/main/java/chess/piece/Bishop.java
@@ -8,7 +8,7 @@
 public class Bishop extends Piece{
 
     @Override
-    public boolean canMove(Position start, Position target) {
+    public boolean availablePath(Position start, Position target) {
         return start.onDiagonal(target);
     }
 
diff --git a/src/main/java/chess/piece/King.java b/src/main/java/chess/piece/King.java
index a3e5f5b2fbd..52615bc14f4 100644
--- a/src/main/java/chess/piece/King.java
+++ b/src/main/java/chess/piece/King.java
@@ -21,7 +21,7 @@ public King() {
         this.availableMovement = kingMovement;
     }
 
-    public boolean canMove(Position start, Position target) {
+    public boolean availablePath(Position start, Position target) {
         for (Movement movement : availableMovement) {
             if(!start.canMove(movement)) {
                 continue;
diff --git a/src/main/java/chess/piece/Knight.java b/src/main/java/chess/piece/Knight.java
index 402a4f466e8..c5c9957b612 100644
--- a/src/main/java/chess/piece/Knight.java
+++ b/src/main/java/chess/piece/Knight.java
@@ -34,7 +34,7 @@ public Knight() {
         this.availableMovement = knightMovement;
     }
 
-    public boolean canMove(Position start, Position target) {
+    public boolean availablePath(Position start, Position target) {
         for (Movement movement : availableMovement) {
             if(!start.canMove(movement)) {
                 continue;
diff --git a/src/main/java/chess/piece/Piece.java b/src/main/java/chess/piece/Piece.java
index 6e3e91b8627..f84a1a59404 100644
--- a/src/main/java/chess/piece/Piece.java
+++ b/src/main/java/chess/piece/Piece.java
@@ -8,7 +8,7 @@ public abstract class Piece {
     Piece() {
     }
 
-    public abstract boolean canMove(Position start, Position target);
+    public abstract boolean availablePath(Position start, Position target);
 
     public abstract List<Position> findAllRouteToTarget(Position start, Position target);
 }
diff --git a/src/main/java/chess/piece/Queen.java b/src/main/java/chess/piece/Queen.java
index 9c25ab28721..f65094735cf 100644
--- a/src/main/java/chess/piece/Queen.java
+++ b/src/main/java/chess/piece/Queen.java
@@ -9,7 +9,7 @@
 public class Queen extends Piece {
 
     @Override
-    public boolean canMove(Position start, Position target) {
+    public boolean availablePath(Position start, Position target) {
         return start.onStraight(target) || start.onDiagonal(target);
     }
 
diff --git a/src/main/java/chess/piece/Rook.java b/src/main/java/chess/piece/Rook.java
index 5df98f00652..f6b41809098 100644
--- a/src/main/java/chess/piece/Rook.java
+++ b/src/main/java/chess/piece/Rook.java
@@ -7,7 +7,7 @@
 public class Rook extends Piece {
 
     @Override
-    public boolean canMove(Position start, Position target) {
+    public boolean availablePath(Position start, Position target) {
         return start.onStraight(target);
     }
 
diff --git a/src/test/java/chess/piece/BishopTest.java b/src/test/java/chess/piece/BishopTest.java
index 33e5a391153..302aca28ed0 100644
--- a/src/test/java/chess/piece/BishopTest.java
+++ b/src/test/java/chess/piece/BishopTest.java
@@ -17,7 +17,7 @@ void Bishop_canMove_diagonal() {
         Bishop bishop = new Bishop();
 
         // when
-        boolean canMove = bishop.canMove(A1, B2);
+        boolean canMove = bishop.availablePath(A1, B2);
 
         // then
         assertThat(canMove).isTrue();
@@ -30,7 +30,7 @@ void Bishop_cannotMove_Straight() {
         Bishop bishop = new Bishop();
 
         // when
-        boolean canMove = bishop.canMove(A1, A2);
+        boolean canMove = bishop.availablePath(A1, A2);
 
         // then
         assertThat(canMove).isFalse();
diff --git a/src/test/java/chess/piece/KingTest.java b/src/test/java/chess/piece/KingTest.java
index d55a6c9d527..b718a936234 100644
--- a/src/test/java/chess/piece/KingTest.java
+++ b/src/test/java/chess/piece/KingTest.java
@@ -25,7 +25,7 @@ void King_canMove_Left(Position target) {
         King king = new King();
 
         // when
-        boolean canMove = king.canMove(B2, target);
+        boolean canMove = king.availablePath(B2, target);
 
         // then
         assertThat(canMove).isTrue();
@@ -37,7 +37,7 @@ void King_cannotMove() {
         King king = new King();
 
         // when
-        boolean canMove = king.canMove(B2, D2);
+        boolean canMove = king.availablePath(B2, D2);
 
         // then
         assertThat(canMove).isFalse();
diff --git a/src/test/java/chess/piece/KnightTest.java b/src/test/java/chess/piece/KnightTest.java
index 29832c28cde..793189b6cb7 100644
--- a/src/test/java/chess/piece/KnightTest.java
+++ b/src/test/java/chess/piece/KnightTest.java
@@ -2,7 +2,6 @@
 
 import static chess.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.*;
 
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
@@ -16,8 +15,8 @@ void Horse_canMoveTest() {
         Piece knight = new Knight();
 
         // when
-        boolean canMove = knight.canMove(B1, C3);
-        boolean canMove2 = knight.canMove(B1, A3);
+        boolean canMove = knight.availablePath(B1, C3);
+        boolean canMove2 = knight.availablePath(B1, A3);
 
         // then
         assertThat(canMove).isTrue();
@@ -31,7 +30,7 @@ void Horse_canMove_False() {
         Piece knight = new Knight();
 
         // when
-        boolean canMove = knight.canMove(B1, C2);
+        boolean canMove = knight.availablePath(B1, C2);
 
         // then
         assertThat(canMove).isFalse();
diff --git a/src/test/java/chess/piece/QueenTest.java b/src/test/java/chess/piece/QueenTest.java
index a8c5e9a3592..46c6c7ee84e 100644
--- a/src/test/java/chess/piece/QueenTest.java
+++ b/src/test/java/chess/piece/QueenTest.java
@@ -17,7 +17,7 @@ void Queen_canMove_diagonal() {
         Queen queen = new Queen();
 
         // when
-        boolean canMove = queen.canMove(A1, C3);
+        boolean canMove = queen.availablePath(A1, C3);
 
         // then
         assertThat(canMove).isTrue();
@@ -30,7 +30,7 @@ void Queen_canMove_Straight() {
         Queen queen = new Queen();
 
         // when
-        boolean canMove = queen.canMove(A1, A3);
+        boolean canMove = queen.availablePath(A1, A3);
 
         // then
         assertThat(canMove).isTrue();
@@ -43,7 +43,7 @@ void Queen_cannotMove() {
         Queen queen = new Queen();
 
         // when
-        boolean canMove = queen.canMove(A1, B3);
+        boolean canMove = queen.availablePath(A1, B3);
 
         // then
         assertThat(canMove).isFalse();
diff --git a/src/test/java/chess/piece/RookTest.java b/src/test/java/chess/piece/RookTest.java
index 81212a282b7..15142bceaf8 100644
--- a/src/test/java/chess/piece/RookTest.java
+++ b/src/test/java/chess/piece/RookTest.java
@@ -17,7 +17,7 @@ void Rook_canMove_Straight_Row() {
         Rook rook = new Rook();
 
         // when
-        boolean canMove = rook.canMove(A1, A8);
+        boolean canMove = rook.availablePath(A1, A8);
 
         // then
         assertThat(canMove).isTrue();
@@ -30,7 +30,7 @@ void Rook_canMove_Straight_Column() {
         Rook rook = new Rook();
 
         // when
-        boolean canMove = rook.canMove(A1, H1);
+        boolean canMove = rook.availablePath(A1, H1);
 
         // then
         assertThat(canMove).isTrue();
@@ -43,7 +43,7 @@ void Rook_cannotMove_when_notStraight() {
         Rook rook = new Rook();
 
         // when
-        boolean canMove = rook.canMove(A1, B2);
+        boolean canMove = rook.availablePath(A1, B2);
 
         // then
         assertThat(canMove).isFalse();

From c9885df617890c7319582e92afe79fe3037a289c Mon Sep 17 00:00:00 2001
From: YuyoungRhee <bbclara@naver.com>
Date: Sat, 22 Mar 2025 16:21:24 +0900
Subject: [PATCH 10/18] =?UTF-8?q?feat(Pawn):=20=ED=8F=B0=20=EC=9B=80?=
 =?UTF-8?q?=EC=A7=81=EC=9E=84=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/chess/TeamColor.java        |  8 +++
 src/main/java/chess/piece/Bishop.java     | 16 ++++-
 src/main/java/chess/piece/EmptyPiece.java | 31 +++++++++
 src/main/java/chess/piece/King.java       | 14 +++-
 src/main/java/chess/piece/Knight.java     | 15 ++++-
 src/main/java/chess/piece/Pawn.java       | 55 ++++++++++++++-
 src/main/java/chess/piece/Piece.java      | 10 ++-
 src/main/java/chess/piece/Queen.java      | 17 ++++-
 src/main/java/chess/piece/Rook.java       | 15 +++++
 src/test/java/chess/piece/BishopTest.java |  7 +-
 src/test/java/chess/piece/KingTest.java   |  5 +-
 src/test/java/chess/piece/KnightTest.java |  5 +-
 src/test/java/chess/piece/PawnTest.java   | 82 +++++++++++++++++++++++
 src/test/java/chess/piece/QueenTest.java  |  9 +--
 src/test/java/chess/piece/RookTest.java   |  9 +--
 15 files changed, 274 insertions(+), 24 deletions(-)
 create mode 100644 src/main/java/chess/TeamColor.java
 create mode 100644 src/main/java/chess/piece/EmptyPiece.java
 create mode 100644 src/test/java/chess/piece/PawnTest.java

diff --git a/src/main/java/chess/TeamColor.java b/src/main/java/chess/TeamColor.java
new file mode 100644
index 00000000000..cd68c81f60b
--- /dev/null
+++ b/src/main/java/chess/TeamColor.java
@@ -0,0 +1,8 @@
+package chess;
+
+public enum TeamColor {
+    WHITE,
+    BLACK,
+    NONE,
+    ;
+}
diff --git a/src/main/java/chess/piece/Bishop.java b/src/main/java/chess/piece/Bishop.java
index 2a73d0cdf14..f3da6e6f002 100644
--- a/src/main/java/chess/piece/Bishop.java
+++ b/src/main/java/chess/piece/Bishop.java
@@ -1,12 +1,16 @@
 package chess.piece;
 
-import chess.Movement;
 import chess.Position;
+import chess.TeamColor;
 import java.util.ArrayList;
 import java.util.List;
 
 public class Bishop extends Piece{
 
+    public Bishop(TeamColor teamColor) {
+        super(teamColor);
+    }
+
     @Override
     public boolean availablePath(Position start, Position target) {
         return start.onDiagonal(target);
@@ -27,4 +31,14 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
 
         return positions;
     }
+
+    @Override
+    public boolean canMove(Piece targetPiece, Position start, Position target) {
+        return false;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return false;
+    }
 }
diff --git a/src/main/java/chess/piece/EmptyPiece.java b/src/main/java/chess/piece/EmptyPiece.java
new file mode 100644
index 00000000000..4c47031176f
--- /dev/null
+++ b/src/main/java/chess/piece/EmptyPiece.java
@@ -0,0 +1,31 @@
+package chess.piece;
+
+import chess.Position;
+import chess.TeamColor;
+import java.util.List;
+
+public class EmptyPiece extends Piece{
+    public EmptyPiece() {
+        super(TeamColor.NONE);
+    }
+
+    @Override
+    public boolean availablePath(Position start, Position target) {
+        return false;
+    }
+
+    @Override
+    public List<Position> findAllRouteToTarget(Position start, Position target) {
+        return null;
+    }
+
+    @Override
+    public boolean canMove(Piece targetPiece, Position start, Position target) {
+        return false;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return true;
+    }
+}
diff --git a/src/main/java/chess/piece/King.java b/src/main/java/chess/piece/King.java
index 52615bc14f4..82bf3c2ed15 100644
--- a/src/main/java/chess/piece/King.java
+++ b/src/main/java/chess/piece/King.java
@@ -2,6 +2,7 @@
 
 import chess.Movement;
 import chess.Position;
+import chess.TeamColor;
 import java.util.List;
 
 public class King extends Piece{
@@ -17,7 +18,8 @@ public class King extends Piece{
 
     private final List<Movement> availableMovement;
 
-    public King() {
+    public King(TeamColor teamColor) {
+        super(teamColor);
         this.availableMovement = kingMovement;
     }
 
@@ -39,4 +41,14 @@ public boolean availablePath(Position start, Position target) {
     public List<Position> findAllRouteToTarget(Position start, Position target) {
         return List.of(target);
     }
+
+    @Override
+    public boolean canMove(Piece targetPiece, Position start, Position target) {
+        return false;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return false;
+    }
 }
diff --git a/src/main/java/chess/piece/Knight.java b/src/main/java/chess/piece/Knight.java
index c5c9957b612..551c4c84a7b 100644
--- a/src/main/java/chess/piece/Knight.java
+++ b/src/main/java/chess/piece/Knight.java
@@ -13,7 +13,7 @@
 import chess.Movement;
 import chess.Position;
 import chess.Row;
-import java.util.ArrayList;
+import chess.TeamColor;
 import java.util.List;
 
 public class Knight extends Piece{
@@ -30,7 +30,8 @@ public class Knight extends Piece{
 
     private final List<Movement> availableMovement;
 
-    public Knight() {
+    public Knight(TeamColor teamColor) {
+        super(teamColor);
         this.availableMovement = knightMovement;
     }
 
@@ -56,4 +57,14 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
         Position position = new Position(row, column);
         return List.of(position);
     }
+
+    @Override
+    public boolean canMove(Piece targetPiece, Position start, Position target) {
+        return false;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return false;
+    }
 }
diff --git a/src/main/java/chess/piece/Pawn.java b/src/main/java/chess/piece/Pawn.java
index c8b6cafa51e..c80b3775bfb 100644
--- a/src/main/java/chess/piece/Pawn.java
+++ b/src/main/java/chess/piece/Pawn.java
@@ -1,5 +1,58 @@
 package chess.piece;
 
-public class Pawn {
+import chess.Movement;
+import chess.Position;
+import chess.TeamColor;
+import java.util.List;
+
+public class Pawn extends Piece{
+    private final static Movement pawnMovement = Movement.UP;
+    private final static List<Movement> pawnTakeMovements =
+            List.of(Movement.LEFT_UP, Movement.RIGHT_UP);
+
+    Pawn(TeamColor teamColor) {
+        super(teamColor);
+    }
+
+
+    @Override
+    public boolean availablePath(Position start, Position target) {
+        return false;
+    }
+
+    @Override
+    public List<Position> findAllRouteToTarget(Position start, Position target) {
+        return List.of(target);
+    }
+
+    @Override
+    public boolean canMove(Piece targetPiece, Position start, Position target) {
+        if(targetPiece.isEmpty()) {
+            if(!start.canMoveUp(1)) {
+                return false;
+            }
+            Position moved = start.moveUp(1);
+            return moved.equals(target);
+        }
+
+        //적이 있을때
+        for (Movement takeMovement : pawnTakeMovements) {
+            if(!start.canMove(takeMovement)) {
+                continue;
+            }
+
+            Position moved = start.move(takeMovement);
+            if(moved.equals(target)){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return false;
+    }
+
 
 }
diff --git a/src/main/java/chess/piece/Piece.java b/src/main/java/chess/piece/Piece.java
index f84a1a59404..d2d8c941e13 100644
--- a/src/main/java/chess/piece/Piece.java
+++ b/src/main/java/chess/piece/Piece.java
@@ -1,14 +1,20 @@
 package chess.piece;
 
 import chess.Position;
+import chess.TeamColor;
 import java.util.List;
 
 public abstract class Piece {
+    private final TeamColor teamColor;
 
-    Piece() {
+    Piece(TeamColor teamColor) {
+        this.teamColor = teamColor;
     }
 
     public abstract boolean availablePath(Position start, Position target);
-
     public abstract List<Position> findAllRouteToTarget(Position start, Position target);
+
+    public abstract boolean canMove(Piece targetPiece, Position start, Position target);
+
+    public abstract boolean isEmpty();
 }
diff --git a/src/main/java/chess/piece/Queen.java b/src/main/java/chess/piece/Queen.java
index f65094735cf..bdfc1c512f2 100644
--- a/src/main/java/chess/piece/Queen.java
+++ b/src/main/java/chess/piece/Queen.java
@@ -1,13 +1,16 @@
 package chess.piece;
 
-import chess.Movement;
 import chess.Position;
+import chess.TeamColor;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
 
 public class Queen extends Piece {
 
+    public Queen(TeamColor teamColor) {
+        super(teamColor);
+    }
+
     @Override
     public boolean availablePath(Position start, Position target) {
         return start.onStraight(target) || start.onDiagonal(target);
@@ -45,4 +48,14 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
         return positions;
     }
 
+    @Override
+    public boolean canMove(Piece targetPiece, Position start, Position target) {
+        return false;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return false;
+    }
+
 }
diff --git a/src/main/java/chess/piece/Rook.java b/src/main/java/chess/piece/Rook.java
index f6b41809098..d3d22867fca 100644
--- a/src/main/java/chess/piece/Rook.java
+++ b/src/main/java/chess/piece/Rook.java
@@ -1,11 +1,16 @@
 package chess.piece;
 
 import chess.Position;
+import chess.TeamColor;
 import java.util.ArrayList;
 import java.util.List;
 
 public class Rook extends Piece {
 
+    public Rook(TeamColor teamColor) {
+        super(teamColor);
+    }
+
     @Override
     public boolean availablePath(Position start, Position target) {
         return start.onStraight(target);
@@ -37,4 +42,14 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
         return positions;
     }
 
+    @Override
+    public boolean canMove(Piece targetPiece, Position start, Position target) {
+        return false;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return false;
+    }
+
 }
diff --git a/src/test/java/chess/piece/BishopTest.java b/src/test/java/chess/piece/BishopTest.java
index 302aca28ed0..a67a9daa946 100644
--- a/src/test/java/chess/piece/BishopTest.java
+++ b/src/test/java/chess/piece/BishopTest.java
@@ -4,6 +4,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 import chess.Position;
+import chess.TeamColor;
 import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
@@ -14,7 +15,7 @@ class BishopTest {
     @Test
     void Bishop_canMove_diagonal() {
         // given
-        Bishop bishop = new Bishop();
+        Bishop bishop = new Bishop(TeamColor.BLACK);
 
         // when
         boolean canMove = bishop.availablePath(A1, B2);
@@ -27,7 +28,7 @@ void Bishop_canMove_diagonal() {
     @Test
     void Bishop_cannotMove_Straight() {
         // given
-        Bishop bishop = new Bishop();
+        Bishop bishop = new Bishop(TeamColor.BLACK);
 
         // when
         boolean canMove = bishop.availablePath(A1, A2);
@@ -40,7 +41,7 @@ void Bishop_cannotMove_Straight() {
     @Test
     void Bishop_findAllRoute() {
         // given
-        Bishop bishop = new Bishop();
+        Bishop bishop = new Bishop(TeamColor.BLACK);
 
         // when
         List<Position> routes = bishop.findAllRouteToTarget(A1, D4);
diff --git a/src/test/java/chess/piece/KingTest.java b/src/test/java/chess/piece/KingTest.java
index b718a936234..d4f5babbc13 100644
--- a/src/test/java/chess/piece/KingTest.java
+++ b/src/test/java/chess/piece/KingTest.java
@@ -4,6 +4,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 import chess.Position;
+import chess.TeamColor;
 import java.util.stream.Stream;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
@@ -22,7 +23,7 @@ static Stream<Position> provideKingMovesTo() {
     @MethodSource("provideKingMovesTo")
     void King_canMove_Left(Position target) {
         // given
-        King king = new King();
+        King king = new King(TeamColor.BLACK);
 
         // when
         boolean canMove = king.availablePath(B2, target);
@@ -34,7 +35,7 @@ void King_canMove_Left(Position target) {
     @DisplayName("킹이 이동할 수 없는 칸이면 false")
     @Test
     void King_cannotMove() {
-        King king = new King();
+        King king = new King(TeamColor.BLACK);
 
         // when
         boolean canMove = king.availablePath(B2, D2);
diff --git a/src/test/java/chess/piece/KnightTest.java b/src/test/java/chess/piece/KnightTest.java
index 793189b6cb7..fd8019a82d8 100644
--- a/src/test/java/chess/piece/KnightTest.java
+++ b/src/test/java/chess/piece/KnightTest.java
@@ -3,6 +3,7 @@
 import static chess.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
+import chess.TeamColor;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
@@ -12,7 +13,7 @@ class KnightTest {
     @Test
     void Horse_canMoveTest() {
         // given
-        Piece knight = new Knight();
+        Piece knight = new Knight(TeamColor.BLACK);
 
         // when
         boolean canMove = knight.availablePath(B1, C3);
@@ -27,7 +28,7 @@ void Horse_canMoveTest() {
     @Test
     void Horse_canMove_False() {
         // given
-        Piece knight = new Knight();
+        Piece knight = new Knight(TeamColor.BLACK);
 
         // when
         boolean canMove = knight.availablePath(B1, C2);
diff --git a/src/test/java/chess/piece/PawnTest.java b/src/test/java/chess/piece/PawnTest.java
new file mode 100644
index 00000000000..0102a80a983
--- /dev/null
+++ b/src/test/java/chess/piece/PawnTest.java
@@ -0,0 +1,82 @@
+package chess.piece;
+
+import static chess.Fixtures.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import chess.TeamColor;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class PawnTest {
+
+    @DisplayName("폰은 앞에 적이 없을 때, 앞으로 한 칸 이동할 수 있다.")
+    @Test
+    void Pawn_canMoveUp() {
+        // given
+        Pawn pawn = new Pawn(TeamColor.BLACK);
+        Piece targetPiece = new EmptyPiece();
+
+        // when
+        boolean canMove = pawn.canMove(targetPiece, A1, A2);
+
+        // then
+        assertThat(canMove).isTrue();
+    }
+
+    @DisplayName("폰은 앞에 적이 있으면, 앞으로 한 칸 이동할 수 없다.")
+    @Test
+    void Pawn_cannotMoveUp_whenExistEnemy() {
+        // given
+        Pawn pawn = new Pawn(TeamColor.BLACK);
+        Piece targetPiece = new Pawn(TeamColor.WHITE);
+
+        // when
+        boolean canMove = pawn.canMove(targetPiece, A1, A2);
+
+        // then
+        assertThat(canMove).isFalse();
+    }
+
+    @DisplayName("폰은 대각선에 적이 있으면 대각선 한칸 이동할 수 있다.")
+    @Test
+    void Pawn_canMoveDiagonal_whenExistEnemy() {
+        // given
+        Pawn pawn = new Pawn(TeamColor.BLACK);
+        Piece targetPiece = new Pawn(TeamColor.WHITE);
+
+        // when
+        boolean canMove = pawn.canMove(targetPiece, B1, C2);
+
+        // then
+        assertThat(canMove).isTrue();
+    }
+
+    @DisplayName("폰은 대각선에 적이 있으면 대각선 한칸 이동할 수 있다.")
+    @Test
+    void Pawn_canMoveDiagonal_whenExistEnemy2() {
+        // given
+        Pawn pawn = new Pawn(TeamColor.BLACK);
+        Piece targetPiece = new Pawn(TeamColor.WHITE);
+
+        // when
+        boolean canMove = pawn.canMove(targetPiece, B1, A2);
+
+        // then
+        assertThat(canMove).isTrue();
+    }
+
+    @DisplayName("폰은 대각선에 적이 없으면 대각선으로는 이동할 수 없다.")
+    @Test
+    void Pawn_cannotMoveDiagonal_whenEmptyTarget() {
+        // given
+        Pawn pawn = new Pawn(TeamColor.BLACK);
+        Piece targetPiece = new EmptyPiece();
+
+        // when
+        boolean canMove = pawn.canMove(targetPiece, B1, A2);
+
+        // then
+        assertThat(canMove).isFalse();
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/chess/piece/QueenTest.java b/src/test/java/chess/piece/QueenTest.java
index 46c6c7ee84e..338d4df8931 100644
--- a/src/test/java/chess/piece/QueenTest.java
+++ b/src/test/java/chess/piece/QueenTest.java
@@ -4,6 +4,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 import chess.Position;
+import chess.TeamColor;
 import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
@@ -14,7 +15,7 @@ class QueenTest {
     @Test
     void Queen_canMove_diagonal() {
         // given
-        Queen queen = new Queen();
+        Queen queen = new Queen(TeamColor.BLACK);
 
         // when
         boolean canMove = queen.availablePath(A1, C3);
@@ -27,7 +28,7 @@ void Queen_canMove_diagonal() {
     @Test
     void Queen_canMove_Straight() {
         // given
-        Queen queen = new Queen();
+        Queen queen = new Queen(TeamColor.BLACK);
 
         // when
         boolean canMove = queen.availablePath(A1, A3);
@@ -40,7 +41,7 @@ void Queen_canMove_Straight() {
     @Test
     void Queen_cannotMove() {
         // given
-        Queen queen = new Queen();
+        Queen queen = new Queen(TeamColor.BLACK);
 
         // when
         boolean canMove = queen.availablePath(A1, B3);
@@ -53,7 +54,7 @@ void Queen_cannotMove() {
     @Test
     void Queen_findAllRoute() {
         // given
-        Queen queen = new Queen();
+        Queen queen = new Queen(TeamColor.BLACK);
 
         // when
         List<Position> routes = queen.findAllRouteToTarget(D4, G7);
diff --git a/src/test/java/chess/piece/RookTest.java b/src/test/java/chess/piece/RookTest.java
index 15142bceaf8..4247cdd4e27 100644
--- a/src/test/java/chess/piece/RookTest.java
+++ b/src/test/java/chess/piece/RookTest.java
@@ -4,6 +4,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 import chess.Position;
+import chess.TeamColor;
 import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
@@ -14,7 +15,7 @@ class RookTest {
     @Test
     void Rook_canMove_Straight_Row() {
         // given
-        Rook rook = new Rook();
+        Rook rook = new Rook(TeamColor.BLACK);
 
         // when
         boolean canMove = rook.availablePath(A1, A8);
@@ -27,7 +28,7 @@ void Rook_canMove_Straight_Row() {
     @Test
     void Rook_canMove_Straight_Column() {
         // given
-        Rook rook = new Rook();
+        Rook rook = new Rook(TeamColor.BLACK);
 
         // when
         boolean canMove = rook.availablePath(A1, H1);
@@ -40,7 +41,7 @@ void Rook_canMove_Straight_Column() {
     @Test
     void Rook_cannotMove_when_notStraight() {
         // given
-        Rook rook = new Rook();
+        Rook rook = new Rook(TeamColor.BLACK);
 
         // when
         boolean canMove = rook.availablePath(A1, B2);
@@ -53,7 +54,7 @@ void Rook_cannotMove_when_notStraight() {
     @Test
     void Rook_findAllRoute() {
         // given
-        Rook rook = new Rook();
+        Rook rook = new Rook(TeamColor.BLACK);
 
         // when
         List<Position> routes = rook.findAllRouteToTarget(A1, A4);

From a675c1c107db25f546818e6789eb0bd6e11c20c4 Mon Sep 17 00:00:00 2001
From: YuyoungRhee <bbclara@naver.com>
Date: Sat, 22 Mar 2025 16:57:10 +0900
Subject: [PATCH 11/18] =?UTF-8?q?feat(ChessBoard):=20=EC=9B=80=EC=A7=81?=
 =?UTF-8?q?=EC=9E=84=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/chess/ChessBoard.java       | 87 +++++++++++++++++++++++
 src/main/java/chess/piece/Bishop.java     |  7 +-
 src/main/java/chess/piece/EmptyPiece.java | 10 ++-
 src/main/java/chess/piece/King.java       |  4 +-
 src/main/java/chess/piece/Knight.java     |  9 ++-
 src/main/java/chess/piece/Pawn.java       |  8 +--
 src/main/java/chess/piece/Piece.java      |  6 +-
 src/main/java/chess/piece/Queen.java      |  7 +-
 src/main/java/chess/piece/Rook.java       |  7 +-
 src/test/java/chess/ChessBoardTest.java   | 43 +++++++++++
 src/test/java/chess/piece/PawnTest.java   | 15 ++--
 11 files changed, 178 insertions(+), 25 deletions(-)
 create mode 100644 src/main/java/chess/ChessBoard.java
 create mode 100644 src/test/java/chess/ChessBoardTest.java

diff --git a/src/main/java/chess/ChessBoard.java b/src/main/java/chess/ChessBoard.java
new file mode 100644
index 00000000000..60eff1d929d
--- /dev/null
+++ b/src/main/java/chess/ChessBoard.java
@@ -0,0 +1,87 @@
+package chess;
+
+import chess.piece.Bishop;
+import chess.piece.EmptyPiece;
+import chess.piece.King;
+import chess.piece.Knight;
+import chess.piece.Pawn;
+import chess.piece.Piece;
+import chess.piece.Queen;
+import chess.piece.Rook;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ChessBoard {
+    private final Map<Position, Piece> board;
+
+    public ChessBoard(Map<Position, Piece> board) {
+        this.board = board;
+    }
+
+    public static ChessBoard createInitialBoard() {
+        Map<Position, Piece> piecePositionInfo = new HashMap<>();
+        for (Column col : Column.values()) {
+            piecePositionInfo.put(new Position(Row.TWO, col), new Pawn(TeamColor.WHITE));
+        }
+        piecePositionInfo.put(new Position(Row.ONE, Column.A), new Rook(TeamColor.WHITE));
+        piecePositionInfo.put(new Position(Row.ONE, Column.H), new Rook(TeamColor.WHITE));
+
+        piecePositionInfo.put(new Position(Row.ONE, Column.B), new Knight(TeamColor.WHITE));
+        piecePositionInfo.put(new Position(Row.ONE, Column.G), new Knight(TeamColor.WHITE));
+
+        piecePositionInfo.put(new Position(Row.ONE, Column.C), new Bishop(TeamColor.WHITE));
+        piecePositionInfo.put(new Position(Row.ONE, Column.F), new Bishop(TeamColor.WHITE));
+
+        piecePositionInfo.put(new Position(Row.ONE, Column.D), new Queen(TeamColor.WHITE));
+
+        piecePositionInfo.put(new Position(Row.ONE, Column.E), new King(TeamColor.WHITE));
+
+        // 흑 팀
+        for (Column col : Column.values()) {
+            piecePositionInfo.put(new Position(Row.SEVEN, col), new Pawn(TeamColor.BLACK));
+        }
+
+        piecePositionInfo.put(new Position(Row.EIGHT, Column.A), new Rook(TeamColor.BLACK));
+        piecePositionInfo.put(new Position(Row.EIGHT, Column.H), new Rook(TeamColor.BLACK));
+
+        piecePositionInfo.put(new Position(Row.EIGHT, Column.B), new Knight(TeamColor.BLACK));
+        piecePositionInfo.put(new Position(Row.EIGHT, Column.G), new Knight(TeamColor.BLACK));
+
+        piecePositionInfo.put(new Position(Row.EIGHT, Column.C), new Bishop(TeamColor.BLACK));
+        piecePositionInfo.put(new Position(Row.EIGHT, Column.F), new Bishop(TeamColor.BLACK));
+
+        piecePositionInfo.put(new Position(Row.EIGHT, Column.D), new Queen(TeamColor.BLACK));
+
+        piecePositionInfo.put(new Position(Row.EIGHT, Column.E), new King(TeamColor.BLACK));
+
+        return new ChessBoard(piecePositionInfo);
+    }
+
+
+    public Piece findPieceBy(Position position) {
+        return board.getOrDefault(position, EmptyPiece.getInstance());
+    }
+
+
+    public void move(Piece piece, Position start, Position target) {
+        boolean availablePath = piece.availablePath(start, target);
+        if (!availablePath) {
+            throw new IllegalArgumentException("이동할 수 없는 위치입니다.");
+        }
+
+        List<Position> routes = piece.findAllRouteToTarget(start, target);
+        List<Piece> piecesOnRoute = routes.stream()
+                .map(this::findPieceBy)
+                .toList();
+
+        boolean canMove = piece.canMove(piecesOnRoute, start, target);
+
+        if (!canMove) {
+            throw new IllegalArgumentException("이동할 수 없는 위치입니다.");
+        }
+
+        board.remove(start);
+        board.put(target, piece);
+    }
+}
diff --git a/src/main/java/chess/piece/Bishop.java b/src/main/java/chess/piece/Bishop.java
index f3da6e6f002..3c10467d876 100644
--- a/src/main/java/chess/piece/Bishop.java
+++ b/src/main/java/chess/piece/Bishop.java
@@ -33,8 +33,11 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
     }
 
     @Override
-    public boolean canMove(Piece targetPiece, Position start, Position target) {
-        return false;
+    public boolean canMove(List<Piece> piecesOnRoute, Position start, Position target) {
+        if(piecesOnRoute.size() != 1){
+            return false;
+        }
+        return piecesOnRoute.getLast().isEmpty() || this.isOtherTeam(piecesOnRoute.getLast());
     }
 
     @Override
diff --git a/src/main/java/chess/piece/EmptyPiece.java b/src/main/java/chess/piece/EmptyPiece.java
index 4c47031176f..993cde3534d 100644
--- a/src/main/java/chess/piece/EmptyPiece.java
+++ b/src/main/java/chess/piece/EmptyPiece.java
@@ -5,10 +5,16 @@
 import java.util.List;
 
 public class EmptyPiece extends Piece{
-    public EmptyPiece() {
+    private final static EmptyPiece INSTANCE = new EmptyPiece();
+
+    private EmptyPiece() {
         super(TeamColor.NONE);
     }
 
+    public static EmptyPiece getInstance() {
+        return INSTANCE;
+    }
+
     @Override
     public boolean availablePath(Position start, Position target) {
         return false;
@@ -20,7 +26,7 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
     }
 
     @Override
-    public boolean canMove(Piece targetPiece, Position start, Position target) {
+    public boolean canMove(List<Piece> piecesOnRoute, Position start, Position target) {
         return false;
     }
 
diff --git a/src/main/java/chess/piece/King.java b/src/main/java/chess/piece/King.java
index 82bf3c2ed15..a301a064254 100644
--- a/src/main/java/chess/piece/King.java
+++ b/src/main/java/chess/piece/King.java
@@ -43,8 +43,8 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
     }
 
     @Override
-    public boolean canMove(Piece targetPiece, Position start, Position target) {
-        return false;
+    public boolean canMove(List<Piece> piecesOnRoute, Position start, Position target) {
+        return piecesOnRoute.getLast().isEmpty() || this.isOtherTeam(piecesOnRoute.getLast());
     }
 
     @Override
diff --git a/src/main/java/chess/piece/Knight.java b/src/main/java/chess/piece/Knight.java
index 551c4c84a7b..feb15f5656a 100644
--- a/src/main/java/chess/piece/Knight.java
+++ b/src/main/java/chess/piece/Knight.java
@@ -55,12 +55,15 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
         Column column = Column.from((start.colValue() + target.colValue()) / 2);
 
         Position position = new Position(row, column);
-        return List.of(position);
+        return List.of(position, target);
     }
 
     @Override
-    public boolean canMove(Piece targetPiece, Position start, Position target) {
-        return false;
+    public boolean canMove(List<Piece> piecesOnRoute, Position start, Position target) {
+        boolean empty = piecesOnRoute.getLast().isEmpty();
+        boolean otherTeam = this.isOtherTeam(piecesOnRoute.getLast());
+
+        return piecesOnRoute.getLast().isEmpty() || this.isOtherTeam(piecesOnRoute.getLast());
     }
 
     @Override
diff --git a/src/main/java/chess/piece/Pawn.java b/src/main/java/chess/piece/Pawn.java
index c80b3775bfb..47dbfa3891c 100644
--- a/src/main/java/chess/piece/Pawn.java
+++ b/src/main/java/chess/piece/Pawn.java
@@ -10,14 +10,14 @@ public class Pawn extends Piece{
     private final static List<Movement> pawnTakeMovements =
             List.of(Movement.LEFT_UP, Movement.RIGHT_UP);
 
-    Pawn(TeamColor teamColor) {
+    public Pawn(TeamColor teamColor) {
         super(teamColor);
     }
 
 
     @Override
     public boolean availablePath(Position start, Position target) {
-        return false;
+        return true;
     }
 
     @Override
@@ -26,8 +26,8 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
     }
 
     @Override
-    public boolean canMove(Piece targetPiece, Position start, Position target) {
-        if(targetPiece.isEmpty()) {
+    public boolean canMove(List<Piece> piecesOnRoute, Position start, Position target) {
+        if(piecesOnRoute.getFirst().isEmpty()) {
             if(!start.canMoveUp(1)) {
                 return false;
             }
diff --git a/src/main/java/chess/piece/Piece.java b/src/main/java/chess/piece/Piece.java
index d2d8c941e13..b07e35eda2a 100644
--- a/src/main/java/chess/piece/Piece.java
+++ b/src/main/java/chess/piece/Piece.java
@@ -14,7 +14,11 @@ public abstract class Piece {
     public abstract boolean availablePath(Position start, Position target);
     public abstract List<Position> findAllRouteToTarget(Position start, Position target);
 
-    public abstract boolean canMove(Piece targetPiece, Position start, Position target);
+    public abstract boolean canMove(List<Piece> piecesOnRoute, Position start, Position target);
 
     public abstract boolean isEmpty();
+
+    public boolean isOtherTeam(Piece other) {
+        return this.teamColor != other.teamColor;
+    }
 }
diff --git a/src/main/java/chess/piece/Queen.java b/src/main/java/chess/piece/Queen.java
index bdfc1c512f2..ccbeb2444a1 100644
--- a/src/main/java/chess/piece/Queen.java
+++ b/src/main/java/chess/piece/Queen.java
@@ -49,8 +49,11 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
     }
 
     @Override
-    public boolean canMove(Piece targetPiece, Position start, Position target) {
-        return false;
+    public boolean canMove(List<Piece> piecesOnRoute, Position start, Position target) {
+        if(piecesOnRoute.size() != 1){
+            return false;
+        }
+        return piecesOnRoute.getLast().isEmpty() || this.isOtherTeam(piecesOnRoute.getLast());
     }
 
     @Override
diff --git a/src/main/java/chess/piece/Rook.java b/src/main/java/chess/piece/Rook.java
index d3d22867fca..1e92024247b 100644
--- a/src/main/java/chess/piece/Rook.java
+++ b/src/main/java/chess/piece/Rook.java
@@ -43,8 +43,11 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
     }
 
     @Override
-    public boolean canMove(Piece targetPiece, Position start, Position target) {
-        return false;
+    public boolean canMove(List<Piece> piecesOnRoute, Position start, Position target) {
+        if(piecesOnRoute.size() != 1){
+            return false;
+        }
+        return piecesOnRoute.getLast().isEmpty() || this.isOtherTeam(piecesOnRoute.getLast());
     }
 
     @Override
diff --git a/src/test/java/chess/ChessBoardTest.java b/src/test/java/chess/ChessBoardTest.java
new file mode 100644
index 00000000000..9dddf7a8162
--- /dev/null
+++ b/src/test/java/chess/ChessBoardTest.java
@@ -0,0 +1,43 @@
+package chess;
+
+import static chess.Fixtures.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import chess.piece.EmptyPiece;
+import chess.piece.Piece;
+import chess.piece.Rook;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class ChessBoardTest {
+
+    @DisplayName("체스판 초기화")
+    @Test
+    void check_ChessBoardInitialize() {
+        // given
+        ChessBoard board = ChessBoard.createInitialBoard();
+
+        // when
+        Piece piece = board.findPieceBy(A1);
+
+        // then
+        assertThat(piece).isInstanceOf(Rook.class);
+    }
+
+    @DisplayName("체스 움직임")
+    @Test
+    void move_onBoard() {
+        // given
+        ChessBoard board = ChessBoard.createInitialBoard();
+        Piece piece = board.findPieceBy(B1);
+
+        // when
+        board.move(piece, B1, C3);
+
+        // then
+        Piece movedPiece = board.findPieceBy(C3);
+        assertThat(movedPiece).isEqualTo(piece);
+        assertThat(board.findPieceBy(B1)).isEqualTo(EmptyPiece.getInstance());
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/chess/piece/PawnTest.java b/src/test/java/chess/piece/PawnTest.java
index 0102a80a983..b42650852dc 100644
--- a/src/test/java/chess/piece/PawnTest.java
+++ b/src/test/java/chess/piece/PawnTest.java
@@ -4,6 +4,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 import chess.TeamColor;
+import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
@@ -14,10 +15,10 @@ class PawnTest {
     void Pawn_canMoveUp() {
         // given
         Pawn pawn = new Pawn(TeamColor.BLACK);
-        Piece targetPiece = new EmptyPiece();
+        Piece targetPiece = EmptyPiece.getInstance();
 
         // when
-        boolean canMove = pawn.canMove(targetPiece, A1, A2);
+        boolean canMove = pawn.canMove(List.of(targetPiece), A1, A2);
 
         // then
         assertThat(canMove).isTrue();
@@ -31,7 +32,7 @@ void Pawn_cannotMoveUp_whenExistEnemy() {
         Piece targetPiece = new Pawn(TeamColor.WHITE);
 
         // when
-        boolean canMove = pawn.canMove(targetPiece, A1, A2);
+        boolean canMove = pawn.canMove(List.of(targetPiece), A1, A2);
 
         // then
         assertThat(canMove).isFalse();
@@ -45,7 +46,7 @@ void Pawn_canMoveDiagonal_whenExistEnemy() {
         Piece targetPiece = new Pawn(TeamColor.WHITE);
 
         // when
-        boolean canMove = pawn.canMove(targetPiece, B1, C2);
+        boolean canMove = pawn.canMove(List.of(targetPiece), B1, C2);
 
         // then
         assertThat(canMove).isTrue();
@@ -59,7 +60,7 @@ void Pawn_canMoveDiagonal_whenExistEnemy2() {
         Piece targetPiece = new Pawn(TeamColor.WHITE);
 
         // when
-        boolean canMove = pawn.canMove(targetPiece, B1, A2);
+        boolean canMove = pawn.canMove(List.of(targetPiece), B1, A2);
 
         // then
         assertThat(canMove).isTrue();
@@ -70,10 +71,10 @@ void Pawn_canMoveDiagonal_whenExistEnemy2() {
     void Pawn_cannotMoveDiagonal_whenEmptyTarget() {
         // given
         Pawn pawn = new Pawn(TeamColor.BLACK);
-        Piece targetPiece = new EmptyPiece();
+        Piece targetPiece = EmptyPiece.getInstance();
 
         // when
-        boolean canMove = pawn.canMove(targetPiece, B1, A2);
+        boolean canMove = pawn.canMove(List.of(targetPiece), B1, A2);
 
         // then
         assertThat(canMove).isFalse();

From c4f889e9da3b97a6e6a33389ec45ad726afdd1e1 Mon Sep 17 00:00:00 2001
From: YuyoungRhee <bbclara@naver.com>
Date: Sat, 22 Mar 2025 16:58:03 +0900
Subject: [PATCH 12/18] =?UTF-8?q?chore:=20=ED=8C=A8=ED=82=A4=EC=A7=80=20?=
 =?UTF-8?q?=EA=B5=AC=EC=A1=B0=20=EB=B3=80=EA=B2=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../chess/controller/ChessController.java     |  5 ++++
 .../java/chess/{ => domain}/ChessBoard.java   | 20 ++++++-------
 src/main/java/chess/{ => domain}/Color.java   |  2 +-
 src/main/java/chess/{ => domain}/Column.java  |  2 +-
 .../java/chess/{ => domain}/Movement.java     |  2 +-
 .../java/chess/{ => domain}/Position.java     |  2 +-
 src/main/java/chess/{ => domain}/Row.java     |  2 +-
 .../java/chess/{ => domain}/TeamColor.java    |  2 +-
 .../java/chess/{ => domain}/piece/Bishop.java |  6 ++--
 .../chess/{ => domain}/piece/EmptyPiece.java  |  6 ++--
 .../java/chess/{ => domain}/piece/King.java   |  8 +++---
 .../java/chess/{ => domain}/piece/Knight.java | 28 +++++++++----------
 .../java/chess/{ => domain}/piece/Pawn.java   |  8 +++---
 .../java/chess/{ => domain}/piece/Piece.java  |  6 ++--
 .../java/chess/{ => domain}/piece/Queen.java  |  6 ++--
 .../java/chess/{ => domain}/piece/Rook.java   |  6 ++--
 src/main/java/chess/view/InputView.java       |  4 +++
 src/main/java/chess/view/OutputView.java      | 16 +++++++++++
 src/test/java/chess/ChessBoardTest.java       |  7 +++--
 src/test/java/chess/ColumnTest.java           |  1 +
 src/test/java/chess/Fixtures.java             |  4 +++
 src/test/java/chess/PositionTest.java         |  2 ++
 src/test/java/chess/RowTest.java              |  1 +
 src/test/java/chess/piece/BishopTest.java     |  5 ++--
 src/test/java/chess/piece/KingTest.java       |  5 ++--
 src/test/java/chess/piece/KnightTest.java     |  4 ++-
 src/test/java/chess/piece/PawnTest.java       |  5 +++-
 src/test/java/chess/piece/QueenTest.java      |  5 ++--
 src/test/java/chess/piece/RookTest.java       |  5 ++--
 29 files changed, 109 insertions(+), 66 deletions(-)
 create mode 100644 src/main/java/chess/controller/ChessController.java
 rename src/main/java/chess/{ => domain}/ChessBoard.java (91%)
 rename src/main/java/chess/{ => domain}/Color.java (95%)
 rename src/main/java/chess/{ => domain}/Column.java (98%)
 rename src/main/java/chess/{ => domain}/Movement.java (97%)
 rename src/main/java/chess/{ => domain}/Position.java (99%)
 rename src/main/java/chess/{ => domain}/Row.java (98%)
 rename src/main/java/chess/{ => domain}/TeamColor.java (74%)
 rename src/main/java/chess/{ => domain}/piece/Bishop.java (93%)
 rename src/main/java/chess/{ => domain}/piece/EmptyPiece.java (88%)
 rename src/main/java/chess/{ => domain}/piece/King.java (92%)
 rename src/main/java/chess/{ => domain}/piece/Knight.java (74%)
 rename src/main/java/chess/{ => domain}/piece/Pawn.java (91%)
 rename src/main/java/chess/{ => domain}/piece/Piece.java (86%)
 rename src/main/java/chess/{ => domain}/piece/Queen.java (95%)
 rename src/main/java/chess/{ => domain}/piece/Rook.java (94%)
 create mode 100644 src/main/java/chess/view/InputView.java
 create mode 100644 src/main/java/chess/view/OutputView.java

diff --git a/src/main/java/chess/controller/ChessController.java b/src/main/java/chess/controller/ChessController.java
new file mode 100644
index 00000000000..ee7476dc668
--- /dev/null
+++ b/src/main/java/chess/controller/ChessController.java
@@ -0,0 +1,5 @@
+package chess.controller;
+
+public class ChessController {
+
+}
diff --git a/src/main/java/chess/ChessBoard.java b/src/main/java/chess/domain/ChessBoard.java
similarity index 91%
rename from src/main/java/chess/ChessBoard.java
rename to src/main/java/chess/domain/ChessBoard.java
index 60eff1d929d..d1a0a5e6dbc 100644
--- a/src/main/java/chess/ChessBoard.java
+++ b/src/main/java/chess/domain/ChessBoard.java
@@ -1,13 +1,13 @@
-package chess;
-
-import chess.piece.Bishop;
-import chess.piece.EmptyPiece;
-import chess.piece.King;
-import chess.piece.Knight;
-import chess.piece.Pawn;
-import chess.piece.Piece;
-import chess.piece.Queen;
-import chess.piece.Rook;
+package chess.domain;
+
+import chess.domain.piece.Bishop;
+import chess.domain.piece.EmptyPiece;
+import chess.domain.piece.King;
+import chess.domain.piece.Knight;
+import chess.domain.piece.Pawn;
+import chess.domain.piece.Piece;
+import chess.domain.piece.Queen;
+import chess.domain.piece.Rook;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
diff --git a/src/main/java/chess/Color.java b/src/main/java/chess/domain/Color.java
similarity index 95%
rename from src/main/java/chess/Color.java
rename to src/main/java/chess/domain/Color.java
index 55cd020b681..1a29e732d1a 100644
--- a/src/main/java/chess/Color.java
+++ b/src/main/java/chess/domain/Color.java
@@ -1,4 +1,4 @@
-package chess;
+package chess.domain;
 
 public enum Color {
 
diff --git a/src/main/java/chess/Column.java b/src/main/java/chess/domain/Column.java
similarity index 98%
rename from src/main/java/chess/Column.java
rename to src/main/java/chess/domain/Column.java
index 1ebd6088592..f8ae273ec39 100644
--- a/src/main/java/chess/Column.java
+++ b/src/main/java/chess/domain/Column.java
@@ -1,4 +1,4 @@
-package chess;
+package chess.domain;
 
 import java.util.Arrays;
 
diff --git a/src/main/java/chess/Movement.java b/src/main/java/chess/domain/Movement.java
similarity index 97%
rename from src/main/java/chess/Movement.java
rename to src/main/java/chess/domain/Movement.java
index e57c6e91bb9..07b5d153f67 100644
--- a/src/main/java/chess/Movement.java
+++ b/src/main/java/chess/domain/Movement.java
@@ -1,4 +1,4 @@
-package chess;
+package chess.domain;
 
 public enum Movement {
     UP(0, 1),
diff --git a/src/main/java/chess/Position.java b/src/main/java/chess/domain/Position.java
similarity index 99%
rename from src/main/java/chess/Position.java
rename to src/main/java/chess/domain/Position.java
index 5b792096495..f77b89e3046 100644
--- a/src/main/java/chess/Position.java
+++ b/src/main/java/chess/domain/Position.java
@@ -1,4 +1,4 @@
-package chess;
+package chess.domain;
 
 public record Position(
         Column column,
diff --git a/src/main/java/chess/Row.java b/src/main/java/chess/domain/Row.java
similarity index 98%
rename from src/main/java/chess/Row.java
rename to src/main/java/chess/domain/Row.java
index 0339d40782b..38f0651af76 100644
--- a/src/main/java/chess/Row.java
+++ b/src/main/java/chess/domain/Row.java
@@ -1,4 +1,4 @@
-package chess;
+package chess.domain;
 
 import java.util.Arrays;
 
diff --git a/src/main/java/chess/TeamColor.java b/src/main/java/chess/domain/TeamColor.java
similarity index 74%
rename from src/main/java/chess/TeamColor.java
rename to src/main/java/chess/domain/TeamColor.java
index cd68c81f60b..61c44cf61bb 100644
--- a/src/main/java/chess/TeamColor.java
+++ b/src/main/java/chess/domain/TeamColor.java
@@ -1,4 +1,4 @@
-package chess;
+package chess.domain;
 
 public enum TeamColor {
     WHITE,
diff --git a/src/main/java/chess/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java
similarity index 93%
rename from src/main/java/chess/piece/Bishop.java
rename to src/main/java/chess/domain/piece/Bishop.java
index 3c10467d876..ce0207bf59b 100644
--- a/src/main/java/chess/piece/Bishop.java
+++ b/src/main/java/chess/domain/piece/Bishop.java
@@ -1,7 +1,7 @@
-package chess.piece;
+package chess.domain.piece;
 
-import chess.Position;
-import chess.TeamColor;
+import chess.domain.Position;
+import chess.domain.TeamColor;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/src/main/java/chess/piece/EmptyPiece.java b/src/main/java/chess/domain/piece/EmptyPiece.java
similarity index 88%
rename from src/main/java/chess/piece/EmptyPiece.java
rename to src/main/java/chess/domain/piece/EmptyPiece.java
index 993cde3534d..f12a817ae79 100644
--- a/src/main/java/chess/piece/EmptyPiece.java
+++ b/src/main/java/chess/domain/piece/EmptyPiece.java
@@ -1,7 +1,7 @@
-package chess.piece;
+package chess.domain.piece;
 
-import chess.Position;
-import chess.TeamColor;
+import chess.domain.Position;
+import chess.domain.TeamColor;
 import java.util.List;
 
 public class EmptyPiece extends Piece{
diff --git a/src/main/java/chess/piece/King.java b/src/main/java/chess/domain/piece/King.java
similarity index 92%
rename from src/main/java/chess/piece/King.java
rename to src/main/java/chess/domain/piece/King.java
index a301a064254..59af60ae4e4 100644
--- a/src/main/java/chess/piece/King.java
+++ b/src/main/java/chess/domain/piece/King.java
@@ -1,8 +1,8 @@
-package chess.piece;
+package chess.domain.piece;
 
-import chess.Movement;
-import chess.Position;
-import chess.TeamColor;
+import chess.domain.Movement;
+import chess.domain.Position;
+import chess.domain.TeamColor;
 import java.util.List;
 
 public class King extends Piece{
diff --git a/src/main/java/chess/piece/Knight.java b/src/main/java/chess/domain/piece/Knight.java
similarity index 74%
rename from src/main/java/chess/piece/Knight.java
rename to src/main/java/chess/domain/piece/Knight.java
index feb15f5656a..1441dc689d6 100644
--- a/src/main/java/chess/piece/Knight.java
+++ b/src/main/java/chess/domain/piece/Knight.java
@@ -1,19 +1,19 @@
-package chess.piece;
+package chess.domain.piece;
 
-import static chess.Movement.DOWN_DOWN_LEFT;
-import static chess.Movement.DOWN_DOWN_RIGHT;
-import static chess.Movement.LEFT_LEFT_DOWN;
-import static chess.Movement.LEFT_LEFT_UP;
-import static chess.Movement.RIGHT_RIGHT_DOWN;
-import static chess.Movement.RIGHT_RIGHT_UP;
-import static chess.Movement.UP_UP_LEFT;
-import static chess.Movement.UP_UP_RIGHT;
+import static chess.domain.Movement.DOWN_DOWN_LEFT;
+import static chess.domain.Movement.DOWN_DOWN_RIGHT;
+import static chess.domain.Movement.LEFT_LEFT_DOWN;
+import static chess.domain.Movement.LEFT_LEFT_UP;
+import static chess.domain.Movement.RIGHT_RIGHT_DOWN;
+import static chess.domain.Movement.RIGHT_RIGHT_UP;
+import static chess.domain.Movement.UP_UP_LEFT;
+import static chess.domain.Movement.UP_UP_RIGHT;
 
-import chess.Column;
-import chess.Movement;
-import chess.Position;
-import chess.Row;
-import chess.TeamColor;
+import chess.domain.Column;
+import chess.domain.Movement;
+import chess.domain.Position;
+import chess.domain.Row;
+import chess.domain.TeamColor;
 import java.util.List;
 
 public class Knight extends Piece{
diff --git a/src/main/java/chess/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java
similarity index 91%
rename from src/main/java/chess/piece/Pawn.java
rename to src/main/java/chess/domain/piece/Pawn.java
index 47dbfa3891c..bb0cbf1a8c5 100644
--- a/src/main/java/chess/piece/Pawn.java
+++ b/src/main/java/chess/domain/piece/Pawn.java
@@ -1,8 +1,8 @@
-package chess.piece;
+package chess.domain.piece;
 
-import chess.Movement;
-import chess.Position;
-import chess.TeamColor;
+import chess.domain.Movement;
+import chess.domain.Position;
+import chess.domain.TeamColor;
 import java.util.List;
 
 public class Pawn extends Piece{
diff --git a/src/main/java/chess/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java
similarity index 86%
rename from src/main/java/chess/piece/Piece.java
rename to src/main/java/chess/domain/piece/Piece.java
index b07e35eda2a..0ecf51395ec 100644
--- a/src/main/java/chess/piece/Piece.java
+++ b/src/main/java/chess/domain/piece/Piece.java
@@ -1,7 +1,7 @@
-package chess.piece;
+package chess.domain.piece;
 
-import chess.Position;
-import chess.TeamColor;
+import chess.domain.Position;
+import chess.domain.TeamColor;
 import java.util.List;
 
 public abstract class Piece {
diff --git a/src/main/java/chess/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java
similarity index 95%
rename from src/main/java/chess/piece/Queen.java
rename to src/main/java/chess/domain/piece/Queen.java
index ccbeb2444a1..b674089868c 100644
--- a/src/main/java/chess/piece/Queen.java
+++ b/src/main/java/chess/domain/piece/Queen.java
@@ -1,7 +1,7 @@
-package chess.piece;
+package chess.domain.piece;
 
-import chess.Position;
-import chess.TeamColor;
+import chess.domain.Position;
+import chess.domain.TeamColor;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/src/main/java/chess/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java
similarity index 94%
rename from src/main/java/chess/piece/Rook.java
rename to src/main/java/chess/domain/piece/Rook.java
index 1e92024247b..4f5349c7a9a 100644
--- a/src/main/java/chess/piece/Rook.java
+++ b/src/main/java/chess/domain/piece/Rook.java
@@ -1,7 +1,7 @@
-package chess.piece;
+package chess.domain.piece;
 
-import chess.Position;
-import chess.TeamColor;
+import chess.domain.Position;
+import chess.domain.TeamColor;
 import java.util.ArrayList;
 import java.util.List;
 
diff --git a/src/main/java/chess/view/InputView.java b/src/main/java/chess/view/InputView.java
new file mode 100644
index 00000000000..d9666f96fdb
--- /dev/null
+++ b/src/main/java/chess/view/InputView.java
@@ -0,0 +1,4 @@
+package chess.view;
+
+public class InputView {
+}
diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java
new file mode 100644
index 00000000000..3dfaa4d0d31
--- /dev/null
+++ b/src/main/java/chess/view/OutputView.java
@@ -0,0 +1,16 @@
+package chess.view;
+
+import chess.domain.ChessBoard;
+import chess.domain.Column;
+import chess.domain.Row;
+
+public class OutputView {
+
+    public void displayBoard(ChessBoard board) {
+        for(Row row: Row.values()) {
+            for(Column column : Column.values()) {
+
+            }
+        }
+    }
+}
diff --git a/src/test/java/chess/ChessBoardTest.java b/src/test/java/chess/ChessBoardTest.java
index 9dddf7a8162..b512ea841a7 100644
--- a/src/test/java/chess/ChessBoardTest.java
+++ b/src/test/java/chess/ChessBoardTest.java
@@ -3,9 +3,10 @@
 import static chess.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
-import chess.piece.EmptyPiece;
-import chess.piece.Piece;
-import chess.piece.Rook;
+import chess.domain.ChessBoard;
+import chess.domain.piece.EmptyPiece;
+import chess.domain.piece.Piece;
+import chess.domain.piece.Rook;
 
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
diff --git a/src/test/java/chess/ColumnTest.java b/src/test/java/chess/ColumnTest.java
index e43523240f7..73225bfe923 100644
--- a/src/test/java/chess/ColumnTest.java
+++ b/src/test/java/chess/ColumnTest.java
@@ -1,5 +1,6 @@
 package chess;
 
+import chess.domain.Column;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
diff --git a/src/test/java/chess/Fixtures.java b/src/test/java/chess/Fixtures.java
index f940ab37137..c1b135539fd 100644
--- a/src/test/java/chess/Fixtures.java
+++ b/src/test/java/chess/Fixtures.java
@@ -1,5 +1,9 @@
 package chess;
 
+import chess.domain.Column;
+import chess.domain.Position;
+import chess.domain.Row;
+
 @SuppressWarnings("unused")
 public final class Fixtures {
 
diff --git a/src/test/java/chess/PositionTest.java b/src/test/java/chess/PositionTest.java
index 3ad7cc64084..031fdd196a9 100644
--- a/src/test/java/chess/PositionTest.java
+++ b/src/test/java/chess/PositionTest.java
@@ -1,5 +1,7 @@
 package chess;
 
+import chess.domain.Movement;
+import chess.domain.Position;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
diff --git a/src/test/java/chess/RowTest.java b/src/test/java/chess/RowTest.java
index fcb65485410..feeb0883429 100644
--- a/src/test/java/chess/RowTest.java
+++ b/src/test/java/chess/RowTest.java
@@ -1,5 +1,6 @@
 package chess;
 
+import chess.domain.Row;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
diff --git a/src/test/java/chess/piece/BishopTest.java b/src/test/java/chess/piece/BishopTest.java
index a67a9daa946..709e85d9ad8 100644
--- a/src/test/java/chess/piece/BishopTest.java
+++ b/src/test/java/chess/piece/BishopTest.java
@@ -3,8 +3,9 @@
 import static chess.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
-import chess.Position;
-import chess.TeamColor;
+import chess.domain.Position;
+import chess.domain.TeamColor;
+import chess.domain.piece.Bishop;
 import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
diff --git a/src/test/java/chess/piece/KingTest.java b/src/test/java/chess/piece/KingTest.java
index d4f5babbc13..42727b109d3 100644
--- a/src/test/java/chess/piece/KingTest.java
+++ b/src/test/java/chess/piece/KingTest.java
@@ -3,8 +3,9 @@
 import static chess.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
-import chess.Position;
-import chess.TeamColor;
+import chess.domain.Position;
+import chess.domain.TeamColor;
+import chess.domain.piece.King;
 import java.util.stream.Stream;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
diff --git a/src/test/java/chess/piece/KnightTest.java b/src/test/java/chess/piece/KnightTest.java
index fd8019a82d8..0c8456a8535 100644
--- a/src/test/java/chess/piece/KnightTest.java
+++ b/src/test/java/chess/piece/KnightTest.java
@@ -3,7 +3,9 @@
 import static chess.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
-import chess.TeamColor;
+import chess.domain.TeamColor;
+import chess.domain.piece.Knight;
+import chess.domain.piece.Piece;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
diff --git a/src/test/java/chess/piece/PawnTest.java b/src/test/java/chess/piece/PawnTest.java
index b42650852dc..ff5d9c7b3ef 100644
--- a/src/test/java/chess/piece/PawnTest.java
+++ b/src/test/java/chess/piece/PawnTest.java
@@ -3,7 +3,10 @@
 import static chess.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
-import chess.TeamColor;
+import chess.domain.TeamColor;
+import chess.domain.piece.EmptyPiece;
+import chess.domain.piece.Pawn;
+import chess.domain.piece.Piece;
 import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
diff --git a/src/test/java/chess/piece/QueenTest.java b/src/test/java/chess/piece/QueenTest.java
index 338d4df8931..5ef99cbda06 100644
--- a/src/test/java/chess/piece/QueenTest.java
+++ b/src/test/java/chess/piece/QueenTest.java
@@ -3,8 +3,9 @@
 import static chess.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
-import chess.Position;
-import chess.TeamColor;
+import chess.domain.Position;
+import chess.domain.TeamColor;
+import chess.domain.piece.Queen;
 import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
diff --git a/src/test/java/chess/piece/RookTest.java b/src/test/java/chess/piece/RookTest.java
index 4247cdd4e27..2d401c02874 100644
--- a/src/test/java/chess/piece/RookTest.java
+++ b/src/test/java/chess/piece/RookTest.java
@@ -3,8 +3,9 @@
 import static chess.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
-import chess.Position;
-import chess.TeamColor;
+import chess.domain.Position;
+import chess.domain.TeamColor;
+import chess.domain.piece.Rook;
 import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;

From 5badb87bfb4a48880fac67a7cd7812f71746ddb8 Mon Sep 17 00:00:00 2001
From: YuyoungRhee <bbclara@naver.com>
Date: Sat, 22 Mar 2025 16:58:24 +0900
Subject: [PATCH 13/18] =?UTF-8?q?chore:=20=ED=8C=A8=ED=82=A4=EC=A7=80=20?=
 =?UTF-8?q?=EA=B5=AC=EC=A1=B0=20=EB=B3=80=EA=B2=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../chess/{ => domain}/ChessBoardTest.java    |  5 +-
 .../java/chess/{ => domain}/ColumnTest.java   |  2 +-
 .../java/chess/{ => domain}/Fixtures.java     |  2 +-
 .../java/chess/{ => domain}/PositionTest.java | 50 +++++++++----------
 src/test/java/chess/{ => domain}/RowTest.java |  2 +-
 .../chess/{ => domain}/piece/BishopTest.java  |  5 +-
 .../chess/{ => domain}/piece/KingTest.java    |  5 +-
 .../chess/{ => domain}/piece/KnightTest.java  |  6 +--
 .../chess/{ => domain}/piece/PawnTest.java    |  7 +--
 .../chess/{ => domain}/piece/QueenTest.java   |  5 +-
 .../chess/{ => domain}/piece/RookTest.java    |  5 +-
 11 files changed, 41 insertions(+), 53 deletions(-)
 rename src/test/java/chess/{ => domain}/ChessBoardTest.java (92%)
 rename src/test/java/chess/{ => domain}/ColumnTest.java (99%)
 rename src/test/java/chess/{ => domain}/Fixtures.java (99%)
 rename src/test/java/chess/{ => domain}/PositionTest.java (92%)
 rename src/test/java/chess/{ => domain}/RowTest.java (99%)
 rename src/test/java/chess/{ => domain}/piece/BishopTest.java (93%)
 rename src/test/java/chess/{ => domain}/piece/KingTest.java (93%)
 rename src/test/java/chess/{ => domain}/piece/KnightTest.java (88%)
 rename src/test/java/chess/{ => domain}/piece/PawnTest.java (93%)
 rename src/test/java/chess/{ => domain}/piece/QueenTest.java (94%)
 rename src/test/java/chess/{ => domain}/piece/RookTest.java (95%)

diff --git a/src/test/java/chess/ChessBoardTest.java b/src/test/java/chess/domain/ChessBoardTest.java
similarity index 92%
rename from src/test/java/chess/ChessBoardTest.java
rename to src/test/java/chess/domain/ChessBoardTest.java
index b512ea841a7..f6e42ce10b6 100644
--- a/src/test/java/chess/ChessBoardTest.java
+++ b/src/test/java/chess/domain/ChessBoardTest.java
@@ -1,9 +1,8 @@
-package chess;
+package chess.domain;
 
-import static chess.Fixtures.*;
+import static chess.domain.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
-import chess.domain.ChessBoard;
 import chess.domain.piece.EmptyPiece;
 import chess.domain.piece.Piece;
 import chess.domain.piece.Rook;
diff --git a/src/test/java/chess/ColumnTest.java b/src/test/java/chess/domain/ColumnTest.java
similarity index 99%
rename from src/test/java/chess/ColumnTest.java
rename to src/test/java/chess/domain/ColumnTest.java
index 73225bfe923..88abeed5a31 100644
--- a/src/test/java/chess/ColumnTest.java
+++ b/src/test/java/chess/domain/ColumnTest.java
@@ -1,4 +1,4 @@
-package chess;
+package chess.domain;
 
 import chess.domain.Column;
 import org.junit.jupiter.api.DisplayName;
diff --git a/src/test/java/chess/Fixtures.java b/src/test/java/chess/domain/Fixtures.java
similarity index 99%
rename from src/test/java/chess/Fixtures.java
rename to src/test/java/chess/domain/Fixtures.java
index c1b135539fd..466fc3f74de 100644
--- a/src/test/java/chess/Fixtures.java
+++ b/src/test/java/chess/domain/Fixtures.java
@@ -1,4 +1,4 @@
-package chess;
+package chess.domain;
 
 import chess.domain.Column;
 import chess.domain.Position;
diff --git a/src/test/java/chess/PositionTest.java b/src/test/java/chess/domain/PositionTest.java
similarity index 92%
rename from src/test/java/chess/PositionTest.java
rename to src/test/java/chess/domain/PositionTest.java
index 031fdd196a9..271a33cca78 100644
--- a/src/test/java/chess/PositionTest.java
+++ b/src/test/java/chess/domain/PositionTest.java
@@ -1,7 +1,5 @@
-package chess;
+package chess.domain;
 
-import chess.domain.Movement;
-import chess.domain.Position;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -9,29 +7,29 @@
 
 import java.util.stream.Stream;
 
-import static chess.Fixtures.A1;
-import static chess.Fixtures.A2;
-import static chess.Fixtures.A3;
-import static chess.Fixtures.A6;
-import static chess.Fixtures.A7;
-import static chess.Fixtures.A8;
-import static chess.Fixtures.B1;
-import static chess.Fixtures.B2;
-import static chess.Fixtures.B3;
-import static chess.Fixtures.B7;
-import static chess.Fixtures.B8;
-import static chess.Fixtures.C1;
-import static chess.Fixtures.F1;
-import static chess.Fixtures.F8;
-import static chess.Fixtures.G1;
-import static chess.Fixtures.G2;
-import static chess.Fixtures.G6;
-import static chess.Fixtures.G7;
-import static chess.Fixtures.G8;
-import static chess.Fixtures.H1;
-import static chess.Fixtures.H2;
-import static chess.Fixtures.H7;
-import static chess.Fixtures.H8;
+import static chess.domain.Fixtures.A1;
+import static chess.domain.Fixtures.A2;
+import static chess.domain.Fixtures.A3;
+import static chess.domain.Fixtures.A6;
+import static chess.domain.Fixtures.A7;
+import static chess.domain.Fixtures.A8;
+import static chess.domain.Fixtures.B1;
+import static chess.domain.Fixtures.B2;
+import static chess.domain.Fixtures.B3;
+import static chess.domain.Fixtures.B7;
+import static chess.domain.Fixtures.B8;
+import static chess.domain.Fixtures.C1;
+import static chess.domain.Fixtures.F1;
+import static chess.domain.Fixtures.F8;
+import static chess.domain.Fixtures.G1;
+import static chess.domain.Fixtures.G2;
+import static chess.domain.Fixtures.G6;
+import static chess.domain.Fixtures.G7;
+import static chess.domain.Fixtures.G8;
+import static chess.domain.Fixtures.H1;
+import static chess.domain.Fixtures.H2;
+import static chess.domain.Fixtures.H7;
+import static chess.domain.Fixtures.H8;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
diff --git a/src/test/java/chess/RowTest.java b/src/test/java/chess/domain/RowTest.java
similarity index 99%
rename from src/test/java/chess/RowTest.java
rename to src/test/java/chess/domain/RowTest.java
index feeb0883429..7f015059bad 100644
--- a/src/test/java/chess/RowTest.java
+++ b/src/test/java/chess/domain/RowTest.java
@@ -1,4 +1,4 @@
-package chess;
+package chess.domain;
 
 import chess.domain.Row;
 import org.junit.jupiter.api.DisplayName;
diff --git a/src/test/java/chess/piece/BishopTest.java b/src/test/java/chess/domain/piece/BishopTest.java
similarity index 93%
rename from src/test/java/chess/piece/BishopTest.java
rename to src/test/java/chess/domain/piece/BishopTest.java
index 709e85d9ad8..38d415eae17 100644
--- a/src/test/java/chess/piece/BishopTest.java
+++ b/src/test/java/chess/domain/piece/BishopTest.java
@@ -1,11 +1,10 @@
-package chess.piece;
+package chess.domain.piece;
 
-import static chess.Fixtures.*;
+import static chess.domain.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import chess.domain.Position;
 import chess.domain.TeamColor;
-import chess.domain.piece.Bishop;
 import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
diff --git a/src/test/java/chess/piece/KingTest.java b/src/test/java/chess/domain/piece/KingTest.java
similarity index 93%
rename from src/test/java/chess/piece/KingTest.java
rename to src/test/java/chess/domain/piece/KingTest.java
index 42727b109d3..38066b10b9d 100644
--- a/src/test/java/chess/piece/KingTest.java
+++ b/src/test/java/chess/domain/piece/KingTest.java
@@ -1,11 +1,10 @@
-package chess.piece;
+package chess.domain.piece;
 
-import static chess.Fixtures.*;
+import static chess.domain.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import chess.domain.Position;
 import chess.domain.TeamColor;
-import chess.domain.piece.King;
 import java.util.stream.Stream;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
diff --git a/src/test/java/chess/piece/KnightTest.java b/src/test/java/chess/domain/piece/KnightTest.java
similarity index 88%
rename from src/test/java/chess/piece/KnightTest.java
rename to src/test/java/chess/domain/piece/KnightTest.java
index 0c8456a8535..fca52cb135e 100644
--- a/src/test/java/chess/piece/KnightTest.java
+++ b/src/test/java/chess/domain/piece/KnightTest.java
@@ -1,11 +1,9 @@
-package chess.piece;
+package chess.domain.piece;
 
-import static chess.Fixtures.*;
+import static chess.domain.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import chess.domain.TeamColor;
-import chess.domain.piece.Knight;
-import chess.domain.piece.Piece;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
diff --git a/src/test/java/chess/piece/PawnTest.java b/src/test/java/chess/domain/piece/PawnTest.java
similarity index 93%
rename from src/test/java/chess/piece/PawnTest.java
rename to src/test/java/chess/domain/piece/PawnTest.java
index ff5d9c7b3ef..2765c5860db 100644
--- a/src/test/java/chess/piece/PawnTest.java
+++ b/src/test/java/chess/domain/piece/PawnTest.java
@@ -1,12 +1,9 @@
-package chess.piece;
+package chess.domain.piece;
 
-import static chess.Fixtures.*;
+import static chess.domain.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import chess.domain.TeamColor;
-import chess.domain.piece.EmptyPiece;
-import chess.domain.piece.Pawn;
-import chess.domain.piece.Piece;
 import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
diff --git a/src/test/java/chess/piece/QueenTest.java b/src/test/java/chess/domain/piece/QueenTest.java
similarity index 94%
rename from src/test/java/chess/piece/QueenTest.java
rename to src/test/java/chess/domain/piece/QueenTest.java
index 5ef99cbda06..5b3f7af5bd5 100644
--- a/src/test/java/chess/piece/QueenTest.java
+++ b/src/test/java/chess/domain/piece/QueenTest.java
@@ -1,11 +1,10 @@
-package chess.piece;
+package chess.domain.piece;
 
-import static chess.Fixtures.*;
+import static chess.domain.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import chess.domain.Position;
 import chess.domain.TeamColor;
-import chess.domain.piece.Queen;
 import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
diff --git a/src/test/java/chess/piece/RookTest.java b/src/test/java/chess/domain/piece/RookTest.java
similarity index 95%
rename from src/test/java/chess/piece/RookTest.java
rename to src/test/java/chess/domain/piece/RookTest.java
index 2d401c02874..e85ca60dedb 100644
--- a/src/test/java/chess/piece/RookTest.java
+++ b/src/test/java/chess/domain/piece/RookTest.java
@@ -1,11 +1,10 @@
-package chess.piece;
+package chess.domain.piece;
 
-import static chess.Fixtures.*;
+import static chess.domain.Fixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import chess.domain.Position;
 import chess.domain.TeamColor;
-import chess.domain.piece.Rook;
 import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;

From 7779e1e800589e0006f98e0198e5f4b2d4050178 Mon Sep 17 00:00:00 2001
From: YuyoungRhee <bbclara@naver.com>
Date: Sat, 22 Mar 2025 18:47:52 +0900
Subject: [PATCH 14/18] =?UTF-8?q?feat:=20=ED=9D=91=ED=8C=80=20=EC=9B=80?=
 =?UTF-8?q?=EC=A7=81=EC=9E=84=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/chess/Application.java          | 16 +++++++
 .../chess/controller/ChessController.java     | 45 +++++++++++++++++++
 src/main/java/chess/domain/ChessBoard.java    |  4 +-
 src/main/java/chess/domain/Column.java        | 27 +++++++----
 src/main/java/chess/domain/TeamColor.java     | 16 +++++--
 .../java/chess/domain/game/BlackTurn.java     | 32 +++++++++++++
 .../java/chess/domain/game/ChessGame.java     | 25 +++++++++++
 src/main/java/chess/domain/game/Turn.java     | 12 +++++
 .../java/chess/domain/game/WhiteTurn.java     | 32 +++++++++++++
 src/main/java/chess/domain/piece/Bishop.java  |  2 +-
 .../java/chess/domain/piece/EmptyPiece.java   |  2 +-
 src/main/java/chess/domain/piece/King.java    |  2 +-
 src/main/java/chess/domain/piece/Knight.java  |  2 +-
 src/main/java/chess/domain/piece/Pawn.java    | 25 ++++++++---
 src/main/java/chess/domain/piece/Piece.java   |  8 +++-
 .../java/chess/domain/piece/PieceType.java    | 14 ++++++
 src/main/java/chess/domain/piece/Queen.java   |  2 +-
 src/main/java/chess/domain/piece/Rook.java    |  2 +-
 src/main/java/chess/view/InputView.java       | 15 +++++++
 src/main/java/chess/view/OutputView.java      | 15 ++++++-
 src/main/java/chess/view/PieceTypeView.java   | 38 ++++++++++++++++
 .../java/chess/domain/ChessBoardTest.java     |  2 +-
 22 files changed, 310 insertions(+), 28 deletions(-)
 create mode 100644 src/main/java/chess/Application.java
 create mode 100644 src/main/java/chess/domain/game/BlackTurn.java
 create mode 100644 src/main/java/chess/domain/game/ChessGame.java
 create mode 100644 src/main/java/chess/domain/game/Turn.java
 create mode 100644 src/main/java/chess/domain/game/WhiteTurn.java
 create mode 100644 src/main/java/chess/domain/piece/PieceType.java
 create mode 100644 src/main/java/chess/view/PieceTypeView.java

diff --git a/src/main/java/chess/Application.java b/src/main/java/chess/Application.java
new file mode 100644
index 00000000000..117e6ef42e8
--- /dev/null
+++ b/src/main/java/chess/Application.java
@@ -0,0 +1,16 @@
+package chess;
+
+import chess.controller.ChessController;
+import chess.domain.ChessBoard;
+import chess.view.InputView;
+import chess.view.OutputView;
+
+public class Application {
+    public static void main(String[] args) {
+        InputView inputView = new InputView();
+        OutputView outputView = new OutputView();
+
+        ChessController chessController = new ChessController(inputView, outputView);
+        chessController.play();
+    }
+}
diff --git a/src/main/java/chess/controller/ChessController.java b/src/main/java/chess/controller/ChessController.java
index ee7476dc668..2ea2942aa40 100644
--- a/src/main/java/chess/controller/ChessController.java
+++ b/src/main/java/chess/controller/ChessController.java
@@ -1,5 +1,50 @@
 package chess.controller;
 
+import chess.domain.ChessBoard;
+import chess.domain.Column;
+import chess.domain.Position;
+import chess.domain.Row;
+import chess.domain.game.ChessGame;
+import chess.domain.game.WhiteTurn;
+import chess.view.InputView;
+import chess.view.OutputView;
+
 public class ChessController {
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public ChessController(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void play() {
+        ChessBoard board = ChessBoard.createInitialBoard();
+        outputView.displayBoard(board);
+
+        ChessGame game = new ChessGame(new WhiteTurn(board));
+
+        while (!game.isFinished()) {
+            String[] command = inputView.readMoveCommand(game.getTurnColor().getTeamName());
+            String startInput = command[0];
+            String targetInput = command[1];
+
+            Position start = stringToPosition(startInput);
+            Position target = stringToPosition(targetInput);
+
+            game.move(start, target);
+            outputView.displayBoard(board);
+        }
+
+    }
+
+    private Position stringToPosition(String input) {
+        char col = input.charAt(0);
+        Column column = Column.from(col);
+        char rowChar = input.charAt(1);
+        int rowNum = Integer.parseInt(String.valueOf(rowChar));
+        Row row = Row.from(rowNum);
 
+        return new Position(row, column);
+    }
 }
diff --git a/src/main/java/chess/domain/ChessBoard.java b/src/main/java/chess/domain/ChessBoard.java
index d1a0a5e6dbc..00f4ae2bf3a 100644
--- a/src/main/java/chess/domain/ChessBoard.java
+++ b/src/main/java/chess/domain/ChessBoard.java
@@ -64,7 +64,9 @@ public Piece findPieceBy(Position position) {
     }
 
 
-    public void move(Piece piece, Position start, Position target) {
+    public void move(Position start, Position target) {
+        Piece piece = findPieceBy(start);
+
         boolean availablePath = piece.availablePath(start, target);
         if (!availablePath) {
             throw new IllegalArgumentException("이동할 수 없는 위치입니다.");
diff --git a/src/main/java/chess/domain/Column.java b/src/main/java/chess/domain/Column.java
index f8ae273ec39..91273a0ed98 100644
--- a/src/main/java/chess/domain/Column.java
+++ b/src/main/java/chess/domain/Column.java
@@ -4,19 +4,21 @@
 
 public enum Column {
 
-    A(1),
-    B(2),
-    C(3),
-    D(4),
-    E(5),
-    F(6),
-    G(7),
-    H(8);
+    A(1, 'a'),
+    B(2, 'b'),
+    C(3, 'c'),
+    D(4, 'd'),
+    E(5, 'e'),
+    F(6, 'f'),
+    G(7, 'g'),
+    H(8, 'h');
 
     private final int value;
+    private final char charValue;
 
-    Column(int value) {
+    Column(int value, char charValue) {
         this.value = value;
+        this.charValue = charValue;
     }
 
     public static Column from(int value) {
@@ -26,6 +28,13 @@ public static Column from(int value) {
                 .orElseThrow();
     }
 
+    public static Column from(char charValue) {
+        return Arrays.stream(Column.values())
+                .filter(col -> col.charValue == charValue)
+                .findAny()
+                .orElseThrow();
+    }
+
     public boolean isFarLeft() {
         return ordinal() == 0;
     }
diff --git a/src/main/java/chess/domain/TeamColor.java b/src/main/java/chess/domain/TeamColor.java
index 61c44cf61bb..db65f29adcc 100644
--- a/src/main/java/chess/domain/TeamColor.java
+++ b/src/main/java/chess/domain/TeamColor.java
@@ -1,8 +1,18 @@
 package chess.domain;
 
 public enum TeamColor {
-    WHITE,
-    BLACK,
-    NONE,
+    WHITE("백팀"),
+    BLACK("흑팀"),
+    NONE("X"),
     ;
+
+    private final String teamName;
+
+    TeamColor(String teamName) {
+        this.teamName = teamName;
+    }
+
+    public String getTeamName() {
+        return teamName;
+    }
 }
diff --git a/src/main/java/chess/domain/game/BlackTurn.java b/src/main/java/chess/domain/game/BlackTurn.java
new file mode 100644
index 00000000000..e7f59dced08
--- /dev/null
+++ b/src/main/java/chess/domain/game/BlackTurn.java
@@ -0,0 +1,32 @@
+package chess.domain.game;
+
+import chess.domain.ChessBoard;
+import chess.domain.Position;
+import chess.domain.TeamColor;
+
+public class BlackTurn implements Turn{
+    private final ChessBoard board;
+    private final TeamColor turnColor;
+
+    public BlackTurn(ChessBoard board) {
+        this.board = board;
+        this.turnColor = TeamColor.BLACK;
+    }
+
+    @Override
+    public Turn movePiece(Position start, Position target) {
+        board.move(start, target);
+
+        return new WhiteTurn(board);
+    }
+
+    @Override
+    public TeamColor getTeamColor() {
+        return turnColor;
+    }
+
+    @Override
+    public boolean isFinished() {
+        return false;
+    }
+}
diff --git a/src/main/java/chess/domain/game/ChessGame.java b/src/main/java/chess/domain/game/ChessGame.java
new file mode 100644
index 00000000000..1b9951f896f
--- /dev/null
+++ b/src/main/java/chess/domain/game/ChessGame.java
@@ -0,0 +1,25 @@
+package chess.domain.game;
+
+import chess.domain.Position;
+import chess.domain.TeamColor;
+import chess.domain.piece.PieceType;
+
+public class ChessGame {
+    public ChessGame(Turn turn) {
+        this.turn = turn;
+    }
+
+    private Turn turn;
+
+    public void move( Position start, Position target) {
+        this.turn = turn.movePiece(start, target);
+    }
+
+    public TeamColor getTurnColor() {
+        return turn.getTeamColor();
+    }
+
+    public boolean isFinished() {
+        return turn.isFinished();
+    }
+}
diff --git a/src/main/java/chess/domain/game/Turn.java b/src/main/java/chess/domain/game/Turn.java
new file mode 100644
index 00000000000..adb735403fa
--- /dev/null
+++ b/src/main/java/chess/domain/game/Turn.java
@@ -0,0 +1,12 @@
+package chess.domain.game;
+
+import chess.domain.Position;
+import chess.domain.TeamColor;
+
+public interface Turn {
+    Turn movePiece(Position start, Position target);
+
+    TeamColor getTeamColor();
+
+    boolean isFinished();
+}
diff --git a/src/main/java/chess/domain/game/WhiteTurn.java b/src/main/java/chess/domain/game/WhiteTurn.java
new file mode 100644
index 00000000000..f1c75de0a6a
--- /dev/null
+++ b/src/main/java/chess/domain/game/WhiteTurn.java
@@ -0,0 +1,32 @@
+package chess.domain.game;
+
+import chess.domain.ChessBoard;
+import chess.domain.Position;
+import chess.domain.TeamColor;
+
+public class WhiteTurn implements Turn{
+    private final ChessBoard board;
+    private final TeamColor turnColor;
+
+    public WhiteTurn(ChessBoard board) {
+        this.board = board;
+        this.turnColor = TeamColor.WHITE;
+    }
+
+    @Override
+    public Turn movePiece(Position start, Position target) {
+        board.move(start, target);
+
+        return new BlackTurn(board);
+    }
+
+    @Override
+    public TeamColor getTeamColor() {
+        return turnColor;
+    }
+
+    @Override
+    public boolean isFinished() {
+        return false;
+    }
+}
diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java
index ce0207bf59b..f9fc83020e0 100644
--- a/src/main/java/chess/domain/piece/Bishop.java
+++ b/src/main/java/chess/domain/piece/Bishop.java
@@ -8,7 +8,7 @@
 public class Bishop extends Piece{
 
     public Bishop(TeamColor teamColor) {
-        super(teamColor);
+        super(teamColor, PieceType.BISHOP);
     }
 
     @Override
diff --git a/src/main/java/chess/domain/piece/EmptyPiece.java b/src/main/java/chess/domain/piece/EmptyPiece.java
index f12a817ae79..75cdeb5a3c4 100644
--- a/src/main/java/chess/domain/piece/EmptyPiece.java
+++ b/src/main/java/chess/domain/piece/EmptyPiece.java
@@ -8,7 +8,7 @@ public class EmptyPiece extends Piece{
     private final static EmptyPiece INSTANCE = new EmptyPiece();
 
     private EmptyPiece() {
-        super(TeamColor.NONE);
+        super(TeamColor.NONE, PieceType.NONE);
     }
 
     public static EmptyPiece getInstance() {
diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java
index 59af60ae4e4..9ff0634a496 100644
--- a/src/main/java/chess/domain/piece/King.java
+++ b/src/main/java/chess/domain/piece/King.java
@@ -19,7 +19,7 @@ public class King extends Piece{
     private final List<Movement> availableMovement;
 
     public King(TeamColor teamColor) {
-        super(teamColor);
+        super(teamColor, PieceType.KING);
         this.availableMovement = kingMovement;
     }
 
diff --git a/src/main/java/chess/domain/piece/Knight.java b/src/main/java/chess/domain/piece/Knight.java
index 1441dc689d6..b241555c5a6 100644
--- a/src/main/java/chess/domain/piece/Knight.java
+++ b/src/main/java/chess/domain/piece/Knight.java
@@ -31,7 +31,7 @@ public class Knight extends Piece{
     private final List<Movement> availableMovement;
 
     public Knight(TeamColor teamColor) {
-        super(teamColor);
+        super(teamColor, PieceType.KNIGHT);
         this.availableMovement = knightMovement;
     }
 
diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java
index bb0cbf1a8c5..6d01908314c 100644
--- a/src/main/java/chess/domain/piece/Pawn.java
+++ b/src/main/java/chess/domain/piece/Pawn.java
@@ -2,16 +2,17 @@
 
 import chess.domain.Movement;
 import chess.domain.Position;
+import chess.domain.Row;
 import chess.domain.TeamColor;
 import java.util.List;
 
-public class Pawn extends Piece{
+public class Pawn extends Piece {
     private final static Movement pawnMovement = Movement.UP;
     private final static List<Movement> pawnTakeMovements =
             List.of(Movement.LEFT_UP, Movement.RIGHT_UP);
 
     public Pawn(TeamColor teamColor) {
-        super(teamColor);
+        super(teamColor, PieceType.PAWN);
     }
 
 
@@ -27,8 +28,20 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
 
     @Override
     public boolean canMove(List<Piece> piecesOnRoute, Position start, Position target) {
-        if(piecesOnRoute.getFirst().isEmpty()) {
-            if(!start.canMoveUp(1)) {
+
+        if (target.rowValue() - start.rowValue() == 2) {
+            if (!start.canMoveUp(2)) {
+                return false;
+            }
+            if (start.row() != Row.TWO) {
+                return false;
+            }
+            Position moved = start.moveUp(2);
+            return moved.equals(target);
+        }
+
+        if (piecesOnRoute.getLast().isEmpty()) {
+            if (!start.canMoveUp(1)) {
                 return false;
             }
             Position moved = start.moveUp(1);
@@ -37,12 +50,12 @@ public boolean canMove(List<Piece> piecesOnRoute, Position start, Position targe
 
         //적이 있을때
         for (Movement takeMovement : pawnTakeMovements) {
-            if(!start.canMove(takeMovement)) {
+            if (!start.canMove(takeMovement)) {
                 continue;
             }
 
             Position moved = start.move(takeMovement);
-            if(moved.equals(target)){
+            if (moved.equals(target)) {
                 return true;
             }
         }
diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java
index 0ecf51395ec..fcda3ab2de1 100644
--- a/src/main/java/chess/domain/piece/Piece.java
+++ b/src/main/java/chess/domain/piece/Piece.java
@@ -6,9 +6,11 @@
 
 public abstract class Piece {
     private final TeamColor teamColor;
+    private final PieceType pieceType;
 
-    Piece(TeamColor teamColor) {
+    Piece(TeamColor teamColor, PieceType pieceType) {
         this.teamColor = teamColor;
+        this.pieceType = pieceType;
     }
 
     public abstract boolean availablePath(Position start, Position target);
@@ -21,4 +23,8 @@ public abstract class Piece {
     public boolean isOtherTeam(Piece other) {
         return this.teamColor != other.teamColor;
     }
+
+    public PieceType getPieceType() {
+        return pieceType;
+    }
 }
diff --git a/src/main/java/chess/domain/piece/PieceType.java b/src/main/java/chess/domain/piece/PieceType.java
new file mode 100644
index 00000000000..6aff483fdfe
--- /dev/null
+++ b/src/main/java/chess/domain/piece/PieceType.java
@@ -0,0 +1,14 @@
+package chess.domain.piece;
+
+public enum PieceType {
+    PAWN,
+    BISHOP,
+    KING,
+    KNIGHT,
+    QUEEN,
+    ROOK,
+    HORSE,
+    NONE,
+    ;
+
+}
diff --git a/src/main/java/chess/domain/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java
index b674089868c..6114c41b37e 100644
--- a/src/main/java/chess/domain/piece/Queen.java
+++ b/src/main/java/chess/domain/piece/Queen.java
@@ -8,7 +8,7 @@
 public class Queen extends Piece {
 
     public Queen(TeamColor teamColor) {
-        super(teamColor);
+        super(teamColor, PieceType.QUEEN);
     }
 
     @Override
diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java
index 4f5349c7a9a..37da4d32acc 100644
--- a/src/main/java/chess/domain/piece/Rook.java
+++ b/src/main/java/chess/domain/piece/Rook.java
@@ -8,7 +8,7 @@
 public class Rook extends Piece {
 
     public Rook(TeamColor teamColor) {
-        super(teamColor);
+        super(teamColor, PieceType.ROOK);
     }
 
     @Override
diff --git a/src/main/java/chess/view/InputView.java b/src/main/java/chess/view/InputView.java
index d9666f96fdb..f754db84325 100644
--- a/src/main/java/chess/view/InputView.java
+++ b/src/main/java/chess/view/InputView.java
@@ -1,4 +1,19 @@
 package chess.view;
 
+import chess.domain.TeamColor;
+import java.util.List;
+import java.util.Scanner;
+
 public class InputView {
+    private final Scanner scanner = new Scanner(System.in);
+
+    public String[] readMoveCommand(String teamName) {
+        System.out.println(teamName + " 차례입니다.");
+        System.out.println("이동 명령을 입력해주세요.");
+        System.out.println("형식: 시작위치 목적위치 ex) b1 b3");
+
+        String input = scanner.nextLine();
+
+        return input.split(" ");
+    }
 }
diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java
index 3dfaa4d0d31..ea6cd73fc10 100644
--- a/src/main/java/chess/view/OutputView.java
+++ b/src/main/java/chess/view/OutputView.java
@@ -2,15 +2,28 @@
 
 import chess.domain.ChessBoard;
 import chess.domain.Column;
+import chess.domain.Position;
 import chess.domain.Row;
+import chess.domain.piece.Piece;
+import chess.domain.piece.PieceType;
 
 public class OutputView {
 
     public void displayBoard(ChessBoard board) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("   a b c d e f g h \n");
         for(Row row: Row.values()) {
+            sb.append(row.intValue() + "| ");
             for(Column column : Column.values()) {
-
+                Piece piece = board.findPieceBy(new Position(row, column));
+                PieceType pieceType = piece.getPieceType();
+                PieceTypeView pieceTypeView = PieceTypeView.from(pieceType);
+                sb.append(pieceTypeView.getPieceNameBy(pieceType) + " ");
             }
+            sb.append(System.lineSeparator());
         }
+
+        sb.append("   a b c d e f g h \n");
+        System.out.println(sb);
     }
 }
diff --git a/src/main/java/chess/view/PieceTypeView.java b/src/main/java/chess/view/PieceTypeView.java
new file mode 100644
index 00000000000..e60a03a4249
--- /dev/null
+++ b/src/main/java/chess/view/PieceTypeView.java
@@ -0,0 +1,38 @@
+package chess.view;
+
+import chess.domain.piece.PieceType;
+import java.util.Arrays;
+
+public enum PieceTypeView {
+    PAWN(PieceType.PAWN, "P"),
+    BISHOP(PieceType.BISHOP, "B"),
+    KING(PieceType.KING, "K"),
+    KNIGHT(PieceType.KNIGHT, "N"),
+    QUEEN(PieceType.QUEEN, "Q"),
+    ROOK(PieceType.ROOK, "R"),
+    HORSE(PieceType.HORSE, "H"),
+    NONE(PieceType.NONE, "."),
+    ;
+
+    private final PieceType pieceType;
+    private final String pieceName;
+
+    PieceTypeView(PieceType pieceType, String pieceName) {
+        this.pieceType = pieceType;
+        this.pieceName = pieceName;
+    }
+
+    public static PieceTypeView from(PieceType pieceType) {
+        return Arrays.stream(PieceTypeView.values())
+                .filter(pieceTypeView -> pieceTypeView.pieceType == pieceType)
+                .findAny()
+                .orElse(NONE);
+    }
+    public  String getPieceNameBy(PieceType pieceType) {
+        return Arrays.stream(PieceTypeView.values())
+                .filter(pieceTypeView -> pieceTypeView.pieceType == pieceType)
+                .findAny()
+                .orElse(NONE)
+                .pieceName;
+    }
+}
diff --git a/src/test/java/chess/domain/ChessBoardTest.java b/src/test/java/chess/domain/ChessBoardTest.java
index f6e42ce10b6..5091c503094 100644
--- a/src/test/java/chess/domain/ChessBoardTest.java
+++ b/src/test/java/chess/domain/ChessBoardTest.java
@@ -33,7 +33,7 @@ void move_onBoard() {
         Piece piece = board.findPieceBy(B1);
 
         // when
-        board.move(piece, B1, C3);
+        board.move(B1, C3);
 
         // then
         Piece movedPiece = board.findPieceBy(C3);

From be817fa04de17eb50af4bc33bcdfc41f0ac12c12 Mon Sep 17 00:00:00 2001
From: YuyoungRhee <bbclara@naver.com>
Date: Sat, 22 Mar 2025 19:00:19 +0900
Subject: [PATCH 15/18] =?UTF-8?q?feat(Pawn):=20=EC=B2=98=EC=9D=8C=20?=
 =?UTF-8?q?=EB=91=90=EC=B9=B8=20=EC=9D=B4=EB=8F=99=20=EA=B0=80=EB=8A=A5=20?=
 =?UTF-8?q?=EA=B8=B0=EB=8A=A5=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/chess/domain/piece/Pawn.java  | 21 +++++++++++++--------
 src/main/java/chess/domain/piece/Piece.java | 14 ++++++++++++--
 2 files changed, 25 insertions(+), 10 deletions(-)

diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java
index 6d01908314c..d4369992e0b 100644
--- a/src/main/java/chess/domain/piece/Pawn.java
+++ b/src/main/java/chess/domain/piece/Pawn.java
@@ -29,26 +29,31 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
     @Override
     public boolean canMove(List<Piece> piecesOnRoute, Position start, Position target) {
 
-        if (target.rowValue() - start.rowValue() == 2) {
-            if (!start.canMoveUp(2)) {
+        // 백팀은 2번 행에서 시작하고 위로 이동
+        int direction = (teamColor == TeamColor.WHITE) ? 1 : -1;
+
+        // 두 칸 전진 가능
+        if (target.rowValue() - start.rowValue() == 2 * direction) {
+            if (!start.canMoveUp(2 * direction)) {
                 return false;
             }
-            if (start.row() != Row.TWO) {
+            if(moveCount != 0) {
                 return false;
             }
-            Position moved = start.moveUp(2);
+            Position moved = start.moveUp(2 * direction);
             return moved.equals(target);
         }
 
-        if (piecesOnRoute.getLast().isEmpty()) {
-            if (!start.canMoveUp(1)) {
+        // 한 칸 전진 가능
+        if (piecesOnRoute.isEmpty()) {
+            if (!start.canMoveUp(1 * direction)) {
                 return false;
             }
-            Position moved = start.moveUp(1);
+            Position moved = start.moveUp(1 * direction);
             return moved.equals(target);
         }
 
-        //적이 있을때
+        // 적이 있을 때
         for (Movement takeMovement : pawnTakeMovements) {
             if (!start.canMove(takeMovement)) {
                 continue;
diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java
index fcda3ab2de1..6b32e2f2189 100644
--- a/src/main/java/chess/domain/piece/Piece.java
+++ b/src/main/java/chess/domain/piece/Piece.java
@@ -5,8 +5,9 @@
 import java.util.List;
 
 public abstract class Piece {
-    private final TeamColor teamColor;
-    private final PieceType pieceType;
+    final TeamColor teamColor;
+    final PieceType pieceType;
+    int moveCount;
 
     Piece(TeamColor teamColor, PieceType pieceType) {
         this.teamColor = teamColor;
@@ -14,6 +15,7 @@ public abstract class Piece {
     }
 
     public abstract boolean availablePath(Position start, Position target);
+
     public abstract List<Position> findAllRouteToTarget(Position start, Position target);
 
     public abstract boolean canMove(List<Piece> piecesOnRoute, Position start, Position target);
@@ -27,4 +29,12 @@ public boolean isOtherTeam(Piece other) {
     public PieceType getPieceType() {
         return pieceType;
     }
+
+    public TeamColor getTeamColor() {
+        return teamColor;
+    }
+
+    public void incrementMoveCount() {
+        moveCount++;
+    }
 }

From d90bdae04aa7f2605bfa01ace535ccc143ac1256 Mon Sep 17 00:00:00 2001
From: YuyoungRhee <bbclara@naver.com>
Date: Sat, 22 Mar 2025 19:02:28 +0900
Subject: [PATCH 16/18] =?UTF-8?q?feat:=20=ED=8C=80=20=EC=83=89=EA=B9=94?=
 =?UTF-8?q?=EB=B3=84=EB=A1=9C=20=EA=B8=B0=EB=AC=BC=20=EC=B6=9C=EB=A0=A5?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/chess/domain/game/ChessGame.java     |  2 +-
 src/main/java/chess/view/OutputView.java      | 21 ++++++++++++++++---
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/src/main/java/chess/domain/game/ChessGame.java b/src/main/java/chess/domain/game/ChessGame.java
index 1b9951f896f..6af135e44c1 100644
--- a/src/main/java/chess/domain/game/ChessGame.java
+++ b/src/main/java/chess/domain/game/ChessGame.java
@@ -2,7 +2,7 @@
 
 import chess.domain.Position;
 import chess.domain.TeamColor;
-import chess.domain.piece.PieceType;
+
 
 public class ChessGame {
     public ChessGame(Turn turn) {
diff --git a/src/main/java/chess/view/OutputView.java b/src/main/java/chess/view/OutputView.java
index ea6cd73fc10..3188251fbf5 100644
--- a/src/main/java/chess/view/OutputView.java
+++ b/src/main/java/chess/view/OutputView.java
@@ -4,18 +4,21 @@
 import chess.domain.Column;
 import chess.domain.Position;
 import chess.domain.Row;
+import chess.domain.TeamColor;
 import chess.domain.piece.Piece;
 import chess.domain.piece.PieceType;
 
 public class OutputView {
+    private static final String defaultColor = "\033[0m";
 
     public void displayBoard(ChessBoard board) {
         StringBuilder sb = new StringBuilder();
-        sb.append("   a b c d e f g h \n");
+        sb.append("\033[36m" + "   a b c d e f g h \n");
         for(Row row: Row.values()) {
-            sb.append(row.intValue() + "| ");
+            sb.append("\033[36m" + row.intValue() + "| ");
             for(Column column : Column.values()) {
                 Piece piece = board.findPieceBy(new Position(row, column));
+                sb.append(colorString(piece.getTeamColor()));
                 PieceType pieceType = piece.getPieceType();
                 PieceTypeView pieceTypeView = PieceTypeView.from(pieceType);
                 sb.append(pieceTypeView.getPieceNameBy(pieceType) + " ");
@@ -23,7 +26,19 @@ public void displayBoard(ChessBoard board) {
             sb.append(System.lineSeparator());
         }
 
-        sb.append("   a b c d e f g h \n");
+        sb.append("\033[36m" + "   a b c d e f g h \n " + defaultColor);
         System.out.println(sb);
+
+    }
+
+    public String colorString(TeamColor teamColor) {
+        if(teamColor == TeamColor.BLACK) {
+            return "\033[30m";
+        }
+        if(teamColor == TeamColor.WHITE) {
+            return "\033[97m";
+        }
+
+        return "\033[33m";
     }
 }

From 02e3062b2d22563e81b8362ad05f2c09e4e703af Mon Sep 17 00:00:00 2001
From: YuyoungRhee <bbclara@naver.com>
Date: Sat, 22 Mar 2025 19:10:49 +0900
Subject: [PATCH 17/18] =?UTF-8?q?feat:=20=EC=9E=90=EC=8B=A0=EC=9D=98=20?=
 =?UTF-8?q?=EA=B8=B0=EB=AC=BC=EC=9D=B4=20=EC=95=84=EB=8B=8C=20=EA=B2=83?=
 =?UTF-8?q?=EC=9D=80=20=EC=9B=80=EC=A7=81=EC=9D=B4=EC=A7=80=20=EB=AA=BB?=
 =?UTF-8?q?=ED=95=98=EB=8F=84=EB=A1=9D=20=EA=B2=80=EC=A6=9D=20=EC=B6=94?=
 =?UTF-8?q?=EA=B0=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../chess/controller/ChessController.java     | 18 +++++++++++-
 .../java/chess/domain/game/BlackTurn.java     | 10 +++++++
 src/main/java/chess/domain/game/Finished.java | 28 +++++++++++++++++++
 .../java/chess/domain/game/WhiteTurn.java     | 11 +++++++-
 src/main/java/chess/domain/piece/Bishop.java  |  5 ++++
 .../java/chess/domain/piece/EmptyPiece.java   |  5 ++++
 src/main/java/chess/domain/piece/King.java    |  5 ++++
 src/main/java/chess/domain/piece/Knight.java  |  5 ++++
 src/main/java/chess/domain/piece/Pawn.java    |  5 ++++
 src/main/java/chess/domain/piece/Piece.java   |  6 ++++
 src/main/java/chess/domain/piece/Queen.java   |  5 ++++
 src/main/java/chess/domain/piece/Rook.java    |  5 ++++
 12 files changed, 106 insertions(+), 2 deletions(-)
 create mode 100644 src/main/java/chess/domain/game/Finished.java

diff --git a/src/main/java/chess/controller/ChessController.java b/src/main/java/chess/controller/ChessController.java
index 2ea2942aa40..cde22225997 100644
--- a/src/main/java/chess/controller/ChessController.java
+++ b/src/main/java/chess/controller/ChessController.java
@@ -25,6 +25,13 @@ public void play() {
         ChessGame game = new ChessGame(new WhiteTurn(board));
 
         while (!game.isFinished()) {
+            playTurn(game, board);
+        }
+
+    }
+
+    private void playTurn(ChessGame game, ChessBoard board) {
+        progressWithReturn(() -> {
             String[] command = inputView.readMoveCommand(game.getTurnColor().getTeamName());
             String startInput = command[0];
             String targetInput = command[1];
@@ -34,8 +41,17 @@ public void play() {
 
             game.move(start, target);
             outputView.displayBoard(board);
-        }
+        });
+    }
 
+    private void progressWithReturn(Runnable runnable) {
+        while(true) {
+            try {
+                runnable.run();
+            } catch (Exception e) {
+                System.out.println("[Error] " + e.getMessage());
+            }
+        }
     }
 
     private Position stringToPosition(String input) {
diff --git a/src/main/java/chess/domain/game/BlackTurn.java b/src/main/java/chess/domain/game/BlackTurn.java
index e7f59dced08..4cb19c2aba5 100644
--- a/src/main/java/chess/domain/game/BlackTurn.java
+++ b/src/main/java/chess/domain/game/BlackTurn.java
@@ -3,6 +3,7 @@
 import chess.domain.ChessBoard;
 import chess.domain.Position;
 import chess.domain.TeamColor;
+import chess.domain.piece.Piece;
 
 public class BlackTurn implements Turn{
     private final ChessBoard board;
@@ -15,7 +16,16 @@ public BlackTurn(ChessBoard board) {
 
     @Override
     public Turn movePiece(Position start, Position target) {
+        Piece startPiece = board.findPieceBy(start);
+        if(startPiece.isOtherTeamColor(turnColor)) {
+            throw new IllegalArgumentException("자신의 기물이 아닙니다.");
+        }
+
+        Piece targetPiece = board.findPieceBy(target);
         board.move(start, target);
+        if(targetPiece.isKing()) {
+            return new Finished(turnColor);
+        }
 
         return new WhiteTurn(board);
     }
diff --git a/src/main/java/chess/domain/game/Finished.java b/src/main/java/chess/domain/game/Finished.java
new file mode 100644
index 00000000000..825ad7081e5
--- /dev/null
+++ b/src/main/java/chess/domain/game/Finished.java
@@ -0,0 +1,28 @@
+package chess.domain.game;
+
+import chess.domain.Position;
+import chess.domain.TeamColor;
+
+public class Finished implements Turn{
+    public Finished(TeamColor winnerColor) {
+        this.winnerColor = winnerColor;
+    }
+
+    private final TeamColor winnerColor;
+
+
+    @Override
+    public Turn movePiece(Position start, Position target) {
+        return null;
+    }
+
+    @Override
+    public TeamColor getTeamColor() {
+        return null;
+    }
+
+    @Override
+    public boolean isFinished() {
+        return true;
+    }
+}
diff --git a/src/main/java/chess/domain/game/WhiteTurn.java b/src/main/java/chess/domain/game/WhiteTurn.java
index f1c75de0a6a..77faeba6729 100644
--- a/src/main/java/chess/domain/game/WhiteTurn.java
+++ b/src/main/java/chess/domain/game/WhiteTurn.java
@@ -3,6 +3,7 @@
 import chess.domain.ChessBoard;
 import chess.domain.Position;
 import chess.domain.TeamColor;
+import chess.domain.piece.Piece;
 
 public class WhiteTurn implements Turn{
     private final ChessBoard board;
@@ -15,11 +16,19 @@ public WhiteTurn(ChessBoard board) {
 
     @Override
     public Turn movePiece(Position start, Position target) {
+        Piece startPiece = board.findPieceBy(start);
+        if(startPiece.isOtherTeamColor(turnColor)) {
+            throw new IllegalArgumentException("자신의 기물이 아닙니다.");
+        }
+
+        Piece targetPiece = board.findPieceBy(target);
         board.move(start, target);
+        if(targetPiece.isKing()) {
+            return new Finished(turnColor);
+        }
 
         return new BlackTurn(board);
     }
-
     @Override
     public TeamColor getTeamColor() {
         return turnColor;
diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java
index f9fc83020e0..4b9d8a823ae 100644
--- a/src/main/java/chess/domain/piece/Bishop.java
+++ b/src/main/java/chess/domain/piece/Bishop.java
@@ -44,4 +44,9 @@ public boolean canMove(List<Piece> piecesOnRoute, Position start, Position targe
     public boolean isEmpty() {
         return false;
     }
+
+    @Override
+    public boolean isKing() {
+        return false;
+    }
 }
diff --git a/src/main/java/chess/domain/piece/EmptyPiece.java b/src/main/java/chess/domain/piece/EmptyPiece.java
index 75cdeb5a3c4..2c2f7348a90 100644
--- a/src/main/java/chess/domain/piece/EmptyPiece.java
+++ b/src/main/java/chess/domain/piece/EmptyPiece.java
@@ -34,4 +34,9 @@ public boolean canMove(List<Piece> piecesOnRoute, Position start, Position targe
     public boolean isEmpty() {
         return true;
     }
+
+    @Override
+    public boolean isKing() {
+        return false;
+    }
 }
diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java
index 9ff0634a496..6ed2c13db07 100644
--- a/src/main/java/chess/domain/piece/King.java
+++ b/src/main/java/chess/domain/piece/King.java
@@ -51,4 +51,9 @@ public boolean canMove(List<Piece> piecesOnRoute, Position start, Position targe
     public boolean isEmpty() {
         return false;
     }
+
+    @Override
+    public boolean isKing() {
+        return true;
+    }
 }
diff --git a/src/main/java/chess/domain/piece/Knight.java b/src/main/java/chess/domain/piece/Knight.java
index b241555c5a6..fba418d40f8 100644
--- a/src/main/java/chess/domain/piece/Knight.java
+++ b/src/main/java/chess/domain/piece/Knight.java
@@ -70,4 +70,9 @@ public boolean canMove(List<Piece> piecesOnRoute, Position start, Position targe
     public boolean isEmpty() {
         return false;
     }
+
+    @Override
+    public boolean isKing() {
+        return false;
+    }
 }
diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java
index d4369992e0b..b5058f7a8a5 100644
--- a/src/main/java/chess/domain/piece/Pawn.java
+++ b/src/main/java/chess/domain/piece/Pawn.java
@@ -72,5 +72,10 @@ public boolean isEmpty() {
         return false;
     }
 
+    @Override
+    public boolean isKing() {
+        return false;
+    }
+
 
 }
diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java
index 6b32e2f2189..9e1d10a676d 100644
--- a/src/main/java/chess/domain/piece/Piece.java
+++ b/src/main/java/chess/domain/piece/Piece.java
@@ -37,4 +37,10 @@ public TeamColor getTeamColor() {
     public void incrementMoveCount() {
         moveCount++;
     }
+
+    public boolean isOtherTeamColor(TeamColor teamColor) {
+        return this.teamColor != teamColor;
+    }
+
+    public abstract boolean isKing();
 }
diff --git a/src/main/java/chess/domain/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java
index 6114c41b37e..9a3903db7ed 100644
--- a/src/main/java/chess/domain/piece/Queen.java
+++ b/src/main/java/chess/domain/piece/Queen.java
@@ -61,4 +61,9 @@ public boolean isEmpty() {
         return false;
     }
 
+    @Override
+    public boolean isKing() {
+        return false;
+    }
+
 }
diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java
index 37da4d32acc..54d2ba6edf2 100644
--- a/src/main/java/chess/domain/piece/Rook.java
+++ b/src/main/java/chess/domain/piece/Rook.java
@@ -55,4 +55,9 @@ public boolean isEmpty() {
         return false;
     }
 
+    @Override
+    public boolean isKing() {
+        return false;
+    }
+
 }

From 53e2b096df3b10f0829db8c7bbe4e208e097b590 Mon Sep 17 00:00:00 2001
From: YuyoungRhee <bbclara@naver.com>
Date: Sat, 22 Mar 2025 19:23:20 +0900
Subject: [PATCH 18/18] =?UTF-8?q?fix:=20=EA=B8=B0=EB=AC=BC=20=EC=9D=B4?=
 =?UTF-8?q?=EB=8F=99=20=EC=98=A4=EB=A5=98=20=EC=88=98=EC=A0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/chess/domain/ChessBoard.java       |  2 ++
 src/main/java/chess/domain/piece/Bishop.java     |  6 +++---
 src/main/java/chess/domain/piece/EmptyPiece.java |  2 +-
 src/main/java/chess/domain/piece/King.java       |  4 ++--
 src/main/java/chess/domain/piece/Knight.java     |  7 ++-----
 src/main/java/chess/domain/piece/Pawn.java       | 13 +++++++++----
 src/main/java/chess/domain/piece/Piece.java      |  8 +++++++-
 src/main/java/chess/domain/piece/Queen.java      |  6 +++---
 src/main/java/chess/domain/piece/Rook.java       |  6 +++---
 src/test/java/chess/domain/piece/PawnTest.java   |  4 ++--
 10 files changed, 34 insertions(+), 24 deletions(-)

diff --git a/src/main/java/chess/domain/ChessBoard.java b/src/main/java/chess/domain/ChessBoard.java
index 00f4ae2bf3a..e50845f4341 100644
--- a/src/main/java/chess/domain/ChessBoard.java
+++ b/src/main/java/chess/domain/ChessBoard.java
@@ -85,5 +85,7 @@ public void move(Position start, Position target) {
 
         board.remove(start);
         board.put(target, piece);
+
+        piece.incrementMoveCount();
     }
 }
diff --git a/src/main/java/chess/domain/piece/Bishop.java b/src/main/java/chess/domain/piece/Bishop.java
index 4b9d8a823ae..ae63cd23af1 100644
--- a/src/main/java/chess/domain/piece/Bishop.java
+++ b/src/main/java/chess/domain/piece/Bishop.java
@@ -34,14 +34,14 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
 
     @Override
     public boolean canMove(List<Piece> piecesOnRoute, Position start, Position target) {
-        if(piecesOnRoute.size() != 1){
+        if(countPieceOnRoute(piecesOnRoute) != 0){
             return false;
         }
-        return piecesOnRoute.getLast().isEmpty() || this.isOtherTeam(piecesOnRoute.getLast());
+        return piecesOnRoute.getLast().isEmptyPiece() || this.isOtherTeam(piecesOnRoute.getLast());
     }
 
     @Override
-    public boolean isEmpty() {
+    public boolean isEmptyPiece() {
         return false;
     }
 
diff --git a/src/main/java/chess/domain/piece/EmptyPiece.java b/src/main/java/chess/domain/piece/EmptyPiece.java
index 2c2f7348a90..8adee08f1a6 100644
--- a/src/main/java/chess/domain/piece/EmptyPiece.java
+++ b/src/main/java/chess/domain/piece/EmptyPiece.java
@@ -31,7 +31,7 @@ public boolean canMove(List<Piece> piecesOnRoute, Position start, Position targe
     }
 
     @Override
-    public boolean isEmpty() {
+    public boolean isEmptyPiece() {
         return true;
     }
 
diff --git a/src/main/java/chess/domain/piece/King.java b/src/main/java/chess/domain/piece/King.java
index 6ed2c13db07..8df5acb8d88 100644
--- a/src/main/java/chess/domain/piece/King.java
+++ b/src/main/java/chess/domain/piece/King.java
@@ -44,11 +44,11 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
 
     @Override
     public boolean canMove(List<Piece> piecesOnRoute, Position start, Position target) {
-        return piecesOnRoute.getLast().isEmpty() || this.isOtherTeam(piecesOnRoute.getLast());
+        return piecesOnRoute.getLast().isEmptyPiece() || this.isOtherTeam(piecesOnRoute.getLast());
     }
 
     @Override
-    public boolean isEmpty() {
+    public boolean isEmptyPiece() {
         return false;
     }
 
diff --git a/src/main/java/chess/domain/piece/Knight.java b/src/main/java/chess/domain/piece/Knight.java
index fba418d40f8..f1f25eefe63 100644
--- a/src/main/java/chess/domain/piece/Knight.java
+++ b/src/main/java/chess/domain/piece/Knight.java
@@ -60,14 +60,11 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
 
     @Override
     public boolean canMove(List<Piece> piecesOnRoute, Position start, Position target) {
-        boolean empty = piecesOnRoute.getLast().isEmpty();
-        boolean otherTeam = this.isOtherTeam(piecesOnRoute.getLast());
-
-        return piecesOnRoute.getLast().isEmpty() || this.isOtherTeam(piecesOnRoute.getLast());
+        return piecesOnRoute.getLast().isEmptyPiece() || this.isOtherTeam(piecesOnRoute.getLast());
     }
 
     @Override
-    public boolean isEmpty() {
+    public boolean isEmptyPiece() {
         return false;
     }
 
diff --git a/src/main/java/chess/domain/piece/Pawn.java b/src/main/java/chess/domain/piece/Pawn.java
index b5058f7a8a5..97b920a239b 100644
--- a/src/main/java/chess/domain/piece/Pawn.java
+++ b/src/main/java/chess/domain/piece/Pawn.java
@@ -29,7 +29,6 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
     @Override
     public boolean canMove(List<Piece> piecesOnRoute, Position start, Position target) {
 
-        // 백팀은 2번 행에서 시작하고 위로 이동
         int direction = (teamColor == TeamColor.WHITE) ? 1 : -1;
 
         // 두 칸 전진 가능
@@ -38,14 +37,17 @@ public boolean canMove(List<Piece> piecesOnRoute, Position start, Position targe
                 return false;
             }
             if(moveCount != 0) {
-                return false;
+                throw new IllegalArgumentException("폰은 처음에만 두 칸을 이동할 수 있습니다.");
             }
             Position moved = start.moveUp(2 * direction);
             return moved.equals(target);
         }
 
+        if(piecesOnRoute.size() != 1) {
+            return false;
+        }
         // 한 칸 전진 가능
-        if (piecesOnRoute.isEmpty()) {
+        if (piecesOnRoute.getLast().isEmptyPiece()) {
             if (!start.canMoveUp(1 * direction)) {
                 return false;
             }
@@ -55,6 +57,9 @@ public boolean canMove(List<Piece> piecesOnRoute, Position start, Position targe
 
         // 적이 있을 때
         for (Movement takeMovement : pawnTakeMovements) {
+            if (!this.isOtherTeam(piecesOnRoute.getLast())) {
+                return false;
+            }
             if (!start.canMove(takeMovement)) {
                 continue;
             }
@@ -68,7 +73,7 @@ public boolean canMove(List<Piece> piecesOnRoute, Position start, Position targe
     }
 
     @Override
-    public boolean isEmpty() {
+    public boolean isEmptyPiece() {
         return false;
     }
 
diff --git a/src/main/java/chess/domain/piece/Piece.java b/src/main/java/chess/domain/piece/Piece.java
index 9e1d10a676d..0764368385a 100644
--- a/src/main/java/chess/domain/piece/Piece.java
+++ b/src/main/java/chess/domain/piece/Piece.java
@@ -20,7 +20,7 @@ public abstract class Piece {
 
     public abstract boolean canMove(List<Piece> piecesOnRoute, Position start, Position target);
 
-    public abstract boolean isEmpty();
+    public abstract boolean isEmptyPiece();
 
     public boolean isOtherTeam(Piece other) {
         return this.teamColor != other.teamColor;
@@ -42,5 +42,11 @@ public boolean isOtherTeamColor(TeamColor teamColor) {
         return this.teamColor != teamColor;
     }
 
+    public int countPieceOnRoute(List<Piece> pieces) {
+        return (int) pieces.stream()
+                .filter(piece -> !piece.isEmptyPiece())
+                .count();
+    }
+
     public abstract boolean isKing();
 }
diff --git a/src/main/java/chess/domain/piece/Queen.java b/src/main/java/chess/domain/piece/Queen.java
index 9a3903db7ed..0d26633eeca 100644
--- a/src/main/java/chess/domain/piece/Queen.java
+++ b/src/main/java/chess/domain/piece/Queen.java
@@ -50,14 +50,14 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
 
     @Override
     public boolean canMove(List<Piece> piecesOnRoute, Position start, Position target) {
-        if(piecesOnRoute.size() != 1){
+        if(countPieceOnRoute(piecesOnRoute) != 0){
             return false;
         }
-        return piecesOnRoute.getLast().isEmpty() || this.isOtherTeam(piecesOnRoute.getLast());
+        return piecesOnRoute.getLast().isEmptyPiece() || this.isOtherTeam(piecesOnRoute.getLast());
     }
 
     @Override
-    public boolean isEmpty() {
+    public boolean isEmptyPiece() {
         return false;
     }
 
diff --git a/src/main/java/chess/domain/piece/Rook.java b/src/main/java/chess/domain/piece/Rook.java
index 54d2ba6edf2..348e15ce9f5 100644
--- a/src/main/java/chess/domain/piece/Rook.java
+++ b/src/main/java/chess/domain/piece/Rook.java
@@ -44,14 +44,14 @@ public List<Position> findAllRouteToTarget(Position start, Position target) {
 
     @Override
     public boolean canMove(List<Piece> piecesOnRoute, Position start, Position target) {
-        if(piecesOnRoute.size() != 1){
+        if(countPieceOnRoute(piecesOnRoute) != 0){
             return false;
         }
-        return piecesOnRoute.getLast().isEmpty() || this.isOtherTeam(piecesOnRoute.getLast());
+        return piecesOnRoute.getLast().isEmptyPiece() || this.isOtherTeam(piecesOnRoute.getLast());
     }
 
     @Override
-    public boolean isEmpty() {
+    public boolean isEmptyPiece() {
         return false;
     }
 
diff --git a/src/test/java/chess/domain/piece/PawnTest.java b/src/test/java/chess/domain/piece/PawnTest.java
index 2765c5860db..4b982131d2f 100644
--- a/src/test/java/chess/domain/piece/PawnTest.java
+++ b/src/test/java/chess/domain/piece/PawnTest.java
@@ -14,7 +14,7 @@ class PawnTest {
     @Test
     void Pawn_canMoveUp() {
         // given
-        Pawn pawn = new Pawn(TeamColor.BLACK);
+        Pawn pawn = new Pawn(TeamColor.WHITE);
         Piece targetPiece = EmptyPiece.getInstance();
 
         // when
@@ -70,7 +70,7 @@ void Pawn_canMoveDiagonal_whenExistEnemy2() {
     @Test
     void Pawn_cannotMoveDiagonal_whenEmptyTarget() {
         // given
-        Pawn pawn = new Pawn(TeamColor.BLACK);
+        Pawn pawn = new Pawn(TeamColor.WHITE);
         Piece targetPiece = EmptyPiece.getInstance();
 
         // when