Chess Crown – Chess Game

Introduction

Thank you for purchasing Chess Crown. This guide covers everything from opening the project to publishing your own version of the game. The settings you need are in one place (the Game Config), the screens and popups are regular prefabs, the chess engine is plain C# you can read and change, and the puzzles are a CSV file you can edit with the built-in Puzzle Editor.

Included content & third parties

A short list of what the download contains and what it doesn't, so you (and anyone checking the package) can verify it quickly.

Screens

Every screen and popup of the game, as screenshots taken on an Android phone (Samsung Galaxy A71, 1080 × 2400). The Puzzle Editor of the Unity editor is shown in Puzzles & Puzzle Editor.

Requirements

• Unity 6000.0 LTS (made with 6000.0.84f1, newer 6000.0 patches work too).
• For Android: the Android Build Support module with its SDK, NDK and OpenJDK (all installed from Unity Hub).
• For iOS: the iOS Build Support module, a Mac with Xcode and CocoaPods.

Unity packages come from Unity's Package Manager, not from the download. Unity IAP 5.4.3 (com.unity.purchasing, Unity's free In-App Purchasing package, with Google Play Billing Library 9) and uGUI with TextMesh Pro are listed in Packages/manifest.json, so Unity downloads them by itself the first time you open the project. No package is copied into the download; only TextMesh Pro's essential resources (shaders and settings) sit in Assets/TextMesh Pro, as in every project that uses TextMesh Pro.

Not included: the Google Mobile Ads Unity plugin. Google distributes it, so you import it from Google when you want AdMob ads (free, see Ads). Without it the game runs without ads; the editor and development builds show simulated ads.

Your own accounts and possible costs

AdMob and Unity IAP are third-party services. The project contains the complete integration, but to show real ads, sell in-app purchases and publish the game you have to set up your own accounts, and some of them cost money:

• Google AdMob (ads): your own AdMob account. Creating it is free; Google pays your ad earnings under its own terms and payment thresholds.
• Google Play (Android release and in-app purchases): a Google Play Console developer account, with a one-time registration fee (US$25 at the time of writing).
• App Store (iOS release and in-app purchases): an Apple Developer Program membership (US$99 per year at the time of writing) and a Mac.
• Store fees: Google and Apple keep a commission on every in-app purchase, usually between 15% and 30%.
• Unity: Unity's own license terms apply; Unity Personal is free within Unity's revenue limits.

Getting started

1. Unzip the download. In Unity Hub choose Add → Add project from disk and select the ChessCrown folder.
2. Open it with Unity 6000.0. The first import takes a few minutes. If Unity offers to install the Microsoft GDK package (only needed for the Xbox store), choose Don't install.
3. Open the scene with Tools → Chess Crown → Open Main Scene and press Play.
4. Switch the platform to Android or iOS in File → Build Profiles.
5. Open the settings with Tools → Chess Crown → Game Config.

The Chess Crown menu

Project structure

Game Config

All gameplay, economy, ads and shop settings live in ChessCrown/Resources/GameConfig.asset. Select it with Tools → Chess Crown → Game Config; hover a field in the Inspector for a short explanation.

Computer

Two players

Puzzles

Economy

Two player games give no coins, so they can't be used to farm rewards; undo is free there.

Star Chest and Lucky Spin

Ads, purchases, links, themes

Ads and purchases are explained in Ads and In-app purchases, themes in Themes. The Links group holds your privacy policy, your store pages (for the Rate button) and your support e-mail, used by the Settings popup.

Chess engine & levels

The engine is plain C# in Scripts/Runtime/Chess, with no Unity code in it, so it is easy to read, test and reuse:

Computer levels

Each entry of Ai Levels has these fields:

The default levels were tuned with hundreds of engine-against-engine games so each level wins most games against the one below it: 1-2 play random-ish beginner moves, 3-6 hang fewer and fewer pieces, 7-8 rarely blunder, 9 and 10 search fully (level 10 thinks up to 2.5 seconds). The computer runs on a background thread (AiRunner), so the game keeps animating while it thinks.

