Ero sivun ”Python 2/Wikishakkisivu” versioiden välillä

Poistettu sisältö Lisätty sisältö
Raimondo (keskustelu | muokkaukset)
Ei muokkausyhteenvetoa
Raimondo (keskustelu | muokkaukset)
Ei muokkausyhteenvetoa
Rivi 563:
Ratkaisu on työnalla. Nyt ohjelmaan lisätään parametrointi ja parametrinä annetun siirron toteutus. Siirron toteutus voidaan ohjelmoida kolmessa vaiheessa
* Parametri annetaan pitkällä algebrallisella notaatiolla, jolloin siitä saadaan sekä lähtö että kohderuutu.
 
{{hidden begin|title=Neljas karvalakkiversio|toggle=right}}
 
Rivi 797 ⟶ 798:
* Parametri annetaan lyhyellä algebrallisella notaatiolla, jolloin lähtöruutu pitää päätellä nappulakirjaimen ja kohderuudun sekä mahdollisen lisävihjeen perusteella. Sotilaiden etenemissuunnan selvittämiseksi tarvitaan myös siirtovuorotieto, jota saadaan siirtonotaatioss olevien pisteiden määrästä. Valkoisen siirrossa on vain yksipiste (.) siirtonumeron perässä ja mustan sirrossa on kolme pistettä (...)
 
{{hidden begin|title=Viides karvalakkiversio|toggle=right}}
* Lopuksi ohjelmaan voidaan lisätä vielä annetun siirron oikeellisuuden tarkistus. Edellisessä kohdassa on jo jouduttu tekemään joitakin tarkistuksia oikein syötetyn toiminnan mahdollistamiseksi. Tässä kohdassa on eliminoitava kaikki mahdolliset paramertseissä ja parametritiedostoissa annetut virheellisyydet.
 
Seuraava ohjelma lukee kommentteja sisältävän shakkilautamallineen parametrinä annetusta syötetiedostosta asema0, tallettaa yläotsikkorivit sellaisenaan tyotiedostoon temp, talletaa sisältörivit matriisiin, suorittaa lyhyella algebrallisella notaatiolla annetun siirron matriisissa, tallettaa muokatun matriisin ja alaotsikkorivit sellaisenaan työtiedostoon sekä kopioi lopuksi tyotiedoston takaisin syötetiedostoon.
 
Ohjelman rakenetta on selkeytetty kayttamalla aiempaa enemman aliohjelmia. Ohjelmasta puuttuu vielä moniselitteisten siirtojen tarkennusmerkintojen kasittely, linnoittautuminen ja valinnainen korottuminen (siina on toteutettu talla hetkella automaattinen korottuminen kuningattareksi).
 
;Koodi:
<source lang="Python">
# -*- coding: cp1252 -*-
import numpy as N
 
#------------------------------------------------------------------------
# Positiomerkinnasta sl-matriisin indekseiksi
#------------------------------------------------------------------------
def s2x(sarake):
si = 1
for s_i in ['a','b','c','d','e','f','g','h']:
if s_i == sarake:
break
si = si+1 # tuntematon palauttaa 9
return si
 
def r2y(rivi):
ri=0
for r_i in ['8','7','6','5','4','3','2','1']:
if r_i == rivi:
break
ri =ri+1 # tuntematon palauttaa 8
return ri
 
def pos2ind(sarake, rivi):
si = s2x(sarake)
ri = r2y(rivi)
return [ri, si]
 
#------------------------------------------------------------------------
# Nappuloiden (T, L, D ja K) lahderuutujen hakufunktiot
#------------------------------------------------------------------------
# Seuraavat funktiot palauttavat ensimmaisen ei tyhjan ruudun sisalon ja indeksit
# tai tyhjan sisallon ja laitaruudun indeksin ellei nappulaa loydy.
 
