Merge branch 'master' into feature/chat-remove-first-message-id

.env.example

···
 # USER_MAX_MULTIPLAYER_ROOMS=1
 # USER_MAX_MULTIPLAYER_ROOMS_SUPPORTER=5
 
+# MULTIPLAYER_MAX_ATTEMPTS_LIMIT=128
+
 # NOTIFICATION_QUEUE=notification
 # NOTIFICATION_REDIS_HOST=127.0.0.1
 # NOTIFICATION_REDIS_PORT=6379

app/Http/Controllers/AccountController.php

···
             'beatmapset_download:string',
             'beatmapset_show_nsfw:bool',
             'beatmapset_title_show_original:bool',
+            'comments_show_deleted:bool',
             'comments_sort:string',
             'extras_order:string[]',
             'forum_posts_show_deleted:bool',

app/Http/Controllers/BeatmapsetsController.php

···
             return $set;
         } else {
             $commentBundle = CommentBundle::forEmbed($beatmapset);
-            $hasDiscussion = $beatmapset->discussion_enabled;
 
             if (priv_check('BeatmapsetMetadataEdit', $beatmapset)->can()) {
                 $genres = Genre::listing();
···
                 'beatmapset',
                 'commentBundle',
                 'genres',
-                'hasDiscussion',
                 'languages',
                 'noindex',
                 'set'

app/Http/Controllers/Multiplayer/Rooms/Playlist/ScoresController.php

···
                 $clientHash = md5($clientHash);
             }
 
-            Build::where([
+            $buildExists = Build::where([
                 'hash' => hex2bin($clientHash),
                 'allow_ranking' => true,
-            ])->firstOrFail();
+            ])->exists();
+            abort_if(!$buildExists, 422, 'invalid client hash');
         }
 
         $score = $room->startPlay($user, $playlistItem);

app/Http/Controllers/NewsController.php

···
 
         $postsJson = [
             'news_posts' => json_collection($posts, 'NewsPost', ['preview']),
+            'news_sidebar' => $this->sidebarMeta($posts[0] ?? null),
             'search' => $search['params'],
             'cursor' => $search['cursorHelper']->next($posts),
         ];
···
                     'title' => 'osu!news Feed',
                 ],
                 'postsJson' => $postsJson,
-                'sidebarMeta' => $this->sidebarMeta($posts[0] ?? null),
             ]);
         }
     }
···
         }
 
         $currentYear = $currentYear ?? date('Y');
+        $latestPost = NewsPost::select('updated_at')->default()->first();
+        $lastUpdate = $latestPost === null ? 0 : $latestPost->updated_at->timestamp;
 
-        $years = NewsPost::selectRaw('DISTINCT YEAR(published_at) year')
-            ->whereNotNull('published_at')
-            ->orderBy('year', 'DESC')
-            ->pluck('year')
-            ->toArray();
+        return cache_remember_with_fallback(
+            "news_sidebar_meta_{$currentYear}_{$lastUpdate}",
+            3600,
+            function () use ($currentYear) {
+                $years = NewsPost::selectRaw('DISTINCT YEAR(published_at) year')
+                    ->whereNotNull('published_at')
+                    ->orderBy('year', 'DESC')
+                    ->pluck('year')
+                    ->toArray();
 
-        $posts = NewsPost::default()->year($currentYear)->get();
+                $posts = NewsPost::default()->year($currentYear)->get();
 
-        return [
-            'current_year' => $currentYear,
-            'news_posts' => json_collection($posts, 'NewsPost'),
-            'years' => $years,
-        ];
+                return [
+                    'current_year' => $currentYear,
+                    'news_posts' => json_collection($posts, 'NewsPost'),
+                    'years' => $years,
+                ];
+            }
+        );
     }
 }

app/Jobs/Notifications/UserBeatmapsetNew.php

···
 
 class UserBeatmapsetNew extends BroadcastNotificationBase
 {
-    const NOTIFICATION_OPTION_NAME = UserNotificationOption::BEATMAPSET_MODDING;
+    const NOTIFICATION_OPTION_NAME = UserNotificationOption::MAPPING;
 
     protected $beatmapset;
 

app/Libraries/Markdown/OsuMarkdownProcessor.php

···
             return;
         }
 
-        $this->firstImage = $this->node->getUrl();
+        $this->firstImage = proxy_media($this->node->getUrl());
     }
 
     public function setTitle()

app/Libraries/Multiplayer/Mod.php

···
             'overall_difficulty' => 'float',
             'circle_size' => 'float',
             'approach_rate' => 'float',
