protected function acceptRematch(Player $player)
{
$game = $player->getGame();
$opponent = $player->getOpponent();
// if the rematch is already accepted
// can happen if the guy clicks frenetically
// on the rematch accept button
if ($nextGame = $game->getNext()) {
$nextOpponent = $nextGame->getPlayer($player->getColor());
$nextPlayer = $nextOpponent->getOpponent();
} else {
$nextOpponent = $this->gameGenerator->createReturnGame($opponent);
$nextPlayer = $nextOpponent->getOpponent();
$nextGame = $nextOpponent->getGame();
$this->logger->notice($player, 'Player:rematch accept');
$this->messenger->addSystemMessage($game, 'Rematch offer accepted');
$nextGame->start();
$this->memory->setAlive($nextPlayer);
// the opponent still pings the old game,
// so we set it as active on the new game
if ($this->memory->getActivity($opponent)) {
$this->memory->setAlive($nextOpponent);
}
}
// tell spectators to reload the table
$game->addEventToStacks(array('type' => 'reload_table'));
// tell players to move to next game
foreach (array(array($player, $nextPlayer), array($opponent, $nextOpponent)) as $pair) {
$pair[0]->addEventToStack(array('type' => 'redirect', 'url' => $this->urlGenerator->generate('lichess_player', array('id' => $pair[1]->getFullId()))));
}
$this->objectManager->persist($nextGame);
}
public function join(Player $player)
{
$game = $player->getGame();
if ($game->getIsStarted()) {
return false;
}
$this->playerBlamer->blame($player);
return $this->starter->start($game);
}
/**
* After the player has moved, run the AI to get the next move applied immediatly
*
* @param Player $player
* @return void
*/
protected function performAiAnswer(Player $player)
{
$game = $player->getGame();
$opponent = $player->getOpponent();
$stack = new Stack();
$manipulator = $this->manipulatorFactory->create($game, $stack);
$possibleMoves = $manipulator->play($this->ai->move($game, $opponent->getAiLevel()));
$player->addEventToStack(array('type' => 'possible_moves', 'possible_moves' => $possibleMoves));
$player->addEventsToStack($stack->getEvents());
}
public function blame(Player $player)
{
if ($token = $this->securityContext->getToken()) {
if ($this->securityContext->isGranted('IS_AUTHENTICATED_REMEMBERED')) {
$user = $token->getUser();
if ($user instanceof User) {
$player->setUser($user);
}
}
}
}
public function join(Player $player)
{
$game = $player->getGame();
if ($game->getIsStarted()) {
$this->logger->warn($player, 'Game:join started');
throw new InvalidArgumentException('Cannot join started game');
}
$this->playerBlamer->blame($player);
$game->start();
$player->getOpponent()->addEventToStack(array('type' => 'redirect', 'url' => $this->urlGenerator->generate('lichess_player', array('id' => $player->getOpponent()->getFullId()))));
$this->logger->notice($player, 'Game:join');
}
protected function getDiffEvents(Player $player, $clientVersion)
{
$playerStack = $player->getStack();
$stackVersion = $playerStack->getVersion();
if ($stackVersion === $clientVersion) {
return array();
}
if (!$playerStack->hasVersion($clientVersion)) {
throw new OutOfBoundsException(sprintf('ClientUpdater:OutOfBound player=%d requested=%s', $stackVersion, $clientVersion));
}
$events = array();
for ($version = $clientVersion + 1; $version <= $stackVersion; $version++) {
$events[] = $playerStack->getEvent($version);
}
return $events;
}
/**
* Creates a return game for the given player,
* reverting players colors
*
* @param Player the player who creates the return game
* @return Player the new player on the new game
**/
public function createReturnGame(Player $player)
{
$game = $player->getGame();
$variant = $game->getVariant();
$nextGame = $this->createGame($variant);
if (Game::VARIANT_960 == $game->getVariant()) {
Forsyth::import($nextGame, $game->getInitialFen());
$nextGame->setInitialFen($game->getInitialFen());
}
$nextPlayer = $nextGame->getPlayer($player->getOpponent()->getColor());
$nextGame->setCreator($nextPlayer);
if ($game->hasClock()) {
$nextGame->setClock(clone $game->getClock());
}
$nextGame->setIsRated($game->getIsRated());
$nextGame->getPlayer('white')->setUser($game->getPlayer('black')->getUser());
$nextGame->getPlayer('black')->setUser($game->getPlayer('white')->getUser());
$game->setNext($nextGame);
return $nextPlayer;
}
protected function acceptRematch(Player $player)
{
$game = $player->getGame();
$opponent = $player->getOpponent();
// if the rematch is already accepted
// can happen if the guy clicks frenetically
// on the rematch accept button
if ($nextGame = $game->getNext()) {
$nextOpponent = $nextGame->getPlayer($player->getColor());
$nextPlayer = $nextOpponent->getOpponent();
$messages = array();
} else {
$nextOpponent = $this->gameGenerator->createReturnGame($opponent);
$nextPlayer = $nextOpponent->getOpponent();
$nextGame = $nextOpponent->getGame();
$messages = $this->starter->start($nextGame);
$this->objectManager->persist($nextGame);
}
return array($nextGame, $messages);
}
protected function getPgnPlayerElo(Player $player)
{
if ($player->getIsAi()) {
return '?';
}
if (!$player->getElo()) {
return '?';
}
return $player->getElo();
}
protected function getCastleRookInDirection(Player $player, $dx)
{
$king = $player->getKing();
if ($king->hasMoved()) {
return null;
}
for ($x = $king->getX() + $dx; $x < 9 && $x > 0; $x += $dx) {
if ($piece = $this->board->getPieceByPos($x, $king->getY())) {
if ('Rook' === $piece->getClass() && !$piece->hasMoved() && $piece->getColor() === $king->getColor()) {
return $piece;
}
}
}
}
public function getGame()
{
return $this->player->getGame();
}
public function setCreator(Player $player)
{
$this->setCreatorColor($player->getColor());
}
public function synchronize(Player $player, $version, $isSigned)
{
$player->getGame()->cachePlayerVersions();
$this->httpPush->poll($player, $version);
return $this->clientUpdater->getEventsSinceClientVersion($player, $version, $isSigned);
}
protected function calculateBlurFactor(Player $player)
{
$blurs = $player->getGame()->getBlurs();
return round(100 * max(0, min(1, $blurs[$player->getColor()] / $player->getGame()->getFullmoveNumber())));
}
protected function getLastPiece(Player $player)
{
$pieces = PieceFilter::filterNotClass(PieceFilter::filterAlive($player->getPieces()), 'King');
return empty($pieces) ? null : $pieces[0];
}
public function getPlayerKey(Player $player)
{
return $player->getGame()->getId() . '.' . $player->getColor() . '.alive';
}
public function addPlayerMessage(Player $player, $message)
{
return $this->addMessage($player->getGame(), $player->getColor(), $message);
}
private function gameColorUrl(Player $player)
{
return $player->getGame()->getId() . '/' . $player->getColor();
}
/**
* The player cancels his previous draw offer
*
* @param Player $player
* @return void
*/
public function cancel(Player $player)
{
$game = $player->getGame();
if ($player->getIsOfferingDraw()) {
$this->messenger->addSystemMessage($game, 'Draw offer canceled');
$player->setIsOfferingDraw(false);
$player->getOpponent()->addEventToStack(array('type' => 'reload_table'));
$this->logger->notice($player, 'Player:cancelDrawOffer');
} else {
$this->logger->warn($player, 'Player:cancelDrawOffer no offered draw');
}
}
public function renderGameBoard(Player $player, $checkSquareKey)
{
$board = $player->getGame()->getBoard();
$squares = $board->getSquares();
$isGameStarted = $player->getGame()->getIsStarted();
if ($player->isBlack()) {
$squares = array_reverse($squares, true);
}
$x = $y = 1;
$html = '<div class="lichess_board">';
foreach ($squares as $squareKey => $square) {
$html .= sprintf('<div class="lcs %s%s" id="%s" style="top:%dpx;left:%dpx;">', $square->getColor(), $checkSquareKey === $squareKey ? ' check' : '', $squareKey, 64 * (8 - $x), 64 * ($y - 1));
$html .= '<div class="lcsi"></div>';
if ($piece = $board->getPieceByKey($squareKey)) {
if ($isGameStarted || $piece->getPlayer() === $player) {
$html .= sprintf('<div class="lichess_piece %s %s"></div>', strtolower($piece->getClass()), $piece->getColor());
}
}
$html .= '</div>';
if (++$x === 9) {
$x = 1;
++$y;
}
}
$html .= '</div>';
return $html;
}
public function expandPlayer(Player $player)
{
return sprintf('player(%s,%s,%s,%s) %s', $player->getColor(), $player->getIsAi() ? 'AI' : $player->getUsernameWithElo(), $player->getGame()->hasClock() ? $player->getGame()->getClock()->getRemainingTime($player->getColor()) . 's.' : '-', $this->generator->generate('lichess_player', array('id' => $player->getFullId()), true), $this->expandGame($player->getGame()));
}
/**
* The player resigns and loses the game
*
* @param Player $player
* @return void
*/
public function resign(Player $player)
{
$game = $player->getGame();
if (!$game->isResignable()) {
$this->logger->warn($player, 'Player:resign non-resignable');
throw new FinisherException();
}
$opponent = $player->getOpponent();
$game->setStatus(Game::RESIGN);
$game->setWinner($opponent);
$this->finish($game);
$game->addEventToStacks(array('type' => 'end'));
$this->logger->notice($player, 'Player:resign');
}
