Chess

[Dan Cardin]

I've written chess in python. I haven't yet written in check(mates) because i completely forgot about them until i already started making the thread. Everything else should work though afaik. No AI unless I get really ambitious.

To make the window smaller, change "res" on line 17 to something smaller (it will look prettier if you keep the numbers the same). Feedback, as always is appreciated.

[i luffs yeww]

ImportError: No module named pygame

D:

lol oops. I got it.

[Sex]

How do you forget the object of the game O_o.

[Dan Cardin]

I was too preoccupied with the rest of the game. The logic for piece moving went from really difficult originally to fairly easy, and it flip-flopped a couple of times. I dont expect being in check to be difficult. Checkmate will be a bit moreso. Then there's always a menu and whatnot.

#!/user/bin/env python

import sys,os,pygame,random
from pygame.locals import *

#--- Init pygame
os.environ["SDL_VIDEO_CENTERED"] = "1"
pygame.init
pygame.font.init()

#--- Setup
gameName = "Chess!"
levelFile = ""
tilesetFile = "tileset.bmp"
screenSize = (8, 8)
FPS = 30
res = (32, 32)

#--- Variables
clock = pygame.time.Clock()
level = []
for i in range(0, screenSize[0]):
level.append([])
for e in range(0, screenSize[1]):
level[i].append(0)

class Piece(object):
def __init__(self, poss, colour, types, tiles):
self.color = colour
self.type = types
self.pos = poss
self.movenum = 0


self.bmp = pygame.surface.Surface((por[0],por[1]))
self.bmp.set_colorkey((255,255,255))
self.bmp.blit(tiles, (-self.type * por[0], {0:0, 1:-por[1]}[self.color], por[0], por[1]))

def pathCollide(self, poss, dir):
result = False
tPos = self.pos
while tPos <> poss:
for i in pieces:
if tPos == i.pos:
if i <> self:
return True
tPos = (tPos[0] + dir[0], tPos[1] + dir[1])
for i in pieces:
if tPos == i.pos:
if i.color == pick.color:
return True
return result

def pawn(self, inpos):
result = False
if self.color == 0:
x = - 1
else:
x = 1
if self.movenum == 0:
if inpos == (self.pos[0], self.pos[1] + 2 * x):
result = True
self.movenum += 1
if inpos == (self.pos[0], self.pos[1] + x):
y = True
for i in pieces:
if i.pos == inpos:
y = False
if y:
result = True
self.movenum += 1
elif inpos == (self.pos[0] + 1, self.pos[1] + x) or inpos == (self.pos[0] - 1 , self.pos[1] + x):
for i in pieces:
if i.color != self.color:
if i.pos == inpos:
result = True
self.movenum += 1
return result

def rook(self, inpos):
result = False
if inpos[0] == self.pos[0] or inpos[1] == self.pos[1]:
case = {
False: {True: (-1, 0), False: (1,0)}[inpos[0] < self.pos[0]],
True: {True: (0, -1), False: (0,1)}[inpos[1] < self.pos[1]]
}[inpos[0] == self.pos[0]]
if not self.pathCollide(inpos, case):
return True
return result

def knight(self, inpos):
result = False

rue = False
if not (inpos[0] > self.pos[0] + 2 or inpos[0] < self.pos[0] - 2 or inpos[1] > self.pos[1] + 2 or inpos[1] < self.pos[1] - 2):
if inpos[0] <> self.pos[0]:
if abs(inpos[1] - self.pos[1]) / abs(inpos[0] - self.pos[0]) == 2:
rue = True
case = {
False: {True: (1, -3), False: (1,3)}[inpos[1] < self.pos[1]],
True: {True: (-1, -3), False: (-1,3)}[inpos[1] < self.pos[1]]
}[inpos[0] < self.pos[0]]
elif float(abs(inpos[1] - self.pos[1])) / float(abs(inpos[0] - self.pos[0])) == .5:
rue = True
case = {
False: {True: (3, -1), False: (3,1)}[inpos[1] < self.pos[1]],
True: {True: (-3, -1), False: (-3,1)}[inpos[1] < self.pos[1]]
}[inpos[0] < self.pos[0]]
if rue:
result = True
for i in pieces:
if inpos == i.pos:
if i.color == pick.color:
result = False
return result