# haetaan ensimmainen nappula kohteesta sarakesuuntaan ylos
def sy_haku(ks, kr, matriisi):
(y, x) = pos2ind(ks, kr)
if y > 0:
y = y-1
while matriisi[y][x] == ' ':
if y==0:
break
y = y-1
return [matriisi[y][x], y, x]
# haetaan ensimmainen nappula kohteesta sarakesuuntaan alas
def sa_haku(ks, kr, matriisi):
(y, x) = pos2ind(ks, kr)
if y < 7:
y = y+1
while matriisi[y][x] == ' ':
if y==7:
break
y = y+1
return [matriisi[y][x], y, x]
# haetaan ensimmainen nappula kohteesta rivin uuntaan vasemmalle
def rv_haku(ks, kr, matriisi):
(y, x) = pos2ind(ks, kr)
if x > 1:
x = x-1
while matriisi[y][x] == ' ':
if x==1:
break
x = x-1
return [matriisi[y][x], y, x]
# haetaan ensimmainen nappula kohteesta rivin suuntaan oikealle
def ro_haku(ks, kr, matriisi):
(y, x) = pos2ind(ks, kr)
if x < 8:
x = x+1
while matriisi[y][x] == ' ':
if x==8:
break
x = x+1
return [matriisi[y][x], y, x]
# haetaan ensimmainen nappula kohteesta diagonaalin suuntaan oikealle ylos
def oy_haku(ks, kr, matriisi):
(y, x) = pos2ind(ks, kr)
if (y > 0) and (x < 8):
y = y-1
x = x+1
while matriisi[y][x] == ' ':
if (x==8) or (y==0):
break
y = y-1
x = x+1
return [matriisi[y][x], y, x]
# haetaan ensimmainen nappula kohteesta diagonaalin suuntaan oikealle alas
def oa_haku(ks, kr, matriisi):
(y, x) = pos2ind(ks, kr)
if (y < 7) and (x < 8):
y = y+1
x = x+1
while matriisi[y][x] == ' ':
if (x==8) or y==7:
break
y = y+1
x = x+1
return [matriisi[y][x], y, x]
# haetaan ensimmainen nappula kohteesta diagonaalin suuntaan vasemmalle ylos
def vy_haku(ks, kr, matriisi):
(y, x) = pos2ind(ks, kr)
if (y > 0) and (x > 1):
y = y-1
x = x-1
while matriisi[y][x] == ' ':
if (x==1) or (y==0):
break
y = y-1
x = x-1
return [matriisi[y][x], y, x]
# haetaan ensimmainen nappula kohteesta diagonaalin suuntaan vasemmalle alas
def va_haku(ks, kr, matriisi):
(y, x) = pos2ind(ks, kr)
if (y < 7) and (x > 1):
y = y+1
x = x-1
while matriisi[y][x] == ' ':
if (x==1) or (y==7):
break
y = y+1
x = x-1
return [matriisi[y][x], y, x]
 
#-----------------------------------------------------------------------
# LTDK-haku
#----------------------------------------------------------------------
 
# Lahettihaku n = 1...4
# Tornihaku n = 5...8
# Kuningatar- ja kuningashaku n = 1...8
 
# TAHAN LISATAAN VIELA TARKENNUSTEN TESTAUS (Jos tarkennusmerkkeja ei ole suoritetaan
# yksi haku. Jos on yksi tarkennus, toistetaan hakua niin kauan, etta myos se tasmaa.
# Jos on kaksi tarkennusta, ei suoritetaan haun asemasta vain koordinaattimuunnos.)
# JA LINNOITUSTESTAUS (Jos kuningas siirtyy kaksi ruutua, niin myos tornia siirretaan.)
 
def LTDK_haku(ks, kr, sl, n): # n on jarjestys indeksi
if n==1:
(nappula, ly, lx)=oy_haku(ks, kr, sl)
elif n==2:
(nappula, ly, lx)=oa_haku(ks, kr, sl)
elif n==3:
(nappula, ly, lx)=vy_haku(ks, kr, sl)
elif n==4:
(nappula, ly, lx)=va_haku(ks, kr, sl)
elif n==5:
(nappula, ly, lx)=sy_haku(ks, kr, sl)
elif n==6:
(nappula, ly, lx)=sa_haku(ks, kr, sl)
elif n==7:
(nappula, ly, lx)=ro_haku(ks, kr, sl)
elif n==8:
(nappula, ly, lx)=rv_haku(ks, kr, sl)
return [nappula, ly, lx]
 
