Highlights

New Feature: Scheduling Experiments

The experiment configuration modal has been redesigned and experiments now support scheduling, allowing you to configure when to start and end an experiment.

Major Improvement: SDK Initialization Performance Optimization

One of the primary ways of interacting with the Metaplay SDK from your game's C# code has always been the ability to declare game-specific implementations of SDK base classes and interfaces, and to provide additional customization via declarations tagged with specific attributes. This is how you declare the contents of your game-specific Models and Actions, implement custom logic for Activables or LiveOps Events, configure your GameConfig build pipelines -- just to name a few examples.

To keep the amount of boilerplate at minimum and to make using the SDK feel fun and easy the SDK generally automatically discovers and interprets your integrations and customizations. For example to add a new Player Action to your game logic you simply create a new class that derives from PlayerActionBase in your shared code assembly and the SDK will automatically discover it and add it to the set of allowed shared code actions, validate that it has been set up correctly and resolve any additional configuration from attributes -- such as DevelopmentOnlyAction that would make the action legal only in development environments and for players marked as developers.

Up until now the process of discovering and interpreting integration types has been carried out as part of SDK initialization using runtime reflection. To do this, the SDK has had to scan through all assemblies that potentially contain integration types and use C# reflection APIs to discover details about them. This has the obvious downsides of both being a potentially slow process but also not being able to statically know what types are actually needed during the build, all while in practice all of the required information is already present when the code is being compiled!

In R33 we are introducing the use of Roslyn Incremental Source Generators to replace the use of runtime reflection in the SDK initialization. The Metaplay Source generators implemented in the Metaplay.CodeAnalyzers.Shared project will get run whenever game assemblies are compiled both by Unity Editor and the standalone dotnet builds and will produce per-assembly integration information right into the assembly that is being compiled.

The goal is to ultimately replace all use of init-time runtime reflection in favour of source generators, including the generation of the binary serialization code. In this release we are taking a big step towards this goal by setting up the framework for source generators and migrating some of the most expensive runtime initialization steps, but the work will continue over the course of the next few SDK releases.

We've done everything in our power to make this transition transparent and seamless to integrations, but a few sacrifices had to be made. Unavoidable API changes are documented in the migration guide below, as usual.

Changes

Metaplay SDK

• Source Generation: A number of SDK initialization steps have been ported from use of runtime reflection to the Incremental Source Generator declared in Metaplay.CodeAnalyzers.Shared.Generator.
• Unity 2021 Support Removed: The minimum Unity version is bumped to 2022.3 LTS in this release. It is the oldest LTS version that is still supported by Unity itself.
• .NET 8 Support Removed: The minimum Dotnet runtime version for the backend is .NET 9.

Complete List

• Added: Added a new Prometheus Metric game_entity_crashed_total with the entity, and exception labels (EntityKind and Exception type respectively).
• Added: Added DatabaseScanProcessor.ShouldStop property to allow stopping database scan before processing all items.
• Added: Added PlayerActorBase.DetachAuthenticationMethodAsync to allow programmatically detaching authentication methods of the player.
• Added: When Session unsubscribes from an Entity, the goodbye message is now an InternalEntitySessionGoodbyeMessage containing information why the entity was unsubscribed.
• Added: Added dotnet_memory_max_working_set Prometheus metric for observing memory limits.
• Added: Added PlayerActorBase.SendToClient(), for consistency with MultiplayerEntityActorBase.
• Added: Added to PlayerActorBase and MultiplayerEntityActorBase virtual methods for OnBeforeTick(), OnAfterTick(), OnBeforeAction() and OnAfterAction().
• Added: The time taken on client for the game to start from app launch is now reported as an (server-side) analytics event and in Dashboard in player's Event Log.
• Added: Added a LeagueStateProxyActor that proxies season state from leagues to all nodes. You can access the season state by calling LeagueStateProxyActor.GetSeasonState().
• Added: Added MetaplayCore.InitializeForExternalApp() helper method to initialize SDK on an external custom helper application.

• Changed: Updated Go version to 1.24.4 for entrypoint binary.
• Changed: Deprecated IPlayerModel.IsBanned and IPlayerModel.IsPermaBanned in favor of IPlayerModel.BanInfo.
• Changed: Removed MetaplayCoreEditor.EnsureInitialized() and added MetaplayCoreEditor.RunAfterMetaplayEditorInit() for InitializeOnLoad logic that requires MetaplayCore.
• Changed: IntegrationRegistry no longer checks for mandatory integrations being provided to make MetaplayCore initialization work without introducing stub integration classes.
• Changed: Dictionary and HashSet types are no longer allowed by default in [MetaSerializable] type, due to their nondeterministic iteration order.
• Changed: Removed the enum AuthenticationType.JWT. It was only used to help with the transition from R31 to R32.
• Changed: League participant-division associations are now fetched in a single database call in session start for a given participant, instead of for each league separately.
• Changed: AdminApi and PublicWebApi no longer enable Razor pages by default.
• Changed: OfflineServer.OnSessionStart() now takes in bool isFirstLogin, similarly to the PlayerActor.
• Changed: MetaplaySDK.OnApplicationAboutToBePaused() now allows pausing to happen up to 5 seconds after the call. Previously the hint was ignored if application did not pause within 1 second of the call.
• Changed: EntityAskAsync() will now throw EntityUnreachableError in target entity cannot be reached. Previously, the call would throw TimeoutException after the timeout.
• Changed: EnumerateInstanceDataMembersInUnspecifiedOrder no longer returns members marked by IgnoreDataMemberAttribute.
• Changed: ConfigArchiveBuildUtility.ReadArchiveHeader() now returns a struct instead of a tuple.
• Changed: The compatibility mode AnalyticsSinkBigQuery:AddContextFieldsAsExtraEventParams has been removed and is now always assumed to be true.
• Changed: In MultiplayerEntityActorBase, renamed SendToClientEntity() to SendToClient() and SendToAllClientEntities() to SendToAllClients().
• Changed: In PlayerActorBase, renamed TryGetOwnerSession() to TryGetSession().
• Changed: Runtime Options for System:StaticGameConfigPath, System:StaticLocalizationsPath and System:StaticLocalizationsIsFolder have been removed. The initial boot-time GameConfigs and Localizations can now be configured by implementing a custom ServerInitialGameConfigProvider.
• Changed: All MetaplayCore (re-)initialization paths now require parameter roots that contains the generated IntegrationAssembly instances for the "root" assemblies, i.e. assemblies that are not referred to by other assemblies containing Metaplay integration types. IntegrationAssembly.FindRoots() can be used in cases where reflection-based discovery of generated information is available.
• Changed: MetaplayCore initialization in Unity editor now happens in generated code for the AssemblyCSharpEditor assembly.
• Changed: Unity client builds now declare the root integration assembly by setting MetaplayCore.ClientIntegrationAssembly in the generated code for AssemblyCSharp.
• Changed: Removed type scanning from IntegrationRegistry initialization, the per-assembly integration registry type info is now generated in the build and the runtime initialization of the integration registry merges the per-assembly generated data.
• Changed: Removed global extension making UnityWebRequestAsyncOperation awaitable as it conflicted with AsyncOperation extensions.
• Changed: Deprecated MultiplayerEntityActorBase.OnPostTick() in favor of MultiplayerEntityActorBase.OnAfterTick().
• Changed: Removed allowSynchronousExecution argument from PlayerActorBase.EnqueueServerAction().
• Changed: Changed PersistedMultiplayerEntityActorBase.MigrateState() to protected so that it can be used by custom model importing code.
• Changed: The game-server will now log a warning if client-side TLS authentication did not pass.
• Changed: On client, MessageDispatcher listeners for SessionProtocol.SessionStartSuccess and other handshake messages are now called after IMetaplayLifecycleDelegate.OnSessionStarted(Async)() has completed.
• Changed: Persisted multiplayer entities can now be optionally initialized from a different message than a setup message. You'll have to override the AllowEntityCreationOnMessage bool to return true to allow this.
• Changed: Divisions now automatically sync to the current season's schedule if it changes. To disable this, override the AutoSyncSeasonSchedule bool to return false.
• Changed: Division entities are now initialized by the first player trying to join them during a season, or by the league manager during a season migration.
• Changed: Moved Application.LoadLocalAssemblies() into AssemblyUtil.LoadLocalAssemblies().