+            'scroll_speed' => 'float',
         ],
         self::DOUBLETIME => [
             'speed_change' => 'float',

app/Libraries/UserRegistration.php

···
 namespace App\Libraries;
 
 use App\Exceptions\ValidationException;
-use App\Jobs\EsIndexDocument;
 use App\Models\User;
 use Carbon\Carbon;
 use Datadog;
···
         try {
             $this->user->getConnection()->transaction(function () {
                 User::findAndRenameUserForInactive($this->user->username);
+                $this->user->shouldReindex = true;
                 if (!$this->user->save()) {
                     // probably failed because of validation
                     throw new ValidationException($this->user->validationErrors());
···
 
                 Datadog::increment('osu.new_account_registrations', 1, ['source' => 'osu-web']);
             });
-
-            dispatch(new EsIndexDocument($this->user));
         } catch (Exception $e) {
             if (is_sql_unique_exception($e)) {
                 $this->user->validationErrors()->add('username', '.unknown_duplicate');

app/Models/Multiplayer/PlaylistItem.php

···
     {
         $obj = new self();
         foreach (['beatmap_id', 'ruleset_id'] as $field) {
-            $obj->$field = array_get($json, $field);
-            if (!present($obj->$field)) {
+            $value = get_int($json[$field] ?? null);
+            if ($value === null) {
                 throw new InvariantException("{$field} is required.");
             }
+            $obj->$field = $value;
         }
 
+        $obj->max_attempts = get_int($json['max_attempts'] ?? null);
+
         $obj->allowed_mods = Mod::parseInputArray(
-            array_get($json, 'allowed_mods') ?? [],
+            $json['allowed_mods'] ?? [],
             $obj->ruleset_id
         );
 
         $obj->required_mods = Mod::parseInputArray(
-            array_get($json, 'required_mods') ?? [],
+            $json['required_mods'] ?? [],
             $obj->ruleset_id
         );
 
···
             ->orderBy('score_id', 'asc');
     }
 
+    private function assertValidMaxAttempts()
+    {
+        if ($this->max_attempts === null) {
+            return;
+        }
+
+        $maxAttemptsLimit = config('osu.multiplayer.max_attempts_limit');
+        if ($this->max_attempts < 1 || $this->max_attempts > $maxAttemptsLimit) {
+            throw new InvariantException("field 'max_attempts' must be between 1 and {$maxAttemptsLimit}");
+        }
+    }
+
     private function validateRuleset()
     {
         // osu beatmaps can be played in any mode, but non-osu maps can only be played in their specific modes
···
 
     public function save(array $options = [])
     {
+        $this->assertValidMaxAttempts();
         $this->validateRuleset();
         $this->validateModOverlaps();
         Mod::validateSelection(array_column($this->allowed_mods, 'acronym'), $this->ruleset_id, true);

app/Models/Multiplayer/Room.php

···
             throw new InvariantException('number of simultaneously active rooms reached');
         }
 
-        $this->name = $params['name'] ?? null;
+        $this->name = get_string($params['name'] ?? null);
         $this->user_id = $owner->getKey();
         $this->max_attempts = get_int($params['max_attempts'] ?? null);
         $this->starts_at = now();
···
             $this->category = $category;
             $this->ends_at = now()->addSeconds(30);
         } else {
-            if ($params['ends_at'] ?? null !== null) {
-                $this->ends_at = Carbon::parse($params['ends_at']);
-            } elseif ($params['duration'] ?? null !== null) {
-                $this->ends_at = $this->starts_at->copy()->addMinutes(get_int($params['duration']));
+            $endsAt = parse_time_to_carbon($params['ends_at'] ?? null);
+            if ($endsAt !== null) {
+                $this->ends_at = $endsAt;
+            } else {
+                $duration = get_int($params['duration'] ?? null);
+                if ($duration !== null) {
+                    $this->ends_at = $this->starts_at->copy()->addMinutes($duration);
+                }
             }
         }
 
···
         }
 
         if ($this->max_attempts !== null) {
-            if ($this->max_attempts < 1 || $this->max_attempts > 32) {
-                throw new InvariantException("field 'max_attempts' must be between 1 and 32");
+            $maxAttemptsLimit = config('osu.multiplayer.max_attempts_limit');
+            if ($this->max_attempts < 1 || $this->max_attempts > $maxAttemptsLimit) {
+                throw new InvariantException("field 'max_attempts' must be between 1 and {$maxAttemptsLimit}");
             }
         }
     }
···
             throw new InvariantException('Room has already ended.');
         }
 
-        if (
-            $this->max_attempts !== null
-            && $playlistItem->scores()->where('user_id', $user->getKey())->count() >= $this->max_attempts
-        ) {
-            throw new InvariantException('You have reached the maximum number of tries allowed.');
+        if ($this->max_attempts !== null) {
+            $roomStats = $this->userHighScores()->where('user_id', $user->getKey())->first();
+            if ($roomStats !== null && $roomStats->attempts >= $this->max_attempts) {
+                throw new InvariantException('You have reached the maximum number of tries allowed.');
+            }
+        }
+
+        if ($playlistItem->max_attempts !== null) {
+            $playlistAttempts = $playlistItem->scores()->where('user_id', $user->getKey())->count();
+            if ($playlistAttempts >= $playlistItem->max_attempts) {
+                throw new InvariantException('You have reached the maximum number of tries allowed.');
+            }
         }
     }
 }

app/Models/User.php

···
 use App\Libraries\BBCodeForDB;
 use App\Libraries\ChangeUsername;
 use App\Libraries\Elasticsearch\Indexable;
+use App\Libraries\Transactions\AfterCommit;
 use App\Libraries\User\DatadogLoginAttempt;
 use App\Libraries\UsernameValidation;
 use App\Models\Forum\TopicWatch;
···
 use Illuminate\Auth\Authenticatable;
 use Illuminate\Contracts\Auth\Authenticatable as AuthenticatableContract;
 use Illuminate\Contracts\Translation\HasLocalePreference;
-use Illuminate\Database\QueryException as QueryException;
+use Illuminate\Database\QueryException;
 use Laravel\Passport\HasApiTokens;
 use Request;
 
···
  * @property string|null $username_previous
  * @property int|null $userpage_post_id
  */
-class User extends Model implements AuthenticatableContract, HasLocalePreference, Indexable
+class User extends Model implements AfterCommit, AuthenticatableContract, HasLocalePreference, Indexable
 {
     use Elasticsearch\UserTrait, Store\UserTrait;
     use Authenticatable, HasApiTokens, Memoizes, Reportable, UserAvatar, UserScoreable, Validatable;
···
         'user_website' => 200,
     ];
 
+    public $shouldReindex = false;
+
     private $validateCurrentPassword = false;
     private $validatePasswordConfirmation = false;
     public $password = null;
···
 
             $skipValidations = in_array($type, ['inactive', 'revert'], true);
             $this->saveOrExplode(['skipValidations' => $skipValidations]);
-            dispatch(new EsIndexDocument($this));
+            $this->shouldReindex = true;
 
             return $history;
         });
···
     public function recommendedStarDifficulty(string $mode)
     {
         $stats = $this->statistics($mode);
-        if ($stats) {
-            return pow($stats->rank_score, 0.4) * 0.195;
-        }
+
+        return UserStatistics\Model::calculateRecommendedStarDifficulty($stats);
+    }
+
+    /**
+     * Recommended star difficulty for all modes.
+     *
+     * @return float
+     */
+    public function recommendedStarDifficultyAll()
+    {
+        return $this->memoize(__FUNCTION__, function () {
+            $unionQuery = null;
+
+            foreach (Beatmap::MODES as $key => $_value) {
+                $query = $this->statistics($key, true)->selectRaw("'{$key}' AS game_mode, rank_score");
+
+                if ($unionQuery === null) {
+                    $unionQuery = $query;
+                } else {
+                    $unionQuery->unionAll($query);
+                }
+            }
+
+            $stats = $unionQuery->get()->keyBy('game_mode');
+
+            foreach (Beatmap::MODES as $key => $_value) {
+                $recs[$key] = UserStatistics\Model::calculateRecommendedStarDifficulty($stats[$key] ?? null);
+            }
 
-        return 1.0;
+            return $recs;
+        });
     }
 
     public function refreshForumCache($forum = null, $postsChangeCount = 0)
···
         }
 
         return $this->isValid() && parent::save($options);
+    }
+
+    public function afterCommit()
+    {
+        if ($this->shouldReindex) {
+            $this->shouldReindex = false;
+            dispatch(new EsIndexDocument($this));
+        }
     }
 
     protected function newReportableExtraParams(): array

app/Models/UserNotificationOption.php

···
     const COMMENT_REPLY = 'comment_reply';
     const DELIVERY_MODES = ['mail', 'push'];
     const FORUM_TOPIC_REPLY = Notification::FORUM_TOPIC_REPLY;
+    const MAPPING = 'mapping';
 
     const HAS_DELIVERY_MODES = [
+        self::MAPPING,
         self::BEATMAPSET_MODDING,
         Notification::CHANNEL_MESSAGE,
         Notification::COMMENT_NEW,

app/Models/UserProfileCustomization.php

···
         $this->setOption('beatmapset_title_show_original', $value);
     }
 
+    public function setCommentsShowDeletedAttribute($value)
+    {
+        if (!is_bool($value)) {
+            $value = null;
+        }
+
+        $this->setOption('comments_show_deleted', $value);
+    }
+
+    public function getCommentsShowDeletedAttribute()
+    {
+        return $this->getOptions()['comments_show_deleted'] ?? false;
+    }
+
     public function getCommentsSortAttribute()
     {
         return $this->getOptions()['comments_sort'] ?? Comment::DEFAULT_SORT;

app/Models/UserStatistics/Model.php

···
         return $this->count300 + $this->count100 + $this->count50;
     }
 