#-------------------------------------------------------------------------
# Ratsu-haku
#-----------------------------------------------------------
 
# haetaan kohderuudun ymparistosta ensimmainen mahdollinen kohderuutuun siirtyva ratsu
 
def ratsu_haku(ks, kr, matriisi, n): # n on jarjestys indeksi
(y, x) = pos2ind(ks, kr)
if n==1:
if (y-2 >= 0) and (x+1 <= 8):
y = y-2
x = x+1
return [matriisi[y][x], y, x]
else:
return [' ', y, x]
elif n==2:
if (y-1 >= 0) and (x+2 <= 8):
y = y-1
x = x+2
return [matriisi[y][x], y, x]
else:
return [' ', y, x]
elif n==3:
if (y+1 <= 7) and (x+2 <= 8):
y = y+1
x = x+2
return [matriisi[y][x], y, x]
else:
return [' ', y, x]
elif n==4:
if (y+2 <= 7) and (x+1 <= 8):
y = y+2
x = x+1
return [matriisi[y][x], y, x]
else:
return [' ', y, x]
elif n==5:
if (y+2 <= 7) and (x-1 >= 1):
y = y+2
x = x-1
return [matriisi[y][x], y, x]
else:
return [' ', y, x]
elif n==6:
if (y+1 > 0) and (x-2 >= 1):
y = y+1
x = x-2
return [matriisi[y][x], y, x]
else:
return [' ', y, x]
elif n==7:
if (y-2 >= 0) and (x-1 >= 1):
y = y-2
x = x-1
return [matriisi[y][x], y, x]
else:
return [' ', y, x]
elif n==8:
if (y-1 >= 0) and (x-2 >= 1):
y = y-1
x = x-2
return [matriisi[y][x], y, x]
else:
return [' ', y, x]
 
#-----------------------------------------------------------------------
# Sotilashaku (lahderuudun sisalto ja indeksit)
#----------------------------------------------------------------------
def sotilas_haku(ks, kr, sl, siirto):
 
# Tahan pitaa lisata viela valinnainen korotus
i=0
while siirto[i]!='.':
i=i+1
if siirto[i+2] == '.':
vuoro = 'musta'
if kr=='1':
nappulakoodi = 'qd' # automaattinen korotus kuningattareksi
else:
nappulakoodi = 'pd'
else:
vuoro = 'valkea'
if kr=='8':
nappulakoodi = 'ql' # automaattinen korotus kuningattareksi
else:
nappulakoodi = 'pl'
 
for i in range(0, len(siirto)):
if siirto[i] in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']:
if siirto[i+1] =='x':
lx = s2x(siirto[i])
if (vuoro == 'musta'):
ly = r2y(kr) - 1
else:
ly = r2y(kr) + 1
else:
# muu sotilassiirto
lx = s2x(siirto[i])
if (vuoro == 'musta'):
if kr == '5': # Kylla. Vuoro on mustalla.
(y,x)=pos2ind(ks, '6')
if sl[y][x]==' ': #Kahden askeleen siirto?
ly = r2y('7') # Kylla
else:
ly = r2y('6') # Ei
else:
ly = r2y(kr) - 1 # yhdenaskeleen siirto
else: # vuoro == valkea
if kr == '4':
(y,x)=pos2ind(ks, '3')
if sl[y][x]==' ': #Kahden askeleen siirto?
ly = r2y('2') # Kylla
else:
ly = r2y('3')# Ei
else:
ly = r2y(kr) + 1 # yhdenaskeleen siirto
break
# Ohestalyontitesti
if sl[r2y(kr)][s2x(ks)] ==' ': #Onko lyonnin kohderuutu tyhja?
ol=1
else:
ol=0
 
return [nappulakoodi, ly, lx, ol]
 
#------------------------------------------------------------------------
# Siirtyvan nappulan vari, nappulatunnus, sisaltokoodi,kohdetunnus ja kohdeindeksit
#------------------------------------------------------------------------
def siirtyva_nappula(siirto):
# siirtonotaation analyysi. Sirtomerkinnassa voi olla seuraavia merkkeja:
# a = sarakeaakkonen (a...h)
# n = rivinumero (1...8)
# x = lyontimerkki
# U = upseeritunnus
# = valilyonti
# . = sarakeaakkonen
 