• Fixed: Tolerate NullReferenceException on client Mono builds if connection fails, due to Unity stripping WebRequest.CreateHttp internals.
• Fixed: On WebGL, FileUtil.ReadAllBytesAsync now throws IOException when accessing a http-path that results in a 404. Previously the error message contents were returned.
• Fixed: Fixed rare SQLite Error 5 errors when running a local server.
• Fixed: WebGL clients no longer produce misleading Metaplay.InternalWatchdogDeadlineExceeded incidents.
• Fixed: When a LiveOps Event had no schedule but is then edited to add a schedule including a preview phase, the admin API for the the LiveOps Events dashboard page used to throw an error.
• Fixed: It is no longer necessary for the user code to implement IPlayerModelClientListenerCore.InAppPurchaseValidationFailed(InAppPurchaseEvent) merely to call IAPManager.InAppPurchaseValidationFailed(...). The SDK now handles this internally, automatically routing the purchase failure information to IAPFlowTracker and other to users of the IAPManager.OnPurchaseFinishedInMetaplay event.
• Fixed: KeyValuePair<K, V> are now JSON serializable.
• Fixed: When an IAP fails with "missing dynamic content" status, the failure is now routed to the client listeners, allowing the client UI to react e.g. by removing a UI-blocking spinner. In certain rare failure scenarios, this fix avoids the client getting stuck in a state where the user cannot attempt to purchase the same product again.
• Fixed: Fixed "Appear As Platform" in Unity Editor sometimes defaulting to Unknown instead of UnityEditor.
• Fixed: Migrations of PlayerModel are now run with the Experiment changes applied in GameConfig. Previously migrations were run with the Baseline config.
• Fixed: Fixed MetaplayGuildClient.DiscoverGuilds() and SearchGuilds() throwing ArgumentOutOfRangeException if session had ended.
• Fixed: Fixed ExecuteOnActorContextAsync() throwing ArgumentOutOfRangeException if actor had shut down.
• Fixed: Fixed a regression where BigQuery analytics event format validity checks weren't run in the container image building phase.
• Fixed: When entity event log events were produced at a high rate (>50 events synchronously), the event log used to grow without bound, failing to remove enough of the old events. This has been fixed and it now respects the maximum count limit even under such high-rate circumstances.
• Fixed: Fix rare server boot-time error when GlobalStateProxy failed to subscribe to GlobalStateManager with EntityUnreachableError.
• Fixed: Facebook data deletion and deauthorization webhooks now accept requests again. They were broken due to refusing the correct Content-Type that is used for HTTP form content.
• Fixed: Service-node restart no longer invalidates Session resumption tokens.
• Fixed: Disabled the known proxy check in UseForwardedHeaders middleware used by PublicWebApi as it is redundant and will cause redirect URIs to be generated with wrong protocol after the .NET June 2025 update.
• Fixed: Fix the fetching of serverStatusHint.json (maintenance mode state) to not be affected by aggressive code stripping settings in Unity.

LiveOps Dashboard

• Player Incident Report Typings Reworked: In addition to reworking the incident detail view into tabs, the backend and frontend now share a new interface type called IncidentDashboardInfo which contains all the members sent from the backend to the frontend for Player Incident Reports. It also contains a member called ExtraInfo that is automatically visualized by the generated UI system. Use custom incident report types and the ExtraInfo member to easily visualize custom members of incident reports. Find out more: Implementing Custom Incident Reports.

• New Player Search by Social ID: You can now search users by their Social ID in Player Search. Searching <PlatformName>:<PlatformUserId> where PlatformName and PlatformUserId are as shown in Player's Login Methods in Dashboard. For example searching FacebookLogin:1234567890 finds the user with the Facebook account attached.

Complete List

• Added: New getGameDataByLibrary(libraryNames: string[]) and getGameDataByLibrarySubscriptionOptions(libraryNames: string[]) API function to fetch a subset of the game config libraries.
• Added: Node start time when reporting uptime in the Environment Detail view to clearly indicate when the server last started.

