Results 1 to 4 of 4

Thread: Chess

  1. #1
    Join Date
    Apr 2007
    Posts
    3,152
    Mentioned
    3 Post(s)
    Quoted
    1 Post(s)

    Default Chess

    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.
    SCAR Tutorials: The Form Tutorial | Types, Arrays, and Classes
    Programming Projects: NotePad | Tetris | Chess


  2. #2
    Join Date
    Jan 2010
    Posts
    5,227
    Mentioned
    6 Post(s)
    Quoted
    60 Post(s)

    Default

    ImportError: No module named pygame

    D:

    lol oops. I got it.
    Last edited by i luffs yeww; 04-03-2011 at 03:02 AM.

  3. #3
    Join Date
    Oct 2009
    Location
    Stockton, CA
    Posts
    2,040
    Mentioned
    0 Post(s)
    Quoted
    1 Post(s)

    Default

    How do you forget the object of the game O_o.
    Join the IRC! irc.rizon.net:6667/srl | SQLite (0.99rc3+) | SRL Doc | Simba Doc | Extra Simba Libraries (openSSL & sqlite3)
    Quote Originally Posted by #srl
    10:45 < Toter> daphil when can get sex anyday I want
    10:45 < Toter> he is always on #SRL
    "A programmer is just a tool which converts caffeine into code"

  4. #4
    Join Date
    Apr 2007
    Posts
    3,152
    Mentioned
    3 Post(s)
    Quoted
    1 Post(s)

    Default

    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.

    SCAR Code:
    #!/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(tilesetFile), (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 ()
    Last edited by Dan Cardin; 04-05-2011 at 04:39 PM.
    SCAR Tutorials: The Form Tutorial | Types, Arrays, and Classes
    Programming Projects: NotePad | Tetris | Chess


Thread Information

Users Browsing this Thread

There are currently 1 users browsing this thread. (0 members and 1 guests)

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •