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 BsonDocument Serialize(Game game)
{
var document = new BsonDocument();
document.Set("_id", new BsonObjectId(game.Id));
document.Set("active_player", PlayerUtils.ToString(game.Engine.ActivePlayer));
document.Set("game_state", GameStateUtils.ToString(game.Engine.QuantumChessboard.GameState));
document.Set("creation_time", game.Engine.CreationTime);
document.Set("last_modification_time", DateTime.Now);
var bson_harmonics = new BsonArray();
foreach (QuantumHarmonic harmonic in game.Engine.QuantumChessboard.Harmonics)
{
var bson_harmonic = new BsonDocument();
bson_harmonic.Set("harmonic_state", GameStateUtils.ToString(harmonic.Board.GameState));
bson_harmonic.Set("degeneracy", Convert.ToInt64(harmonic.Degeneracy));
var bson_chessboard = new BsonArray();
for (int i = 0; i < 64; i++)
{
Piece?piece = harmonic.Board[i];
if (piece.HasValue)
{
var bson_piece = new BsonDocument();
bson_piece.Set("player", PlayerUtils.ToString(piece.Value.Player));
bson_piece.Set("piece", PieceTypeUtils.ToString(piece.Value.PieceType));
bson_chessboard.Add(bson_piece);
}
else
{
bson_chessboard.Add(BsonNull.Value);
}
}
bson_harmonic.Set("chessboard", bson_chessboard);
bson_harmonics.Add(bson_harmonic);
}
document.Set("harmonics", bson_harmonics);
var last_move_positions = new BsonArray();
foreach (Position pos in game.Engine.LastMovePositions)
{
last_move_positions.Add(pos.ToString());
}
document.Set("last_move_positions", last_move_positions);
return(document);
}
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));
}
public void Draw(RenderWindow window, Hold hold)
{
if (hold.currentPiece != PieceType.Empty)
{
List <Vector2i> pieceToDraw = PieceTypeUtils.GetPieceTypeBlocks(hold.currentPiece);
float xOffset = hold.currentPiece == PieceType.I ? 1.5f : hold.currentPiece == PieceType.O ? 1.5f : 2.0f;
float yOffset = hold.currentPiece == PieceType.I ? 4.0f : 3.5f;
foreach (Vector2i position in pieceToDraw)
{
Sprite sprite = new Sprite();
sprite.Texture = AssetPool.blockTextures[(int)hold.currentPiece];
sprite.Position = new Vector2f(
AssetPool.holdSprite.Position.X + AssetPool.blockSize.X * (xOffset + position.X),
AssetPool.holdSprite.Position.Y + AssetPool.blockSize.Y * (yOffset + position.Y));
window.Draw(sprite);
}
}
}
public void Draw(RenderWindow window, PieceQueue pieceQueue)
{
float yHeightModifier = 0;
foreach (PieceType pieceType in pieceQueue.Get())
{
float xOffset = pieceType == PieceType.I ? 1.5f : pieceType == PieceType.O ? 1.5f : 2.0f;
float yOffset = pieceType == PieceType.I ? 3.0f : 2.5f;
foreach (Vector2i position in PieceTypeUtils.GetPieceTypeBlocks(pieceType))
{
Sprite sprite = new Sprite();
sprite.Texture = AssetPool.blockTextures[(int)pieceType];
sprite.Position = new Vector2f(
AssetPool.queueSprite.Position.X + AssetPool.blockSize.X * (position.X + xOffset),
AssetPool.queueSprite.Position.Y + AssetPool.blockSize.Y * (position.Y + yOffset) + yHeightModifier);
window.Draw(sprite);
}
yHeightModifier += AssetPool.blockSize.Y * 3;
}
}