def bishop(self, inpos):
result = False
if inpos[0] <> self.pos[0]:
if float(abs(inpos[1] - self.pos[1])) / float(abs(inpos[0] - self.pos[0])) == 1.0:
case = {
False: {True: (1, -1), False: (1,1)}[inpos[1] < self.pos[1]],
True: {True: (-1, -1), False: (-1,1)}[inpos[1] < self.pos[1]]
}[inpos[0] < self.pos[0]]
if not self.pathCollide(inpos, case):
return True
return result

def king(self, inpos):
result = False
go = False
if not (inpos[0] > self.pos[0] + 1 or inpos[0] < self.pos[0] - 1 or inpos[1] > self.pos[1] + 1 or inpos[1] < self.pos[1] - 1):
if inpos[0] == self.pos[0]:
go = True
case = {True: (0, -1), False: (0,1)}[inpos[1] < self.pos[1]]
else:
slo = float(abs(inpos[1] - self.pos[1])) / float(abs(inpos[0] - self.pos[0]))
if slo == 1.0 or slo == 0.0:
case = {
False: {
False: {True: (1, -1), False: (1,1)}[inpos[1] < self.pos[1]],
True: {True: (-1, -1), False: (-1,1)}[inpos[1] < self.pos[1]]
}[inpos[0] < self.pos[0]],
True: {True: (-1, 0), False: (1,0)}[inpos[0] < self.pos[0]]
}[slo == 0.0]
go = True
if go:
if not self.pathCollide(inpos, case):
for i in pieces:
if i.color != self.color:
if i.canMove(inpos):
return False
return True
return result

def queen(self, inpos):
result = False
go = False
if inpos[0] == self.pos[0]:
go = True
case = {True: (0, -1), False: (0,1)}[inpos[1] < self.pos[1]]
else:
slo = float(abs(inpos[1] - self.pos[1])) / float(abs(inpos[0] - self.pos[0]))
if slo == 1.0 or slo == 0.0:
case = {
False: {
False: {True: (1, -1), False: (1,1)}[inpos[1] < self.pos[1]],
True: {True: (-1, -1), False: (-1,1)}[inpos[1] < self.pos[1]]
}[inpos[0] < self.pos[0]],
True: {True: (-1, 0), False: (1,0)}[inpos[0] < self.pos[0]]
}[slo == 0.0]
go = True
if go:
if not self.pathCollide(inpos, case):
return True
return result

def canMove(self, gopos):
case = {
0: self.pawn,
1: self.rook,
2: self.knight,
3: self.bishop,
4: self.queen,
5: self.king
}
return case[self.type](gopos)

def move(self, poss):
global check
if self.pos != poss:
if self.canMove(poss):
tPos = self.pos
self.pos = poss
for i in pieces:
if i.color <> self.color:
if i.type == 5:
break
for e in pieces:
if self.canMove(i.pos) == True:
check = {False:-1, True:1}[self.color == 0]
print "checl"
break
else:
check = 0
if check <> 0:
if team % 2 == self.color:
self.pos = tPos
return False

for i in pieces:
if i.pos == poss:
garbage.append(i)
pieces.remove(i)

self.pos = poss
return True


def input(type):
global mousePos, mousedown
if type == MOUSEBUTTONDOWN:
mousedown = True
elif type == MOUSEBUTTONUP:
mousedown = False


def tick(inputs):
global mousedown, pickedup, pick, mPos, team
mPos = pygame.mouse.get_pos()
if inputs != 0:
input(inputs)

if mousedown:
for i in pieces:
if i.color == team % 2:
if (i.pos[0] * por[0] < mPos[0]) and (i.pos[1] * por[1] < mPos[1]):
if (i.pos[0] * por[0] + por[0] > mPos[0]) and (i.pos[1] * por[1] + por[1] > mPos[1]):
pickedup = True
pick = i
break
else:
if pickedup:
if pick.move((mPos[0] / por[0], mPos[1] / por[1])):
team += 1
pickedup = False
pick = 0


