I normally don’t share little strange bits of unfinished code – but I thought this was pretty cool. I was messing around with coding a little “fish tank” game in Python utilizing Pygame. One thing I’m bad about doing is attempting to make everything modular – which is why my Text Adventure game turned out to be a Text Adventure Engine. I wanted to utilize Pygame, but I wanted to load in sprite sheets in a predictable manner. In this case I found some sprites that are generally utilized for RPG Maker that always contain a predictable pattern (Multiple sprites on the same sheet, differing only by color). Given that there are so many available due to its popularity, it also makes things easy to play with. I believe there are licensing problems here, but this is just for personal use as an example. You could utilize any sheets that are uniform in size. Here’s a little example of one if those sheets.

I found some example code to use as a base, but it contained errors and didn’t account for multiple sprites in the same sheet. Below is the SpriteSheet class. Essentially – this code reads the size of the total image in pixels, and you pass in the number of columns/rows (distinct cells groupings of blue fish, green fish, etc.). In the image above, that would be two rows by four columns. After that, some simple (sort of) math determines the size of each fish individually (I believe this example is 32px by 32px). Essentially – this means you can load in any sprite sheet that follows this same pattern (regardless of size), and this class can take account of it. Really it’s just kind of cool, it minimizes the code a bit.

class SpriteSheet():
    def __init__(self, filename, o_rows, o_cols, rows, cols, p_rows, p_cols):
        """SpriteSheet Contructor"""
        self.image = pg.image.load(filename).convert_alpha()
        self.o_rows = o_rows    #Number of rows of options in sprite total
        self.o_cols = o_cols    #Number of cols of options in sprite total
        self.rows = rows        #Number of rows for sprite chosen
        self.cols = cols        #Number of cols for sprite chosen
        self.p_rows = p_rows    #Row number of chosen sprite in sheet
        self.p_cols = p_cols    #Column number of chosen sprite in sheet
        self.totalCellCount = cols * rows #Total cells in the specific sprite option chosen
        self.option_w = self.image.get_rect().width / self.o_cols #Width of particular option in sheet
        self.option_h = self.image.get_rect().height / self.o_rows #Height of particular option in sheet
        self.offset_x = self.option_w * p_cols #Offset the X based on which option in the sheet
        self.offset_y = self.option_h * p_rows #Offset the Y based on which option in the sheet
        self.init_rect = pg.Rect(0, 0, self.option_w, self.option_h) #Form initial rectangle (before we break it up into cells)

        self.w = self.cellWidth = self.init_rect.width / cols
        self.h = self.cellHeight = self.init_rect.height / rows
        #Get a list of (X,Y) coordinates of each cell in the sprite sheet with associated heights/widths
        #self.cells = list([((index % cols * self.w) + self.offset_x , (index / cols * self.h) + self.offset_y, self.w, self.h) for index in range(self.totalCellCount)])
        #self.cells = list([((index % cols * self.w), (index % rows * self.h), self.w, self.h) for index in range(self.totalCellCount)])
        self.cells = []
        myCounter = 0
        for ry in range(0, rows):
            for rx in range(0,cols):
                self.cells.append(((myCounter % cols * self.w) + self.offset_x, (ry * self.h) + self.offset_y, self.w, self.h))
                myCounter += 1
    def draw(self, cellIndex = 0, x = 25, y = 25):
        self.rect = pg.Rect(x,y,self.w,self.h) #Form rectangle around cell
        #pg.draw.rect(screen,(100,100,100),self.rect,0) #debug, show rectangles
        screen.blit(self.image, (x, y), self.cells[cellIndex])

You’ll notice a bit of debugging code that is disabled as it’s not 100% polished, but it works. In my Main function, I draw a randomized selection of fish. Really this means I’m choosing a sprite sheet and picking a random (X,Y) of the sheet which corresponds to (Row,Column) and therefore am essentially randomizing the color and number of fish to appear.

def main():
    #My Fish
    fish = []
    #Tiny Fishes
    for _ in range(10):
    #Smallish Fishes
    for _ in range(3):
    #Medium Fishes
    for _ in range(3):
    for f in fish:
        #Draw all fish on the screen
        f.draw(x = random.randrange(0,screen.get_width()), y = random.randrange(0, screen.get_height()))
    while True:
        event = pg.event.poll()
        if event.type == pg.QUIT:
        if event.type == pg.MOUSEBUTTONDOWN:
            # Set the x, y postions of the mouse click
            x, y = event.pos
            for f in fish:
                if f.rect.collidepoint(x, y):
        for f in fish:
        clock.tick(30) #never run more than 30fps
        screen.fill((30, 30, 30))
if __name__ == "__main__" :

