public async Task <string> InsertEngine(QuantumChessEngine engine)
{
var game = new Game(ObjectId.GenerateNewId(), engine);
await ActiveGames_.InsertOneAsync(ChessBsonSerializationUtils.Serialize(game));
return(game.Id.ToString());
}
private async Task <dynamic> GameInfo(dynamic args, CancellationToken cancellation_token)
{
string game_id = Request.Query["gameId"];
QuantumChessEngine engine = await WebAppManagers.DatabaseManager.RequestEngine(game_id);
var response = new Model.InfoResponse();
response.ActivePlayer = PlayerUtils.ToString(engine.ActivePlayer);
response.GameState = GameStateUtils.ToString(engine.GameState);
response.Squares = new Dictionary <String, Model.InfoResponse.SquareEncoded>();
for (int i = 0; i < 64; i++)
{
Position pos = Position.FromIndex(i);
QuantumPiece qpiece = engine.QuantumChessboard.GetQuantumPiece(pos);
if (qpiece.Piece.HasValue)
{
response.Squares[pos.ToString()] = new Model.InfoResponse.SquareEncoded()
{
Player = PlayerUtils.ToString(qpiece.Piece.Value.Player),
Piece = PieceTypeUtils.ToString(qpiece.Piece.Value.PieceType),
Probability = qpiece.Probability
};
}
else
{
response.Squares[pos.ToString()] = null;
}
}
response.LastMovePositions = engine.LastMovePositions.Select((pos) => pos.ToString().ToLower()).ToArray();
return(Response.AsJson(response));
}
public static QuantumChessMove ReadMoveRepeated(QuantumChessEngine engine)
{
for (;;)
{
try {
return(ReadMove(engine));
} catch (MoveParseException e) {
Console.WriteLine(e.Message);
}
}
}
public QuantumChessMove Parse(QuantumChessEngine engine)
{
if (MoveType == "ordinary")
{
Position source = Position.Parse(Source);
Position target = Position.Parse(Target);
Piece? piece = engine.QuantumChessboard.GetQuantumPiece(source).Piece;
if (piece.HasValue)
{
return(new OrdinaryMove(piece.Value, source, target));
}
else
{
throw new MoveParseException($"No piece found at {source}");
}
}
else if (MoveType == "quantum")
{
Position source = Position.Parse(Source);
Position?middle = null;
if (!String.IsNullOrEmpty(Middle))
{
middle = Position.Parse(Middle);
}
Position target = Position.Parse(Target);
Piece? piece = engine.QuantumChessboard.GetQuantumPiece(source).Piece;
if (piece.HasValue)
{
return(new QuantumMove(piece.Value, source, middle, target));
}
else
{
throw new MoveParseException($"No piece found at {source}");
}
}
else if (MoveType == "capitulate")
{
return(new CapitulateMove(engine.ActivePlayer));
}
else if (MoveType == "castle_left")
{
return(new CastleMove(engine.ActivePlayer, CastleType.Left));
}
else if (MoveType == "castle_right")
{
return(new CastleMove(engine.ActivePlayer, CastleType.Right));
}
else
{
throw new MoveParseException($"Unsupported move type: {MoveType}");
}
}
public static void Main(string[] args)
{
int cols = 8;
if (args.Length >= 1)
{
cols = Convert.ToInt32(args[0]);
}
var engine = new QuantumChessEngine();
for (;;)
{
Output.DisplayQuantumChessboard(engine.QuantumChessboard, cols);
Console.WriteLine();
for (;;)
{
try {
QuantumChessMove move = Input.ReadMoveRepeated(engine);
engine.Submit(move);
break;
} catch (MoveParseException e) {
Console.WriteLine(e.Message);
} catch (MoveProcessException e) {
Console.WriteLine(e.Message);
}
}
switch (engine.GameState)
{
case GameState.WhiteVictory:
Console.WriteLine();
Console.WriteLine("White victory!");
return;
case GameState.BlackVictory:
Console.WriteLine();
Console.WriteLine("Black victory!");
return;
case GameState.Tie:
Console.WriteLine();
Console.WriteLine("Players are tied!");
return;
}
}
}
public static Game Deserialize(BsonDocument document)
{
ObjectId id = document["_id"].AsObjectId;
Player active_player = PlayerUtils.FromString(document["active_player"].AsString);
GameState game_state = GameStateUtils.FromString(document["game_state"].AsString);
DateTime creation_time = document["creation_time"].ToLocalTime();
var harmonics = new List <QuantumHarmonic>();
foreach (BsonValue bson_harmonic_val in document["harmonics"].AsBsonArray)
{
BsonDocument bson_harmonic = bson_harmonic_val.AsBsonDocument;
GameState harmonic_state = GameStateUtils.FromString(bson_harmonic["harmonic_state"].AsString);
ulong degeneracy = Convert.ToUInt64(bson_harmonic["degeneracy"].AsInt64);
BsonArray bson_chessboard = bson_harmonic["chessboard"].AsBsonArray;
var chessboard = Chessboard.EmptyChessboard(harmonic_state);
for (int i = 0; i < 64; i++)
{
BsonValue bson_square_val = bson_chessboard[i];
if (bson_square_val.IsBsonNull)
{
chessboard[i] = null;
}
else
{
BsonDocument bson_square = bson_square_val.AsBsonDocument;
Player square_player = PlayerUtils.FromString(bson_square["player"].AsString);
PieceType square_piece = PieceTypeUtils.FromString(bson_square["piece"].AsString);
chessboard[i] = new Piece(square_player, square_piece);
}
}
harmonics.Add(new QuantumHarmonic(chessboard, degeneracy));
}
var quantum_chessboard = new QuantumChessboard(harmonics, game_state);
var last_move_positions = new List <Position>();
foreach (BsonValue pos_val in document["last_move_positions"].AsBsonArray)
{
last_move_positions.Add(Position.Parse(pos_val.AsString));
}
var engine = new QuantumChessEngine(quantum_chessboard, active_player, creation_time, last_move_positions.ToArray());
return(new Game(id, engine));
}
private async Task <dynamic> SubmitMove(dynamic args, CancellationToken cancellation_token)
{
Model.MoveRequest request = this.Bind <Model.MoveRequest>();
try {
QuantumChessEngine engine = await WebAppManagers.DatabaseManager.RequestEngine(request.GameId);
QuantumChessMove move = request.Parse(engine);
engine.Submit(move);
await WebAppManagers.DatabaseManager.UpdateEngine(request.GameId, engine);
return(new {
Success = true
});
} catch (QuantumChessException e) {
return(new {
Success = false,
Message = e.Message
});
}
}
private async Task <dynamic> NewGame(dynamic args, CancellationToken cancellation_token)
{
if (WebAppConfig.Instance.Captcha.Enabled)
{
bool captcha_validated = await ValidateCaptchaResponse(Request.Query["captcha_response"]);
if (!captcha_validated)
{
return(500);
}
}
var engine = new QuantumChessEngine();
string game_id = await WebAppManagers.DatabaseManager.InsertEngine(engine);
var new_game_response = new Model.NewGameResponse()
{
GameId = game_id
};
return(Response.AsJson(new_game_response));
}
public Game(ObjectId id, QuantumChessEngine engine)
{
Id = id;
Engine = engine;
}
public async Task UpdateEngine(string gameId, QuantumChessEngine engine)
{
var replacement = new Game(new ObjectId(gameId), engine);
await ActiveGames_.FindOneAndReplaceAsync(FilterById(gameId), ChessBsonSerializationUtils.Serialize(replacement));
}
public static QuantumChessMove ReadMove(QuantumChessEngine engine)
{
switch (engine.ActivePlayer)
{
case Player.White:
Console.Write("white> ");
break;
case Player.Black:
Console.Write("black> ");
break;
}
string move_str = Console.ReadLine();
string capitulate_move_regex = @"^(quit|exit|capitulate)$";
string agree_to_tie_move_regex = @"^tie$";
string ordinary_move_regex = @"^([A-Za-z][1-8])\s*([A-Za-z][1-8])$";
string quantum_move_regex = @"^(?:q|Q|quantum)\s+([A-Za-z][1-8])\s*((?:[A-Za-z][1-8])?)\s*([A-Za-z][1-8])$";
string castle_move_regex = @"^castle (left|right)$";
Match ordinary_match = Regex.Match(move_str, ordinary_move_regex);
Match quantum_match = Regex.Match(move_str, quantum_move_regex);
Match castle_match = Regex.Match(move_str, castle_move_regex);
if (Regex.IsMatch(move_str, capitulate_move_regex))
{
return(new CapitulateMove(engine.ActivePlayer));
}
else if (Regex.IsMatch(move_str, agree_to_tie_move_regex))
{
return(new AgreeToTieMove(engine.ActivePlayer));
}
else if (ordinary_match.Success)
{
Position source = Position.Parse(ordinary_match.Groups[1].Captures[0].Value);
Position target = Position.Parse(ordinary_match.Groups[2].Captures[0].Value);
QuantumPiece qpiece = engine.QuantumChessboard.GetQuantumPiece(source);
if (qpiece.Piece.HasValue)
{
return(new OrdinaryMove(qpiece.Piece.Value, source, target));
}
else
{
throw new MoveParseException($"No piece found at {source}");
}
}
else if (quantum_match.Success)
{
Position source = Position.Parse(quantum_match.Groups[1].Captures[0].Value);
Position?middle = null;
if (quantum_match.Groups[2].Captures[0].Length > 0)
{
middle = Position.Parse(quantum_match.Groups[2].Captures[0].Value);
}
Position target = Position.Parse(quantum_match.Groups[3].Captures[0].Value);
QuantumPiece qpiece = engine.QuantumChessboard.GetQuantumPiece(source);
if (qpiece.Piece.HasValue)
{
return(new QuantumMove(qpiece.Piece.Value, source, middle, target));
}
else
{
throw new MoveParseException($"No piece found at {source}");
}
}
else if (castle_match.Success)
{
string castle_type_str = castle_match.Groups[1].Captures[0].Value;
CastleType castle_type;
if (castle_type_str == "left")
{
castle_type = CastleType.Left;
}
else if (castle_type_str == "right")
{
castle_type = CastleType.Right;
}
else
{
throw new MoveParseException($"Unsupported castle type: {castle_type_str}");
}
return(new CastleMove(engine.ActivePlayer, castle_type));
}
else
{
throw new MoveParseException("Unable to parse move");
}
}