# Siirtonotaatiolla voi olla seuraavia muotoja:
 
# n.Uan
# n.aUan
# n.nUan
# n.anUan
# n.Uxan
# n.aUxan
# n.nUxan
# n.anUxan
# n...Uan
# n...aUan
# n...nUan
# n...anUan
# n...Uxan
# n...aUxan
# n...nUxan
# n...anUxan
# n. ...Uan
# n. ...aUan
# n. ...nUan
# n. ...anUan
# n. ...Uxan
# n. ...aUxan
# n. ...nUxan
# n. ...anUxan
 
# Etsitaan U, jolloin seuraavat merkit tai mahdollista lyontimerkkia
# seuraavat merkit antavat kohdeposition ja edelliset pienella testauksella
# mahdolliset tarkennukset. Seuraavassa on U:n suhteen mahdolliset tapaukset:
# i-1 ei sarakekirjain eika rivinumero ==>> haussa ensimmainen loytyva on lahderuutu
# i-1 = sarakekirjain, i-2 ei rivinumero ==>> jatkettava hakua ellei sarake tasmaa
# i-1 = rivinumero, i-2 ei sarakekirjain ==>> jatkettava hakua ellei rivi tasmaa
# i-1 = rivinumero, i-2 = sarakekirjain ==>> ei tarvita hakua (suora muunnos riittaa)
# jos ennen U-tunnusta loytyy sarakekirjain, on kyseessa sotilas
# n.an
# n.axan
# n. an
# n. axan
# n...an
# n...axan
# n. ...an
# n. ...axan
# selvitetaan pienella testauksella kohde ja mahdollinen tarkennus. Seuraavassa on
# sarakekirjaimen suhteen mahdolliset tapaukset:
# i+1 = kohteen rivinumero, i = kohteen sarakekirjain, i = lahteen sarakekirjain
# i+1 = x, i+2 = kohteen sarakekirjain i+3 = kohteen rivinumero, i = lahteen sarakekirjain
 
# Lahteen rivi riippuu siirtovuorosta (se on yhta pienempi tai suurempi kohderivia,
# paitsi mahdollisen kaksoisaskeleen tapauksessa) Tama selvitetaan sotilas_haku-funktiossa
# Huom! Vuoro selviaa myös implisiittisesti tassa funktiossa lasketusta sisaltokoodista.
 
 
# Siirtovuoron selvitys
# mahdollisia siirto notaatioita mustan vuorolla
# nn...
# nn. ...
# etsitään ensimmäisen pisteen indeksi i ja tarkistetaan
# onko piste myös paikassa i+2, jos on vuoro on mustalla
i=0
nappulatunnus = '?' # merkitaan aluksi tuntemattomaksi
while siirto[i]!='.':
i=i+1
if siirto[i+2] == '.':
vuoro = 'musta'
else:
vuoro = 'valkea'
for i in range(0, len(siirto)):
if siirto[i] in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']:
nappulatunnus= ' ' #sotilas'
if siirto[i+1] == 'x': # lyontisiirto sisaltaa x-merkin
ks = siirto[i+2]
kr = siirto[i+3]
else:
ks = siirto[i]
kr = siirto[i+1]
break
elif siirto[i] in ['D', 'K', 'L', 'R', 'T']:
# nappula on upseeri
nappulatunnus = siirto[i]
# seuraava toimii vain yksiselitteisessa tapauksessa
if siirto[i+1] == 'x': # lyontisiirto sisaltaa x-merkin
ks = siirto[i+2]
kr = siirto[i+3]
else:
ks = siirto[i+1]
kr = siirto[i+2]
break
# siirtomerkinta oli virheellinen (nappulatunnus = '?')
 
(ky,kx) = pos2ind(ks, kr)
 