def getEvents():
global gameRunning
res = 0
for event in pygame.event.get():
if event.type == pygame.QUIT:
gameRunning = False
sys.exit()
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
gameRunning = False
sys.exit()
elif event.type == MOUSEBUTTONDOWN or event.type == MOUSEBUTTONUP:
res = event.type
return res

#--- Object Creation
pygame.display.set_caption(gameName)
screen = pygame.display.set_mode((20 * res[0] + 200, 20 * res[1]))


por = (res[0] * 20 / screenSize[0], res[1] * 20 / screenSize[1])
gameRunning = True
pieces = []
tileset = pygame.transform.scale(pygame.image.load(tilesetFi le), (por[0] * 6, 2 * por[1])).convert()
for i in range(0,8):
pieces.append(Piece((i, 6), 0, 0, tileset))
pieces.append(Piece((0, 7), 0, 1, tileset))
pieces.append(Piece((7, 7), 0, 1, tileset))
pieces.append(Piece((1, 7), 0, 2, tileset))
pieces.append(Piece((6, 7), 0, 2, tileset))
pieces.append(Piece((2, 7), 0, 3, tileset))
pieces.append(Piece((5, 7), 0, 3, tileset))
pieces.append(Piece((3, 7), 0, 4, tileset))
pieces.append(Piece((4, 7), 0, 5, tileset))
for i in range(0,8):
pieces.append(Piece((i, 1), 1, 0, tileset))
pieces.append(Piece((0, 0), 1, 1, tileset))
pieces.append(Piece((7, 0), 1, 1, tileset))
pieces.append(Piece((1, 0), 1, 2, tileset))
pieces.append(Piece((6, 0), 1, 2, tileset))
pieces.append(Piece((2, 0), 1, 3, tileset))
pieces.append(Piece((5, 0), 1, 3, tileset))
pieces.append(Piece((3, 0), 1, 4, tileset))
pieces.append(Piece((4, 0), 1, 5, tileset))
garbage = []

mousedown = False
team = 0
pickedup = False
mPos = (0,0)
pick = 0
check = 0

while gameRunning:
tick(getEvents())

x = 0
screen.fill((0, 0, 0))
for i in range(0, len(level)):
x += 1
for e in range(0, len(level[i])):
x += 1
til = pygame.surface.Surface((por[0],por[1]))
if x % 2 == 0:
til.fill((255,255,255))
else:
til.fill((0,0,0))
screen.blit(til, (i * por[0], e * por[1], i * por[0] + por[0], e * por[1] + por[1]))

radius = por[0] / 2
for i in pieces:
if pickedup:
screen.blit(pick.bmp, (mPos[0] - pick.bmp.get_width() / 2,mPos[1] - pick.bmp.get_height() / 2, mPos[0] + por[0], mPos[0] + por[1]))
if pick != i:
screen.blit(i.bmp, (i.pos[0] * por[0], i.pos[1] * por[1], i.pos[0] * por[0] + por[0], i.pos[1] * por[1] + por[1]))

Font = pygame.font.Font(None,25)
text = Font.render('Complete Turns: ' + str((team + 1) / 2),1, (0,255,0))
screen.blit(text,(por[0] * 8 + 10,10))

text = Font.render('Player: White',1, (0,255,0))
screen.blit(text,(por[0] * 8 + 10,50))

text = Font.render('Player: Black',1, (0,255,0))
screen.blit(text,(por[0] * 8 + 10,50 + 150))

if check <> 0:
text = Font.render({-1: 'White', 1: 'Black'}[check] + ' king in Check!',1, (0,255,0))
screen.blit(text,(por[0] * 8 + 10,300))

for c in range(0,2):
w, h = 0, 0
for i in garbage:
if i.color == c:
screen.blit(pygame.transform.scale(i.bmp, (28, 28)), (8 * por[0] + 10 + 32 * w, 70 + h * 32 + 150 * c, 8 * por[0] + 10 + 32 * w + 32, 70 + h * 32 + 32 + 150 * c))
w += 1
if w == 6:
w = 0
h += 1

clock.tick(FPS)
pygame.display.flip()
pygame.quit ()