def test_board_initial_state():
board = Board()
board._populate_with_default()
nose.tools.ok_(isinstance(board['a1'], Rook))
nose.tools.ok_(isinstance(board['b1'], Knight))
nose.tools.ok_(isinstance(board['c1'], Bishop))
nose.tools.ok_(isinstance(board['d1'], Queen))
nose.tools.ok_(isinstance(board['e1'], King))
nose.tools.ok_(isinstance(board['f1'], Bishop))
nose.tools.ok_(isinstance(board['g1'], Knight))
nose.tools.ok_(isinstance(board['h1'], Rook))
nose.tools.ok_(isinstance(board['a8'], Rook))
nose.tools.ok_(isinstance(board['b8'], Knight))
nose.tools.ok_(isinstance(board['c8'], Bishop))
nose.tools.ok_(isinstance(board['d8'], Queen))
nose.tools.ok_(isinstance(board['e8'], King))
nose.tools.ok_(isinstance(board['f8'], Bishop))
nose.tools.ok_(isinstance(board['g8'], Knight))
nose.tools.ok_(isinstance(board['h8'], Rook))
for col in COLUMNS:
nose.tools.ok_(isinstance(board[col + '2'], Pawn))
nose.tools.ok_(isinstance(board[col + '7'], Pawn))
nose.tools.eq_(board[col + '1'].color, Color.White)
nose.tools.eq_(board[col + '2'].color, Color.White)
nose.tools.eq_(board[col + '3'], None)
nose.tools.eq_(board[col + '4'], None)
nose.tools.eq_(board[col + '5'], None)
nose.tools.eq_(board[col + '6'], None)
nose.tools.eq_(board[col + '7'].color, Color.Black)
nose.tools.eq_(board[col + '8'].color, Color.Black)
class TextPresenter:
def __init__(self):
self._board = Board()
def get_piece_from_location(self, location):
return self._board.get_piece_from_location(location)
def print_board(self):
for i in range(7, -1, -1):
row = str(i + 1) + " "
for j in range(7, -1, -1):
piece_on_location = self.get_piece_from_location((i, j))
if (i + j) % 2 == 1:
row += " " + piece_on_location + " "
else:
row += "[" + piece_on_location + "]"
print(row)
final_row = " A B C D E F G H"
print(final_row)
def move_piece(self, loc_str, new_loc_str):
try:
location = Location(loc_str)
new_location = Location(new_loc_str)
self.move(location, new_location)
except (InvalidMoveException, InvalidLocationException):
print("Invalid move: " + loc_str + " -> " + new_loc_str)
def validate_move(self, location, new_location):
pass
def move(self, location, new_location):
self.validate_move(location, new_location)
self._board.get_piece_from_location()
def run_AI_battle(player1, player2, gameNumber):
if isinstance(player1, AI_Player) and isinstance(player2, AI_Player):
p1Win = 0
p2Win = 0
draw = 0
for i in range(int(gameNumber / 2)):
board = Board()
player1.set_board(board)
player2.set_board(board)
game = AI_Game(board, player1, player2)
res = game.run()
if res == 0:
p1Win += 1
elif res == 1:
p2Win += 1
else:
draw += 1
print(res)
for i in range(gameNumber - int(gameNumber / 2)):
board = Board()
player1.set_board(board)
player2.set_board(board)
game = AI_Game(board, player2, player1)
res = game.run()
if res == 0:
p2Win += 1
elif res == 1:
p1Win += 1
else:
draw += 1
print(res)
return [p1Win, p2Win, draw]
else:
print("Erreur : Les 2 joueurs doivent être des IA")
def test_board_move_exceptions():
board = Board()
board._populate_with_default()
nose.tools.assert_raises(InvalidLocationException,
board.move, 'dg3', 'd4')
nose.tools.assert_raises(EmptyLocationException,
board.move, 'd3', 'd4')
nose.tools.assert_raises(EmptyLocationException,
board.move, 'd5', 'd2')
def add():
u = current_user()
if not u:
return redirect(url_for("topic.index"))
if request.method == "GET":
return render_template("board/add_board.html")
else:
Board.new_and_save(request.form)
return redirect(url_for("topic.index"))
class Chess():
def __init__(self):
self.board = Board()
self.win = None
self.setup()
def setup(self):
print("Welcome to Chess, type 'Start' to play.")
while (input().lower() != "start"):
pass
self.running()
def running(self):
while self.win == None:
self.playerTurn()
if not self.win:
self.aiTurn()
def playerTurn(self):
self.board.toString()
print("Type 'move yx' where y is A to H and x is 1 to 8.")
command = ""
while self.invalidCommand(command):
command = input()
print("Invalid Command")
words = command.split(' ')
piece = self.board.get(words[1])
print(piece.toString())
def invalidCommand(self, command):
try:
words = command.split(' ')
if words[0] != "move":
return True
if words[2] != "to":
return True
if not isCoords(words[1]):
return True
if not isCoords(words[3]):
return True
return False
except:
return True
def isCoords(self, coords):
if coords[0] in ROWS:
if coords[1] in range(8):
return True
return False
def aiTurn(self):
pass
def resolve_battle_handler():
data = request.get_json()
board1 = Board.from_dict(data['player1'])
board2 = Board.from_dict(data['player2'])
winner, player_hp_change, log = resolve_battle(board1, board2)
return {
"winner": winner,
"playerHpChange": player_hp_change,
"log": log,
}
def run():
# Board
board = Board()
# AI
# P1
#oracle1 = AI_MonteCarlo(board, Co.P1_PIECE, 3000)
#player1 = AI_Player("Player 1", oracle1.board, oracle1.piece, oracle1)
oracle2 = AI_MonteCarlo_Up_Heur(board, Co.P2_PIECE, 1000)
player2 = AI_Player("Player 2", oracle2.board, oracle2.piece, oracle2)
# Human
player1 = Player("Player 1", board, Co.P1_PIECE)
#player2 = Player("Player 2", board, Co.P2_PIECE)
# View
#view = TextView()
view = GraphicView()
# Game / Controller
game = Game(board, player1, player2, view)
res = game.run()
if isinstance(view, GraphicView):
time.sleep(5)
print(res)
def mainGUI():
app = QApplication(sys.argv)
try:
# ajout de l'id de l'application
myappid = 'ValentinLe.lecteur_musique'
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
except AttributeError:
pass
# ajout de l'icone de l'application
app.setWindowIcon(QIcon(QPixmap("assets/logo.ico")))
# couleurs pour la scrollBar
palette = QPalette()
palette.setColor(QPalette.Base, QColor("#454545"))
palette.setColor(QPalette.Light, QColor("#454545"))
app.setPalette(palette)
# affichage de la fenetre principale
board = Board()
window = MainWindow(board)
window.setWindowTitle("Musique")
window.showMaximized()
# window.show()
sys.exit(app.exec_())
def main():
board = Board()
engine = GameEngine(board)
cross_player = AIPlayer(1, "dude", engine)
noughts_player = HumanPlayer(-1, "Rand", engine)
view = BoardView(board)
done = False
view.update()
while not done:
try:
cross_player.make_move()
view.update()
if engine.game_ended():
view.reset()
continue
noughts_player.make_move()
view.update()
if engine.game_ended():
view.reset()
continue
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
except Exception:
traceback.print_exc()
def get_board(self, board_id):
url = self.base_url + board_id
response = self.initialize_board(url)
if response is not None:
data = response.json()
return Board(data)
else:
return
def init_game(self, size):
self.board = Board(size)
self.speed = 10
self.prev_limit = 0
self.level_limit = 500
self.level = 1
self.score = 0
self.player.init()
def new_and_save(cls, form=None, **kwargs):
m = cls.new(form, **kwargs)
user_id = form.get("user_id")
user = User.find_by_id(int(user_id))
m.username = user.username
board_id = form.get("board_id")
m.board = Board.find_by_id(board_id).title
m.save()
return m
def add():
u = current_user()
if not u:
return redirect(url_for("auth.login"))
if request.method == "GET":
boards = Board.all()
return render_template("topic/add.html", user_id=u.id, boards=boards)
Topic.new_and_save(request.form)
return redirect(url_for(".index"))
def index():
board_id = request.args.get("board", None)
if board_id:
board_id = int(board_id)
topics = get_topics(board_id)
boards = Board.all()
user = current_user()
return render_template("topic/index.html",
user=user,
topics=topics,
board_id=board_id,
boards=boards)
def setup_boards(json_settings):
for board_info in json_settings["boards"]:
name = board_info["name"]
threadlimit = board_info.get("threadlimit") or json_settings["default_threadlimit"]
mimetypes = board_info.get("mimetypes")
if mimetypes is None:
mimetypes = json_settings["default_mimetypes"]
extra_mimetypes = board_info.get("extra_mimetypes")
if extra_mimetypes:
mimetypes = mimetypes + "|" + extra_mimetypes
rule_file = board_info.get("rules")
rules = ""
if rule_file:
rules = open(os.path.join("deploy-configs", rule_file)).read()
board = Board(name=name, max_threads=threadlimit, mimetypes=mimetypes, rules=rules)
db.session.add(board)
def test_init():
d = {
"units": [
{
"id": "43",
"attack": 1,
"defense": 10,
"magicResist": 10,
"criticalChance": 40,
"hp": 100,
"range": 40,
"attackSpeed": 10,
"type": "MAGICAL/PHYSICAL",
"price": 100
},
{
"id": "44",
"attack": 1,
"defense": 10,
"magicResist": 10,
"criticalChance": 40,
"hp": 100,
"range": 40,
"attackSpeed": 10,
"type": "MAGICAL/PHYSICAL",
"price": 100
},
],
"unitsPlacement": [
{"unitId": "43", "x": 2, "y": 3},
{"unitId": "44", "x": 5, "y": 7},
],
}
board = Board.from_dict(d)
assert len(board.tokens) == 2
token43, token44 = board.tokens
assert token43.unit.id == "43"
assert token43.position == (2, 3)
assert token44.unit.id == "44"
assert token44.position == (5, 7)
def __init__(self):
self.board = Board()
self.win = None
self.setup()
import os
from customjsonencoder import CustomJSONEncoder
from model.Board import Board
from model.Slip import gen_slip
from model.Tag import Tag
import model.Media
import model.Poster
from shared import db
db.create_all()
# set up some boards
for board_name in ("anime", "tech", "meta", "politics", "gaming", "music"):
board = Board(name=board_name)
db.session.add(board)
# admin credentials generation
admin = gen_slip("admin", "admin")
admin.is_admin = True
db.session.add(admin)
# special tags
for tag_name, bg_style, text_style in (("general", "bg-secondary", "text-light"),):
tag = Tag(name=tag_name, bg_style=bg_style, text_style=text_style)
db.session.add(tag)
db.session.commit()
# write a secret so we can have session support
open("secret", "w").write(str(os.urandom(16)))
# create upload and thumbnail directory if necessary
if not os.path.exists("uploads/thumb"):
os.makedirs("uploads/thumb")
def __init__(self):
self._board = Board()
from model.Snake import Snake
from model.Board import Board
from tkinter import Tk, Label, Button
import tkinter as tk
snake = Snake(0, 0, 3, 2)
board = Board(20, 20)
class MyFirstGUI:
def __init__(self, master):
self.master = master
master.title("PythonGame - Snake inspired")
self.label = Label(master, text="Hello in PythonGame!")
self.label.pack()
self.greet_button = Button(master, text="Start!", command=self.greet)
self.greet_button.pack()
self.close_button = Button(master,
text="Hall Of Fame",
command=self.hall_of_fame)
self.close_button.pack()
self.close_button = Button(master, text="Exit", command=master.quit)
self.close_button.pack()
def greet(self):
print("Greetings!")
def test_move_pawn_forward_one():
board = Board()
board._populate_with_default()
board.move('d2', 'd3')
nose.tools.ok_(isinstance(board['d3'], Pawn))
nose.tools.ok_(board.is_location_empty('d2'))
board = Board.from_dict(d)
assert len(board.tokens) == 2
token43, token44 = board.tokens
assert token43.unit.id == "43"
assert token43.position == (2, 3)
assert token44.unit.id == "44"
assert token44.position == (5, 7)
@pytest.mark.parametrize('board, expected', [
(
Board([]),
False
),
(
Board([
Token(Unit(id=2, hp=0), (3, 5))
]),
False
),
(
Board([
Token(Unit(id=2, hp=100), (3, 5))
]),
True
),
(
def test_board_is_location_empty():
board = Board()
nose.tools.ok_(board.is_location_empty("d2"))
nose.tools.ok_(board.is_location_empty("a1"))
nose.tools.ok_(board.is_location_empty("h7"))
def index():
if get_slip() and get_slip().is_admin:
boards = db.session.query(Board).all()
slips = db.session.query(Slip).all()
if (request.method == "POST"):
for slip in slips:
admin_status = request.form.getlist(slip.name + "_grant_admin")
mod_status = request.form.getlist(slip.name + "_grant_mod")
revoke_slip = request.form.getlist(slip.name + "_revoke_slip")
new_board_name = request.form.getlist("board_name")
# editing mod/admin status
if (len(admin_status) > 0 and admin_status[0] == "on"):
slip.is_admin = True
else:
slip.is_admin = False
if (len(mod_status) > 0 and mod_status[0] == "on"):
slip.is_mod = True
else:
slip.is_mod = False
old_slip = db.session.query(Slip).filter(
Slip.name == slip.name).one()
old_slip.is_admin = slip.is_admin
old_slip.is_mod = slip.is_mod
# revoking slip
if (len(revoke_slip) > 0 and revoke_slip[0] == "on"):
db.session.query(Slip).filter(
Slip.name == slip.name).delete()
# add board
if (len(new_board_name) > 0 and len(new_board_name[0]) > 0):
# check to see that board already exists
existing_boards = db.session.query(Board).filter(
Board.name == new_board_name[0]).all()
if (len(existing_boards) == 0):
new_board = Board(name=new_board_name[0],
max_threads=50,
mimetypes="",
rules="",
subreddits="")
db.session.add(new_board)
# Delete board
for board in boards:
delete_board = request.form.getlist(board.name +
"_delete_board")
if (len(delete_board) > 0 and delete_board[0] == "on"):
boards_to_delete = db.session.query(Board).filter(
Board.name == board.name).all()
for tmp_board in boards_to_delete:
threads_to_delete = db.session.query(Thread).filter(
Thread.board == tmp_board.id).all()
for thread in threads_to_delete:
posts_to_delete = db.session.query(Post).filter(
Post.thread == thread.id).all()
for post in posts_to_delete:
db.session.query(Post).filter(
Post.id == post.id).delete()
db.session.query(Thread).filter(
Thread.id == thread.id).delete()
db.session.query(Board).filter(
Board.id == tmp_board.id).delete()
db.session.commit()
# edit FAQ
faq = request.form.getlist("faq")
if (len(faq) > 0):
faq = faq[0]
# edit rules
rules = request.form.getlist("rules")
if (len(rules) > 0):
rules = rules[0]
elif (request.method == "GET"):
print("doing nothing")
return render_template("site-admin.html",
boards=boards,
slips=slips,
faq=render_template("faq.html"),
rules=render_template("rules.html"))
else:
flash("Only admins can access board administration!")
return redirect(url_for("main.faq"))