if vuoro == 'valkea':
if nappulatunnus == ' ':
sisaltokoodi = 'pl'
elif nappulatunnus == 'D':
sisaltokoodi = 'ql'
elif nappulatunnus == 'K':
sisaltokoodi = 'kl'
elif nappulatunnus == 'L':
sisaltokoodi = 'bl'
elif nappulatunnus == 'R':
sisaltokoodi = 'nl'
elif nappulatunnus == 'T':
sisaltokoodi = 'rl'
else:
sisaltokoodi = '?l'
else: # vuoro == musta
if nappulatunnus == ' ':
sisaltokoodi = 'pd'
elif nappulatunnus == 'D':
sisaltokoodi = 'qd'
elif nappulatunnus == 'K':
sisaltokoodi = 'kd'
elif nappulatunnus == 'L':
sisaltokoodi = 'bd'
elif nappulatunnus == 'R':
sisaltokoodi = 'nd'
elif nappulatunnus == 'T':
sisaltokoodi = 'rd'
else:
sisaltokoodi = '?d'
#print 'vuoro=', vuoro, 'nappula=', nappulatunnus, 'ks=', ks, 'kr=', kr
#print 'sisalto=', sisaltokoodi, 'ky=', ky, 'kx=', kx
 
return [vuoro, nappulatunnus, ks, kr, sisaltokoodi, ky, kx] # !!!!!!!!!!!!
# HUOM! Vuorotieto ja nappulatunnus sisaltyy implisiitisesti sisaltokoodiin.
# Samoin ks ja kr on redundanttista tietoa ky ja kx sisaltaa saman tiedon
 
#------------------------------------------------------------------------
# Tiedoston tulostus
#------------------------------------------------------------------------
def print_file(tiedosto):
f_kahva = open(tiedosto, 'r') # Avataan lukemista varten
data = f_kahva.read() # Luetaan tiedosto merkkijonoksi
f_kahva.close() # Suljetaan tiedosto
print(data) # Tulostetaan merkkijono
 
#------------------------------------------------------------------------
# Tiedoston kopiointi
#------------------------------------------------------------------------
def copy_file(mista, mihin):
fr_kahva = open(mista, 'r') # Avataan lukemista varten
fw_kahva = open(mihin, 'w') # Avataan lukemista varten
data = fr_kahva.read() # Luetaan tiedosto merkkijonoksi
fw_kahva.write(data) # Kirjoitetaan merkkijono tiedostoon
fr_kahva.close() # Suljetaan tiedosto
fw_kahva.close() # Suljetaan tiedosto
 
#---------------------------------------------------------
# Funktio suorittaa shakkisiirron
#---------------------------------------------------------
def shakkisiirto (siirto, asema='asema0.txt', temp='asema1.txt'):
 
