AI Algorithm for Reversed Reversi

AI Algorithm for Reversed Reversi
March 14, 2024
Abstract
Reversed Reversi is a relatively simple board game. Players take turns placing chess
pieces on the board with their assigned color facing up. During a play, any pieces of the
opponent’s color that are in a straight line and bounded by the piece just placed and
another piece of the current player’s color are turned over to the current player’s color.
The object of the game is to have the fewest pieces turned to display your color when
the last playable empty square is filled. In this assignment, we use the default board of
size 8*8 board (administrators can modify the settings as needed). Students need to
implement the AI algorithm of Reversed Reversi according to the interface requirements
and submit it to the platform as required for the usability tests and round-robin.
1 Schedule
The Project is divided into two phases, each with one or two weeks for coding and improving
your current coding.
Evaluation Rule DeadLine
Phase 1 Score according to the number of test cases passed. 2024/03/29
Phase 2 Score according to the rank in round-robin. 2024/04/12
Coding_Score = Phase1+Phase2 (Parse1:Parse2=1:2)
2 How to Use The Platform
The Reversed Reversi platform is logged in with your student ID and password. The default
password is your student ID. At the first login, the platform will ask you to change your
password. After logging in successfully, you can see the page below.
Now, you can submit your own AI algorithm to the Reversed Reversi battle platform.
The platform will first do the usability tests after submission. The submission is successful
only if your AI algorithm passes the usability tests. After submitting your AI algorithm
successfully, you can click on “Auto Play” to challenge the players who rank ahead of you for
a PK. In order to avoid the first-hand advantage, the PK is played for 2 rounds with each
1
Figure 1: Home page
other starting the game first. In each round, if one of your wins, then his (or her) score is
increased by 5 points. If one of you loses, then his (or her) score is reduced by 5 points. If
a draw occurs, both of your scores remain unchanged.
The whole battle process will be recorded for each match. You can play back the game
you just experienced by playing and backing写 AI Algorithm for Reversed  buttons, or you can download the game data as
a text file so that you can debug or review their code and algorithms. On the right side, you
can see the leader-boards, showing only the top ten and their points, as well as your ranking
and points. Click on “play” to see the live broadcast for the battle of the top-ten players.
If you want to evaluate your newly uploaded algorithm, please use the function of “playto”.
Just input the opponent’s Student ID you want to challenge and click “playto”, then you can
play a pre-PK with this opponent. This pre-PK will not affect your rankings.
Your ranking on the platform does not affect your final score. The platform
is just a tool to help you improve your algorithm.
After the Phase 2 DDL, the round-robin is started. Every students will play a PK with
each other students. The score is accumulated, and each student’s ranking is given according
to the final points.
3 Code Requirements
1. Version Details
2
(a) Python version: 3.7.6
(b) Numpy: 1.21.0
(c) Numba: 0.56.4
2. Code template:
1 import numpy as np
2 import random
3 import time
4
5 COLOR_BLACK=−1
6 COLOR_WHITE=1
7 COLOR_NONE=0
8 random.seed(0)
9 #don’t change the class name
10 class AI(object):
11 #chessboard_size, color, time_out passed from agent
12 def __init__(self, chessboard_size, color , time_out):
13 self .chessboard_size = chessboard_size
14 # You are white or black
15 self . color = color
16 # the max time you should use, your algorithm’s run
17 # time must not exceed the time limit.
18 self .time_out = time_out
19 # You need to add your decision to your candidate_list.
20 # The system will get the end of your candidate_list as your decision.
21 self . candidate_list = []
22
23 # The input is the current chessboard. Chessboard is a numpy array.
24 def go( self , chessboard ):
25 # Clear candidate_list, must do this step
26 self . candidate_list . clear ()
27 #============================================
28 #Write your algorithm here
29 #Here is the simplest sample:Random decision
30 idx = np.where(chessboard == COLOR_NONE)
31 idx = list (zip(idx [0], idx [1]))
32 #==============Find new pos==================
33 # Make sure that the position of your decision on the chess board is empty.
34 # If not, the system will return error.
35 # Add your decision into candidate_list, Records the chessboard
36 # You need to add all the positions which are valid
37 # candidate_list example: [(3,3),(4,4)]
38 # You need append your decision at the end of the candidate_list,
39 # candidate_list example: [(3,3),(4,4),(4,4)]
3
40 # we will pick the last element of the candidate_list
41 # as the position you choose.
42 # In above example, we will pick (4,4) as your decision.
43 # If there is no valid position , you must return an empty list.
3. Time measurement
1 start = time.time()
2 # Your algorithm
3 run_time = (time.time() − start)
4. Note: import os is not allowed to use.
5. The usage of memory cannot go more than 100M, the time to find a place to drop
cannot be longer than 5s, the whole battle cannot be longer than 180s.
4 Requirements for Each Phase
4.1 Phase 1
Usability tests: In this tests, we will use some simple board test cases where students need
to find the best place to drop. Only jobs that pass the usability test can pass. This is to
prevent students from submitting code including illegal operations, infinite loop or random
drop. The usability tests includes: the os package cannot be imported in the code file to
prevent the student code from affecting the platform.
A total of 10 test cases were prepared, each with 10 points, and the scores were determined
by the number of test cases passed.
4.2 Phase 2
Students who pass the usability tests can use the platform to improve the algorithm. The
specific competition rules of the platform are as follows: Students can submit their AI
algorithm to the Reversed Reversi battle platform (it is a successful submission if it passes
the usability tests). After a successful submission, you can click on “Auto Play” to challenge
the player who ranks ahead of you for a PK. In order to avoid the first-hand advantage, the
PK is played for 2 rounds with each one starting the game first. In each round, if one of
your wins, then his (or her) score is increased by 5 points. If one of you loses, then his (or
her) score is reduced by 5 points. If a draw occurs, both of your scores remain unchanged.
Students can submit and update their AI algorithm to the Reversed Reversi battle platform before Phase 2 DDL. After the Phase 2 DDL, the round-robin is started. Every student
will play a PK with each other. The score is accumulated and the ranking for each student
WX：codinghelp