def main():
args = parse_args()
proxy = setup_proxy(args.proxy_url, args.proxy_auth)
image = Image(args.file)
bot = Bot(image, args.fingerprint, args.start_x, args.start_y, args.mode_defensive, args.colors_ignored, proxy, args.draw_strategy)
bot.run()
def entry():
try:
if request.args.get(SALAM_BOT_TOKEN_KEY) != SALAM_BOT_TOKEN_VALUE:
raise Exception('BAD_TOKEN')
bot = Bot(json.loads(request.get_data()))
bot.run()
return jsonify({'success': 'true'})
except Exception as e:
logging.error(e, exc_info=True)
abort(404)
import json
from src.bot import Bot
import os
config = json.load(open(os.path.abspath("./config.json")))
bot = Bot(config)
bot.run()
#!/usr/bin/env python3
import sys
import traceback
import redis
from src.bot import Bot
from src.utils import fprint
from src.const import BOT, TOKEN, REDIS_URL, DEFAULT_COGS
db = redis.from_url(REDIS_URL)
bot = Bot(db)
if __name__ == "__main__":
for cog in DEFAULT_COGS:
try:
bot.load_extension("src.cogs." + cog)
except Exception:
fprint(f"Failed to load cogs ({cog})", file=sys.stderr)
traceback.print_exc()
bot.run(TOKEN, bot=BOT, reconnect=True)
import os
# lets get all our details like the bot token
# the token
from config import *
from src.bot import Bot
from src.tweeter import Twitter
myBot = Bot(SLACK_TOKEN_ID, bot_user="******")
twitter = Twitter(consumer_key=CONSUMER_KEY, consumer_secret=CONSUMER_SECRET,
access_token=ACCESS_TOKEN, access_token_secret=ACCESS_TOKEN_SECRET)
twitter.auth()
myBot.registerListener(twitter.listenForMsg,'message')
twitter.registerListener(myBot.listenForMsg, 'tweet')
if __name__ == "__main__":
myBot.run()
def __run_bot(event, data=()):
bot = Bot({
'event': event,
'data': data,
})
bot.run()
from os import getenv
from dotenv import load_dotenv
from src.bot import Bot
load_dotenv()
bot = Bot()
bot.load_extensions(
"jishaku",
"src.cogs.logging",
)
bot.run(getenv("TOKEN"))
class Game:
def __init__(self) -> None:
# basic init for pygame: window/screen, blackground, clock and fonts
# fonts need to be initialized extra
pygame.init()
pygame.font.init()
pygame.display.set_caption(GAME_NAME)
self.window = pygame.display.set_mode(
(WINDOW_SIZE_X + TERMINAL_WIDTH, WINDOW_SIZE_Y))
self.background = pygame.Surface(
(TILE_HEIGHT * ROWS, TILE_WIDTH * COLS))
self.clock = pygame.time.Clock()
self.terminal_font = pygame.font.SysFont(FONT_TYPE, TERMINAL_FONT_SIZE)
self.description_font = pygame.font.SysFont(FONT_TYPE,
DESCRIPTION_FONT_SIZE)
self.game_over_font = pygame.font.SysFont(FONT_TYPE,
GAME_OVER_FONT_SIZE)
# init chessboard
# an array of meeples is created that reflects the default setup
# sprites are loaded from board list which are then added to the sprite group, because it is easier to draw them
self.board = Chessboard()
self.sprites = self.board.loadSprites()
self.chess_sprite_list = pygame.sprite.Group()
self.chess_sprite_list.add(self.sprites)
# tile representation of the chessboard
# used to determine tile/meeple on click events
self.chessboard_tiles = self.board.loadTiles(self.background)
# init terminal
# clickable button without UX -> no highlighting are click reaction
# terminal window that logs the moves performed by the players
# notations for each player are saved to different arrays; if notations exceed 28 lines -> list.pop is used / no scrolling possible
# instance variables for a white meeple that a player has selected and the possbile moves for the according meeple
self.terminal = Terminal(self.terminal_font)
# init black player
self.bot = Bot()
# draw terminal on the right side of the game window including a "new game" button
drawTerminal(self)
# conditions for the game loop
self.gameRunning = True # condition for gameloop
self.playerTurn = True # white starts playing
self.selectedField = False # player has selected a field
self.check_white = False
self.check_black = False
self.draw = False
self.check_mate_white = False
self.check_mate_black = False
# init first possible moves for white player
# saves the next possibles for each side
self.number_of_moves = self.board.getAllMoves("w")
def run(self):
while self.gameRunning:
if pygame.event.get(pygame.QUIT):
sys.exit()
# white player's turn
if self.playerTurn:
if pygame.event.get(pygame.MOUSEBUTTONDOWN):
mouse_x, mouse_y = pygame.mouse.get_pos()
# reset the game when clicking on the "new game" button by calling __init__ from Game
if self.terminal.button.collidepoint((mouse_x, mouse_y)):
self.__init__()
self.board.getAllMoves("w")
if self.number_of_moves > 0:
self.check_white = False
# finds selected tiles on the chessboard
selected_tile = [
tile for tile in self.chessboard_tiles
if tile.collidepoint((mouse_x, mouse_y))
]
# if a position outside the chessboard was selected, jump to the next iteration of the game loop
# prevents out of bound exception
if len(selected_tile) != 1:
continue
tile_x, tile_y = convert(selected_tile[0].x,
selected_tile[0].y)
# in this game status the white player has to select a meeple to see possible moves
# a move can only be performed when a highlighted possible move is clicked
if not self.selectedField:
meeple = self.board.highlightMeeple(
tile_x, tile_y) # choose from available moves
# if the clicked meeple is a white meeple -> the according tiles are highlighted
if meeple != None and meeple.colour == "w":
moves = meeple.possible_moves
self.board.highlightMoves(moves)
self.selectedField = True
else:
# while possible moves (yellow tiles) are displayed, clicking on the highlighted meeple (green) or on any
# other tile on the chessboard, desselects the possible moves and the highlighted meeple and returns to previous
# if statement where the player has to select a meeple
if not (tile_x,
tile_y) in self.board.highlightedMoveTiles:
self.board.highlightMoves([])
self.board.highlightedMeeple = None
self.selectedField = False
else:
# if a hightlighted possible move is clicked (yellow tiles), the move to this tile is performed
# sprites group is updated, check status calculated and move rendered on terminal
self.board.highlightMoves([])
result = self.board.moveMeeple(
(tile_x, tile_y))
self.updateSprites()
self.check_black = self.board.king_b.isCheck(
self.board)
self.number_of_moves = self.board.getAllMoves(
"b")
self.displayNotation(result)
self.playerTurn = False
# black player's turn represented by a stupid computer player
else:
self.playerTurn = True
self.selectedField = False
# directly skip to end game screen when black is check mate; if possibles moves is > 0 check can be dissolved because
# there are only moves calculated that "free" the king of check
if self.number_of_moves > 0:
# delay black side move a little bit to see that the black king was checked
pygame.time.delay(400)
self.check_black = False
meeple = self.bot.run(self.board)
meeple = self.board.highlightMeeple(meeple.x, meeple.y)
result = self.board.moveMeeple(
random.choice(meeple.possible_moves))
self.updateSprites()
self.check_white = self.board.king_w.isCheck(self.board)
self.number_of_moves = self.board.getAllMoves("w")
self.displayNotation(result, "b")
#draw GUI - end of loop
self.drawChessboard()
if self.draw or self.check_mate_black or self.check_mate_white:
showGameOver(self)
pygame.display.flip()
self.clock.tick(30)
# when a meeple is moved, the function is used to update the sprites group which is rendered thereafter
def updateSprites(self):
self.chess_sprite_list.empty()
meeple_sprites = self.board.loadSprites()
self.chess_sprite_list.add(meeple_sprites)
def displayNotation(self, result: List, side: str = "w") -> None:
if side == "w":
if self.number_of_moves > 0 and self.check_black:
result[6].append("check")
self.check_black = True
if self.number_of_moves < 1 and self.check_black:
result[6].append("check_mate")
self.check_mate_black = True
if self.number_of_moves < 1 and not self.check_black:
result[6].append("draw")
self.draw = True
else:
if self.number_of_moves > 0 and self.check_white:
result[6].append("check")
self.check_white = True
if self.number_of_moves < 1 and self.check_white:
result[6].append("check_mate")
self.check_mate_white = True
if self.number_of_moves < 1 and not self.check_white:
result[6].append("draw")
self.draw = True
self.terminal.addNotation(result, side)
# important that all drawings on the chessboard are in one function so the layering can be controlled
def drawChessboard(self) -> None:
self.window.blit(self.background, (0, 0))
pygame.draw.rect(self.window, COLOUR_WHITE, self.terminal.button)
pygame.draw.rect(self.window, COLOUR_WHITE,
self.terminal.terminal_background)
self.window.blit(self.terminal.button_text,
(BUTTON_TEXT_X, BUTTON_TEXT_Y))
# indicator for the selected meeple and the resulting possible moves
# selected player meeple is highlighted with a green rec while possible moves are indicated with yellow recs
highlights = self.board.drawHighlightedMeeple(
) + self.board.drawHighlightedMoves()
board_description = self.board.loadChessboardDescription(
self.description_font)
for highlight_info in highlights:
if highlight_info != None:
self.window.blit(highlight_info[0],
(highlight_info[1], highlight_info[2]))
# board descrption in red color that indicate the row and col
for letter_info in board_description[0]:
if letter_info != None:
self.window.blit(letter_info[0],
(letter_info[1], letter_info[2]))
for number_info in board_description[1]:
if number_info != None:
self.window.blit(number_info[0],
(number_info[1], number_info[2]))
# draws text from terminal arrays to terminal box with a column for white (left side) including the numbered round and black (right side)
for index, text in enumerate(self.terminal.terminal_white_notation):
self.window.blit(text, (TERMINAL_TEXT_X_WHITE, TERMINAL_TEXT_Y +
index * TERMINAL_TEXT_Y_OFFSET))
for index, text in enumerate(self.terminal.terminal_black_notation):
self.window.blit(text, (TERMINAL_TEXT_X_BLACK, TERMINAL_TEXT_Y +
index * TERMINAL_TEXT_Y_OFFSET))
# draws a red rectangle under the kings if they are check
if self.check_black:
surface = pygame.Surface((TILE_WIDTH, TILE_HEIGHT))
surface.set_alpha(COLOUR_ALPHA)
surface.fill(COLOUR_RED)
self.window.blit(surface, (self.board.king_b.x * TILE_HEIGHT,
self.board.king_b.y * TILE_WIDTH))
if self.check_white:
surface = pygame.Surface((TILE_WIDTH, TILE_HEIGHT))
surface.set_alpha(COLOUR_ALPHA)
surface.fill(COLOUR_RED)
self.window.blit(surface, (self.board.king_w.x * TILE_HEIGHT,
self.board.king_w.y * TILE_WIDTH))
#draw sprites at last so they are on top of everything
self.chess_sprite_list.draw(self.window)
