database/migrations/structure/20210510_2000_challenge.sql

@@ -1,7 +1,7 @@
 CREATE TABLE `challenges` (
   `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
   `token` int(10) unsigned NOT NULL,
-  `time_limit` int(10) unsigned,
+  `timer_sec` int(10) unsigned,
   `no_move` tinyint(1) NOT NULL DEFAULT 0,
   `no_pan` tinyint(1) NOT NULL DEFAULT 0,
   `no_zoom` tinyint(1) NOT NULL DEFAULT 0,
@@ -13,7 +13,7 @@ CREATE TABLE `user_in_challenge` (
   `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
   `user_id` int(10) unsigned NOT NULL,
   `challenge_id` int(10) unsigned NOT NULL,
-  `current_round` smallint(5) signed NOT NULL DEFAULT 0,
+  `round` smallint(5) signed NOT NULL DEFAULT 0,
   `time_left` int(10) unsigned,
   `is_owner` tinyint(1) NOT NULL DEFAULT 0,
   PRIMARY KEY (`id`),
@@ -27,13 +27,13 @@ CREATE TABLE `place_in_challenge` (
   `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
   `place_id` int(10) unsigned NOT NULL,
   `challenge_id` int(10) unsigned NOT NULL,
-  `round` smallint(5) unsigned NOT NULL,
+  `order` smallint(5) unsigned NOT NULL,
   PRIMARY KEY (`id`),
   KEY `place_id` (`place_id`),
   KEY `challenge_id` (`challenge_id`),
   CONSTRAINT `place_in_challenge_place_id` FOREIGN KEY (`place_id`) REFERENCES `places` (`id`),
   CONSTRAINT `place_in_challenge_challenge_id` FOREIGN KEY (`challenge_id`) REFERENCES `challenges` (`id`),
-  CONSTRAINT `unique_order_in_challenge` UNIQUE (`round`, `challenge_id`)
+  CONSTRAINT `unique_order_in_challenge` UNIQUE (`order`, `challenge_id`)
 ) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
 
 CREATE TABLE `guesses` (

public/static/js/game.js

@@ -297,11 +297,8 @@ const GameType = Object.freeze({'SINGLE': 0, 'MULTI': 1, 'CHALLENGE': 2});
 
                 Game.history = this.response.history;
 
-                if (this.response.history !== undefined) {
                 for (var i = 0; i < this.response.history.length; ++i) {
                     var round = this.response.history[i];
-                        
-                        if (round.result) {
                     Game.rounds.push({ position: round.position, guessPosition: round.result.guessPosition, realMarker: null, guessMarkers: [] });
                     Game.addPositionToResultMap(true);
                     if (round.result.guessPosition) {
@@ -309,8 +306,6 @@ const GameType = Object.freeze({'SINGLE': 0, 'MULTI': 1, 'CHALLENGE': 2});
                     }
                     Game.scoreSum += round.result.score;
 
-
-                            if (round.allResults !== undefined) {
                     for (var j = 0; j < round.allResults.length; ++j) {
                         var result = round.allResults[j];
                         if (result.guessPosition) {
@@ -319,10 +314,6 @@ const GameType = Object.freeze({'SINGLE': 0, 'MULTI': 1, 'CHALLENGE': 2});
                     }
                 }
 
-                        }
-                    }
-                }
-
                 if (this.response.finished) {
 
                     // TODO: refactor - it is necessary for mobile
@@ -809,7 +800,6 @@ const GameType = Object.freeze({'SINGLE': 0, 'MULTI': 1, 'CHALLENGE': 2});
                 }
                 Game.scoreSum += round.result.score;
 
-                if(round.allResults !== undefined) {
                 for (var j = 0; j < round.allResults.length; ++j) {
                     var result = round.allResults[j];
                     if (result.guessPosition) {
@@ -817,7 +807,6 @@ const GameType = Object.freeze({'SINGLE': 0, 'MULTI': 1, 'CHALLENGE': 2});
                     }
                 }
             }
-            }
 
 
             var distanceInfo = document.getElementById('distanceInfo');

src/Controller/GameController.php

@@ -113,7 +113,7 @@ class GameController
         $challenge->setCreatedDate(new DateTime());
         
         if($this->request->post('timerEnabled') !== null && $this->request->post('timeLimit') !== null) {
-            $challenge->setTimeLimit($this->request->post('timeLimit'));
+            $challenge->setTimerSec($this->request->post('timeLimit'));
         }
         if($this->request->post('noMove') !== null) {
             $challenge->setNoMove(true);
@@ -135,7 +135,7 @@ class GameController
         $userInChallenge = new UserInChallenge();
         $userInChallenge->setUserId($userId);
         $userInChallenge->setChallenge($challenge);
-        $userInChallenge->setTimeLeft($challenge->getTimeLimit());
+        $userInChallenge->setTimeLeft($challenge->getTimerSec());
         $userInChallenge->setIsOwner(true);
 
         $this->pdm->saveToDb($userInChallenge);
@@ -147,12 +147,12 @@ class GameController
 
         $places = $this->placeRepository->getRandomNPlaces($mapId, static::NUMBER_OF_ROUNDS, $userId);
 
-        $round = 0;
+        $order = 1;
         foreach ($places as $place) {
             $placeInChallenge = new PlaceInChallenge();
             $placeInChallenge->setPlace($place);
             $placeInChallenge->setChallenge($challenge);
-            $placeInChallenge->setRound($round++);
+            $placeInChallenge->setOrder($order++);
             $this->pdm->saveToDb($placeInChallenge);
         }
 
@@ -246,7 +246,7 @@ class GameController
             $userInChallenge = new UserInChallenge();
             $userInChallenge->setUserId($userId);
             $userInChallenge->setChallenge($challenge);
-            $userInChallenge->setTimeLeft($challenge->getTimeLimit());
+            $userInChallenge->setTimeLeft($challenge->getTimerSec());
             $this->pdm->saveToDb($userInChallenge);
         }
 

src/Controller/GameFlowController.php

@@ -6,7 +6,7 @@ use MapGuesser\Util\Geo\Position;
 use MapGuesser\Response\JsonContent;
 use MapGuesser\Interfaces\Response\IContent;
 use MapGuesser\Multi\MultiConnector;
-use MapGuesser\PersistentData\Model\Challenge;
+use MapGuesser\PersistentData\Model\UserInChallenge;
 use MapGuesser\PersistentData\PersistentDataManager;
 use MapGuesser\PersistentData\Model\Guess;
 use MapGuesser\PersistentData\Model\UserPlayedPlace;
@@ -141,47 +141,6 @@ class GameFlowController
         return new JsonContent(['ok' => true]);
     }
 
-    private function prepareChallengeResponse(int $userId, Challenge $challenge, int $currentRound): array
-    {
-        $allGuessesInChallenge = iterator_to_array($this->guessRepository->getAllInChallenge($challenge));
-
-        foreach ($allGuessesInChallenge as $guess) {
-            $round = $guess->getPlaceInChallenge()->getRound();
-
-            if ($guess->getUser()->getId() === $userId) {
-                $response['history'][$round]['position'] = 
-                        $guess->getPlaceInChallenge()->getPlace()->getPosition()->toArray();
-                $response['history'][$round]['result'] = [
-                        'guessPosition' => $guess->getPosition()->toArray(),
-                        'distance' => $guess->getDistance(),
-                        'score' => $guess->getScore()
-                ];
-            } else {
-                $response['history'][$round]['allResults'][] = [
-                    'userName' => $guess->getUser()->getDisplayName(),
-                    'guessPosition' => $guess->getPosition()->toArray(),
-                    'distance' => $guess->getDistance(),
-                    'score' => $guess->getScore()
-                ];
-            }
-        }
-
-        
-        $currentPlace = $this->placeRepository->getByRoundInChallenge($challenge, $currentRound);
-        
-        if(!isset($currentPlace)) { // game finished
-            $response['finished'] = true;
-
-        } else { // continue game
-            $response['place'] = [
-                'panoId' => $currentPlace->getPanoIdCached(),
-                'pov' => [$currentPlace->getPov()->toArray()]
-            ];
-        }
-
-        return $response;
-    }
-
     public function challengeInitialData(): IContent
     {
         $session = $this->request->session();
@@ -194,9 +153,53 @@ class GameFlowController
         }
 
         $challenge = $userInChallenge->getChallenge();
-        $currentRound = $userInChallenge->getCurrentRound();
+        $currentRound = $userInChallenge->getRound();
+        $currentPlace = $this->placeRepository->getByRoundInChallenge($challenge, $currentRound);
 
-        $response = $this->prepareChallengeResponse($userId, $challenge, $currentRound);
+        $response = [];
+
+        $response['history'] = [];
+
+        $allGuessesInChallenge = iterator_to_array($this->guessRepository->getAllInChallenge($challenge));
+        $guessesByUser = iterator_to_array($this->guessRepository->getAllInChallengeByUser($userId, $challenge));
+        $places = iterator_to_array($this->placeRepository->getAllInChallenge($challenge));
+        
+
+        for($i = 0; $i < $currentRound; ++$i) {
+
+            $response['history'][] = [
+                'position' => $places[$i]->getPosition()->toArray(),
+                'result' => [
+                    'guessPosition' => $guessesByUser[$i]->getPosition()->toArray(),
+                    'distance' => $guessesByUser[$i]->getDistance(),
+                    'score' => $guessesByUser[$i]->getScore()
+                ],
+                'allResults' => []
+            ];
+
+            foreach($this->guessRepository->getAllInChallengeByRound($i, $challenge) as $guess) {
+                if($guess->getUserId() != $userId) {
+                    $user = $this->userRepository->getByGuess($guess);
+
+                    $response['history'][$i]['allResults'][] = [
+                        'userName' => $user->getDisplayName(),
+                        'guessPosition' => $guess->getPosition()->toArray(),
+                        'distance' => $guess->getDistance(),
+                        'score' => $guess->getScore()
+                    ];
+                }
+            }
+        }
+        
+        if(!isset($currentPlace)) { // game finished
+            $response['finished'] = true;
+
+        } else { // continue game
+            $response['place'] = [
+                'panoId' => $currentPlace->getPanoIdCached(),
+                'pov' => [$currentPlace->getPov()->toArray()]
+            ];
+        }
 
         return new JsonContent($response);
     }
@@ -313,11 +316,22 @@ class GameFlowController
         }
 
         $challenge = $userInChallenge->getChallenge();
-        $currentRound = $userInChallenge->getCurrentRound();
+        $currentRound = $userInChallenge->getRound();
-        $currentPlaceInChallenge = $this->placeInChallengeRepository->getByRoundInChallenge($currentRound, $challenge);
+        $currentPlace = $this->placeRepository->getByRoundInChallenge($challenge, $currentRound);
-        $currentPlace = $currentPlaceInChallenge->getPlace();
+        $map = $this->mapRepository->getByPlace($currentPlace);
-        $map = $currentPlace->getMap();
+        $placeInChallenge = $this->placeInChallengeRepository->getByPlaceAndChallenge($currentPlace, $challenge);
 
+        // fill in all other results for the round
+        $response['allResults'] = [];
+        foreach($this->guessRepository->getAllInChallengeByRound($currentRound, $challenge) as $guess) {
+            $user = $this->userRepository->getByGuess($guess);
+            $response['allResults'][] = [
+                'userName' => $user->getDisplayName(),
+                'guessPosition' => $guess->getPosition()->toArray(),
+                'distance' => $guess->getDistance(),
+                'score' => $guess->getScore()
+            ];
+        }
 
         $guessPosition = new Position((float) $this->request->post('lat'), (float) $this->request->post('lng'));
         $result = $this->evaluateGuess($currentPlace->getPosition(), $guessPosition, $map->getArea());
@@ -325,32 +339,66 @@ class GameFlowController
         // save guess
         $guess = new Guess();
         $guess->setUserId($userId);
-        $guess->setPlaceInChallenge($currentPlaceInChallenge);
+        $guess->setPlaceInChallenge($placeInChallenge);
         $guess->setPosition($guessPosition);
         $guess->setDistance($result['distance']);
         $guess->setScore($result['score']);
         $this->pdm->saveToDb($guess);
 
-        
+        // $response = [
+        //     'position' => $currentPlace->getPosition()->toArray(),
+        //     'result' => $result
+        // ];
+        $response['position'] = $currentPlace->getPosition()->toArray();
+        $response['result'] = $result;
 
         // update round
         $nextRound = $currentRound + 1;
 
-        $userInChallenge->setCurrentRound($nextRound);
+        $userInChallenge->setRound($nextRound);
         $this->pdm->saveToDb($userInChallenge);
 
+        if ($nextRound < static::NUMBER_OF_ROUNDS) {
 
-        // creating response
+            $nextPlace = $this->placeRepository->getByRoundInChallenge($challenge, $nextRound);
-        $response = $this->prepareChallengeResponse($userId, $challenge, $nextRound);
 
-        $response['position'] = $currentPlace->getPosition()->toArray();
+            $response['place'] = [
-        $response['result'] = $result;
+                'panoId' => $nextPlace->getPanoIdCached(),
+                'pov' => $nextPlace->getPov()->toArray()
+            ];
 
-        if(isset($response['history'][$currentRound]['allResults'])) {
+        } else {
-            $response['allResults'] = $response['history'][$currentRound]['allResults'];
+
+            $guessesByUser = iterator_to_array($this->guessRepository->getAllInChallengeByUser($userId, $challenge));
+            $places = iterator_to_array($this->placeRepository->getAllInChallenge($challenge));
+
+            for($i = 0; $i < $nextRound; ++$i) {
+
+                $response['history'][] = [
+                    'position' => $places[$i]->getPosition()->toArray(),
+                    'result' => [
+                        'guessPosition' => $guessesByUser[$i]->getPosition()->toArray(),
+                        'distance' => $guessesByUser[$i]->getDistance(),
+                        'score' => $guessesByUser[$i]->getScore()
+                    ],
+                    'allResults' => []
+                ];
+    
+                foreach($this->guessRepository->getAllInChallengeByRound($i, $challenge) as $guess) {
+                    if($guess->getUserId() != $userId) {
+                        $user = $this->userRepository->getByGuess($guess);
+    
+                        $response['history'][$i]['allResults'][] = [
+                            'userName' => $user->getDisplayName(),
+                            'guessPosition' => $guess->getPosition()->toArray(),
+                            'distance' => $guess->getDistance(),
+                            'score' => $guess->getScore()
+                        ];
+                    }
+                }
             }
 
-
+        }
 
         $this->saveVisit($currentPlace->getId());
 

src/PersistentData/Model/Challenge.php

@@ -6,13 +6,13 @@ class Challenge extends Model
 {
     protected static string $table = 'challenges';
 
-    protected static array $fields = ['token', 'time_limit', 'no_move', 'no_pan', 'no_zoom', 'created'];
+    protected static array $fields = ['token', 'timer_sec', 'no_move', 'no_pan', 'no_zoom', 'created'];
 
     protected static array $relations = [];
 
     private int $token;
 
-    private ?int $timeLimit = null;
+    private ?int $timerSec = null;
 
     private bool $noMove = false;
 
@@ -27,10 +27,10 @@ class Challenge extends Model
         $this->token = $token;
     }
 
-    public function setTimeLimit(?int $timeLimit): void
+    public function setTimerSec(?int $timerSec): void
     {
-        if(isset($timeLimit)) {
+        if(isset($timerSec)) {
-            $this->timeLimit = $timeLimit;
+            $this->timerSec = $timerSec;
         }
     }
 
@@ -64,9 +64,9 @@ class Challenge extends Model
         return $this->token;
     }
 
-    public function getTimeLimit(): ?int
+    public function getTimerSec(): ?int
     {
-        return $this->timeLimit;
+        return $this->timerSec;
     }
 
     public function getNoMove(): bool

src/PersistentData/Model/PlaceInChallenge.php

@@ -4,7 +4,7 @@ class PlaceInChallenge extends Model
 {
     protected static string $table = 'place_in_challenge';
 
-    protected static array $fields = ['place_id', 'challenge_id', 'round'];
+    protected static array $fields = ['place_id', 'challenge_id', 'order'];
 
     protected static array $relations = ['place' => Place::class, 'challenge' => Challenge::class];
 
@@ -16,7 +16,7 @@ class PlaceInChallenge extends Model
 
     private ?int $challengeId = null;
 
-    private int $round;
+    private int $order;
 
     public function setPlace(Place $place): void
     {
@@ -38,9 +38,9 @@ class PlaceInChallenge extends Model
         $this->challengeId = $challengeId;
     }
 
-    public function setRound(int $round): void
+    public function setOrder(int $order): void
     {
-        $this->round = $round;
+        $this->order = $order;
     }
 
     public function getPlace(): ?Place
@@ -63,8 +63,8 @@ class PlaceInChallenge extends Model
         return $this->challengeId;
     }
 
-    public function getRound(): int
+    public function getOrder(): int
     {
-        return $this->round;
+        return $this->order;
     }
 }

src/PersistentData/Model/UserInChallenge.php

@@ -4,7 +4,7 @@ class UserInChallenge extends Model
 {
     protected static string $table = 'user_in_challenge';
 
-    protected static array $fields = ['user_id', 'challenge_id', 'current_round', 'time_left', 'is_owner'];
+    protected static array $fields = ['user_id', 'challenge_id', 'round', 'time_left', 'is_owner'];
 
     protected static array $relations = ['user' => User::class, 'challenge' => Challenge::class];
 
@@ -16,7 +16,7 @@ class UserInChallenge extends Model
 
     private ?int $challengeId = null;
 
-    private int $currentRound = 0;
+    private int $round = 0;
 
     private ?int $timeLeft = null;
 
@@ -42,9 +42,9 @@ class UserInChallenge extends Model
         $this->challengeId = $challengeId;
     }
 
-    public function setCurrentRound(int $currentRound): void
+    public function setRound(int $round): void
     {
-        $this->currentRound = $currentRound;
+        $this->round = $round;
     }
 
     public function setTimeLeft(?int $timeLeft): void
@@ -79,9 +79,9 @@ class UserInChallenge extends Model
         return $this->challengeId;
     }
 
-    public function getCurrentRound(): int
+    public function getRound(): int
     {
-        return $this->currentRound;
+        return $this->round;
     }
 
     public function getTimeLeft(): ?int

src/Repository/GuessRepository.php

@@ -45,7 +45,7 @@ class GuessRepository
         $select->innerJoin('place_in_challenge', ['place_in_challenge', 'id'], '=', ['guesses', 'place_in_challenge_id']);
         $select->where('user_id', '=', $userId);
         $select->where('challenge_id', '=', $challenge->getId());
-        $select->orderBy('round');
+        $select->orderBy('order');
 
         yield from $this->pdm->selectMultipleFromDb($select, Guess::class);
     }
@@ -55,18 +55,20 @@ class GuessRepository
         $select = new Select(\Container::$dbConnection);
         // $select->innerJoin('place_in_challenge', ['guesses', 'place_in_challenge_id'], '=', ['place_in_challenge', 'id']);
         $select->where('challenge_id', '=', $challenge->getId());
-        $select->orderBy('round');
+        $select->orderBy('order');
 
         yield from $this->pdm->selectMultipleFromDb($select, Guess::class, true);
     }
 
     public function getAllInChallengeByRound(int $round, Challenge $challenge): Generator
     {
-        $select = new Select(\Container::$dbConnection);
+        $order = $round + 1;
-        // $select->innerJoin('place_in_challenge', ['guesses', 'place_in_challenge_id'], '=', ['place_in_challenge', 'id']);
-        $select->where('challenge_id', '=', $challenge->getId());
-        $select->where('round', '=', $round);
 
-        yield from $this->pdm->selectMultipleFromDb($select, Guess::class, true);
+        $select = new Select(\Container::$dbConnection);
+        $select->innerJoin('place_in_challenge', ['guesses', 'place_in_challenge_id'], '=', ['place_in_challenge', 'id']);
+        $select->where('challenge_id', '=', $challenge->getId());
+        $select->where('order', '=', $order);
+
+        yield from $this->pdm->selectMultipleFromDb($select, Guess::class);
     }
 }

src/Repository/PlaceInChallengeRepository.php

@@ -40,14 +40,4 @@ class PlaceInChallengeRepository
 
         return $this->pdm->selectFromDb($select, PlaceInChallenge::class);
     }
-
-    public function getByRoundInChallenge(int $round, Challenge $challenge): ?PlaceInChallenge
-    {
-        $select = new Select(\Container::$dbConnection);
-        $select->where('challenge_id', '=', $challenge->getId());
-        $select->orderBy('round');
-        $select->limit(1, $round);
-
-        return $this->pdm->selectFromDb($select, PlaceInChallenge::class, true);
-    }
 }

src/Repository/PlaceRepository.php

@@ -183,7 +183,7 @@ class PlaceRepository
         $select = new Select(\Container::$dbConnection);
         $select->innerJoin('place_in_challenge', ['places', 'id'], '=', ['place_in_challenge', 'place_id']);
         $select->where('challenge_id', '=', $challenge->getId());
-        $select->orderBy('round');
+        $select->orderBy('order');
         $select->limit(1, $round);
 
         return $this->pdm->selectFromDb($select, Place::class);
@@ -194,7 +194,7 @@ class PlaceRepository
         $select = new Select(\Container::$dbConnection);
         $select->innerJoin('place_in_challenge', ['places', 'id'], '=', ['place_in_challenge', 'place_id']);
         $select->where('challenge_id', '=', $challenge->getId());
-        $select->orderBy('round');
+        $select->orderBy('order');
 
         yield from $this->pdm->selectMultipleFromDb($select, Place::class);
     }