#------------------------------------------------------------------
# Syotetiedoston testiluku ja tulostus
#------------------------------------------------------------------
print " \n ==== Asema ennen siirtoa ==== \n"
print_file(asema)
#---------------------------------------------------------------------------------------
# Matriisin sl eli shakkilauta alustus ruutujen posititiotunuksilla, seka sisaltorivien
# alku- ja loppuosen tilavarauksilla. Matriisin sisalto ylikirjoitetaan myohemmin alkuaseman
# mukaisella sisaltodatalla.
#------------------------------------------------------------------------------------------
sl = N.array(([' ', 'a8', 'b8', 'c8', 'd8', 'e8', 'f8', 'g8', 'h8', ' '],
[' ', 'a7', 'b7', 'c7', 'd7', 'e7', 'f7', 'g7', 'h7', ' '],
[' ', 'a6', 'b6', 'c6', 'd6', 'e6', 'f6', 'g6', 'h6', ' '],
[' ', 'a5', 'b5', 'c5', 'd5', 'e5', 'f5', 'g5', 'h5', ' '],
[' ', 'a4', 'b4', 'c4', 'd4', 'e4', 'f4', 'g4', 'h4', ' '],
[' ', 'a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3', 'h3', ' '],
[' ', 'a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2', 'h2', ' '],
[' ', 'a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1', 'h1', ' ']))
#-------------------------------------------------------------------------------------------
# Matriisin solujen indeksit
#--------------------------------------------------------------------------------------------
# alkuosa a b c d e f g h loppuosa
# 8 sl[0][0] sl[0][1] sl[0][2] sl[0][3] sl[0][4] sl[0][5] sl[0][6] sl[0][7] sl[0][8] sl[0][9]
# 7 sl[1][0] sl[1][1] sl[1][2] sl[1][3] sl[1][4] sl[1][5] sl[1][6] sl[1][7] sl[1][8] sl[1][9]
# 6 sl[2][0] sl[2][1] sl[2][2] sl[2][3] sl[2][4] sl[2][5] sl[2][6] sl[2][7] sl[2][8] sl[2][9]
# 5 sl[3][0] sl[3][1] sl[3][2] sl[3][3] sl[3][4] sl[3][5] sl[3][6] sl[3][7] sl[3][8] sl[3][9]
# 4 sl[4][0] sl[4][1] sl[4][2] sl[4][3] sl[4][4] sl[4][5] sl[4][6] sl[4][7] sl[4][8] sl[4][9]
# 3 sl[5][0] sl[5][1] sl[5][2] sl[5][3] sl[5][4] sl[5][5] sl[5][6] sl[5][7] sl[5][8] sl[5][9]
# 2 sl[6][0] sl[6][1] sl[6][2] sl[6][3] sl[6][4] sl[6][5] sl[6][6] sl[6][7] sl[6][8] sl[6][9]
# 1 sl[7][0] sl[7][1] sl[7][2] sl[7][3] sl[7][4] sl[7][5] sl[7][6] sl[7][7] sl[7][8] sl[7][9]
#-------------------------------------------------------------------------------------
# Syotetiedoston ylaotsikkorivit tulostiedostoon ja sisaltorivit matriisiin
#-------------------------------------------------------------------------------------
f_tulos = open(temp, 'w') # Tyhjennetaan tulostiedosto.
f_tulos.close()
f_tulos = open(temp, 'a') # Avataan lisayskirjoitusta varten.
f_rivi = open(asema, 'r') # Avataan lukemista varten.
for j in range(0,4): # Luetaan ja talletaan otsikkorivit tulostiedostoon.
rivi = f_rivi.readline()
f_tulos.write(rivi)
for j in range(0,8): # Luetaan ja talletaan sisaltorivit matriisiin
rivi = f_rivi.readline()
r = rivi.split('|')
sl[j] = r
#----------------------------------------------------------------
# Parametrina annetun siirtomerkinnan testitulostus
#----------------------------------------------------------------
print(' \n ==== Siirto ==== \n')
print(siirto)
#----------------------------------------------------------------
# Analysoidaan siirtonotaatio eli paatellaan
# lahto- ja kohderuutujen positiomerkinnat
#----------------------------------------------------------------
# siirtovuoro, siirtyvan nappulan tunnus, kohdepositiotunnus ja sisaltokoodi
(vuoro, nappula, ks, kr, sisaltokoodi, ky, kx) = siirtyva_nappula(siirto)
# HUOM! Vuorotieto ja nappulatunnus sisaltyy implisiitisesti sisaltokoodiin.
# Samoin ks ja kr on redundanttista tietoa ky ja kx sisaltaa saman tiedon
# Seuraava koodilohko muokataan ensin niin että redundanttiset muuttujat
# voidaan poistaa ja sen jälkeenedellä olevan funktion palautusarvoihin
# lisataan tarkennusrivi- ja saraketiedot ja seuraavaa koodilohkoa taydennetaan
# ne huomioon ottavaksi. Toteutuksen ideointia on funktion sisaisissa kommenteissa
# Taman hetkisessa toteutuksessa sotilaslyonnin tarkennus oletetaan aina
# merkittavaksi ja upseerisiirron tarkennusta ei viela ole toteutettu.
 