Opening book

The lines are in OpeningBook.Lines: a name, then the moves in standard notation. Add your own lines there; positions reached by another move order are found too. Names with a colon (Sicilian Defense: Najdorf) share the family name until the variation is clear.

Puzzles & Puzzle Editor

The puzzles are in ChessCrown/Resources/Puzzles/puzzles.csv, played in file order and unlocked one after the other. The included 2,000 puzzles are original: they come from games played by the engine, and each one was proven by the mate solver (one winning first move, no faster mate). They go from mate in 1 (rated about 600) to mate in 4 (about 2000).

File format

The file uses the same columns as the free Lichess puzzle database:

PuzzleId,FEN,Moves,Rating,Themes
cc0601,4r1k1/1pp2ppp/8/p2p4/7q/P1P2B2/6PP/1bQ1R1K1 w - - 0 27,d1e1 e8e1 c1e1 h4e1,1091,mateIn2 backRankMate

• FEN is the position before the opponent's move.
• Moves (UCI, space separated) starts with that opponent move, which the game plays and highlights, then the solution: player, opponent, player...
• Themes: mateInN marks a mate puzzle, and any other move that still mates in time is accepted. Without it, only the moves of the file are accepted (the last move may be any checkmate). playerFirst means there is no opponent move: the player moves at once (puzzles set up by hand in the editor).

Puzzle Editor

Open Tools → Chess Crown → Puzzle Editor. The list on the left shows every puzzle in game order: search it, move puzzles up and down, sort by rating, delete, and Save. Select a puzzle to see it on the board and step through the solution with the arrows.

• Check proves a mate puzzle: it reports a faster mate, no mate, or more than one winning first move.
• Play Test plays the selected puzzle in the Main scene without saving anything.
• New opens the set-up board: pick a piece and click squares (click again to remove), choose the side to move, then Find Mate & Add. The solver finds the shortest mate (up to 5 moves) and writes the solution for you. Add as tactic adds the position without a solution: click the moves on the board to record them.
• Import Lichess CSV... reads lichess_db_puzzle.csv (download it from database.lichess.org and unpack it). Choose the themes (for example mateIn2, fork, endgame), a rating range and a maximum count. Invalid lines are skipped.
• Generate plays engine games and adds original mate puzzles (about one per game, a second or so each).

Sort by rating after an import so the difficulty keeps rising.

Daily puzzle

The daily puzzle is picked from the middle of the list by the date, the same for everyone on a given day, and pays Daily Puzzle Coins once per day. It follows GameClock, so changing the phone's date doesn't give extra rewards.

Themes

Boards

A board theme (ChessCrown/Config/Board_*.asset) has a name key, a price, the board picture (a1, bottom left, is a dark square), the light and dark square colors (used for the coordinates) and the colors of the last move, selection and legal move dots. Eight are included. To add one, duplicate an asset, assign your picture and add it to Board Themes in the Game Config.

Piece sets

A piece set (Pieces_*.asset) has a name key, a price and twelve sprites: pawn, knight, bishop, rook, queen and king, for white and for black. Six are included: classic, wood, marble, gold & onyx, crystal and candy. Pieces are square pictures with the piece standing on the bottom of the picture and some room around it.

Backgrounds

Background themes (Background_*.asset) have a name key, a price, the background sprite and the color of the faint diamond pattern laid over it (set its alpha to 0 to hide the pattern). Six are included: green felt, walnut, navy leather, burgundy leather, slate and black marble. Add more to Backgrounds in the Game Config.

The Themes popup has a tab for each kind and scrolls, so any number of themes fits.

Reskinning