+    public static function calculateRecommendedStarDifficulty(?self $stats)
+    {
+        if ($stats !== null && $stats->rank_score > 0) {
+            return pow($stats->rank_score, 0.4) * 0.195;
+        }
+
+        return 1.0;
+    }
+
     public static function getClass($modeStr, $variant = null)
     {
         if (!Beatmap::isModeValid($modeStr)) {

app/Transformers/UserCompactTransformer.php

···
             'beatmapset_download',
             'beatmapset_show_nsfw',
             'beatmapset_title_show_original',
+            'comments_show_deleted',
             'forum_posts_show_deleted',
             'ranking_expanded',
             'user_list_filter',

app/helpers.php

···
 
 function proxy_media($url)
 {
+    if (!present($url)) {
+        return '';
+    }
+
+    $url = html_entity_decode_better($url);
+
+    if (config('osu.camo.key') === null) {
+        return $url;
+    }
+
+    $isProxied = starts_with($url, config('osu.camo.prefix'));
+
+    if ($isProxied) {
+        return $url;
+    }
+
     // turn relative urls into absolute urls
     if (!preg_match('/^https?\:\/\//', $url)) {
         // ensure url is relative to the site root
···
         $url = config('app.url').$url;
     }
 
-    $decoded = urldecode(html_entity_decode_better($url));
 
-    if (config('osu.camo.key') === null) {
-        return $decoded;
-    }
-
-    $isProxied = starts_with($decoded, config('osu.camo.prefix'));
-    if ($isProxied) {
-        return $decoded;
-    }
-
-    $url = bin2hex($decoded);
-    $secret = hash_hmac('sha1', $decoded, config('osu.camo.key'));
+    $hexUrl = bin2hex($url);
+    $secret = hash_hmac('sha1', $url, config('osu.camo.key'));
 
-    return config('osu.camo.prefix')."{$secret}/{$url}";
+    return config('osu.camo.prefix')."{$secret}/{$hexUrl}";
 }
 
 function lazy_load_image($url, $class = '', $alt = '')

config/osu.php

···
     'legacy' => [
         'shared_interop_secret' => env('SHARED_INTEROP_SECRET', ''),
     ],
+    'multiplayer' => [
+        'max_attempts_limit' => get_int(env('MULTIPLAYER_MAX_ATTEMPTS_LIMIT')) ?? 128,
+    ],
     'notification' => [
         'endpoint' => presence(env('NOTIFICATION_ENDPOINT'), '/home/notifications/feed'),
         'queue_name' => presence(env('NOTIFICATION_QUEUE'), 'notification'),

database/migrations/2021_02_03_120003_add_max_attempts_to_playlist_items.php

···
+<?php
+
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
+// See the LICENCE file in the repository root for full licence text.
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+class AddMaxAttemptsToPlaylistItems extends Migration
+{
+    /**
+     * Run the migrations.
+     *
+     * @return void
+     */
+    public function up()
+    {
+        Schema::table('multiplayer_playlist_items', function (Blueprint $table) {
+            $table->tinyInteger('max_attempts')->unsigned()->nullable()->after('required_mods');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     *
+     * @return void
+     */
+    public function down()
+    {
+        Schema::table('multiplayer_playlist_items', function (Blueprint $table) {
+            $table->dropColumn('max_attempts');
+        });
+    }
+}

resources/assets/coffee/react/_components/comment.coffee

···
 import { ShowMoreLink } from 'show-more-link'
 import { Spinner } from 'spinner'
 import { UserAvatar } from 'user-avatar'
+import { classWithModifiers } from 'utils/css'
 import { estimateMinLines } from 'utils/estimate-min-lines'
 
 el = React.createElement
···
 
         @renderRepliesToggle()
         @renderCommentableMeta(meta)
+        @renderToolbar()
 
         div
           className: osu.classWithModifiers('comment__main', mainModifiers)
···
               if @props.comment.canHaveVote
                 div
                   className: 'comment__row-item visible-xs'
-                  @renderVoteText()
+                  @renderVoteButton(true)
 
               div
                 className: 'comment__row-item comment__row-item--info'
···
         user.username
 
 
-  # mobile vote button
-  renderVoteButton: =>
-    className = osu.classWithModifiers('comment-vote', @props.modifiers)
-    className += ' comment-vote--posting' if @state.postingVote
-    className += ' comment-vote--disabled' if !@props.comment.canVote
+  renderVoteButton: (inline = false) =>
+    hasVoted = @hasVoted()
+
+    className = classWithModifiers 'comment-vote', @props.modifiers
+    className += classWithModifiers 'comment-vote',
+      disabled: !@props.comment.canVote
+      inline: inline
+      on: hasVoted
+      posting: @state.postingVote
+      true
 
-    if @hasVoted()
-      className += ' comment-vote--on'
-      hover = null
-    else
-      className += ' comment-vote--off'
-      hover = div className: 'comment-vote__hover', '+1'
+    hover = div className: 'comment-vote__hover', '+1' if !inline && !hasVoted
 
     button
       className: className
···
       hover
 
 
-  renderVoteText: =>
-    className = 'comment__action'
-    className += ' comment__action--active' if @hasVoted()
-
-    button
-      className: className
-      type: 'button'
-      onClick: @voteToggle
-      disabled: @state.postingVote
-      "+#{osu.formatNumberSuffixed(@props.comment.votesCount, null, maximumFractionDigits: 1)}"
-
-
   renderCommentableMeta: (meta) =>
     return unless @props.showCommentableMeta
 
···
           osu.trans("comments.commentable_name.#{@props.comment.commentableType}")
       component params,
         meta.title
+
+
+  renderToolbar: =>
+    return unless @props.showToolbar
+
+    div className: 'comment__toolbar',
+      div className: 'sort',
+        div className: 'sort__items',
+          button
+            type: 'button'
+            className: 'sort__item sort__item--button'
+            onClick: @onShowDeletedToggleClick
+            span className: 'sort__item-icon',
+              span className: if uiState.comments.isShowDeleted then 'fas fa-check-square' else 'far fa-square'
+            osu.trans('common.buttons.show_deleted')
 
 
   hasVoted: =>
···
   loadReplies: =>
     @loadMoreRef.current?.load()
     @toggleReplies()
+
+
+  onShowDeletedToggleClick: ->
+    $.publish 'comments:toggle-show-deleted'
 
 
   parentLink: (parent) =>

resources/assets/coffee/react/_components/comments-manager.coffee

···
 
 
   toggleShowDeleted: =>
-    runInAction () ->
-      uiState.comments.isShowDeleted = !uiState.comments.isShowDeleted
+    uiState.toggleShowDeletedComments()
 
 
   toggleFollow: =>

resources/assets/coffee/react/comments-show/main.coffee

···
           el Comment,
             comment: @comment
             showCommentableMeta: true
+            showToolbar: true
             depth: 0
             linkParent: true
             modifiers: ['dark', 'single']

resources/assets/coffee/react/contest-voting/art-entry-list.coffee

···
         key: index,
         displayIndex: index,
         entry: entry,
+        hideIfNotVoted: @state.showVotedOnly
         waitingForResponse: @state.waitingForResponse,
         options: @state.options,
         contest: @state.contest,
···
 
     div className: 'contest__art-list',
       div className: 'contest__vote-summary--art',
+        @renderToggleShowVotedOnly()
         span className: 'contest__vote-summary-text contest__vote-summary-text--art', 'votes'
         el VoteSummary, voteCount: @state.selected.length, maxVotes: @state.contest.max_votes
 

resources/assets/coffee/react/contest-voting/art-entry.coffee

···
 
 export class ArtEntry extends React.Component
   render: ->
+    isSelected = _.includes @props.selected, @props.entry.id
+
+    return null if @props.hideIfNotVoted && !isSelected
+
     votingOver = moment(@props.contest.voting_ends_at).diff() <= 0
-    isSelected = _.includes @props.selected, @props.entry.id
     showVotes = @props.contest.show_votes
     shape = @props.contest.shape
     galleryId = "contest-#{@props.contest.id}"

resources/assets/coffee/react/contest-voting/base-entry-list.coffee

···
 # Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
 # See the LICENCE file in the repository root for full licence text.
 
+import { button, span } from 'react-dom-factories'
+
 export class BaseEntryList extends React.Component
   constructor: (props) ->
     super props
···
       waitingForResponse: false
       contest: @props.contest
       selected: @props.selected
+      showVotedOnly: false
       options:
         showPreview: @props.options.showPreview ? false
         showLink: @props.options.showLink ? false
···
 
   componentWillUnmount: ->
     $.unsubscribe '.contest'
+
+
+  renderToggleShowVotedOnly: =>
+    button
+      type: 'button'
+      className: 'btn-osu-big btn-osu-big--contest-entries-toolbar'
+      onClick: @onToggleShowVotedOnlyClick
+      span className: 'btn-osu-big__icon-inline btn-osu-big__icon-inline--left',
+        span className: if @state.showVotedOnly then 'fas fa-check-square' else 'far fa-square'
+      osu.trans('contest.voting.show_voted_only')
+
+
+  onToggleShowVotedOnlyClick: =>
+    @setState showVotedOnly: !@state.showVotedOnly

resources/assets/coffee/react/contest-voting/entry-list.coffee

···
 import { VoteSummary } from './vote-summary'
 import * as React from 'react'
 import { div,a,i,span } from 'react-dom-factories'
+import { classWithModifiers } from 'utils/css'
 el = React.createElement
 
 export class EntryList extends BaseEntryList
···
         key: entry.id,
         rank: index + 1,
         entry: entry,
+        hideIfNotVoted: @state.showVotedOnly
         waitingForResponse: @state.waitingForResponse,
         options: @state.options,
         contest: @state.contest,
···
 
     div className: 'contest-voting-list__table',
       div className: 'contest-voting-list__header',
+        if @state.contest.show_votes
+          div className: 'contest-voting-list__rank contest-voting-list__rank--blank'
         if @state.options.showPreview
           div className: 'contest-voting-list__icon'
         if @state.options.showLink
-          div className: 'contest-voting-list__icon'
+          div className: classWithModifiers('contest-voting-list__icon', 'best-of': @state.contest.best_of)
         div className: 'contest-voting-list__header-wrapper',
           div className: 'contest-voting-list__header-title', osu.trans('contest.entry._')
+          div className: 'contest-voting-list__header-voted-toggle-button',
+            @renderToggleShowVotedOnly()
           div className: 'contest-voting-list__header-votesummary',
             div className: 'contest__vote-summary-text', osu.trans('contest.vote.list')
             el VoteSummary, voteCount: @state.selected.length, maxVotes: @state.contest.max_votes

resources/assets/coffee/react/contest-voting/entry.coffee

···
 
 export class Entry extends React.Component
   render: ->
+    selected = _.includes @props.selected, @props.entry.id
+
+    return null if @props.hideIfNotVoted && !selected
+
     if @props.contest.show_votes
       votePercentage = _.round((@props.entry.results.votes / @props.totalVotes)*100, 2)
       relativeVotePercentage = _.round((@props.entry.results.votes / @props.winnerVotes)*100, 2)
-
-    selected = _.includes @props.selected, @props.entry.id
 
     div className: "contest-voting-list__row#{if selected && !@props.contest.show_votes then ' contest-voting-list__row--selected' else ''}",
       if @props.contest.show_votes

resources/assets/less/bem/btn-osu-big.less

···
     }
   }
 
+  &--contest-entries-toolbar {
+    font-size: inherit;
+    line-height: normal;
+    text-transform: uppercase;
+    padding: 5px 10px;
+    margin: 0 10px;
+    transition: none;
+    --colour: hsl(var(--hsl-f1));
+    --bg: transparent;
+    --hover-bg: hsl(var(--hsl-b3));
+  }
+
   &--danger {
     background-color: @osu-colour-red-3;
 

resources/assets/less/bem/comment-vote.less

···
     background-color: transparent;
   }
 
+  &--inline {
+    display: inline-flex;
+    padding: 0 8px;
+    font-size: inherit;
+  }
+
   &--on {
     .default-text-shadow();
     color: #fff;

resources/assets/less/bem/comment.less

···
 
     .@{_top}--single & {
       margin-left: 0;
-      margin-bottom: 40px;
+      margin-bottom: 30px;
       flex-direction: column;
       font-size: @font-size--title;
     }
···
     .link-hover({
       color: @osu-colour-l1;
     });
+  }
+
+  &__toolbar {
+    margin: 10px 0;
+    display: flex;
+    justify-content: flex-end;
   }
 
   &__top-show-replies {

resources/assets/less/bem/contest-voting-list.less

···
     font-weight: 100;
     justify-content: center;
     background: @osu-colour-b6;
+
+    &--blank {
+      background-color: transparent;
+    }
   }
 
   &__trophy {
···
 
   &__header-wrapper {
     display: flex;
-    justify-content: space-between;
     width: 100%;
   }
 
···
 
   &__header-title {
     padding-left: 10px;
+    margin-right: auto;
+  }
+
+  &__header-voted-toggle-button {
+    align-self: center;
   }
 
   &__header-votesummary {

resources/assets/less/bem/tournament.less

···
   &__page {
     background-color: @osu-colour-b4;
     .default-box-shadow();
-    padding: 20px;
+    .default-gutter-v2();
+    padding-top: 20px;
+    padding-bottom: $padding-top;
   }
 }

resources/assets/lib/news-index.ts

···
   return {
     container,
     data: osu.parseJson('json-index'),
-    sidebarMeta: osu.parseJson('json-sidebar'),
   };
 });

resources/assets/lib/news-index/main.tsx

···
 interface Props {
   container: HTMLElement;
   data: PostsJson;
-  sidebarMeta: NewsSidebarMetaJson;
 }
 
 interface PostsJson {
   news_posts: PostJson[];
+  news_sidebar: NewsSidebarMetaJson;
   search: Search;
 }
 
···
         <div className='osu-page osu-page--wiki'>
           <div className='wiki-page'>
             <div className='wiki-page__toc'>
-              <NewsSidebar data={this.props.sidebarMeta} />
+              <NewsSidebar data={this.props.data.news_sidebar} />
             </div>
 
             <div className='wiki-page__content'>
···
     const search: Search = {
       cursor: {},
       limit: 21,
-      year: this.props.sidebarMeta.current_year,
+      year: this.props.data.news_sidebar.current_year,
     };
 
     const lastPost = _.last(this.state.posts);

resources/assets/lib/play-detail.coffee

···
 
         div
           className: "#{bn}__pp"
-          if shouldShowPp(score.beatmapset)
+          if shouldShowPp(score.beatmap)
             el React.Fragment, null,
               el PpValue,
                 score: score

resources/assets/lib/stores/ui-state-store.ts

···
 // See the LICENCE file in the repository root for full licence text.
 
 import { CommentBundleJson } from 'interfaces/comment-json';
+import { route } from 'laroute';
 import { Dictionary, orderBy } from 'lodash';
 import { action, observable } from 'mobx';
 import { Comment, CommentSort } from 'models/comment';
···
     this.updatePinnedCommentIds(commentBundle);
 
     this.orderedCommentsByParentId = {};
+    this.comments.isShowDeleted = currentUser?.user_preferences?.comments_show_deleted ?? false;
+  }
+
+  @action
+  toggleShowDeletedComments() {
+    this.comments.isShowDeleted = !this.comments.isShowDeleted;
+
+    if (currentUser.id != null) {
+      $.ajax(route('account.options'), {
+        data: {
+          user_profile_customization: {
+            comments_show_deleted: this.comments.isShowDeleted,
+          },
+        },
+        method: 'PUT',
+      });
+    }
   }
 
   @action

resources/assets/lib/utils/beatmap-helper.ts

···
 
 export function findDefault<T extends BeatmapJson>(params: FindDefaultParams<T>): T | null {
   if (params.items != null) {
-    return _.findLast<T>(params.items, isVisibleBeatmap)
-      ?? _.last(params.items)
-      ?? null;
+    let currentDiffDelta: number;
+    let currentItem: T | null = null;
+    const targetDiff = userRecommendedDifficulty(params.mode ?? modes[0]);
+
+    params.items.forEach((item) => {
+      const diffDelta = Math.abs(item.difficulty_rating - targetDiff);
+
+      if (isVisibleBeatmap(item) && (currentDiffDelta == null || diffDelta < currentDiffDelta)) {
+        currentDiffDelta = diffDelta;
+        currentItem = item;
+      }
+    });
+
+    return currentItem ?? _.last(params.items) ?? null;
   }
 
   if (params.group == null) return null;
···
   const findModes = params.mode == null ? userModes() : [params.mode];
 
   for (const m of findModes) {
-    const beatmap = findDefault({ items: params.group[m] });
+    const beatmap = findDefault({ items: params.group[m], mode: m });
 
     if (beatmap != null) return beatmap;
   }
···
 
   return ret;
 }
+
+let userRecommendedDifficultyCache: Partial<Record<GameMode, number>> | null = null;
+
+function userRecommendedDifficulty(mode: GameMode) {
+  if (userRecommendedDifficultyCache == null) {
+    userRecommendedDifficultyCache = osu.parseJson<Record<GameMode, number> | null>('json-recommended-star-difficulty-all') ?? {};
+    $(document).one('turbolinks:before-cache', () => {
+      userRecommendedDifficultyCache = null;
+    });
+  }
+
+  return userRecommendedDifficultyCache[mode] ?? 1.0;
+}

resources/lang/en/accounts.php

···
             'comment_new' => 'new comments',
             'forum_topic_reply' => 'topic reply',
             'mail' => 'mail',
+            'mapping' => 'beatmap mapper',
             'push' => 'push',
             'user_achievement_unlock' => 'user medal unlocked',
         ],

resources/lang/en/contest.php

···
     ],
 
     'voting' => [
+        'login_required' => 'Please sign in to vote.',
         'over' => 'Voting for this contest has ended',
-        'login_required' => 'Please sign in to vote.',
+        'show_voted_only' => 'Show voted',
 
         'best_of' => [
             'none_played' => "It doesn't look like you played any beatmaps that qualify for this contest!",

resources/views/beatmapsets/_recommended_star_difficulty_all.blade.php

···
+{{--
+    Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
+    See the LICENCE file in the repository root for full licence text.
+--}}
+<script id="json-recommended-star-difficulty-all" type="application/json">
+    {!! json_encode(optional(auth()->user())->recommendedStarDifficultyAll()) !!}
+</script>

resources/views/beatmapsets/discussion.blade.php

···
         {!! json_encode($initialData) !!}
     </script>
 
+    @include('beatmapsets._recommended_star_difficulty_all')
     @include('layout._extra_js', ['src' => 'js/react/beatmap-discussions.js'])
 @endsection

resources/views/beatmapsets/show.blade.php

···
         {!! json_encode($languages) !!}
     </script>
 
+    @include('beatmapsets._recommended_star_difficulty_all')
     @include('layout._extra_js', ['src' => 'js/react/beatmapset-page.js'])
 @endsection

resources/views/news/index.blade.php

···
 @section('content')
     <div class="js-react--news-index osu-layout osu-layout--full"></div>
 
-    <script id="json-sidebar" type="application/json">
-        {!! json_encode($sidebarMeta) !!}
-    </script>
-
     <script id="json-index" type="application/json">
         {!! json_encode($postsJson) !!}
     </script>

tests/Controllers/Multiplayer/Rooms/Playlist/ScoresControllerTest.php

···
             'playlist' => $playlistItem->getKey(),
         ]), [
             'version_hash' => md5('testversion'),
-        ])->assertStatus(404);
+        ])->assertStatus(422);
 
         $this->assertSame($initialScoresCount, Score::count());
     }