#----------------------------------------------------------------
# Lahderuutujen haku (ei huomioi viela siirron tarkennuksia...on tyonalla)
#----------------------------------------------------------------
ol=0
if nappula == ' ': # siirtyva nappula onsotilas
(nappulakoodi, ly, lx, ol) = sotilas_haku(ks, kr, sl, siirto)
elif nappula == 'R':
for n in range(1,9):
(nappulakoodi, ly, lx) = ratsu_haku(ks, kr, sl, n)
if nappulakoodi == sisaltokoodi:
break
elif nappula == 'L':
for n in range(1,5):
(nappulakoodi, ly, lx) = LTDK_haku(ks, kr, sl, n)
if nappulakoodi == sisaltokoodi:
break
elif nappula == 'T':
for n in range(5,9):
(nappulakoodi, ly, lx) = LTDK_haku(ks, kr, sl, n)
if nappulakoodi == sisaltokoodi:
break
elif (nappula == 'D'):
for n in range(1,9):
(nappulakoodi, ly, lx) = LTDK_haku(ks, kr, sl, n)
if nappulakoodi == sisaltokoodi:
break
elif (nappula == 'K'):
for n in range(1,9):
(nappulakoodi, ly, lx) = LTDK_haku(ks, kr, sl, n)
if nappulakoodi == sisaltokoodi:
break
# Jos kuningas siirtyy kaksi askelta asetetaan vastaava linnoituslippu
# pitka_valkea, lyhyt_valkea, pitka_musta, lyhyt_musta
#----------------------------------------------------------------
# Siirron toteutus (loppu osa yhteneva pitkan notaation kanssa)
#----------------------------------------------------------------
 
# Tasta puuttuu viela LINNOITUS ja KOROTTUMINEN
# Toteutetaan siirto
sl[ky][kx] = nappulakoodi # sl[ly][lx] lahtoruudun sisalto kohderuutuun
sl[ly][lx] = ' ' # tyhjataan lahtoruutu
 
# Ohestalyonnin lisatoiminto
if ol==1:
if vuoro == 'musta':
sl[ky-1][kx] = ' ' # poistetaan ohestalyotava musta sotilas
else:
sl[ky+1][kx] = ' ' # poistetaan ohestalyotava valkea sotilas
 
# Tahan tulee linnoitustestin mukainen tornisiirron toteutus. Jos linnoituslippu
# pitka_valkea, lyhyt_valkea, pitka_musta tai lyhyt_musta
# on asetettu, toteutetaan myos vastaava tornisiirto
#----------------------------------------------------------
# Talletaan muokattu matriisi tulostiedostoon
#----------------------------------------------------------
for j in range(0,8):
for i in range(0,10):
# print sl[j][i],
if i==0:
jono = sl[j][i]
else:
jono = '|' + sl[j][i]
f_tulos.write(jono)
#------------------------------------------------------------------
# Talletaan alaotsikkorivit (3 kpl) tulostiedostoon
#------------------------------------------------------------------
for j in range(0,3):
rivi = f_rivi.readline()
f_tulos.write(rivi)
f_rivi.close() # suljetaan tiedosto
f_tulos.close() # suljetaan tiedosto
 
#------------------------------------------------------------------
# Kopioidaan tyotiedosto temp tiedostoon asema
#------------------------------------------------------------------
copy_file(temp, asema) # ----------
#------------------------------------------------------------------
# Tiedosto asema siirron jalkeen
#------------------------------------------------------------------
print " \n ==== Asema siirton jalkeen ==== \n"
#print_file(temp) # -----------
print_file(asema) #-------------
 
#------------------------------------------------------------------
# Siirtokehoite
#------------------------------------------------------------------
if vuoro=='valkea':
print 'Anna mustan siirto!'
else:
print 'Anna valkean siirto!'
 
return [ks, kr, sl, vuoro]
 
#------- testilohko ----------------------------------------------
shakkisiirto('1.Rf3')
 
 
</source>
 
;Testaus:
Ohjelmaa voidaan testata esim. kirjoittamalla ohjelman lopussa olevaan testikutsuun seuraavaksi suoritettava siirto. Siirto pitaa kirjoittaa lyhyen algebrallisen notaation mukaan oikeassa muodossa. Mitaan virhetarkistuksia ei ole viela toteutettu. Siirto toteutetaan tiedostossa asema0.txt olevalle laudalle ja uusi asema talletetaan takaisin samaan tiedostoon.
 
{{hidden end|toggle=right}}
 
* Seuraavaan versioon pitää taydentaa edellisessä versiossa vielä olevat toiminnalliset puutteet ja lisätä kaikkiin virheellisiin syötteisiin äänimerkki virheilmoitukseksi (mitään muutoksia tulostiedostoon ei virheellisillä syötteillä tehdä).
 
===Aiheesta muualla===