• Pictures: replace any PNG in ChessCrown/Art with your own file of the same name. Buttons, panels and frames are 9-sliced, keep the borders when you draw your own. Tools → Chess Crown → Reset Art Import Settings... reapplies the import settings if you change them by mistake.
• Colors: the brass buttons use btn_brass.png; the dark buttons, cards and round buttons use white pictures (btn_face, card, round_face) tinted by the Image color, with a brass outline on top. Change the colors on the prefabs, or redraw the pictures.
• Effects: the light sweeping over the brass buttons is the Sheen component (child "Sheen" of each brass button face: change its interval, or delete the child to switch it off). The drifting gold dust is AmbientMotes on the home and loading screens (count, size, speed and color in the Inspector).
• Icons: the icons are full colour pictures (icon_*_gold.png, booster_*_gold.png and token_*.png in Art/Icons); replace any of them with your own picture of the same name. icon_check and icon_plus are white on transparent and tinted in the scene. The coin, the star, the coin packs of the shop and the home card pictures are full colour too.
• Screens and popups: open the prefabs in ChessCrown/Prefabs/UI. Everything is plain uGUI and TextMesh Pro. The game screen places the board, the player panels and the move list itself to fit any screen.
• Logo: edit Prefabs/UI/Logo.prefab (the brass emblem, the gold king and the word mark), used by the loading screen and the home screen. Art/UI/logo.png is a picture of the same logo for the Unity splash screen, which is off by default; replace it too if you turn the splash on.
• Fonts: assign another TextMesh Pro font asset to the texts, or replace the TTF files in ChessCrown/Fonts.
• Sounds: replace the WAV files in ChessCrown/Audio, keeping the names, or assign new clips on the Audio object of the Main scene.
• App icon and name: Edit → Project Settings → Player. The icon files are app_icon*.png in Art/UI: the full icon, the round one for older Android versions, and the background and foreground layers of the Android adaptive icon.

Localization

The game comes in English, French, Spanish, Portuguese (Brazil) and German. On first launch it follows the phone's language (English for any other), and the language button in Settings cycles through all of them.

All texts are in ChessCrown/Resources/Localization/strings.csv: one row per text, the key first, then one column per language. Lines starting with # are section titles and are ignored.

key,en,fr,es,pt,de
# General
language_name,English,Français,Español,Português,Deutsch
reason_checkmate,Checkmate,Échec et mat,Jaque mate,Xeque-mate,Schachmatt

• Edit the file in any spreadsheet program and save it as CSV (UTF-8).
• To add a language, add a column with its code (for example it) and fill in language_name for it. Then add the matching case in FromSystemLanguage in Loc.cs so the game picks it from the phone's language. The language button in Settings cycles through every column.
• The fonts cover Latin alphabets with accents (ñ, ã, ç, ß...). For Cyrillic, Greek or Asian languages, add a fallback font to the TextMesh Pro font assets.
• Right-to-left languages (Arabic, Hebrew, Persian, Urdu) are not supported out of the box. TextMesh Pro doesn't join Arabic letters or reverse right-to-left text by itself, so adding such a column shows the letters unconnected and in the wrong order. To add one, use a shaping solution such as the free RTLTMPro package (it replaces the TextMesh Pro text components) together with a font that has the Arabic or Hebrew letters, and check the layouts of the popups, which are made for left-to-right text.
• Chess notation (Nf3, O-O) and the opening names stay in English, as in most chess apps.
• In the scene, texts use the Localized Text component with a key. In code, use Loc.Get("key") or Loc.Format("key", value). Numbers go through Loc.Number, which formats them the way each language expects.

Ads (AdMob)

The AdMob integration (banner, interstitial, rewarded and app open ads, and Google's UMP consent) is in Scripts/Runtime/Services/Ads/AdMobProvider.cs. Two things are not included:

• Google's Mobile Ads Unity plugin, with Google's UMP consent SDK. Google distributes it, so you import it from Google: the download contains none of its files (no DLLs or native libraries), and AdMobProvider.cs is only compiled once the plugin is in your project.
• AdMob ids. Chess Crown comes with no AdMob ids at all: the ad unit ids in the Game Config are empty and there is no App ID. Fill in your own ids before you build.

Setting up AdMob

1. Download the latest GoogleMobileAds-v11.x.x.unitypackage from Google's releases page (Chess Crown is tested with 11.5.0). Google's Unity quick start also explains how to add it with the Package Manager.
2. Import it with Assets → Import Package → Custom Package.... Chess Crown notices the plugin and switches its AdMob code on (the CC_ADMOB define).
3. For Android, run Assets → External Dependency Manager → Android Resolver → Force Resolve (the External Dependency Manager comes with Google's plugin) and enable the Gradle templates it asks for.
4. In AdMob, add your app (Android and iOS are separate apps) and create one ad unit per format: banner, interstitial, rewarded and app open.
5. Put your App IDs in Assets → Google Mobile Ads → Settings. Google's plugin stops a build that has no App ID.
6. Paste your ad unit ids into Admob Android and Admob Ios in the Game Config. A format you leave empty is simply not shown.

Tools → Chess Crown → Ads → AdMob Status shows whether the plugin is in, whether your App IDs are set and how many ad unit ids the Game Config has. Until there is at least one ad unit id (or without the plugin), the editor and development builds show simulated ads, so you can test every ad flow, and release builds show none. A warning in the Console reminds you when you make a release build without your ids.

Testing ads

Never click your own live ads: Google can limit or close an account for invalid traffic. While you develop, use test ads, as Google explains in its test ads guide:

• Test devices (recommended): run your build on your phone once and look in the log (Android: adb logcat, iOS: the Xcode console) for the line that mentions setTestDeviceIds with your device id. Add that id to Test Device Ids in the Game Config: your phone then gets test ads from your own ad units, everyone else gets real ads. Android emulators and the iOS simulator always get test ads.
• Google's sample ad units: the same guide lists sample ad unit ids that always show test ads. If you paste them into the Game Config to try something, put your own back before you publish, because a build with Google's sample ids earns nothing.

Consent (GDPR)

The game uses Google's User Messaging Platform. Create a consent message in AdMob under Privacy & messaging and the form shows automatically to users in regions that need it. Ads are only requested once consent allows it, and a Privacy button appears in Settings when the user must be able to change their choice. If the consent request fails (no internet), it is tried again when the app comes back to the foreground.

When ads show

The No Ads purchase removes banners, interstitials and app open ads. Rewarded ads stay available because the player chooses to watch them. To turn ads off completely, untick Enable Ads in the Game Config.

Turning ads off

Untick Enable Ads in the Game Config to run without ads while keeping the plugin. To remove AdMob completely, delete the folders Google's plugin added (GoogleMobileAds, ExternalDependencyManager and its files in Plugins): Chess Crown switches its AdMob code off by itself and compiles without any Google code.

In-app purchases

Purchases use Unity IAP 5 (package com.unity.purchasing 5.4.3), which uses Google Play Billing Library 9 on Android and StoreKit 2 on iOS. Unity IAP is not included in the download: it is Unity's own package, listed in Packages/manifest.json, and Unity's Package Manager installs it when you open the project (you see it in Window → Package Manager → In-App Purchasing). If it is missing, Chess Crown says so in the Console and the shop can't sell anything until you install a 5.x version there. IAPManager is written for the 5.x API: the CC_IAP define in ChessCrown.asmdef turns the store code on for any 5.x version.

Setting up Unity IAP

1. Install the package. Opening the project is enough: Packages/manifest.json lists "com.unity.purchasing": "5.4.3", so Unity downloads it from its registry during the first import (this needs an internet connection). To check, open Window → Package Manager, choose In Project and look for In-App Purchasing 5.4.3. If it isn't there (for example after you removed it), choose Unity Registry, select In-App Purchasing, pick a 5.x version and click Install.
2. The CC_IAP define switches itself on. You don't add it anywhere: Assets/ChessCrown/Scripts/Runtime/ChessCrown.asmdef has a Version Define that sets CC_IAP whenever Unity IAP 5.x is installed (select the asmdef and look at Version Defines in the Inspector). Without Unity IAP 5.x the store code is left out, the game still runs, and a warning in the Console says what to install. Don't add CC_IAP to the Player settings by hand: without the package it would only cause compile errors.
3. Check that it works. Press Play, open the shop and tap a price: Unity IAP's Fake Store window opens (see Testing in the editor).
4. Add your products. Put your product ids in the Game Config (below) and create the same products in Google Play Console and App Store Connect.

The shop sells the Products listed in the Game Config:

1. Change the ids from com.yourcompany.chesscrown.* to your own.
2. Create the same products in Google Play Console (Monetize → Products → In-app products) and App Store Connect. Google only returns products once a build is uploaded to a testing track.
3. Add your Google account as a license tester to buy without being charged.

One-time products (No Ads, the starter bundle) are delivered once and disappear from the shop after purchase. On a new phone or after a reinstall they come back by themselves when the store connects (without their coins, which were already given). Payments the store confirms later, such as cash payments on Google Play or Ask to Buy on iOS, show a "Purchase pending" message and are delivered when they go through, even in a later session. On iOS, Settings and the shop have a Restore button, as Apple requires (it also shows in the editor so you can test it).

Each purchase is delivered, saved, and only then confirmed to the store. The ids of delivered transactions are kept in the save, so if the app closes between the delivery and the confirmation, the store sends the purchase again at the next launch and it is only confirmed, never delivered twice.

Testing in the editor

In Play mode Unity IAP uses its fake store. Tapping a price opens a small Fake Store window: Buy completes the purchase, Cancel cancels it like a player closing the store sheet.

Receipt validation

Every purchase is checked before it is delivered. A purchase that fails the check gets no coins and is not confirmed, so the store refunds it automatically (Google Play after three days).

On the device (Google Play). Unity IAP's CrossPlatformValidator verifies the signature of each Google Play receipt with your app's license key, and IAPManager also checks that the receipt is for the product that was bought. Set it up once:

1. In Google Play Console open your app, then Monetize with Play → Monetization setup, and copy the Licensing key (Base64-encoded RSA public key).
2. In Unity choose Services → In-App Purchasing → Receipt Validation Obfuscator..., paste the key and press Obfuscate Google Play License Key.
3. Unity writes GooglePlayTangle.cs and AppleTangle.cs to Assets/Scripts/UnityPurchasing/generated. There is nothing else to do: IAPManager finds them by name, and ChessCrown/link.xml keeps them in stripped builds.

Until the key is set, Android builds log "Google Play receipts are not validated yet" and purchases are delivered without the check.

On the device (App Store). StoreKit 2 verifies every transaction itself on iOS 15 and newer. On iOS 13 and 14 (StoreKit 1) the App Store receipt is checked with AppleTangle from the same obfuscator.

On your own server (optional). A check on the device can be bypassed on a rooted or jailbroken phone. For the strongest protection, set IAPManager.ServerValidation: the game then waits for your server's answer before it delivers a purchase.

using System;
using UnityEngine;
using UnityEngine.Networking;
using ChessCrown;

public class MyReceiptCheck : MonoBehaviour
{
    [SerializeField] string url = "https://example.com/verify-purchase";

    void Awake() => IAPManager.ServerValidation = Check;

    // your server answers {"valid": true} or {"valid": false}
    [Serializable] class Answer { public bool valid; }

    void Check(PurchaseReceipt purchase, Action<bool> done)
    {
        var request = UnityWebRequest.Post(url, JsonUtility.ToJson(purchase), "application/json");
        request.timeout = 15;
        request.SendWebRequest().completed += _ =>
        {
            bool valid = false;
            if (request.result == UnityWebRequest.Result.Success)
            {
                try { valid = JsonUtility.FromJson<Answer>(request.downloadHandler.text)?.valid == true; }
                catch (ArgumentException) { }   // not JSON: treat as not valid
            }
            request.Dispose();
            done(valid);
        };
    }
}

Add the script to any object of the Main scene. PurchaseReceipt carries the product id, the transaction id, the store name, Unity IAP's receipt, the Google Play purchase token and the App Store signed transaction. Your server checks them with the store:

• Google Play: call the Google Play Developer API purchases.products.get with your package name, the product id and googlePurchaseToken (it needs a Google Cloud service account linked to your Play Console). The purchase is valid when purchaseState is 0.
• App Store: verify the appleSignedTransaction JWS with Apple's certificate chain (Apple's App Store Server Library does it), or ask the App Store Server API for the transaction with transactionId.

Save data & cheating

Protected save

Progress, stats, the unfinished game, coins, hints, undos and purchases are saved in PlayerPrefs (key chesscrown_save) as JSON that is signed with HMAC-SHA256 and lightly scrambled, so the values can't be read or changed with a PlayerPrefs or XML editor. When a save has been edited or damaged, the signature doesn't match: the game starts a new save and keeps the rejected one under chesscrown_save_broken, in case a player writes to support.

This stops casual cheating, which is what a game that keeps its data on the phone can do: the secret is inside the app, so a determined player with a decompiler could still rebuild a save. If your economy needs more than that, keep the wallet on a server.

Daily rewards and the device clock

The Lucky Spin and the daily puzzle follow GameClock, not the phone's clock directly. It remembers the latest time it has seen and never goes back from it:

• Clock set back (the classic trick to get the daily rewards again): detected as soon as the game reads the time. The free spin doesn't come back, the log says how far the clock went back, and the Lucky Spin shows "Clock set back: free spin comes later".
• Clock set forward: the player gets the next days' rewards early, but then waits until the real date catches up, so there is nothing to gain over time.
• Time zones: a reward is given only on a later calendar day than the last one, so flying across time zones (or faking it) doesn't give an extra one.

Limits: the game doesn't check the time online. A player who moves the clock far into the future takes a few rewards early and then waits until that date for the next one, and deleting the app's data resets everything, like any game saved on the phone. If your game has a server, give daily rewards from the server's time instead.

Building

Android

1. In Edit → Project Settings → Player set your company name, product name, Package Name and version.
2. Create a keystore under Publishing Settings.
3. If Gradle complains about missing dependencies, run Assets → External Dependency Manager → Android Resolver → Force Resolve.
4. Tick Build App Bundle (Google Play) in the build profile and build.

The project targets Android 7.0 (API 24) and newer, ARM64 and ARMv7 with IL2CPP, and uses ASTC texture compression. The engine benefits from IL2CPP: it searches much faster than in the editor.

iOS

1. Set the Bundle Identifier and signing team in the Player settings. The minimum iOS version is 13.
2. Build, then open the generated .xcworkspace (not the .xcodeproj). CocoaPods installs the Google Mobile Ads SDK during the build.
3. Set up the tracking prompt as explained below.

App Tracking Transparency (iOS)

Since iOS 14.5, an app must ask permission before it uses the advertising identifier (IDFA) for personalized ads. The game doesn't show this prompt from its own code: Google's UMP SDK shows it, as part of the consent flow that runs at launch (ConsentForm.LoadAndShowConsentFormIfRequired in AdMobProvider). This is how it works:

1. The game starts and asks UMP for the consent status.
2. If you published an IDFA explainer message in AdMob and the player hasn't answered the tracking question yet, UMP shows your explainer screen first (and the GDPR form before it, in the regions that need it).
3. When the player continues, UMP asks iOS for permission and the system prompt "Allow ... to track your activity across other companies' apps and websites?" appears, with the text you entered as User Tracking Usage Description.
4. Ads start once consent allows it. With Allow, AdMob can show personalized ads; with Ask App Not to Track, ads still show, without the IDFA.

Without an IDFA explainer message, iOS never shows the prompt and AdMob serves ads without the IDFA. Set it up like this:

1. In Assets → Google Mobile Ads → Settings, fill in User Tracking Usage Description (it becomes NSUserTrackingUsageDescription in Info.plist). Write it yourself, it is what the player reads.
2. In AdMob open Privacy & messaging, create an IDFA explainer message (shown as "IDFA message" / "iOS ATT" depending on the AdMob version), choose your iOS app, and publish it. Publish your GDPR message there too.

Check it before you submit to the App Store:

1. Install the build on a real iPhone (iOS 14.5 or newer) from Xcode or TestFlight.
2. In Settings → Privacy & Security → Tracking, make sure Allow Apps to Request to Track is on. When it is off, iOS answers "no" for every app and never shows the prompt.
3. Launch the game: the explainer appears, then the system prompt with your text. iOS asks only once per install, so delete the app and install it again to see it another time.
4. In the Xcode console, check that no error mentions NSUserTrackingUsageDescription, and that ads load after you answer.
5. To test the GDPR form outside Europe, add debug settings to the request in AdMobProvider.RequestConsent, then remove them before release:

   var request = new ConsentRequestParameters
   {
       ConsentDebugSettings = new ConsentDebugSettings
       {
           DebugGeography = DebugGeography.EEA,
           TestDeviceHashedIds = new List<string> { "YOUR-HASHED-DEVICE-ID" } // printed in the Xcode console
       }
   };
   ConsentInformation.Update(request, ...);

6. In App Store Connect, answer the App Privacy questions to match: with AdMob, "Device ID" and "Advertising Data" are used for third-party advertising, and tracking is declared when you show the prompt. Apple checks that the prompt appears in the build you submit.

Publishing checklist

• Your own AdMob, Google Play Console and Apple Developer accounts (see possible costs).
• Your own package name / bundle identifier, product name, icon and version.
• Your own AdMob App IDs (Google's settings) and ad unit ids (Game Config): Chess Crown comes without any. No Google sample ad units left in the Game Config.
• A consent message published in AdMob (Privacy & messaging).
• iOS: a User Tracking Usage Description, an IDFA explainer message published in AdMob, and the tracking prompt checked on an iPhone (see App Tracking Transparency).
• Your product ids in the Game Config and the same products created in the stores.
• Unity IAP on a 5.x version (no version warning in the Console).
• Your Google Play license key in the Receipt Validation Obfuscator (see Receipt validation).
• Your own SaveManager.Secret (see Save data).
• Your privacy policy, store links and support e-mail in the Game Config.
• The Google Mobile Ads plugin imported from Google, if your game shows ads.
• A release keystore (Android) and signing team (iOS).
• Tested a release build on a real phone.

Code overview

The code lives in the ChessCrown namespace (the engine in ChessCrown.Chess, see Chess engine). The main game pieces:

How rewards are handed out

Winning a game, solving a puzzle, opening the Star Chest or landing on a Lucky Spin prize saves the reward as pending right away, together with the progress. The popup then shows it and Wallet.ClaimPending() adds it to the wallet when the player collects it. If the app is closed in between, the reward popup comes back on the next launch.

Adding a popup

1. Create a class that inherits from UIPopup and override OnOpen.
2. Duplicate a popup prefab from Prefabs/UI, swap the component, place it under Canvas/Popups in the Main scene.
3. Add it to the Popups list of the UIManager on the Canvas, then open it from code with UIManager.Instance.Get<MyPopup>().Open().

Troubleshooting

No ads show on my phone

Check that the Google Mobile Ads plugin is imported and that your ad unit ids are in the Game Config (Tools → Chess Crown → Ads → AdMob Status shows both), that the phone has internet, that Enable Ads is on and that you haven't bought No Ads in that install. Live ad units can take hours to start serving after you create them; add your phone as a test device to check them right away (see Testing ads). In the EU the consent form must be answered first.

"Store not available right now"

The store doesn't sell your products yet: they aren't created, not active, or the build isn't uploaded to a testing track. Use a development build with Test Purchases on to test the flow meanwhile.

The computer is too slow or too fast in the editor

The engine runs several times faster in an IL2CPP build on a phone than in the editor, so judge the levels on a device. Search time is limited by Time Ms of each level, never by the device.

A puzzle doesn't accept my move

In a mate puzzle, every move that still forces mate in the remaining moves is accepted. In other puzzles only the moves of the file count. Open the puzzle in the Puzzle Editor and press Check.

Pink or missing images in a build

Edit → Project Settings → Graphics must list UI/Default in Always Included Shaders. It is set in this project; keep it if you change graphics settings.

Gradle or dependency errors on Android

With Google's Mobile Ads plugin imported, run Assets → External Dependency Manager → Android Resolver → Force Resolve, and make sure the Gradle templates it needs are enabled in the Player settings (Publishing Settings).

A dialog says the Unity IAP version is not supported

Another major version of Unity IAP is installed, so purchases are switched off. Install a 5.x version (5.4.3 or newer) in Window → Package Manager → In-App Purchasing; the message goes away after the next compile.

"Invalid receipt" in the log and the purchase isn't delivered

The license key in the Receipt Validation Obfuscator doesn't belong to this app, or the build's package name differs from the one in Google Play Console. Copy the key again from Monetization setup and obfuscate it again.

My progress was reset

The save was edited outside the game, or SaveManager.Secret changed since it was written. The old save is kept under the PlayerPrefs key chesscrown_save_broken. While developing, use the Cheats menu instead of editing PlayerPrefs.

My saved progress in the editor gets in the way

Use Tools → Chess Crown → Cheats → Reset All Progress.

Updating to a new version

New versions of Chess Crown are listed in the Changelog. Your game is already changed (your ids, your art, maybe your own code), so don't import a new version over your project blindly:

1. Back up your project first, or commit it to version control, so you can compare and go back.
2. Unzip the new version into a separate folder and open it once with Unity to see what changed (the changelog lists the files).
3. Copy over only the scripts and files the changelog names, then check your changes to them again.

Usually safe to overwrite with the new version: the scripts in Scripts/Runtime/Chess (the engine) and Scripts/Editor (Puzzle Editor, menu, checks), as long as you didn't change them. After updating, run the game in the editor, play a game and a puzzle, test a purchase with the fake store, and make a test build before you publish.

Credits & licenses

The game, its code and chess engine, the pieces, boards, user interface art, the logo, the sounds and the 2,000 puzzles are original work created by the author. Some of it is shared with the author's earlier item Tile Crown: a few generic white UI shapes drawn by the same code (ui_circle, ui_rounded, ui_shadow, ui_glow, ui_rays, ui_triangle, fx_spark, fx_confetti and bar_fill), and the structure of the ads, purchase, save and daily reward code. The design, icons, logo, sounds and screens of Chess Crown are its own. The following assets are included; their licenses are in ChessCrown/ThirdPartyLicenses (or next to the asset) and allow commercial use:

The 2,000 included puzzles are original, made with Chess Crown's own engine and solver; no Lichess data is included. Puzzles you import yourself from the Lichess puzzle database stay under the Lichess database license: if you ship them, you must credit Lichess as its attribution requirements (CC BY 4.0) ask, for example "Puzzles from the Lichess puzzle database (lichess.org)" (see Puzzles). Thanks to Lichess for making its database available. The Google Mobile Ads Unity plugin is not part of the download; when you import it from Google, Google's terms apply to it.

Changelog & support

1.0.0

• First release.

Questions or problems? Contact us through the comments on the item page or the support form on our profile. Please include your Unity version and the platform you build for.