• Changed: MInputDate is now keyboard accessible; it can be selected with the Tab key and dates can be navigated using the arrow keys.
• Changed: MInputCheckbox now shows clearer visual feedback for the different mouse states. It's internals were refactored with additional protection against edge cases such as programmatically toggling disabled checkboxes.
• Changed: MInputTime now visualizes and handles out-of-range time values more gracefully.
• Changed: MInputSwitch now visualizes tab selection with an outline like other input components.
• Changed: MInputDuration now visualizes and handles unexpected-but-technically-correct inputs like 1.45 days more gracefully.
• Changed: MInputSingleFile body element now has hover, drag & drop and active states to make it more obviously interactive.
• Changed: Dropdown inputs like MInputSingleSelectDropdown have more graceful fallback for conflicting selection vs options list values.
• Changed: MInputSingleSelectAsyncDropdown is now clearable using an "x" button.
• Changed: MInputSingleSelectAsyncDropdown now has a min-height prop to ensure the input field has a consistent height even when no value is selected.
• Changed: MInputSingleSelectAsyncDropdown now has clearer loading states for both initial and new results.
• Changed: Removed the badge slot from the MCallout component and replaced it with badgeText and badgeVariant properties instead.
• Changed: The MCard loading state now displays the badge and header-right slots for more information during loading.
• Changed: The Player Incidents, Broadcasts, and Notifications detail views have been split into tabs, making them easier to navigate and find information.
• Changed: The getGameData() API function has been deprecated in favour of the getGameDataByLibrary(libraryNames: string[]) and getGameDataByLibrarySubscriptionOptions(libraryNames: string[]) API functions. The new functions fetch only the game config libraries you need, improving page load times and overall performance.
• Changed: The game config data is no longer pre-fetched during the dashboard loading screen, making the dashboard faster to load in large games.
• Changed: The disabled prop in MInputSwitch is deprecated. To disable the component, use disabledTooltip prop and provide a message explaining the reason.

• Fixed: The scroll position is now correctly preserved when navigating backwards and forwards between previously visited pages.
• Fixed: Push notifications can no longer be created or edited if the notifications system is not enabled.
• Fixed: The MRawDataCard component now properly handles values that are not objects or arrays.
• Fixed: An issue where Debug options in the Push Notifications edit modal were sometimes incorrectly shown as invalid.
• Fixed: An issue with subscriptions where cached error values were ignored when client code subscribed to existing subscriptions.
• Fixed: An issue with MInputNumber where the clear button was not emitting undefined despite the visual state being correct.
• Fixed: An issue with MInputNumber where the clear button remained enabled when the component was in a disabled state.
• Fixed: An issue with MInputDurationOrEndDateTime where the label was not hidden when the label prop was empty.
• Fixed: An issue with MInputDurationOrEndDateTime where editing the duration would incorrectly clamp the selected duration into a rounded end time, causing decimals to be added to the minute selection.
• Fixed: An issue where disabled tooltips in MInputSingleSelectRadio were not displayed in the correct horizontal location.
• Fixed: An issue with mouse hover and active states when the MInputSingleSelectRadio component was disabled.
• Fixed: An issue with MInputDuration where the duration fields were sometimes incorrectly re-balanced during user input.
• Fixed: Various edge cases that could cause vertical layout-shifts in dynamic components such as MInputDuration and MInputDurationOrEndDateTime.
• Fixed: Fixed notifications sometimes not correctly rendering on top of dropdowns.
• Fixed: An issue with MInputSingleFile where the component would not properly react to programmatic changes in the modelValue prop.
• Fixed: An issue with MInputDate where the min and max dates were not correctly inclusive of the current date when set to utcNow.
• Fixed: Moved guild views and tools initialization under the correct feature flag to prevent empty components from being created when guilds are not in use.
• Fixed: MPageOverviewCard layout issue where long title text would break the adjacent badge layout.
• Fixed: Improved styling of MInputSingleSelectDropdown and MInputSingleSelectAsyncDropdown components to make them more readable when they appear above the input control.
• Fixed: Improved readability of segment properties by showing specialized types (i.e. time and duration) with the relevant MetaUiNext components.
• Fixed: Optimized the MetricCard subscription to fetch a single metric at a time instead of fetching all metrics.
• Fixed: "Invalid duration" values in the player details' offer and event cards.
• Fixed: The MInputSwitch component now shows the "pointer" cursor when you hover on the label, correctly indicating that you can click on the label to toggle the switch.
• Fixed: A date format and tooltip regression in dashboard OverviewListsfor date-only items.
• Fixed: The MTimeSeriesBarChart default y-axis values' abbreviation.
• Fixed: An issue in MInputNumber where fields with the clearOnZero option enabled did not emit the expected value when set to 0.
• Fixed: An issue where the Async Matchmaker's chart's dropdowns' display values were not correctly updating.
• Fixed: An issue where the Async Matchmaker's chart's filtered buckets were not being merged correctly.
• Fixed: An issue where the timeline current time marker and events could shift by a day in MEventTimeline.
• Fixed: An issue where local datetime values in the activable schedule were incorrectly displayed as UTC, and UTC datetime values were not properly handled, resulting in the schedule being off by up to one day in some cases.
• Fixed: An issue where the game server metrics view would show the initial duration in minutes instead of days.

Documentation

Complete List

• Added: Improved our Storybook documentation, including updated code samples in the Inputs category. All examples are now fully copy-pasteable and formatted for better readability. Check out the Storybook Changelogfor full details of the updates and improvements.
• Added: Rolling Out Updates describes the steps to take to update your game with minimum friction and downtime.

Migration Guide for All Customers

Please apply the following changes to your project to ensure compatibility with the latest Metaplay SDK.

Backward-Incompatible Changes

Bump your game's MetaplayCoreOptions.supportedLogicVersions to force a synchronized update of your game client and server.

Upgrade Helm Chart to Latest Version

The Metaplay SDK now requires Helm chart v0.8.0 or later for cloud deployments.

Migration Steps:

1. Update your metaplay-project.yaml to the latest Helm chart version.

   metaplay-project.yaml

   serverChartVersion: 0.x.y
   serverChartVersion: 0.8.0

2. Roll out the change to each environment by running the CI job to build and deploy a new version.

   You can do this for each environment separately, whenever is a good time for you.

Unity 2021.3 Support Removed

Unity has officially dropped support of Unity 2021.3 with the release of Unity 6. The Metaplay SDK no longer supports Unity 2021.3, update your project to Unity 2022.3 or later before starting the Metaplay SDK update.

Update Unity to 2022.3 or newer

The Metaplay SDK now requires Unity 2022.3 or newer for all projects. We recommend updating Unity before starting the MetaplaySDK update.

Migration Steps:

1. Update your Unity project to 2022.3 or newer before updating the Metaplay SDK.

Migration Guide for Self-Service Customers

Premium SDK Update Support

If your support contract includes Metaplay-provided SDK updates, all the following steps have already been applied to your project. You can skip this migration guide!

This guide offers step-by-step instructions for migrating your project to the latest version of the Metaplay SDK. You can skip the migrations steps for features you are not using in your project.

For All Metaplay Projects

The following core SDK changes affect all Metaplay projects:

Apply Database Schema Migrations

Metaplay's built-in database schema has changed, and you need to apply the migration steps to your project.

Migration Steps:

1. Generate the database schema migration code with:

   # Install or update the EFCore tool:
   Backend/Server$ dotnet tool install -g dotnet-ef
   # Then, generate the migration code:
   Backend/Server$ dotnet ef migrations add MetaplayRelease33

2. Then, add the generated files to your project's source control. For example, using Git:

   Backend/Server$ git add .
   Backend/Server$ git commit -m "Database schema migrations"

The migration steps will be automatically applied when you deploy the updated game server into an environment.

Upgrade to .NET 9

All server and tool builds depending on MetaplaySDK R33 require using the .NET toolchain from the .NET 9 SDK.

Migration Steps:

1. Update the sdk entry in the global.json file of your project to specify at least version 9.0.100:

   {
     "sdk": {
       "version": "9.0.100",
       "rollForward": "latestFeature"
     }
   }

2. Once the R33 update is merged to your development branch, instruct all developers to install and switch to the .NET 9 SDK.

3. Update the .NET toolchain version used by any CI jobs.

   Note that Dockerfile.server shipped with the Metaplay SDK has been updated to use the .NET 9 SDK so any docker image builds in CI will use the correct .NET SDK version without further action required.

Update the target framework of your server and tools builds to target .NET 9 runtime. The actions for updating your project are:

1. Update the dotnetRuntimeVersion entry in the metaplay-project.yaml file to specify 9.0:

   dotnetRuntimeVersion: "8.0"
   dotnetRuntimeVersion: "9.0"

2. Edit the TargetFramework property in all .csproj files to specify net9.0:

   <Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
       <TargetFramework>net9.0</TargetFramework>
       <OutputType>Exe</OutputType>
       ...

3. Verify that your code continues to build against .NET 9:

   MyProject$ metaplay build server

For Games With Customized LiveOps Dashboard

The following LiveOps Dashboard changes affect projects that have a game-specific dashboard project:

Check and Install the Correct Node Version

The LiveOps Dashboard requires Node version 20 or later, with the latest recomended version being 22.14.0.

Migration Steps:

1. Check your current Node version by running: node --version.

2. If your Node version is lower than 20.x, or you want to update to the latest recomended version:

   # Install Node 22.14.0 with Node Version Manager (nvm).
   nvm install 22.14.0
   
   # Use the newly installed version.
   nvm use 22.14.0
   
   # (Optional) Set the new version as the default.
   nvm alias default 22.14.0

3. Update the Node version in your project's package.json file to reflect the new requirement:

   "engines": {
   "node": "20.x"
   "node": ">=20"
   }

Clear Dashboard Dependencies

Migration Steps:

1. Remove any files that Node has cached in your repository. This will lead to a fresh install of all dependencies.
   • Run git clean -fdx ':(glob)**/node_modules/*' from the root of your repository. This clears any currently installed dependencies.
   • Run git clean -fdx ':(glob)**/dist/*' from the root of your repository. This clears any previously built files.
   • Delete the pnpm-lock.yaml file from the root of your repository. This clears the cached dependency versions.

Update the LiveOps Dashboard Project Files

As usual, we have updated the underlying dependencies and configurations of the LiveOps Dashboard. This causes changes to several configuration files, which you will need to update in your dashboard project. We use the MetaplaySDK/Frontend/DefaultDashboard folder as the source of truth for these files.

Migration Steps:

1. Update the package.json to update your project's dependencies.

   • If you have custom dependencies, manually update them or use a file comparison tool to merge the changes.
   • If not, copy and overwrite the package.json file directly from the MetaplaySDK/Frontend/DefaultDashboard directory. Next, restore the name property inside the file to that of your project. This is typically of the form "name": "<projectName>-dashboard".

2. Run pnpm install in your 'Dashboard' folder. This recreates all of the above files and folders with the correct dependencies.

For Games With Custom LiveOps Dashboard Components

As a part of continued code review and polish of the dashboard codebase, we have done a few breaking changes to internal APIs that you may be using in your custom components.

Migrate the MCallout Component

The badge slot was removed from MCallout component and replaced with badgeText and badgeVariant properties instead.

Migration Steps:

1. Find all instances of the MCallout component that use the badge slot.

