584 lines
26 KiB
Python
584 lines
26 KiB
Python
import random
|
||
import copy
|
||
import math
|
||
import discord
|
||
|
||
from PIL import Image, ImageDraw, ImageFont
|
||
|
||
class ConnectFour():
|
||
def __init__(self,bot):
|
||
self.bot = bot
|
||
self.draw = drawConnectFour(bot)
|
||
self.AISCORES = {
|
||
"middle": 3,
|
||
"two in a row": 10,
|
||
"three in a row": 50,
|
||
"enemy two in a row": -35,
|
||
"enemy three in a row": -200,
|
||
"enemy win": -10000,
|
||
"win": 10000,
|
||
"avoid losing": 100
|
||
}
|
||
|
||
self.ROWCOUNT = 6
|
||
self.COLUMNCOUNT = 7
|
||
|
||
# Starts the game
|
||
async def start(self, ctx, opponent):
|
||
await self.bot.defer(ctx)
|
||
user = f"#{ctx.author.id}"
|
||
channel = str(ctx.channel_id)
|
||
game = self.bot.database["connect 4 games"].find_one({"_id":channel})
|
||
|
||
startedGame = False
|
||
canStart = True
|
||
|
||
if game != None:
|
||
sendMessage = "There's already a connect 4 game going on in this channel"
|
||
logMessage = "There was already a game going on"
|
||
canStart = False
|
||
else:
|
||
if type(opponent) == int:
|
||
# Opponent is Gwendolyn
|
||
if opponent in range(1, 6):
|
||
difficulty = int(opponent)
|
||
diffText = f" with difficulty {difficulty}"
|
||
opponent = f"#{self.bot.user.id}"
|
||
else:
|
||
sendMessage = "Difficulty doesn't exist"
|
||
logMessage = "They tried to play against a difficulty that doesn't exist"
|
||
canStart = False
|
||
|
||
elif type(opponent) == discord.member.Member:
|
||
if opponent.bot:
|
||
# User has challenged a bot
|
||
if opponent == self.bot.user:
|
||
# It was Gwendolyn
|
||
difficulty = 3
|
||
diffText = f" with difficulty {difficulty}"
|
||
opponent = f"#{self.bot.user.id}"
|
||
else:
|
||
sendMessage = "You can't challenge a bot!"
|
||
logMessage = "They tried to challenge a bot"
|
||
canStart = False
|
||
else:
|
||
# Opponent is another player
|
||
if ctx.author != opponent:
|
||
opponent = f"#{opponent.id}"
|
||
difficulty = 5
|
||
diffText = ""
|
||
else:
|
||
sendMessage = "You can't play against yourself"
|
||
logMessage = "They tried to play against themself"
|
||
canStart = False
|
||
|
||
if canStart:
|
||
board = [[0 for _ in range(self.COLUMNCOUNT)] for _ in range(self.ROWCOUNT)]
|
||
players = [user, opponent]
|
||
random.shuffle(players)
|
||
|
||
newGame = {"_id":channel, "board": board, "winner":0,
|
||
"win direction":"", "win coordinates":[0, 0],
|
||
"players":players, "turn":0, "difficulty":difficulty}
|
||
|
||
self.bot.database["connect 4 games"].insert_one(newGame)
|
||
|
||
self.draw.drawImage(channel)
|
||
|
||
gwendoTurn = (players[0] == f"#{self.bot.user.id}")
|
||
startedGame = True
|
||
|
||
opponentName = self.bot.databaseFuncs.getName(opponent)
|
||
turnName = self.bot.databaseFuncs.getName(players[0])
|
||
|
||
startedText = f"Started game against {opponentName}{diffText}."
|
||
turnText = f"It's {turnName}'s turn"
|
||
sendMessage = f"{startedText} {turnText}"
|
||
logMessage = "They started a game"
|
||
|
||
self.bot.log(logMessage)
|
||
await ctx.send(sendMessage)
|
||
|
||
# Sets the whole game in motion
|
||
if startedGame:
|
||
filePath = f"resources/games/connect4Boards/board{ctx.channel_id}.png"
|
||
oldImage = await ctx.channel.send(file = discord.File(filePath))
|
||
|
||
with open(f"resources/games/oldImages/connectFour{ctx.channel_id}", "w") as f:
|
||
f.write(str(oldImage.id))
|
||
|
||
if gwendoTurn:
|
||
await self.connectFourAI(ctx)
|
||
else:
|
||
reactions = ["1️⃣","2️⃣","3️⃣","4️⃣","5️⃣","6️⃣","7️⃣"]
|
||
for reaction in reactions:
|
||
await oldImage.add_reaction(reaction)
|
||
|
||
# Places a piece at the lowest available point in a specific column
|
||
async def placePiece(self, ctx, user, column):
|
||
channel = str(ctx.channel.id)
|
||
game = self.bot.database["connect 4 games"].find_one({"_id":channel})
|
||
playerNumber = game["players"].index(user)+1
|
||
userName = self.bot.databaseFuncs.getName(user)
|
||
placedPiece = False
|
||
|
||
if game is None:
|
||
sendMessage = "There's no game in this channel"
|
||
logMessage = "There was no game in the channel"
|
||
else:
|
||
board = game["board"]
|
||
board = self.placeOnBoard(board, playerNumber, column)
|
||
|
||
if board is None:
|
||
sendMessage = "There isn't any room in that column"
|
||
logMessage = "There wasn't any room in the column"
|
||
else:
|
||
self.bot.database["connect 4 games"].update_one({"_id":channel},{"$set":{"board":board}})
|
||
turn = (game["turn"]+1)%2
|
||
self.bot.database["connect 4 games"].update_one({"_id":channel},{"$set":{"turn":turn}})
|
||
|
||
self.bot.log("Checking for win")
|
||
won, winDirection, winCoordinates = self.isWon(board)
|
||
|
||
if won != 0:
|
||
gameWon = True
|
||
self.bot.database["connect 4 games"].update_one({"_id":channel},{"$set":{"winner":won}})
|
||
self.bot.database["connect 4 games"].update_one({"_id":channel},{"$set":{"win direction":winDirection}})
|
||
self.bot.database["connect 4 games"].update_one({"_id":channel},
|
||
{"$set":{"win coordinates":winCoordinates}})
|
||
|
||
sendMessage = f"{userName} placed a piece in column {column+1} and won."
|
||
logMessage = f"{userName} won"
|
||
winAmount = int(game["difficulty"])**2+5
|
||
if game["players"][won-1] != f"#{self.bot.user.id}":
|
||
sendMessage += " Adding "+str(winAmount)+" GwendoBucks to their account"
|
||
elif 0 not in board[0]:
|
||
gameWon = True
|
||
sendMessage = "It's a draw!"
|
||
logMessage = "The game ended in a draw"
|
||
else:
|
||
gameWon = False
|
||
otherUserName = self.bot.databaseFuncs.getName(game["players"][turn])
|
||
sendMessage = f"{userName} placed a piece in column {column+1}. It's now {otherUserName}'s turn"
|
||
logMessage = "They placed the piece"
|
||
|
||
gwendoTurn = (game["players"][turn] == f"#{self.bot.user.id}")
|
||
|
||
placedPiece = True
|
||
|
||
await ctx.channel.send(sendMessage)
|
||
self.bot.log(logMessage)
|
||
|
||
if placedPiece:
|
||
self.draw.drawImage(channel)
|
||
|
||
with open(f"resources/games/oldImages/connectFour{channel}", "r") as f:
|
||
oldImage = await ctx.channel.fetch_message(int(f.read()))
|
||
|
||
if oldImage is not None:
|
||
await oldImage.delete()
|
||
else:
|
||
self.bot.log("The old image was already deleted")
|
||
|
||
filePath = f"resources/games/connect4Boards/board{channel}.png"
|
||
oldImage = await ctx.channel.send(file = discord.File(filePath))
|
||
|
||
if gameWon:
|
||
self.endGame(channel)
|
||
else:
|
||
with open(f"resources/games/oldImages/connectFour{channel}", "w") as f:
|
||
f.write(str(oldImage.id))
|
||
if gwendoTurn:
|
||
await self.connectFourAI(ctx)
|
||
else:
|
||
reactions = ["1️⃣","2️⃣","3️⃣","4️⃣","5️⃣","6️⃣","7️⃣"]
|
||
for reaction in reactions:
|
||
await oldImage.add_reaction(reaction)
|
||
|
||
# Returns a board where a piece has been placed in the column
|
||
def placeOnBoard(self, board, player, column):
|
||
placementX, placementY = -1, column
|
||
|
||
for x, line in enumerate(board):
|
||
if line[column] == 0:
|
||
placementX = x
|
||
|
||
board[placementX][placementY] = player
|
||
|
||
if placementX == -1:
|
||
return None
|
||
else:
|
||
return board
|
||
|
||
def endGame(self, channel):
|
||
game = self.bot.database["connect 4 games"].find_one({"_id":channel})
|
||
|
||
winner = game["winner"]
|
||
if winner != 0:
|
||
if game["players"][winner-1] != f"#{self.bot.user.id}":
|
||
difficulty = int(game["difficulty"])
|
||
reward = difficulty**2 + 5
|
||
self.bot.money.addMoney(game["players"][winner-1], reward)
|
||
|
||
self.bot.databaseFuncs.deleteGame("connect 4 games", channel)
|
||
|
||
# Parses command
|
||
async def surrender(self, ctx):
|
||
await self.bot.defer(ctx)
|
||
channel = str(ctx.channel_id)
|
||
game = self.bot.database["connect 4 games"].find_one({"_id":channel})
|
||
|
||
if f"#{ctx.author.id}" in game["players"]:
|
||
loserIndex = game["players"].index(f"#{ctx.author.id}")
|
||
winnerIndex = (loserIndex+1)%2
|
||
winnerID = game["players"][winnerIndex]
|
||
winnerName = self.bot.databaseFuncs.getName(winnerID)
|
||
|
||
sendMessage = f"{ctx.author.display_name} surrenders."
|
||
sendMessage += f" This means {winnerName} is the winner."
|
||
if winnerID != f"#{self.bot.user.id}":
|
||
difficulty = int(game["difficulty"])
|
||
reward = difficulty**2 + 5
|
||
sendMessage += f" Adding {reward} to their account"
|
||
|
||
await ctx.send(sendMessage)
|
||
with open(f"resources/games/oldImages/connectFour{channel}", "r") as f:
|
||
oldImage = await ctx.channel.fetch_message(int(f.read()))
|
||
|
||
if oldImage is not None:
|
||
await oldImage.delete()
|
||
else:
|
||
self.bot.log("The old image was already deleted")
|
||
|
||
self.endGame(channel)
|
||
else:
|
||
await ctx.send("You can't surrender when you're not a player")
|
||
|
||
# Checks if someone has won the game and returns the winner
|
||
def isWon(self, board):
|
||
won = 0
|
||
winDirection = ""
|
||
winCoordinates = [0,0]
|
||
|
||
for row in range(self.ROWCOUNT):
|
||
for place in range(self.COLUMNCOUNT):
|
||
if won == 0:
|
||
piecePlayer = board[row][place]
|
||
if piecePlayer != 0:
|
||
# Checks horizontal
|
||
if place <= self.COLUMNCOUNT-4:
|
||
pieces = [board[row][place+1],board[row][place+2],board[row][place+3]]
|
||
else:
|
||
pieces = [0]
|
||
|
||
if all(x == piecePlayer for x in pieces):
|
||
won = piecePlayer
|
||
winDirection = "h"
|
||
winCoordinates = [row,place]
|
||
|
||
# Checks vertical
|
||
if row <= self.ROWCOUNT-4:
|
||
pieces = [board[row+1][place],board[row+2][place],board[row+3][place]]
|
||
else:
|
||
pieces = [0]
|
||
|
||
if all(x == piecePlayer for x in pieces):
|
||
won = piecePlayer
|
||
winDirection = "v"
|
||
winCoordinates = [row,place]
|
||
|
||
# Checks right diagonal
|
||
if row <= self.ROWCOUNT-4 and place <= self.COLUMNCOUNT-4:
|
||
pieces = [board[row+1][place+1],board[row+2][place+2],board[row+3][place+3]]
|
||
else:
|
||
pieces = [0]
|
||
|
||
if all(x == piecePlayer for x in pieces):
|
||
won = piecePlayer
|
||
winDirection = "r"
|
||
winCoordinates = [row,place]
|
||
|
||
# Checks left diagonal
|
||
if row <= self.ROWCOUNT-4 and place >= 3:
|
||
pieces = [board[row+1][place-1],board[row+2][place-2],board[row+3][place-3]]
|
||
else:
|
||
pieces = [0]
|
||
|
||
if all(x == piecePlayer for x in pieces):
|
||
won = piecePlayer
|
||
winDirection = "l"
|
||
winCoordinates = [row,place]
|
||
|
||
|
||
return won, winDirection, winCoordinates
|
||
|
||
# Plays as the AI
|
||
async def connectFourAI(self, ctx):
|
||
channel = str(ctx.channel.id)
|
||
|
||
self.bot.log("Figuring out best move")
|
||
game = self.bot.database["connect 4 games"].find_one({"_id":channel})
|
||
|
||
board = game["board"]
|
||
player = game["players"].index(f"#{self.bot.user.id}")+1
|
||
difficulty = game["difficulty"]
|
||
|
||
scores = [-math.inf for _ in range(self.COLUMNCOUNT)]
|
||
for column in range(self.COLUMNCOUNT):
|
||
testBoard = copy.deepcopy(board)
|
||
testBoard = self.placeOnBoard(testBoard,player,column)
|
||
if testBoard != None:
|
||
scores[column] = await self.minimax(testBoard,difficulty,player%2+1,player,-math.inf,math.inf,False)
|
||
self.bot.log(f"Best score for column {column} is {scores[column]}")
|
||
|
||
possibleScores = scores.copy()
|
||
|
||
while (min(possibleScores) <= (max(possibleScores) - max(possibleScores)/10)) and len(possibleScores) != 1:
|
||
possibleScores.remove(min(possibleScores))
|
||
|
||
highest_score = random.choice(possibleScores)
|
||
|
||
bestColumns = [i for i, x in enumerate(scores) if x == highest_score]
|
||
placement = random.choice(bestColumns)
|
||
|
||
await self.placePiece(ctx, f"#{self.bot.user.id}", placement)
|
||
|
||
# Calculates points for a board
|
||
def AICalcPoints(self,board,player):
|
||
score = 0
|
||
otherPlayer = player%2+1
|
||
|
||
# Adds points for middle placement
|
||
# Checks horizontal
|
||
for row in range(self.ROWCOUNT):
|
||
if board[row][3] == player:
|
||
score += self.AISCORES["middle"]
|
||
rowArray = [int(i) for i in list(board[row])]
|
||
for place in range(self.COLUMNCOUNT-3):
|
||
window = rowArray[place:place+4]
|
||
score += self.evaluateWindow(window,player,otherPlayer)
|
||
|
||
# Checks Vertical
|
||
for column in range(self.COLUMNCOUNT):
|
||
columnArray = [int(i[column]) for i in list(board)]
|
||
for place in range(self.ROWCOUNT-3):
|
||
window = columnArray[place:place+4]
|
||
score += self.evaluateWindow(window,player,otherPlayer)
|
||
|
||
# Checks right diagonal
|
||
for row in range(self.ROWCOUNT-3):
|
||
for place in range(self.COLUMNCOUNT-3):
|
||
window = [board[row][place],board[row+1][place+1],board[row+2][place+2],board[row+3][place+3]]
|
||
score += self.evaluateWindow(window,player,otherPlayer)
|
||
|
||
for place in range(3,self.COLUMNCOUNT):
|
||
window = [board[row][place],board[row+1][place-1],board[row+2][place-2],board[row+3][place-3]]
|
||
score += self.evaluateWindow(window,player,otherPlayer)
|
||
|
||
|
||
## Checks if anyone has won
|
||
#won = isWon(board)[0]
|
||
|
||
## Add points if AI wins
|
||
#if won == player:
|
||
# score += self.AISCORES["win"]
|
||
|
||
return score
|
||
|
||
def evaluateWindow(self, window,player,otherPlayer):
|
||
if window.count(player) == 4:
|
||
return self.AISCORES["win"]
|
||
elif window.count(player) == 3 and window.count(0) == 1:
|
||
return self.AISCORES["three in a row"]
|
||
elif window.count(player) == 2 and window.count(0) == 2:
|
||
return self.AISCORES["two in a row"]
|
||
elif window.count(otherPlayer) == 4:
|
||
return self.AISCORES["enemy win"]
|
||
else:
|
||
return 0
|
||
|
||
async def minimax(self, board, depth, player , originalPlayer, alpha, beta, maximizingPlayer):
|
||
#terminal = ((0 not in board[0]) or (isWon(board)[0] != 0))
|
||
terminal = 0 not in board[0]
|
||
points = self.AICalcPoints(board,originalPlayer)
|
||
# The depth is how many moves ahead the computer checks. This value is the difficulty.
|
||
if depth == 0 or terminal or (points > 5000 or points < -6000):
|
||
return points
|
||
if maximizingPlayer:
|
||
value = -math.inf
|
||
for column in range(0,self.COLUMNCOUNT):
|
||
testBoard = copy.deepcopy(board)
|
||
testBoard = self.placeOnBoard(testBoard,player,column)
|
||
if testBoard != None:
|
||
evaluation = await self.minimax(testBoard,depth-1,player%2+1,originalPlayer,alpha,beta,False)
|
||
if evaluation < -9000: evaluation += self.AISCORES["avoid losing"]
|
||
value = max(value,evaluation)
|
||
alpha = max(alpha,evaluation)
|
||
if beta <= alpha: break
|
||
return value
|
||
else:
|
||
value = math.inf
|
||
for column in range(0,self.COLUMNCOUNT):
|
||
testBoard = copy.deepcopy(board)
|
||
testBoard = self.placeOnBoard(testBoard,player,column)
|
||
if testBoard != None:
|
||
evaluation = await self.minimax(testBoard,depth-1,player%2+1,originalPlayer,alpha,beta,True)
|
||
if evaluation < -9000: evaluation += self.AISCORES["avoid losing"]
|
||
value = min(value,evaluation)
|
||
beta = min(beta,evaluation)
|
||
if beta <= alpha: break
|
||
return value
|
||
|
||
class drawConnectFour():
|
||
def __init__(self, bot):
|
||
self.bot = bot
|
||
|
||
# Draws the whole thing
|
||
def drawImage(self, channel):
|
||
self.bot.log("Drawing connect four board")
|
||
game = self.bot.database["connect 4 games"].find_one({"_id":channel})
|
||
|
||
board = game["board"]
|
||
|
||
border = 40
|
||
gridBorder = 40
|
||
cornerSize = 300
|
||
boardOutlineSize = 10
|
||
pieceOutlineSize = 10
|
||
emptyOutlineSize = 0
|
||
bottomBorder = 110
|
||
exampleCircles = 100
|
||
w, h = 2800,2400
|
||
backgroundColor = (230,230,234,255)
|
||
boardOutlineColor = (0,0,0)
|
||
pieceOutlineColor = (244,244,248)
|
||
emptyOutlineColor = (0,0,0)
|
||
player1Color = (254,74,73)
|
||
player2Color = (254,215,102)
|
||
boardColor = (42,183,202)
|
||
placeSize = 300
|
||
white = (255,255,255,160)
|
||
winBarColor = (250,250,250,255)
|
||
|
||
fnt = ImageFont.truetype('resources/fonts/futura-bold.ttf', exampleCircles)
|
||
|
||
boardSize = [w-(2*(border+gridBorder)),h-(2*(border+gridBorder))]
|
||
placeGridSize = [math.floor(boardSize[0]/7),math.floor(boardSize[1]/6)]
|
||
pieceStartx = (border+gridBorder)+math.floor(placeGridSize[0]/2)-math.floor(placeSize/2)
|
||
pieceStarty = (border+gridBorder)+math.floor(placeGridSize[1]/2)-math.floor(placeSize/2)
|
||
|
||
if game["players"][0] == "Gwendolyn":
|
||
player1 = "Gwendolyn"
|
||
else:
|
||
player1 = self.bot.databaseFuncs.getName(game["players"][0])
|
||
|
||
if game["players"][1] == "Gwendolyn":
|
||
player2 = "Gwendolyn"
|
||
else:
|
||
player2 = self.bot.databaseFuncs.getName(game["players"][1])
|
||
|
||
|
||
background = Image.new("RGB", (w,h+bottomBorder),backgroundColor)
|
||
d = ImageDraw.Draw(background,"RGBA")
|
||
|
||
# This whole part was the easiest way to make a rectangle with rounded corners and an outline
|
||
# - Corners:
|
||
d.ellipse([(border,border),(border+cornerSize,border+cornerSize)],fill=boardColor,outline=boardOutlineColor,width=boardOutlineSize)
|
||
d.ellipse([(w-(border+cornerSize),h-(border+cornerSize)),(w-border,h-border)],fill=boardColor,outline=boardOutlineColor,width=boardOutlineSize)
|
||
d.ellipse([(border,h-(border+cornerSize)),(border+cornerSize,h-border)],fill=boardColor,outline=boardOutlineColor,width=boardOutlineSize)
|
||
d.ellipse([(w-(border+cornerSize),border),(w-border,border+cornerSize)],fill=boardColor,outline=boardOutlineColor,width=boardOutlineSize)
|
||
# - Rectangle:
|
||
d.rectangle([(border+math.floor(cornerSize/2),border),(w-(border+math.floor(cornerSize/2)),h-border)],fill=boardColor,outline=boardOutlineColor,width=boardOutlineSize)
|
||
d.rectangle([(border,border+math.floor(cornerSize/2)),(w-border,h-(border+math.floor(cornerSize/2)))],fill=boardColor,outline=boardOutlineColor,width=boardOutlineSize)
|
||
# - Removing outline on the inside:
|
||
d.rectangle([(border+math.floor(cornerSize/2),border+math.floor(cornerSize/2)),(w-(border+math.floor(cornerSize/2)),h-(border+math.floor(cornerSize/2)))],fill=boardColor)
|
||
d.rectangle([(border+math.floor(cornerSize/2),border+boardOutlineSize),(w-(border+math.floor(cornerSize/2)),h-(border+boardOutlineSize))],fill=boardColor)
|
||
d.rectangle([(border+boardOutlineSize,border+math.floor(cornerSize/2)),(w-(border+boardOutlineSize),h-(border+math.floor(cornerSize/2)))],fill=boardColor)
|
||
|
||
for x, line in enumerate(board):
|
||
for y, piece in enumerate(line):
|
||
|
||
if piece == 1:
|
||
pieceColor = player1Color
|
||
outlineWidth = pieceOutlineSize
|
||
outlineColor = pieceOutlineColor
|
||
elif piece == 2:
|
||
pieceColor = player2Color
|
||
outlineWidth = pieceOutlineSize
|
||
outlineColor = pieceOutlineColor
|
||
else:
|
||
pieceColor = backgroundColor
|
||
outlineWidth = emptyOutlineSize
|
||
outlineColor = emptyOutlineColor
|
||
|
||
startx = pieceStartx + placeGridSize[0]*y
|
||
starty = pieceStarty + placeGridSize[1]*x
|
||
|
||
d.ellipse([(startx,starty),(startx+placeSize,starty+placeSize)],fill=pieceColor,outline=outlineColor,width=outlineWidth)
|
||
|
||
if game["winner"] != 0:
|
||
coordinates = game["win coordinates"]
|
||
startx = border + placeGridSize[0]*coordinates[1] + gridBorder
|
||
starty = border + placeGridSize[1]*coordinates[0] + gridBorder
|
||
a = (placeGridSize[0]*4-gridBorder-border)**2
|
||
b = (placeGridSize[1]*4-gridBorder-border)**2
|
||
diagonalLength = (math.sqrt(a+b))/placeGridSize[0]
|
||
diagonalAngle = math.degrees(math.atan(placeGridSize[1]/placeGridSize[0]))
|
||
|
||
if game["win direction"] == "h":
|
||
winBar = Image.new("RGBA",(placeGridSize[0]*4,placeGridSize[1]),(0,0,0,0))
|
||
winD = ImageDraw.Draw(winBar)
|
||
winD.ellipse([(0,0),(placeGridSize[0],placeGridSize[1])],fill=white)
|
||
winD.ellipse([((placeGridSize[0]*3),0),(placeGridSize[0]*4,placeGridSize[1])],fill=white)
|
||
winD.rectangle([(int(placeGridSize[0]*0.5),0),(int(placeGridSize[0]*3.5),placeGridSize[1])],fill=white)
|
||
|
||
elif game["win direction"] == "v":
|
||
winBar = Image.new("RGBA",(placeGridSize[0],placeGridSize[1]*4),(0,0,0,0))
|
||
winD = ImageDraw.Draw(winBar)
|
||
winD.ellipse([(0,0),(placeGridSize[0],placeGridSize[1])],fill=white)
|
||
winD.ellipse([(0,(placeGridSize[1]*3)),(placeGridSize[0],placeGridSize[1]*4)],fill=white)
|
||
winD.rectangle([0,(int(placeGridSize[1]*0.5)),(placeGridSize[0],int(placeGridSize[1]*3.5))],fill=white)
|
||
|
||
elif game["win direction"] == "r":
|
||
winBar = Image.new("RGBA",(int(placeGridSize[0]*diagonalLength),placeGridSize[1]),(0,0,0,0))
|
||
winD = ImageDraw.Draw(winBar)
|
||
winD.ellipse([(0,0),(placeGridSize[0],placeGridSize[1])],fill=white)
|
||
winD.ellipse([((placeGridSize[0]*(diagonalLength-1)),0),(placeGridSize[0]*diagonalLength,placeGridSize[1])],fill=white)
|
||
winD.rectangle([(int(placeGridSize[0]*0.5),0),(int(placeGridSize[0]*(diagonalLength-0.5)),placeGridSize[1])],fill=white)
|
||
winBar = winBar.rotate(-diagonalAngle,expand=1)
|
||
startx -= 90
|
||
starty -= 100
|
||
|
||
elif game["win direction"] == "l":
|
||
winBar = Image.new("RGBA",(int(placeGridSize[0]*diagonalLength),placeGridSize[1]),(0,0,0,0))
|
||
winD = ImageDraw.Draw(winBar)
|
||
winD.ellipse([(0,0),(placeGridSize[0],placeGridSize[1])],fill=white)
|
||
winD.ellipse([((placeGridSize[0]*(diagonalLength-1)),0),(placeGridSize[0]*diagonalLength,placeGridSize[1])],fill=white)
|
||
winD.rectangle([(int(placeGridSize[0]*0.5),0),(int(placeGridSize[0]*(diagonalLength-0.5)),placeGridSize[1])],fill=white)
|
||
winBar = winBar.rotate(diagonalAngle,expand=1)
|
||
startx -= placeGridSize[0]*3 + 90
|
||
starty -= gridBorder + 60
|
||
|
||
|
||
mask = winBar.copy()#.convert("L")
|
||
#mask.putalpha(128)
|
||
#mask.save("test.png")
|
||
|
||
winBarImage = Image.new("RGBA",mask.size,color=winBarColor)
|
||
background.paste(winBarImage,(startx,starty),mask)
|
||
|
||
# Bottom
|
||
textPadding = 20
|
||
|
||
exampleHeight = h - border + int((bottomBorder+border)/2) - int(exampleCircles/2)
|
||
d.ellipse([(border,exampleHeight),(border+exampleCircles),(exampleHeight+exampleCircles)],fill=player1Color,outline=boardOutlineColor,width=3)
|
||
d.text((border+exampleCircles+textPadding,exampleHeight),player1,font=fnt,fill=(0,0,0))
|
||
|
||
textWidth = fnt.getsize(player2)[0]
|
||
d.ellipse([(w-border-exampleCircles-textWidth-textPadding,exampleHeight),(w-border-textWidth-textPadding),(exampleHeight+exampleCircles)],fill=player2Color,outline=boardOutlineColor,width=3)
|
||
d.text((w-border-textWidth,exampleHeight),player2,font=fnt,fill=(0,0,0))
|
||
|
||
|
||
background.save("resources/games/connect4Boards/board"+channel+".png")
|
||
|