···
             'playlist' => $playlistItem->getKey(),
         ]), [
             'version_hash' => $hash,
-        ])->assertStatus(404);
+        ])->assertStatus(422);
 
         $this->assertSame($initialScoresCount, Score::count());
     }

tests/Models/Multiplayer/RoomTest.php

···
 use App\Models\Multiplayer\PlaylistItem;
 use App\Models\Multiplayer\Room;
 use App\Models\User;
+use Exception;
 use Tests\TestCase;
 
 class RoomTest extends TestCase
···
     {
         $user = factory(User::class)->create();
         $room = factory(Room::class)->create(['max_attempts' => 2]);
-        $playlistItem = factory(PlaylistItem::class)->create([
+        $playlistItem1 = factory(PlaylistItem::class)->create([
+            'room_id' => $room->getKey(),
+        ]);
+        $playlistItem2 = factory(PlaylistItem::class)->create([
             'room_id' => $room->getKey(),
         ]);
 
-        $room->startPlay($user, $playlistItem);
+        $room->startPlay($user, $playlistItem1);
         $this->assertTrue(true);
 
-        $room->startPlay($user, $playlistItem);
+        $room->startPlay($user, $playlistItem2);
         $this->assertTrue(true);
 
         $this->expectException(InvariantException::class);
-        $room->startPlay($user, $playlistItem);
+        $room->startPlay($user, $playlistItem1);
+    }
+
+    public function testMaxAttemptsForItemReached()
+    {
+        $user = factory(User::class)->create();
+        $room = factory(Room::class)->create();
+        $playlistItem1 = factory(PlaylistItem::class)->create([
+            'room_id' => $room->getKey(),
+            'max_attempts' => 1,
+        ]);
+        $playlistItem2 = factory(PlaylistItem::class)->create([
+            'room_id' => $room->getKey(),
+            'max_attempts' => 1,
+        ]);
+
+        $initialCount = $room->scores()->count();
+        $room->startPlay($user, $playlistItem1);
+        $this->assertSame($initialCount + 1, $room->scores()->count());
+
+        $initialCount = $room->scores()->count();
+        try {
+            $room->startPlay($user, $playlistItem1);
+        } catch (Exception $ex) {
+            $this->assertTrue($ex instanceof InvariantException);
+        }
+        $this->assertSame($initialCount, $room->scores()->count());
+
+        $initialCount = $room->scores()->count();
+        $room->startPlay($user, $playlistItem2);
+        $this->assertSame($initialCount + 1, $room->scores()->count());
     }
 }