2. Migrate to use properties instead:

   MCallout(title="My Callout Title") 
     template(#badge) My Badge Text  
   MCallout( 
     title="My Callout Title"
     badge-text="My Badge Text"
     badge-variant="success"
     ) 

Migrate the MInputSwitch Component

The disabled prop was deprecated in favor of disabledTooltip prop.

Migration Steps:

1. Find all instances of the MInputSwitch component that use the disabled prop.

2. Migrate to use the disabledTooltip prop instead:

   MInputSwitch( 
     disabled 
     ...
   MInputSwitch( 
     disabled-tooltip="This is the reason why it is disabled"
     ...
     )

Update Uses of getGameData() API Function

The getGameData() API function was deprecated in favor of the higher performance version getGameDataByLibrary(libraryNames: string[]).

Migration Steps:

1. Replace uses of getGameData() with getGameDataByLibrary(libraryNames: string[]) and pass the libraries you wish to load as a parameter:

   const gameData = await initializationApi.getGameData() 
   const gameData = await initializationApi.getGameDataByLibrary(['Producers', 'ProducerKinds']) 
   
   initializationApi.addStringIdDecorator('Game.Logic.ProducerTypeId', (stringId: string): string => {
     const producer = gameData.gameConfig.Producers[stringId]
     const producerKind = gameData.gameConfig.ProducerKinds[producer.kind]
     return `${producer.name} (${producerKind.name})`
   })

Update Uses of getGameDataSubscriptionOptions() API Function

getGameDataSubscriptionOptions() was deprecated in favor of the higher performance version getGameDataByLibrarySubscriptionOptions(libraryNames: string[]).

Migration Steps:

1. Replace uses of getGameDataSubscriptionOptions() with getGameDataByLibrarySubscriptionOptions(libraryNames: string[]) and pass the libraries you wish to load as a parameter:

   const { data: gameData } = useSubscription(getGameDataSubscriptionOptions()) 
   const { data: gameData } = useSubscription(getGameDataByLibrarySubscriptionOptions(['Producers', 'ProducerKinds'])) 

Make Uses of getGameData()/getGameDataSubscriptionOptions Reactive

In R32 and earlier versions, the game data was loaded before the dashboard was rendered. This behavior is very convenient however when your game grows, it becomes quite slow.

As the game data is no longer available by default, we need to ensure that any custom components can handle this. There are 2 solutions to this problem, Vue Reactivity or ensuring that the data is fetched before the dashboard is rendered.

We strongly recommend using Vue's reactivity systems, the other approaches described here are temporary solutions to keep things working meanwhile.

Vue Reactivity

The preferred approach is to make use of Vue3 reactivity. This will make your dashboard load faster and snappier to use, as the data is loaded asynchronously while the user can interact with the dashboard. However this does mean that you have to handle an extra state when the data is not available yet. Unfortunately there's no one size fits all solution, we'll discuss a few of the basics to help you get started.

Reactivity on it's own is quite simple, when the underlying data changes, it automatically updates the UI and dependent computed properties. As you might imagine, this is very useful for network requests and our subscriptions system. You can simply define a subscription, use it in your UI and it'll automatically update once it is done with downloading.

Additionally, Vue provides computed() and watch() to help keep your code reactive. computed caches a value and "subscribes" to the dependencies, if the dependencies change, it'll re-evaluate and cache the new value. Quite useful for filtering collections or computing more complicated data, however you shouldn't create side-effects, but rather create a chain of computed properties. watch gives you a callback when the value you're observing changes, most of the time this is used to initialize a default value once the data has been downloaded.

Let's take a look at a few simple examples (note that some details are left out for brevity):

<template lang="pug">
//-  Each time allProducers is recalculated, the UI is re-rendered as well.
//-  Even if the player is actively playing, it updates the levels in real time!
div(v-if="allProducers !== undefined")
  div(v-for="producer in allProducers")
    span {{ producer.info }}, Level: {{ producer.level }}
</template>
<script lang="ts" setup>

const { data: gameData } = useSubscription(() => getGameDataByLibrarySubscriptionOptions(['Producers']))
const { data: playerData } = useSubscription(() => getSinglePlayerSubscriptionOptions(props.playerId))

// Since allProducers is dependent on both gameData and playerData,
// the value of allProducers will be recalculated when either of these change.
//
// After allProducers is recalculated, it triggers the UI to re-render as well.
const allProducers = computed(() => {
  if (gameData.value && playerData.value) {
    const availableProducers = gameData.value.gameConfig.Producers
    return Object.keys(availableProducers).map((id) => {
      if (id in playerData.value.model.producers) {
        return playerData.value.model.producers[id]
      } else {
        return {
          info: id,
          level: 0,
        }
      }
    })
  } else {
    return undefined
  }
})

watch(
  // Trigger when player data changes
  playerData,
  (newValue) => {
    if (newValue !== undefined && selectedProducer.value === null) {
      // Find and default to the first producer that the player has unlocked
      selectedProducer.value = Object.keys(newValue.producers)[0] ?? null
    }
  },
  // Setting immediate to true ensures that it is triggered when the component is first rendered, which is useful if the data is already in the cache
  { immediate: true }
)
</script>

Pre-fetching

Libraries can be cached before the dashboard completes loading, ensuring they are available when custom components are ran. Simply add calls to getGameDataByLibrary() with the same library names as you use elsewhere.

1. Await calls to initializationApi.getGameDataByLibrary() in gameSpecific.ts:

   export function GameSpecificPlugin(app: App): void {
   // Feel free to add any customization logic here for your game!
   setGameSpecificInitialization(async (initializationApi) => {
       // Note that libraries are cached by the union of all array items, therefore requesting [a, b] will not cause [a] to be cached and vice-versa.
       await initializationApi.getGameDataByLibrary(['Producers']) 
       await initializationApi.getGameDataByLibrary(['ProducerKinds']) 
   }

Restore old behavior

The previous behavior can easily be restored, simply add a call to getGameData(). Note that getGameData() and getGameDataByLibrary() use different caching mechanisms and are thus fetching one will not cache the other.

1. Await a call to initializationApi.getGameData() to gameSpecific.ts:

   export function GameSpecificPlugin(app: App): void {
       // Feel free to add any customization logic here for your game!
       setGameSpecificInitialization(async (initializationApi) => {
           // eslint-disable-next-line @typescript-eslint/no-deprecated
           await initializationApi.getGameData() 
   
           ...
       }
   }

Check Times Displayed When Using MetaScheduleBase

By default, Luxon parses DateTime strings without time zone information into browser local time. This can lead to incorrect or misleading times displayed on the LiveOps Dashboard. In the case of MetaScheduleBase being sent from the server, the schedule object has an ISO time string without time zone information and a timeMode property that tells whether the schedule times are in UTC or player local time. We recommend handling both of these cases separately when displaying times from MetaScheduleBase or similar objects.

1. Parse UTC times and show player local times correctly

   div() #[MDateTime(:instant="DateTime.fromISO(schedule.start)" show-as="dateTime")]
   div(v-if="schedule.timeMode === 'Utc'") #[MDateTime(:instant="DateTime.fromISO(schedule.start, { zone: 'utc' })" show-as="dateTime")]
   div(v-else) MTooltip(content="The local start time of this schedule is local to the player's game time offset.")
               //- Shorthand format 'ccc, DD, T' -> "Sat, 1 Jan 2000, 12:34"
               | {{ DateTime.fromISO(schedule.start).toFormat('ccc, DD, T') }} local

For Games With Custom Incident Report Types

The following core SDK changes affect projects that have implemented custom incident report types:

Implement the GetIncidentDashboardInfo() method

To visualize your incident reports correctly on the LiveOps dashboard, you must now implement the GetIncidentDashboardInfo() method and return a populated IncidentDashboardInfo object. This allows for better and easier visualization of incident report members.

Migration steps:

1. For each of your custom incident report types, implement GetIncidentDashboardInfo() in the class deriving from PlayerIncidentReport:

   public class MyCustomPlayerIncident : PlayerIncidentReport
   {
       ...
   
       public override IncidentDashboardInfo GetIncidentDashboardInfo() 
       {
           // Use the PreFillDashboardInfo() method to collect the incident's base class members into the dashboardInfo
           IncidentDashboardInfo dashboardInfo = IncidentDashboardInfo.PreFillDashboardInfo(this);
           // Optionally populate the ErrorInfo member to visualize errors and stacktraces neatly
           dashboardInfo.ErrorInfo = new IncidentDashboardInfo.ErrorDashboardInfo() { ... };
           // Optionally populate other members of the IncidentDashboardInfo class to visualize them neatly on the LiveOps dashboard
           dashboardInfo.NetworkInfo = new IncidentDashboardInfo.NetworkDashboardInfo() { ... };
           dashboardInfo.PlayerModelDiffReport = new IncidentDashboardInfo.PlayerModelDiffReportInfo() { ... };
   
           return dashboardInfo;
       }
   }

2. Optionally, implement a class deriving from IncidentDashboardInfo.ExtraIncidentDashboardInfo and populate it in the method override. This allows you to easily visualize extra info for custom incidents without touching the dashboard code:

   [MetaSerializableDerived(101)]
   public class MyCustomPlayerIncident : PlayerIncidentReport
   {
       ...
       [MetaSerializableDerived(101)] // You can give this the same tag ID as your incident report class
       public class ExtraDashboardInfo : IncidentDashboardInfo.ExtraIncidentDashboardInfo
       {
           // Note that we're using implicit MetaMembers here, so no attribute needed for members!
           public string MyExtraString;
       }
   
       public override IncidentDashboardInfo GetIncidentDashboardInfo()
       {
           ...
           // Optionally populate the ExtraInfo member with any additional info that you also want to visualize on the dashboard
           dashboardInfo.ExtraInfo = new ExtraDashboardInfo() { MyExtraString = ... }; 
   
           return dashboardInfo;
       }
   }

Miscellaneous API Changes

These changes affect you in case you happen to use any of the APIs changed. You can build your project to get a list of any incompatibilities instead of going through the list one item at a time.

Source Generation

The Metaplay SDK now requires the source generators provided by the analyzer project Metaplay.CodeAnalyzers.Shared to be run in the compilation of any assemblies that contain Metaplay integration code. For Unity builds (editor and client) this is taken care of automatically by the MetaplaySDK Unity Package declaring the analyzer, for server builds it is now required to have a project reference to the Metaplay.CodeAnalyzers.Shared project.

Migration Steps:

1. Add a project reference to all .csproj files in your server solution:

   <ProjectReference Include="$(MetaplayServerPath)\CodeAnalyzers.Shared\Metaplay.CodeAnalyzers.Shared.csproj">
     <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
     <OutputItemType>Analyzer</OutputItemType>
   </ProjectReference>

IntegrationRegistry changes

The population of the Integration Registry containing information about types implementing the IMetaIntegration interface has been moved from runtime init to happen as part of the build using source generation. This change adds the following requirements to integration types:

1. IMetaIntegrationConstructible and IMetaIntegrationSingleton types must have public constructors. Previously a private constructor was allowed as the reflection-based instance creation circumvented the visibility check.
2. IMetaIntegration types must have public or internal accessibility. Previously an integration type could be declared as a private nested type, this is no longer allowed. In this release, there is a temporary workaround that delegates access to the integration type to happen via runtime reflection. This workaround will be removed in a future release, so we strongly recommend updating your integration.

Migration Steps:

1. Incorrect accessibility of integration types will cause a compilation error. Observe compilation errors of form

   MetaplayIntegrations_SharedCode_IntegrationRegistry.g.cs(20,173): Error CS0122 : 'GlobalOptions.GlobalOptions()' is inaccessible due to its protection level

   And adjust the visibility of the constructor to public accordingly.

2. IMetaIntegration types that have too limited visibility will currently result in a compiler warning of form

   PlayerActor.cs(265,22): Warning MP_IRG_001 : Type 'Game.Server.Player.PlayerActor+GuildComponent' is an integration type for Metaplay SDK type 'global::Metaplay.Server.EntityGuildComponent' but is not publicly or internally visible

   Review these compiler warning and adjust visibility to public or internal accordingly.

Update uses of MetaplayCoreEditor.EnsureInitialized()

MetaplayCore is initialized as part of Unity Editor load using a InitializeOnLoadMethod function. As the order of execution of InitializeOnLoadMethod functions is arbitrary, previously any code that runs as part of editor load and required MetaplayCore to be initialized would call MetaplayCoreEditor.EnsureInitialized() to force initialization. This is now replaced with MetaplayCoreEditor.RunAfterMetaplayEditorInit() that you can use to register actions to be run once the MetaplayCore initialization is complete.

For example, if you previously had an InitializeOnLoadMethod function in your project like this:

[InitializeOnLoadMethod]
static void EditorInitFunctionThatNeedsMetaplay()
{
    MetaplayCoreEditor.EnsureInitialized();
    InitOperation();
}

You would need to refactor the function to look like this:

[InitializeOnLoadMethod]
static void EditorInitFunctionThatNeedsMetaplay()
{
    MetaplayCoreEditor.RunAfterMetaplayEditorInit(InitOperation);
}

Note that this change doesn't remove the need for introducing editor init time logic in a InitializeOnLoadMethod.

Replace Uses of Is(Perma)Banned

IPlayerModel.IsBanned and IPlayerModel.IsPermaBanned were deprecated in favor of IPlayerModel.BanInfo. Update your uses accordingly.

Migration Steps:

1. Replace uses of Is(Perma)Banned in sessions and player actions

   if (Model.IsBanned) 
   if (Model.BanInfo != null) 
   {
       // Handle if the player is banned
   }

2. Replace uses of Is(Perma)Banned outside of sessions

   BanInfo is updated at the beginning of a session. If you're checking whether the player is banned outside of session/player action context, you can use the IsBannedAtTime to verify whether the player is banned currently.

   if (Model.IsBanned) 
   if (Model.BanInfo?.IsBannedAtTime(MetaTime.Now)) 
   {
       // Handle if the player is banned
   }

Replace Dictionary and HashSet in [MetaSerializable] types.

Dictionary and HashSet have an unspecified iteration order. This causes their serialization byte-stream representation to be non-deterministic. This causes any checksums computed from byte-stream to become non-deterministic too. There is no reason to use these types as MetaplaySDK provides drop-in replacements with deterministic iteration order. To continue using non-deterministic collections, the field can be marked with [MetaAllowNondeterministicCollection].

Migration Steps:

1. Replace any use of Dictionary with MetaDictionary in [MetaSerializable] types.

   [MetaSerializable]
   public class MyType
   {
       [MetaMember(1)] Dictionary<string, int> Dictionary; 
       [MetaMember(1)] MetaDictionary<string, int> Dictionary; 
   }

2. Replace any entry iteration using KeyValuePair to use tuple syntax:

   foreach (KeyValuePair<TKey, TValue> entry in dictionary) 
   foreach ((TKey, TValue) entry in dictionary) 
   // or
   foreach ((TKey key, TValue value) in dictionary) 

3. Replace any use of HashSet with OrderedSet in [MetaSerializable] types.

   [MetaSerializable]
   public class MyType
   {
       [MetaMember(1)] HashSet<int> PrimeNumbers; 
       [MetaMember(1)] OrderedSet<int> PrimeNumbers; 
   }

4. If MetaDictionary or OrderedSet cannot be used, mark the field with [MetaAllowNondeterministicCollection].

   [MetaSerializable]
   public class MyType
   {
       [MetaAllowNondeterministicCollection] 
       [MetaMember(1)] HashSet<string> PrimeWords;
   }

Add PersistedParticipantDivisionAssociation argument to custom ILeagueIntegrationHandler.HandleLeagueOnSessionSubscriber.

If you have a custom ILeagueIntegrationHandler class for a league that overrides the HandleLeagueOnSessionSubscriber method, it now takes in a PersistedParticipantDivisionAssociation parameter that contains the assignment database entry for the league and participant. This change was done to reduce excess database calls on session start, since now we can fetch the assignment entry for all leagues in a single operation, instead of doing it for each league separately.

Migration Steps:

1. Replace Task HandleLeagueOnSessionSubscriber() with Task HandleLeagueOnSessionSubscriber(PersistedParticipantDivisionAssociation currentAssociation)

2. Remove any now-obsolete database calls to fetch the association.

public async Task HandleLeagueOnSessionSubscriber() 
public async Task HandleLeagueOnSessionSubscriber(PersistedParticipantDivisionAssociation currentAssociation) 
{
    ...

    PersistedParticipantDivisionAssociation currentAssociation = await MetaDatabase.Get().TryGetParticipantDivisionAssociation(LeagueId, PlayerId); 

    ...
}

Fix Nullability Warnings About MetaDictionary Getters

MetaDictionary's methods TryGetValue(...) and GetValueOrDefault(...) now provide more useful nullability information for the returned value, similar to standard collections such as Dictionary. This may trigger new warnings in your code if you have enabled nullability warnings.

You should inspect the warnings and fix them by either adding the necessary nullability annotations in your code or fixing your code's behavior in case the warning identified an actual bug.

Migration Steps:

1. Fix "Converting null literal or possible null value to non-nullable type" warnings by adding nullability annotations.

   MetaDictionary<int, string> myDict = new();
   
   string x = myDict.GetValueOrDefault(123); 
   string? x = myDict.GetValueOrDefault(123); 
   
   if (!myDict.TryGetValue(456, out string y)) 
   if (!myDict.TryGetValue(456, out string? y)) 
       return;

2. Fix "Dereference of a possibly null reference" warnings. The specific fix is case by case. For example:

   MetaDictionary<int, MyClass> myDict = new();
   
   string x = myDict.GetValueOrDefault(123).ToString(); 
   string x = myDict.GetValueOrDefault(123)?.ToString() ?? "<null>"; 
   
   if (!myDict.TryGetValue(Id, out MyClass? y))
   {
       _log.Error("Could not find object {Id}", y.GetId()); // Mistakenly using `y`
       _log.Error("Could not find object {Id}", Id); 
       return;
   }

Enable Razor View Engine if Using Razor Pages.

Razor view engine is no longer enabled by default in AdminApi and in PublicWebApi. If you use Razor views, you must enable it manually in your PublicWebApi actor. AdminApi does not support Razor views and any views should be migrated to PublicWebApi.

Migration Steps:

1. If you use Razor views on PublicWebApi, inherit PublicWebApiActor if you haven't already and add AddRazorViewEngine() call in ConfigureServices()

   public class MyPublicWebApiActor : PublicWebApiActor
   {
       protected override void ConfigureServices(IServiceCollection services)
       {
           base.ConfigureServices(services);
           services.AddMvcCore().AddRazorViewEngine(); 
       }
   }

2. If you use Razor views on AdminAPI, migrate them to PublicWebApiActor.

Update OfflineServer.OnSessionStart() Signature.

OnSessionStart() has an new parameter bool isFirstLogin. If your implementation overrides this method, you must update the method signature.

Migration Steps:

1. In your OfflineServer implementation, update the signature:

   public class OfflineServer : DefaultOfflineServer
   {
       protected override void OnSessionStart(IPlayerModelBase model) 
       protected override void OnSessionStart(IPlayerModelBase model, bool isFirstLogin) 
       {
           ...
       }
   }

Update custom GlobalState schema version

The schema version of GlobalState has been updated to support scheduling experiments. If your project implements a customized GlobalState, you must update the schema version.

Migration Steps:

1. In your GlobalState implementation, update the schema version:

   [SupportedSchemaVersions(7, 9)] 
   [SupportedSchemaVersions(7, 10)] 
   public class MyGameGlobalState : GlobalState
   {
       ...
   }

Update Return Type for ConfigArchiveBuildUtility.ReadArchiveHeader() calls

ReadArchiveHeader() now returns a struct with named fields instead of a tuple. This improves readability and enables future extensions to the header type.

Migration Steps:

1. In your ReadArchiveHeader() calls, update the return type:

   (int schemaVersion, ContentHash archiveVersion, MetaTime timestamp, int numEntries) = ConfigArchiveBuildUtility.ReadArchiveHeader(reader); 
   ConfigArchiveBuildUtility.ArchiveHeader header = ConfigArchiveBuildUtility.ReadArchiveHeader(reader); 

2. Use the struct fields instead of extracted tuple values:

   schemaVersion 
   header.SchemaVersion 

   archiveVersion 
   header.Version 

   timestamp 
   header.CreatedAt 

   numEntries 
   header.NumEntries 

Remove AnalyticsSinkBigQuery:AddContextFieldsAsExtraEventParams Option

AnalyticsSinkBigQuery:AddContextFieldsAsExtraEventParams Runtime Option has been removed and is now always on, which was already the default mode. All references to this option must be removed.

The mode adds all fields from AnalyticsContext into the BigQuery row as if they were fields of the Analytics Event itself, except that they have a $c: prefix for their name.

Migration Steps:

1. In your server Config/Options.<env>.yaml, remove references enabling the mode:

   AnalyticsSinkBigQuery:
     AddContextFieldsAsExtraEventParams: true

2. If in your Config/Options.<env>.yaml you disable the mode, you must remove the flag, and update your BigQuery processing pipeline to support the Context Fields:

   AnalyticsSinkBigQuery:
     AddContextFieldsAsExtraEventParams: false

Remove MaxPersistedSegmentsToRemoveAtOnce from Event Log Configuration

The MaxPersistedSegmentsToRemoveAtOnce property has been removed from the EventLogForPlayer and EventLogForGuild sections in server options. The logic for removing event log segments has been changed and this property is no longer appropriate.

If you have specified this value, remove it.

Migration Steps:

1. In your Options.*.yaml files, remove MaxPersistedSegmentsToRemoveAtOnce in EventLogForPlayer and EventLogForGuild.

   Options.base.yaml

   EventLogForPlayer:
       MaxPersistedSegmentsToRemoveAtOnce: 10
       # ...
   
   EventLogForGuild:
       MaxPersistedSegmentsToRemoveAtOnce: 10
       # ...

Replace Deprecated MultiplayerEntityActorBase.SendTo*() Calls.

In MultiplayerEntityActorBase, SendToClientEntity() has been renamed to SendToClient(), and SendToAllClientEntities() has been renamed to SendToAllClients().

Migration Steps:

1. Replace calls to SendToClientEntity() with SendToClient()

   SendToClientEntity(clientSession, new MyMessage()); 
   SendToClient(clientSession, new MyMessage()); 

2. Replace calls to SendToAllClientEntities() with SendToAllClients()

   SendToAllClientEntities(new MyMessage()); 
   SendToAllClients(new MyMessage()); 

Replace Deprecated PlayerActorBase.TryGetOwnerSession() Calls.

TryGetOwnerSession() has been renamed to TryGetSession().

Migration Steps:

1. Replace calls to TryGetOwnerSession() with TryGetSession()

   EntitySubscriber session = TryGetOwnerSession(); 
   EntitySubscriber session = TryGetSession(); 
   if (session != null)
   {
       SendMessage(session, new MyMessage());
   }

Implement Awaiter for UnityWebRequest.SendWebRequest() Calls.

Global extension method GetAwaiter() to UnityWebRequest.SendWebRequest() has been removed as it conflicted with AsyncOperation extensions.

Migration Steps:

1. Use extension in UnityEngine namespace (Unity 2023.1 and later):

   using UnityEngine; 
   
   using (UnityWebRequest uploadRequest = UnityWebRequest.Get(url))
   {
       await uploadRequest.SendWebRequest();
   }

2. Alternatively, implement awaiting manually:

   using (UnityWebRequest uploadRequest = UnityWebRequest.Get(url))
   {
       await uploadRequest.SendWebRequest(); 
       UnityWebRequestAsyncOperation asyncOp = uploadRequest.SendWebRequest(); 
       TaskCompletionSource<int> tcs = new TaskCompletionSource<int>(); 
       asyncOp.completed += op => tcs.TrySetResult(0); 
       await tcs.Task; 
   }

Replace Deprecated MultiplayerEntityActorBase.OnPostTick() with OnAfterTick().

OnPostTick(long tick) has been replaced by OnAfterTick().

Migration Steps:

1. Replace OnPostTick(long tick) method with OnAfterTick()

   protected override void OnPostTick(long tick) 
   protected override void OnAfterTick() 
   {
       // tick = Model.CurrentTick - 1
       ...
   }

Remove allowSynchronousExecution Argument from PlayerActorBase.EnqueueServerAction() Calls.

The parameter allowSynchronousExecution has been removed due to unpredictable behavior. The parameter allowed action execution to be performed synchronously in conditions that depended on the sequence of previous calls to the method after the latest flush.

Migration Steps:

1. Remove allowSynchronousExecution argument if synchronous execution is not absolutely necessary

   EnqueueServerAction(action, allowSynchronousExecution: true); 
   EnqueueServerAction(action); 

2. Use ExecuteServerActionImmediately() if synchronous execution is required.

   EnqueueServerAction(action, allowSynchronousExecution: true); 
   ExecuteServerActionImmediately(action); 

Check Division season schedule behavior.

If your project has a league where divisions use a different schedule from the leaguemanager, you'll need to override the AutoSyncSeasonSchedule property in your DivisionActor and set it to false.

If you're not sure if this applies to your project, a common way to do this is to set the division model's StartsAt, EndsAt and EndingSoonStartsAt manually in SetUpModelAsync(). If you don't see any code modifying those values in your division actor implementation, your project is most likely not affected.

public sealed class MyGameDivisionActor : PlayerDivisionActorBase<MyGameDivisionModel, PersistedDivision, MyGameLeagueManagerOptions>
{
    // Disable season schedule synchronization for divisions.
    // Otherwise, the custom division schedule would be overwritten.
    protected override bool AutoSyncSeasonSchedule => false;

    //...
}

Update IMetaplayLifecycleDelegate.OnSessionStarted() to OnSessionStartedAsync().

OnSessionStarted() is now OnSessionStartedAsync() that returns a Task to allow for asynchronous session start logic.

Migration Steps:

1. For synchronous logic, convert the method to return Task.CompletedTask:

   void IMetaplayLifecycleDelegate.OnSessionStarted() 
   Task IMetaplayLifecycleDelegate.OnSessionStartedAsync() 
   {
       ...
       return Task.CompletedTask; 
   }

2. For asynchronous logic, convert the method to return a Task that completes when the asynchronous start operation is complete.

   void IMetaplayLifecycleDelegate.OnSessionStarted() 
   async Task IMetaplayLifecycleDelegate.OnSessionStartedAsync() 
   {
       SceneManager.LoadScene("Game Scene"); 
       await SceneManager.LoadSceneAsync("Game Scene"); 
   }

Update Application.LoadLocalAssemblies() to AssemblyUtil.LoadLocalAssemblies().

LoadLocalAssemblies() has been moved to core to make it accessible to external applications. The method no longer returns the loaded assemblies.

Migration Steps:

1. To load assemblies eagerly, use AssemblyUtil:

   Application.LoadLocalAssemblies(); 
   AssemblyUtil.LoadLocalAssemblies(); 

2. To enumerate all assemblies, use AppDomain.CurrentDomain.GetAssemblies():

   Assembly[] assemblies = Application.LoadLocalAssemblies(); 
   AssemblyUtil.LoadLocalAssemblies(); 
   Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies(); 

Use MetaplayCore.InitializeForExternalApp() Instead of MetaplayCore.Initialize() in External Apps.

MetaplayCore.InitializeForExternalApp() is a new helper for conveniently initializing Metaplay with the correct assembly scope and with a on-demand generated serializer.

Migration Steps:

1. To initialize Metaplay, use the convenience method:

   MetaplayCore.Initialize(init => init.ConfigureMetaSerialization("MyHelperApp")); 
   MetaplayCore.InitializeForExternalApp("MyHelperApp");