From 152f8e39a1daa95e1ad6599ee1ecf482d68d9fad Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 20 Oct 2024 14:03:45 +0800 Subject: [PATCH] Version Packages (#584) Co-authored-by: github-actions[bot] --- .changeset/assignment-alternatives.md | 59 ------------------------ .changeset/upgrade-moddwatch.md | 5 --- .changeset/upgrade-tajriba.md | 5 --- lib/@empirica/core/CHANGELOG.md | 65 +++++++++++++++++++++++++++ lib/@empirica/core/package.json | 2 +- 5 files changed, 66 insertions(+), 70 deletions(-) delete mode 100644 .changeset/assignment-alternatives.md delete mode 100644 .changeset/upgrade-moddwatch.md delete mode 100644 .changeset/upgrade-tajriba.md diff --git a/.changeset/assignment-alternatives.md b/.changeset/assignment-alternatives.md deleted file mode 100644 index 3aea9fc8..00000000 --- a/.changeset/assignment-alternatives.md +++ /dev/null @@ -1,59 +0,0 @@ ---- -"@empirica/core": minor ---- - -Add `preferUnderassignedGames` and `neverOverbookGames` assignment options. - -The default player assignement algorithm assigns randomly to all games in the -first batch that still has game that haven't started. This algorithm will -notably "overbook" games, meaning that it will assign more players than the -game can handle. This is useful to ensure that games start quickly, while -maintaining good randomization. When the game starts, the players that are not -ready yet (because they are still in the intro steps) are automatically -reassigned to other games, with the same treamtent, if available. - -However, in some cases, you may want to avoid overbooking games, or prefer to -assign players to games that are underassigned. This is now possible with the -`preferUnderassignedGames` and `neverOverbookGames` options. - -The `preferUnderassignedGames` option will try to assign players to games that -are underassigned, before assigning to games that are already full, resuming -the assignment process as usual if no underassigned games are available, in the -current batch (this option does not try to prefer games that are underassigned -across batches). - -The `neverOverbookGames` option will never assign players to games that are -already full. This will push players into the next batches, if no games are -available in the current batch. If no games are available in the next batches, -the player will be sent to exit. This option is a bit more strict than -`preferUnderassignedGames` and it can result in longer waiting times for -players, and potentially game that never start if a player never finishes the -intro steps. - -Given the radical nature of the `neverOverbookGames` option, it is recommended -to use `preferUnderassignedGames` option if you do not want the normal behavior -of the assignment algorithm. If you use a single batch, -`preferUnderassignedGames` should fill optimally. - -Note that `neverOverbookGames` takes precedence over `preferUnderassignedGames`, -meaning that if both options are set to `true`, `preferUnderassignedGames` will -be ignored. - -To apply these options, in `server/src/index.js`, you can add the following -options to the `Classic` function: - -```js -ctx.register( - Classic({ - preferUnderassignedGames: true, - }) -); -``` - -```js -ctx.register( - Classic({ - neverOverbookGames: true, - }) -); -``` diff --git a/.changeset/upgrade-moddwatch.md b/.changeset/upgrade-moddwatch.md deleted file mode 100644 index ec201708..00000000 --- a/.changeset/upgrade-moddwatch.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -"@empirica/core": patch ---- - -Upgrade moddwatch to 0.1.0 to fix a macOS warning message. diff --git a/.changeset/upgrade-tajriba.md b/.changeset/upgrade-tajriba.md deleted file mode 100644 index 4ff1f0b9..00000000 --- a/.changeset/upgrade-tajriba.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -"@empirica/core": patch ---- - -Upgrade to `tajriba` tp version `1.7.2` to fix a concurrent map write issue. diff --git a/lib/@empirica/core/CHANGELOG.md b/lib/@empirica/core/CHANGELOG.md index 079dc492..5e69b182 100644 --- a/lib/@empirica/core/CHANGELOG.md +++ b/lib/@empirica/core/CHANGELOG.md @@ -1,5 +1,70 @@ # @empirica/core +## 1.12.0 + +### Minor Changes + +- d99bca1: Add `preferUnderassignedGames` and `neverOverbookGames` assignment options. + + The default player assignement algorithm assigns randomly to all games in the + first batch that still has game that haven't started. This algorithm will + notably "overbook" games, meaning that it will assign more players than the + game can handle. This is useful to ensure that games start quickly, while + maintaining good randomization. When the game starts, the players that are not + ready yet (because they are still in the intro steps) are automatically + reassigned to other games, with the same treamtent, if available. + + However, in some cases, you may want to avoid overbooking games, or prefer to + assign players to games that are underassigned. This is now possible with the + `preferUnderassignedGames` and `neverOverbookGames` options. + + The `preferUnderassignedGames` option will try to assign players to games that + are underassigned, before assigning to games that are already full, resuming + the assignment process as usual if no underassigned games are available, in the + current batch (this option does not try to prefer games that are underassigned + across batches). + + The `neverOverbookGames` option will never assign players to games that are + already full. This will push players into the next batches, if no games are + available in the current batch. If no games are available in the next batches, + the player will be sent to exit. This option is a bit more strict than + `preferUnderassignedGames` and it can result in longer waiting times for + players, and potentially game that never start if a player never finishes the + intro steps. + + Given the radical nature of the `neverOverbookGames` option, it is recommended + to use `preferUnderassignedGames` option if you do not want the normal behavior + of the assignment algorithm. If you use a single batch, + `preferUnderassignedGames` should fill optimally. + + Note that `neverOverbookGames` takes precedence over `preferUnderassignedGames`, + meaning that if both options are set to `true`, `preferUnderassignedGames` will + be ignored. + + To apply these options, in `server/src/index.js`, you can add the following + options to the `Classic` function: + + ```js + ctx.register( + Classic({ + preferUnderassignedGames: true, + }) + ); + ``` + + ```js + ctx.register( + Classic({ + neverOverbookGames: true, + }) + ); + ``` + +### Patch Changes + +- 97a5bd3: Upgrade moddwatch to 0.1.0 to fix a macOS warning message. +- 728f18e: Upgrade to `tajriba` tp version `1.7.2` to fix a concurrent map write issue. + ## 1.11.6 ### Patch Changes diff --git a/lib/@empirica/core/package.json b/lib/@empirica/core/package.json index a0b84e02..05f30659 100644 --- a/lib/@empirica/core/package.json +++ b/lib/@empirica/core/package.json @@ -1,6 +1,6 @@ { "name": "@empirica/core", - "version": "1.11.6", + "version": "1.12.0", "description": "Empirica Core", "author": "Nicolas Paton ", "license": "Apache-2.0",