The collision code is just a placeholder in case I need it later for interaction. Here’s where things took a weird turn. I thought to myself… well fish don’t really always move at a predictable speed or direction. So I need to randomize both of those depending on the size of the fish Obviously they will move Right/Left more often than Up/Down so I weight those first. Then I randomized the length of travel before switching directions.

To be honest this also highlights a big problem with the current version of the code, my sprites are also highly predictable in terms of what specific cell represents up/down/left/right. Without that, I would have to pass the values into each object created which would be annoying – so ignore that problem and make them static.

class WeightedChoice(object):
    def __init__(self, weights):
        self.totals = []
        self.weights = weights
        running_total = 0

        for w in weights:
            running_total += w[1]

    def next(self):
        rnd = random.random() * self.totals[-1]
        i = bisect.bisect_right(self.totals, rnd)
        return self.weights[i][0]

class Fish(SpriteSheet):
    rightPos = 6   #Image index to use while moving right
    leftPos = 3    #Image index to use while moving left
    upPos = 9      #Image index to use while moving up
    downPos = 0    #Image index to use while moving down
    switchImg = 6  #Switch image after every 'x' moves
    def __init__(self, speed, filename, o_rows, o_cols, rows, cols, p_rows, p_cols):
        super().__init__(filename, o_rows, o_cols, rows, cols, p_rows, p_cols)

        self.speed = speed
        self.traveled = 0
        #Set current index of sprite - tried to randomize so that all fins weren't doing the same thing
        self.curRightPos = random.randint(Fish.rightPos,8)
        self.curLeftPos = random.randint(Fish.leftPos,5)
        self.curUpPos = random.randint(Fish.upPos,11)
        self.curDownPos = random.randint(Fish.downPos,3)
    def randomizeTravel(self):
        self.traveled = 0
        self.counter = 0
        self.lenOfTravel = random.randint(10,20)
    def randomizeDirection(self):
        # The weighted list of fish. Each item is a tuple: (VALUE, WEIGHT)
        dirList = (
            ('Right', 85),
            ('Left', 85),
            ('Up', 15),
            ('Down', 15),
        weightedChoice = WeightedChoice(dirList);
        # do this each time you want to grab a random fish:
        self.direction = weightedChoice.next()

Finally – I can call the move (bottom of the Fish class.

    def move(self):
        self.counter += 1
        #Switch up images
        if self.counter >= Fish.switchImg and self.direction == 'Right':
            if self.curRightPos >= Fish.rightPos + 2:
                self.curRightPos = Fish.rightPos
                self.curRightPos += 1
                self.counter = 0
        if self.counter >= Fish.switchImg and self.direction == 'Left':
            if self.curLeftPos >= Fish.leftPos + 2:
                self.curLeftPos = Fish.leftPos
                self.curLeftPos += 1
                self.counter = 0
        if self.counter >= Fish.switchImg and self.direction == 'Up':
            if self.curUpPos >= Fish.upPos + 2:
                self.curUpPos = Fish.upPos
                self.curUpPos += 1
                self.counter = 0
        if self.counter >= Fish.switchImg and self.direction == 'Down':
            if self.curDownPos >= Fish.downPos + 2:
                self.curDownPos = Fish.downPos
                self.curDownPos += 1
                self.counter = 0
        #Move the fish
        #self.draw(self.curRightPos, self.rect.x + self.speed, self.rect.y)
        #self.traveled += self.speed
        if self.direction == 'Right':
            self.draw(self.curRightPos, self.rect.x + self.speed, self.rect.y)
            #self.rect.x += self.speed
            self.traveled += self.speed
        elif self.direction == 'Left':
            self.draw(self.curLeftPos, self.rect.x - self.speed, self.rect.y)
            #self.rect.x -= self.speed
            self.traveled -= self.speed
        elif self.direction == 'Up':
            self.draw(self.curUpPos, self.rect.x, self.rect.y - self.speed)
            #self.rect.y -= self.speed
            self.traveled -= self.speed
            self.draw(self.curDownPos, self.rect.x, self.rect.y + self.speed)
            #self.rect.y += self.speed
            self.traveled += self.speed
        #Check if the fish is off the screen
        if self.rect.top > screen.get_height() - self.h:
            self.direction = 'Up'
        elif self.rect.right > screen.get_width():
            self.direction = 'Left'
        elif self.rect.left < 0:
            self.direction = 'Right'
        elif self.rect.top < 0:
            self.direction = 'Down'
        #Check if we're done traveling
        if self.traveled > self.lenOfTravel:

VOILA! – Here be fish.

I know what you’re thinking, what happens if I change my list to randomize 1000 fish. It looks amazing is what – why stop at 1000. The “final” code is posted here at GitHub in case your interested. I’ll probably keep tinkering and make it a fully fledged project sometime down the road or sooner.