diff --git a/package.json b/package.json
index 67519765..7080054b 100644
--- a/package.json
+++ b/package.json
@@ -48,5 +48,5 @@
         "preview:https": "serve dist",
         "reinstall": "rm -rf node_modules; yarn; vue-tsc --noEmit"
     },
-    "version": "5.0.0-alpha.278"
+    "version": "5.0.0-alpha.280"
 }
diff --git a/src/components/units/AppGame.vue b/src/components/units/AppGame.vue
index e4856b7e..594cbfd5 100644
--- a/src/components/units/AppGame.vue
+++ b/src/components/units/AppGame.vue
@@ -15,11 +15,10 @@
     const route = useRoute();
     const store = useStore();
     /* Change the following values to computed refs if game may change dynamically on this page. */
-    const gameType = route.params.type as string;
     const gameId = route.params.gameId as string;
     const variantId = route.params.variantId as string;
     const initialPosition = route.params.initialPosition as string;
-    store.dispatch(actionTypes.initiateMatch, { gameType: gameType, gameId: gameId, variantId: variantId, startPosition: initialPosition });
+    store.dispatch(actionTypes.initiateMatch, { gameId: gameId, variantId: variantId, startPosition: initialPosition });
     const options = computed(() => store.getters.options);
     const showMenu = computed(() => (options.value ? options.value.showMenu : true));
     onBeforeRouteLeave(() => store.dispatch(actionTypes.exitMatch));
diff --git a/src/components/units/AppGameVariants.vue b/src/components/units/AppGameVariants.vue
index 2b7f8586..83e54437 100644
--- a/src/components/units/AppGameVariants.vue
+++ b/src/components/units/AppGameVariants.vue
@@ -3,12 +3,12 @@
         <h2>{{ gameName }}</h2>
         <h3>{{ t("gameVariantsTitle") }}</h3>
         <div id="variants" v-if="game">
-            <router-link v-for="variant in gameVariants" :key="variant.id" :class="variant.gui_status" :to="{ name: 'game', params: { type: gameType, gameId: gameId, variantId: variant.id } }">
-                <img :src="getLogoSource(variant.id)" :alt="game.name + ' ' + variant.description + ' Logo'" style="width: 8rem" />
-                <p>{{ variant.description }}</p>
+            <router-link v-for="variant in gameVariants" :key="variant.id" :class="variant.gui" :to="{ name: 'game', params: { type: gameType, gameId: gameId, variantId: variant.id } }">
+                <img :src="getLogoSource(variant.id)" :alt="'Logo'" style="width: 8rem" />
+                <p>{{ variant.name }}</p>
             </router-link>
-            <div v-if="gameCustom" v-on:click="customBoardRoute" :class="game.gui_status">
-                <img :src="getLogoSource('custom')" :alt="game.name + ' ' + 'Custom Logo'" style="width: 8rem" />
+            <div v-if="gameCustom" v-on:click="customBoardRoute" :class="game.gui">
+                <img :src="getLogoSource('custom')" :alt="'Logo'" style="width: 8rem" />
                 <p>Custom</p>
             </div>
         </div>
@@ -27,11 +27,13 @@
     const { t } = useI18n();
     const gameType = computed(() => route.params.type as string);
     const gameId = computed(() => route.params.gameId as string);
-    const game = computed(() => store.getters.game(gameType.value, gameId.value));
-    const gameCustom = computed(() => (game.value ? game.value.custom : false));
+    store.dispatch(actionTypes.loadVariants, { gameId: gameId.value });
+
+    const game = computed(() => store.getters.game(gameId.value));
+    const gameCustom = computed(() => (game.value ? game.value.allowCustomVariantCreation : false));
     const gameName = computed(() => (game.value ? game.value.name : ""));
     const gameVariants = computed(() => {
-        let total = game.value.variants.variants;
+        let total = game.value.variants;
         const asArray = Object.entries(total);
         if (asArray.length == 1 && !gameCustom.value) {
             router.replace({ name: 'game', params: { type: gameType.value, gameId: gameId.value, variantId: asArray[0][0] } });
@@ -67,12 +69,11 @@
         return logo[appLogoFilePath].default;
     };
     const customBoardRoute = () => {
-        let boardStr = window.prompt('Enter a valid variant:');
-        if (boardStr !== null) {
-            router.push({ name: 'game', params: { type: gameType.value, gameId: gameId.value, variantId: boardStr } })
+        let variantId = window.prompt('Enter a Valid Variant ID:');
+        if (variantId !== null) {
+            router.push({ name: 'game', params: { type: gameType.value, gameId: gameId.value, variantId: variantId } })
         }
     }
-    store.dispatch(actionTypes.loadVariants, { type: gameType.value, gameId: gameId.value });
 </script>
 
 <style lang="scss" scoped>
diff --git a/src/components/units/AppGames.vue b/src/components/units/AppGames.vue
index f0df4587..11f68d70 100644
--- a/src/components/units/AppGames.vue
+++ b/src/components/units/AppGames.vue
@@ -7,7 +7,7 @@
                 <h2>{{ gameTypeTitle }} with{{ category.name }}</h2>
                 <div class="games">
                     <g v-for="member in category.members" :key="member.id">
-                        <router-link :class="category.id" v-if="member.gui_status === category.id" :to="{ name: 'variants', params: { type: gameType, gameId: member.id } }">
+                        <router-link :class="category.id" v-if="member.gui === category.id" :to="{ name: 'variants', params: { type: gameType, gameId: member.id } }">
                             <img :src="getLogoSource(member)" style="width: 8rem" />
                             <p :style="member.name.length < 17 ? 'font-size: 100%' : 'font-size: 90%'" >{{ member.name }}</p>
                         </router-link>
@@ -43,6 +43,7 @@ const getLogoSource = (game: Game) => {
     return logo[appLogoFilePath].default;
 }
 const gameType = computed(() => route.params.type as string);
+const gameTypeStr = computed(() => gameType.value === "puzzles" ? "onePlayer" : "twoPlayer");
 const gameTypeTitle = computed(() => gameType.value[0].toUpperCase() + gameType.value.slice(1));
 const search = ref("");
 
@@ -54,12 +55,12 @@ interface Category {
 
 const categories = computed(() => {
     let categories: Category[] = [];
-    const asArray = Object.values(store.getters.games(gameType.value).games);
+    const asArray = Object.values(store.getters.games);
     for (const strs of [["v3", " Animated GUIs"], ["v2", " Artisan GUIs"], ["v1", " Standard GUIs"], ["v0", "out GUIs (Still in Development)"]]) {
         categories.push({
             id: strs[0],
             name: strs[1],
-            members: asArray.filter((value) => value.name.toLowerCase().includes(search.value.toLowerCase()) && value.gui_status === strs[0])
+            members: asArray.filter((value) => value.type === gameTypeStr.value && value.name.toLowerCase().includes(search.value.toLowerCase()) && value.gui === strs[0])
         });
     }
     return categories;
diff --git a/src/components/units/DemoMode/AppDemo.vue b/src/components/units/DemoMode/AppDemo.vue
index 4472a137..072ab030 100644
--- a/src/components/units/DemoMode/AppDemo.vue
+++ b/src/components/units/DemoMode/AppDemo.vue
@@ -47,7 +47,6 @@
     const currentGameIndex = ref(0);
     const initiateCurrentGame = async () => {
         await store.dispatch(actionTypes.initiateMatch, {
-            gameType: games[currentGameIndex.value].gameType,
             gameId: games[currentGameIndex.value].gameId,
             variantId: games[currentGameIndex.value].variantId,
             startPosition: games[currentGameIndex.value].startPosition || undefined,
diff --git a/src/components/units/DemoMode/AppDemoBodyBoard.vue b/src/components/units/DemoMode/AppDemoBodyBoard.vue
index f968631d..4024c783 100644
--- a/src/components/units/DemoMode/AppDemoBodyBoard.vue
+++ b/src/components/units/DemoMode/AppDemoBodyBoard.vue
@@ -16,7 +16,7 @@
     const position = computed(() => store.getters.currentPosition);
     const gameBoards: Record<string, any> = {};
     const getGameBoardComponent = computed(() => {
-        if (position.value.match(/^R_(A|B)_([0-9]+)_([0-9]+)_([a-zA-Z0-9-~]+)(?:_(.*))?$/)) return AppGameBodyBoardRegular2D;
+        if (position.value.match(/^(1|2)_([a-zA-Z0-9-~]+)(?:_(.*))?$/)) return AppGameBodyBoardRegular2D;
         const gameBoard = `${gameId}-${variantId}`;
         if (gameBoard in gameBoards) return gameBoards[gameBoard];
         return CharacterAutoGUI;
diff --git a/src/components/units/DemoMode/AppDemoBodyHeaderTitle.vue b/src/components/units/DemoMode/AppDemoBodyHeaderTitle.vue
index eedf8245..107f2074 100644
--- a/src/components/units/DemoMode/AppDemoBodyHeaderTitle.vue
+++ b/src/components/units/DemoMode/AppDemoBodyHeaderTitle.vue
@@ -13,15 +13,15 @@
     const gameId = computed(() => store.getters.currentGameId);
     const variantId = computed(() => store.getters.currentVariantId);
     const gameName = computed(() => {
-        if (!store.getters.games(gameType.value)) return "";
-        if (!store.getters.game(gameType.value, gameId.value)) return "";
-        return store.getters.game(gameType.value, gameId.value).name;
+        if (!store.getters.games) return "";
+        if (!store.getters.game(gameId.value)) return "";
+        return store.getters.game(gameId.value).name;
     });
     const variantDescription = computed(() => {
-        if (!store.getters.games(gameType.value)) return "";
-        if (!store.getters.game(gameType.value, gameId.value)) return "";
-        if (!store.getters.variant(gameType.value, gameId.value, variantId.value)) return "";
-        return store.getters.variant(gameType.value, gameId.value, variantId.value).description;
+        if (!store.getters.games) return "";
+        if (!store.getters.game(gameId.value)) return "";
+        if (!store.getters.variant(gameId.value, variantId.value)) return "";
+        return store.getters.variant(gameId.value, variantId.value).name;
     });
 </script>
 
diff --git a/src/components/units/GameBody/AppGameBodyBoard.vue b/src/components/units/GameBody/AppGameBodyBoard.vue
index f74b77dd..81ffd788 100644
--- a/src/components/units/GameBody/AppGameBodyBoard.vue
+++ b/src/components/units/GameBody/AppGameBodyBoard.vue
@@ -15,10 +15,10 @@
     const store = useStore();
     const gameId = route.params.gameId as string;
     const variantId = route.params.variantId as string;
-    const position = computed(() => store.getters.currentPosition);
+    const position = computed(() => store.getters.currentAutoguiPosition);
     const gameBoards: Record<string, any> = {};
     const getGameBoardComponent = () => {
-        if (position.value.match(/^R_(A|B)_([0-9]+)_([0-9]+)_([a-zA-Z0-9-\.~]+)(?:_(.*))?$/) || position.value[0] == 'C') return AppGameBodyBoardRegular2D;
+        if (position.value.match(/^(1|2)_([a-zA-Z0-9-\.~]+)(?:_(.*))?$/)) return AppGameBodyBoardRegular2D;
         const gameBoard = `${gameId}-${variantId}`;
         if (gameBoard in gameBoards) return gameBoards[gameBoard];
         return CharacterAutoGUI;
diff --git a/src/components/units/GameBody/AppGameBodyBoardRegular2D.vue b/src/components/units/GameBody/AppGameBodyBoardRegular2D.vue
index 73290efd..61b7759e 100644
--- a/src/components/units/GameBody/AppGameBodyBoardRegular2D.vue
+++ b/src/components/units/GameBody/AppGameBodyBoardRegular2D.vue
@@ -17,8 +17,7 @@
     const currentMatch = computed(() => (store.state.app.currentMatch ? store.state.app.currentMatch : undefined));
     const gameId = computed(() => (currentMatch.value ? currentMatch.value.gameId : ""));
     const variantId = computed(() => (currentMatch.value ? currentMatch.value.variantId : ""));
-    const gameType = computed(() => (currentMatch.value ? currentMatch.value.gameType : ""));
-    const imageAutoGUIData = computed(() => store.getters.imageAutoGUIData(gameType.value, gameId.value, variantId.value));
+    const imageAutoGUIData = computed(() => store.getters.imageAutoGUIData(gameId.value, variantId.value));
     const regular2DGameBoards: Record<string, any> = {
         "tictactoe-misere": CustomGUITicTacToe,
         "tictactoe-regular": CustomGUITicTacToe,
diff --git a/src/components/units/GameBody/AppGameBodyHeaderInstructions.vue b/src/components/units/GameBody/AppGameBodyHeaderInstructions.vue
index 963d3fb1..804af9fc 100644
--- a/src/components/units/GameBody/AppGameBodyHeaderInstructions.vue
+++ b/src/components/units/GameBody/AppGameBodyHeaderInstructions.vue
@@ -19,10 +19,10 @@
     const options = computed(() => store.getters.options);
     const preferences = computed(() => store.getters.preferences);
     const instructions = computed(() => {
-        let game = store.getters.game(store.getters.currentGameType, store.getters.currentGameId);
+        let game = store.getters.game(store.getters.currentGameId);
         if (game && game.instructions) {
             if (!(preferences.value.locale in game.instructions)) {
-                store.dispatch(actionTypes.addInstructions, {gameType: store.getters.currentGameType, gameId: store.getters.currentGameId});
+                store.dispatch(actionTypes.addInstructions, {gameId: store.getters.currentGameId, variantId: store.getters.currentVariantId});
             }
             let instructions = game.instructions[preferences.value.locale];
             return instructions ? instructions : "# No Instructions Available"
diff --git a/src/components/units/GameBody/AppGameBodyHeaderOptions.vue b/src/components/units/GameBody/AppGameBodyHeaderOptions.vue
index 91028a3d..741ee1ea 100644
--- a/src/components/units/GameBody/AppGameBodyHeaderOptions.vue
+++ b/src/components/units/GameBody/AppGameBodyHeaderOptions.vue
@@ -214,12 +214,12 @@
     const gameId = route.params.gameId as string;
     const variantId = route.params.variantId as string;
 
-    const game = computed(() => store.getters.game(gameType, gameId));
-    const gameVariant = computed(() => store.getters.variant(gameType, gameId, variantId));
+    const game = computed(() => store.getters.game(gameId));
+    const gameVariant = computed(() => store.getters.variant(gameId, variantId));
     const gameName = computed(() => (game.value ? game.value.name : ""));
     const variantDescription = computed(() => {
         if (!game.value || !gameVariant.value) return "";
-        return gameVariant.value.description;
+        return gameVariant.value.name;
     });
     const gameThemes = computed(() =>
         gameVariant.value.imageAutoGUIData ?
@@ -260,7 +260,7 @@
 
     // Stores true or false, whether the current game supports the Win By view or it does not.
     const supportsWinBy = computed(() =>
-        store.getters.supportsWinBy(currentGameType.value, currentGameId.value)
+        store.getters.supportsWinBy(currentGameId.value)
     );
     
     // Array of the available computer strategies.
diff --git a/src/components/units/GameBody/AppGameBodyHeaderTitle.vue b/src/components/units/GameBody/AppGameBodyHeaderTitle.vue
index 5371eb53..33d95e99 100644
--- a/src/components/units/GameBody/AppGameBodyHeaderTitle.vue
+++ b/src/components/units/GameBody/AppGameBodyHeaderTitle.vue
@@ -1,6 +1,6 @@
 <template>
     <div id="app-game-body-header-title">
-        <h2>{{ gameName }} ({{ variantDescription }})</h2>
+        <h2>{{ gameName }} ({{ variantName }})</h2>
     </div>
 </template>
 
@@ -11,11 +11,10 @@
 
     const route = useRoute();
     const store = useStore();
-    const gameType = route.params.type as string;
     const gameId = route.params.gameId as string;
     const variantId = route.params.variantId as string;
-    const gameName = computed(() => (store.getters.game(gameType, gameId) ? store.getters.game(gameType, gameId).name : ""));
-    const variantDescription = computed(() => (store.getters.game(gameType, gameId) && store.getters.variant(gameType, gameId, variantId) ? store.getters.variant(gameType, gameId, variantId).description : ""));
+    const gameName = computed(() => (store.getters.game(gameId) ? store.getters.game(gameId).name : ""));
+    const variantName = computed(() => (store.getters.game(gameId) && store.getters.variant(gameId, variantId) ? store.getters.variant(gameId, variantId).name : ""));
 </script>
 
 <style lang="scss" scoped>
diff --git a/src/components/units/GameBody/CustomGUIQuarto.vue b/src/components/units/GameBody/CustomGUIQuarto.vue
index 3c8f2ad9..b56222ef 100644
--- a/src/components/units/GameBody/CustomGUIQuarto.vue
+++ b/src/components/units/GameBody/CustomGUIQuarto.vue
@@ -137,18 +137,18 @@
     const gameTheme = computed(() => store.getters.currentGameTheme || "r");
     const otherGameTheme = computed(() => gameTheme.value === "r" ? "b" : "r");
     const animationPlaying = computed(() => store.getters.animationPlaying);
-    const isInitial = computed(() => currentPosition.value === "R_A_17_1_-----------------");
+    const isInitial = computed(() => currentPosition.value === "1_-----------------");
     const richPositionData = computed(() => {
-        const matches = currentPosition.value.match(/^R_(A|B)_([0-9]+)_([0-9]+)_([a-zA-Z0-9-]+)*/)!;
-        const validRichPosition = matches && matches.length >= 5 && matches[4].length == 17;
+        const matches = currentPosition.value.match(/^(1|2)_([a-zA-Z0-9-]+)*/)!;
+        const validRichPosition = matches && matches.length >= 3 && matches[2].length == 17;
         if (validRichPosition) {
             const turn = matches[1];
-            const board = matches[4].substring(0, 16);
+            const board = matches[2].substring(0, 16);
             let tokens: GDefaultRegular2DBoardToken[] = [];
-            const nextPiece = matches[4].slice(-1);
+            const nextPiece = matches[2].slice(-1);
             for (let nextMoveData of Object.values(availableMoves.value)) {        
                 let matches;
-                if ((matches = nextMoveData.move.match(/^A_([a-zA-Z0-9-])_([0-9]+)*/))) {
+                if ((matches = nextMoveData.autoguiMove.match(/^A_([a-zA-Z0-9-])_([0-9]+)*/))) {
                     tokens.push({
                         token: matches[1],
                         to: parseInt(matches[2]),
@@ -160,7 +160,7 @@
                     });
                 }
             }
-
+        
             return {
                 turn: turn,
                 board,
diff --git a/src/components/units/GameBody/CustomGUISim.vue b/src/components/units/GameBody/CustomGUISim.vue
index b6b6ed65..6227b1ee 100644
--- a/src/components/units/GameBody/CustomGUISim.vue
+++ b/src/components/units/GameBody/CustomGUISim.vue
@@ -74,17 +74,17 @@
     
     const richPositionData = computed(() => {
         const position: string = currentPosition.value;
-        const matches = position.match(/^C_([a-zA-Z0-9-]+)*/)!;
-        const validRichPosition = matches && matches.length >= 2;
+        const matches = position.match(/^(1|2)_([a-zA-Z0-9-]+)*/)!;
+        const validRichPosition = matches && matches.length >= 3;
         let moves: GSimMove[] = [];
         if (validRichPosition) {
             for (let nextMoveData of Object.values(currentAvailableMoves.value)) {
                 moves.push({
-                    str: nextMoveData.move,
+                    str: nextMoveData.autoguiMove,
                     hint: nextMoveData.moveValue,
                     hintOpacity: nextMoveData.moveValueOpacity,
-                    from: Number(nextMoveData.moveName[0]) - 1,
-                    to: Number(nextMoveData.moveName[1]) - 1
+                    from: Number(nextMoveData.move[0]) - 1,
+                    to: Number(nextMoveData.move[1]) - 1
                 });
             }
         }
diff --git a/src/components/units/GameBody/CustomGUITicTacToe.vue b/src/components/units/GameBody/CustomGUITicTacToe.vue
index 807e05da..935eda22 100644
--- a/src/components/units/GameBody/CustomGUITicTacToe.vue
+++ b/src/components/units/GameBody/CustomGUITicTacToe.vue
@@ -41,9 +41,8 @@
 </template>
 
 <script lang="ts" setup>
-    import { computed, ref, watch } from "vue";
+    import { computed } from "vue";
     import { actionTypes, useStore } from "../../../scripts/plugins/store";
-    
     type CellData = { mark: string; move: string; hint: string; hintOpacity: number };
     type BoardData = Record<number, CellData>;
     const store = useStore();
@@ -52,17 +51,16 @@
     const showNextMoveHints = computed(() => (options.value ? options.value.showNextMoveHints : true));
     const showNextMoveDeltaRemotenesses = computed(() => (options.value ? options.value.showNextMoveDeltaRemotenesses : true));
     const currentPosition = computed(() => store.getters.currentPosition);
-    const currentValue = computed(() => store.getters.currentPositionValue);
     const currentRemoteness = computed(() => store.getters.currentRemoteness);
     const availableMoves = computed(() => store.getters.currentAvailableMoves);
     const movesAreClickable = computed(() => !(store.getters.currentPlayer.isComputer || (options.value.automoveIfSingleMove && Object.keys(availableMoves.value).length == 1)));
-    const turn = computed(() => currentPosition.value[2]);
+    const turn = computed(() => currentPosition.value[0]);
     const animationPlaying = computed(() => store.getters.animationPlaying);
     const isMisere = computed(() => store.getters.currentVariantId === "misere" ? "misere" : "");
     const board = computed(() => {
         let board: BoardData = {};
-        for (let cell: number = 0; cell < 9; cell++) board[cell] = { mark: currentPosition.value[8 + cell], move: "", hint: "", hintOpacity: 1 };
-        for (let availableMove in availableMoves.value) Object.assign(board[+availableMoves.value[availableMove].move[4]], { move: availableMoves.value[availableMove].move, hint: availableMoves.value[availableMove].moveValue, hintOpacity: availableMoves.value[availableMove].moveValueOpacity });
+        for (let cell: number = 0; cell < 9; cell++) board[cell] = { mark: currentPosition.value[2 + cell], move: "", hint: "", hintOpacity: 1 };
+        for (let availableMove in availableMoves.value) Object.assign(board[+availableMoves.value[availableMove].autoguiMove[4]], { move: availableMoves.value[availableMove].move, hint: availableMoves.value[availableMove].moveValue, hintOpacity: availableMoves.value[availableMove].moveValueOpacity });
         return board;
     });
     const getHintClass = (hint: string): string => (showNextMoveHints.value ? "hint-" + hint : "hint-" + turn.value);
@@ -70,7 +68,7 @@
     const yOffset = (cell: number): number => Math.floor(cell / 3) * 22;
     const b16 = (cond: boolean): number => cond ? 16 : 0;
     const triplets = computed(() => {
-        const str = currentPosition.value.split('_')[4];
+        const str = currentPosition.value.split('_')[1];
         return [
             str[0] != '-' && str[0] == str[1] && str[1] == str[2],
             str[3] != '-' && str[3] == str[4] && str[4] == str[5],
@@ -94,11 +92,11 @@
             stroke: var(--neutralColor);
         }
         .hint- {
-            &A {
+            &1 {
                 stroke: var(--turn1Color);
                 fill: var(--turn1Color);
             }
-            &B {
+            &2 {
                 stroke: var(--turn2Color);
                 fill: var(--turn2Color);
             }
diff --git a/src/components/units/GameBody/ImageAutoGUI.vue b/src/components/units/GameBody/ImageAutoGUI.vue
index 17538509..96293ec7 100644
--- a/src/components/units/GameBody/ImageAutoGUI.vue
+++ b/src/components/units/GameBody/ImageAutoGUI.vue
@@ -165,13 +165,12 @@
 
   const store = useStore();
   const options = computed(() => store.getters.options);
-  const currentPosition = computed(() => store.getters.currentPosition);
+  const currentPosition = computed(() => store.getters.currentAutoguiPosition);
   const currentAvailableMoves = computed(() => store.getters.currentAvailableMoves);
   const movesAreClickable = computed(() => !(store.getters.currentPlayer.isComputer || (options.value.automoveIfSingleMove && Object.keys(currentAvailableMoves.value).length == 1)));
 
   /* Code Cleanup Required Here */
-  const imageAutoGUIData = computed(() => store.getters.imageAutoGUIData(store.getters.currentGameType, 
-    store.getters.currentGameId, store.getters.currentVariantId));
+  const imageAutoGUIData = computed(() => store.getters.imageAutoGUIData(store.getters.currentGameId, store.getters.currentVariantId));
   const currentTheme = computed(() => store.getters.currentGameTheme);
   const theTheme = computed(() => imageAutoGUIData.value.themes[currentTheme.value]);
   const scaledWidth = 100;
@@ -180,7 +179,7 @@
   const scaledHeight = computed(() => space.value[1] * widthFactor.value);
   const entities = computed(() => theTheme.value.entities);
   const centers = computed(() =>
-    theTheme.value.centers.map((a: [number, number]) =>
+    theTheme.value.centers.map((a: Array<number>) =>
       a.map((b: number) => b * widthFactor.value)));
   const getImageSource = (imagePath: string) => gimages["../../../models/images/svg/" + imagePath].default;
   const animationPlaying = computed(() => store.getters.animationPlaying);
@@ -198,11 +197,11 @@
   /* End Code Cleanup Required Here */
 
   const richPositionData = computed(() => {
-    const matches = currentPosition.value.match(/^R_(A|B)_([0-9]+)_([0-9]+)_([a-zA-Z0-9-\.~]+)*/)!;
-    const validRichPosition = matches && matches.length >= 5;
+    const matches = currentPosition.value.match(/^(1|2)_([a-zA-Z0-9-\.~]+)*/)!;
+    const validRichPosition = matches && matches.length >= 3;
     if (validRichPosition) {
       const turn = matches[1];
-      const entityStringParts = matches[4].split("~");
+      const entityStringParts = matches[2].split("~");
       const board = entityStringParts[0];
       let tokens: IAGPointButton[] = [];
       let arrows: IAGArrowButton[] = [];
@@ -226,13 +225,13 @@
         };
 
         let matches;
-        if ((matches = nextMoveData.move.match(/^A_([a-zA-Z0-9-])_([0-9]+)*/))) {
+        if ((matches = nextMoveData.autoguiMove.match(/^A_([a-zA-Z0-9-])_([0-9]+)*/))) {
           tokens.push({token: matches[1], center: parseInt(matches[2]), move})
-        } else if ((matches = nextMoveData.move.match(/^M_([0-9]+)_([0-9]+)*/))) {
+        } else if ((matches = nextMoveData.autoguiMove.match(/^M_([0-9]+)_([0-9]+)*/))) {
           arrows.push({from: parseInt(matches[1]), to: parseInt(matches[2]), move});
-        } else if ((matches = nextMoveData.move.match(/^L_([0-9]+)_([0-9]+)*/))) {
+        } else if ((matches = nextMoveData.autoguiMove.match(/^L_([0-9]+)_([0-9]+)*/))) {
           lines.push({p1: parseInt(matches[1]), p2: parseInt(matches[2]), move });
-        } else if ((matches = nextMoveData.move.match(/^T_([a-zA-Z0-9-])_([0-9]+)*/))) {
+        } else if ((matches = nextMoveData.autoguiMove.match(/^T_([a-zA-Z0-9-])_([0-9]+)*/))) {
           textButtons.push({text: matches[1], center: parseInt(matches[2]), move})
         }
       }
@@ -354,8 +353,8 @@
   .iag-button-point {
     transform-origin: var(--tOrigin);
     
-    [data-turn="A"] &.move { fill: var(--turn1Color); stroke: var(--turn1Color); }
-    [data-turn="B"] &.move { fill: var(--turn2Color); stroke: var(--turn1Color); }
+    [data-turn="1"] &.move { fill: var(--turn1Color); stroke: var(--turn1Color); }
+    [data-turn="2"] &.move { fill: var(--turn2Color); stroke: var(--turn1Color); }
 
     &.move.hint- {
       &win      { fill: var(--winColor); stroke: var(--winColor); }
@@ -379,11 +378,11 @@
     stroke: var(--primaryColor);
     fill: var(--primaryColor);
 
-    [data-turn="A"] & {
+    [data-turn="1"] & {
       stroke: var(--turn1Color);
       fill: var(--turn1Color);
     }
-    [data-turn="B"] & {
+    [data-turn="2"] & {
       stroke: var(--turn2Color);
       fill: var(--turn2Color);
     }
@@ -424,8 +423,8 @@
   .iag-button-line {
     stroke: var(--primaryColor);
 
-    [data-turn="A"] & { stroke: var(--turn1Color); }
-    [data-turn="B"] & { stroke: var(--turn2Color); }
+    [data-turn="1"] & { stroke: var(--turn1Color); }
+    [data-turn="2"] & { stroke: var(--turn2Color); }
 
     &.hint- {
       &win { stroke: var(--winColor); }
diff --git a/src/components/units/GameMenu/AppGameMenuPosition.vue b/src/components/units/GameMenu/AppGameMenuPosition.vue
index 9ebd3b81..13a3e238 100644
--- a/src/components/units/GameMenu/AppGameMenuPosition.vue
+++ b/src/components/units/GameMenu/AppGameMenuPosition.vue
@@ -42,10 +42,8 @@
     import { actionTypes, useStore } from "../../../scripts/plugins/store";
 
     const store = useStore();
-    const isPuzzleGame = computed(() => store.getters.currentGameType === "puzzles");
     const randomize = async () => {
         await store.dispatch(actionTypes.initiateMatch, {
-            gameType: store.getters.currentGameType,
             gameId: store.getters.currentGameId,
             variantId: store.getters.currentVariantId,
             startPosition: "random"
diff --git a/src/components/units/VVH/AppGameVvhBody.vue b/src/components/units/VVH/AppGameVvhBody.vue
index 195559a2..eb6dabbb 100644
--- a/src/components/units/VVH/AppGameVvhBody.vue
+++ b/src/components/units/VVH/AppGameVvhBody.vue
@@ -172,7 +172,7 @@
                                 :y="gridTop + roundNumber * rowHeight - rowHeight / 2"
                                 dominant-baseline="middle"
                                 text-anchor="middle">
-                            {{ currentValuedRounds[roundNumber].moveName }}
+                            {{ currentValuedRounds[roundNumber].move.substring(0,4) === 'zzzz' ? '' : currentValuedRounds[roundNumber].move }}
                         </text>
                         <text class="move-coordinate"
                                 v-else
@@ -180,7 +180,7 @@
                                 :y="gridTop + roundNumber * rowHeight - rowHeight / 2"
                                 dominant-baseline="middle"
                                 text-anchor="middle">
-                            {{ currentValuedRounds[roundNumber].moveName }}
+                            {{ currentValuedRounds[roundNumber].move.substring(0,4) === 'zzzz' ? '' : currentValuedRounds[roundNumber].move }}
                         </text>
                     </template>
 
@@ -903,7 +903,7 @@
                                 :y="gridTop + roundNumber * rowHeight - rowHeight / 2"
                                 dominant-baseline="middle"
                                 text-anchor="middle">
-                            {{ currentValuedRounds[roundNumber].moveName }}
+                            {{ currentValuedRounds[roundNumber].move }}
                         </text>
                         <text class="move-coordinate"
                                 v-else
@@ -911,7 +911,7 @@
                                 :y="gridTop + roundNumber * rowHeight - rowHeight / 2"
                                 dominant-baseline="middle"
                                 text-anchor="middle">
-                            {{ currentValuedRounds[roundNumber].moveName }}
+                            {{ currentValuedRounds[roundNumber].move }}
                         </text>
                     </template>
 
@@ -1197,7 +1197,7 @@
     
     // Stores true or false, whether the current game supports the Win By view or it does not.
     const supportsWinBy = computed(() =>
-        store.getters.supportsWinBy(currentGameType.value, currentGameId.value)
+        currentGameId.value ? store.getters.supportsWinBy(currentGameId.value) : false
     );
 
     /** 
diff --git a/src/components/views/TheGamePage.vue b/src/components/views/TheGamePage.vue
index 8323268e..8ddad45c 100644
--- a/src/components/views/TheGamePage.vue
+++ b/src/components/views/TheGamePage.vue
@@ -11,8 +11,8 @@
 
     const route = useRoute();
     const store = useStore();
-    const game = computed(() => store.getters.games(route.params.type as string) ? store.getters.games(route.params.type as string).games[route.params.gameId as string] : undefined);
+    const game = computed(() => store.getters.games ? store.getters.games[route.params.gameId as string] : undefined);
     const gameName = computed(() => (game.value ? game.value.name : ""));
-    const variantDescription = computed(() => (game.value && game.value.variants.variants[route.params.variantId as string] ? game.value.variants.variants[route.params.variantId as string].description : ""));
-    useMeta(computed(() => ({ title: `${variantDescription.value} ${gameName.value}` })));
+    const variantName = computed(() => (game.value && game.value.variants[route.params.variantId as string] ? game.value.variants[route.params.variantId as string].name : ""));
+    useMeta(computed(() => ({ title: `${variantName.value} ${gameName.value}` })));
 </script>
diff --git a/src/components/views/TheVariantsPage.vue b/src/components/views/TheVariantsPage.vue
index dd7ffbd4..b0b3eaca 100644
--- a/src/components/views/TheVariantsPage.vue
+++ b/src/components/views/TheVariantsPage.vue
@@ -11,7 +11,7 @@
 
     const route = useRoute();
     const store = useStore();
-    const game = computed(() => store.getters.games(route.params.type as string) ? store.getters.games(route.params.type as string).games[route.params.gameId as string] : undefined);
+    const game = computed(() => store.getters.games ? store.getters.games[route.params.gameId as string] : undefined);
     const gameName = computed(() => (game.value ? game.value.name : ""));
     useMeta(computed(() => ({ title: `${gameName.value} Variants` })));
 </script>
diff --git a/src/models/datas/defaultApp.ts b/src/models/datas/defaultApp.ts
index 53d84351..32137b37 100644
--- a/src/models/datas/defaultApp.ts
+++ b/src/models/datas/defaultApp.ts
@@ -16,19 +16,18 @@ export const defaultPreferences: Types.Preferences = {
 
 export const defaultDataSources: Types.DataSources = {
     gitHubRepositoryAPI: "https://api.github.com/repos/GamesCrafters/GamesmanUni",
-    onePlayerGameAPI: "https://nyc.cs.berkeley.edu/puzzles/",
-    //onePlayerGameAPI: "http://localhost:9001/",
-    twoPlayerGameAPI: "https://nyc.cs.berkeley.edu/universal/v1/games",
-    //twoPlayerGameAPI: "http://localhost:8082/games"
+    gameAPI: "https://nyc.cs.berkeley.edu/universal/v1/",
+    //gameAPI: "http://localhost:8082/"
 };
 
 export const defaultAvailableMove: Types.Move = {
-    deltaRemoteness: 0,
     move: "",
-    moveName: "",
+    autoguiMove: "",
+    position: "",
+    autoguiPosition: "",
+    deltaRemoteness: 0,
     moveValue: "",
     moveValueOpacity: 1,
-    position: "",
     positionValue: "",
     remoteness: 0,
     winby: 0,
@@ -46,6 +45,7 @@ export const defaultPosition: Types.Position = {
     availableMoveNames: {},
     availableMoves: {},
     position: "",
+    autoguiPosition: "",
     positionValue: "",
     remoteness: 0,
     mex: "",
@@ -58,42 +58,28 @@ export const defaultPositions: Types.Positions = {};
 
 export const defaultVariant: Types.Variant = {
     id: "",
-    description: "",
+    name: "",
+    gui: "v0",
     startPosition: "",
-    positions: {},
+    autoguiStartPosition: "",
     imageAutoGUIData: null as any,
-    status: "",
-    gui_status: "v0"
+    positions: {},
 };
 
-export const defaultVariants: Types.Variants = {
-    ...defaultUpdate,
-    variants: {},
-};
+// export const defaultVariants: Types.Variants = {
+//     ...defaultUpdate,
+//     variants: {},
+// };
 
 export const defaultGame: Types.Game = {
     id: "",
     name: "",
-    author: "",
-    description: "",
-    dateCreated: "",
     instructions: {},
     type: "",
-    variants: { ...defaultVariants, variants: {} },
-    status: "",
-    custom: false,
-    gui_status: "v0",
-    supportsWinBy: 0,
-};
-
-export const defaultGames: Types.Games = {
-    ...defaultUpdate,
-    games: {},
-};
-
-export const defaultGameTypes: Types.GameTypes = {
-    puzzles: { ...defaultGames, games: {} },
-    games: { ...defaultGames, games: {} },
+    variants: {},
+    allowCustomVariantCreation: false,
+    gui: "v0",
+    supportsWinBy: false,
 };
 
 export const defaultCommit: Types.Commit = {
@@ -134,7 +120,7 @@ export const defaultRound: Types.Round = {
     id: 0,
     firstPlayerTurn: true,
     move: "",
-    moveName: "",
+    autoguiMove: "",
     moveValue: "",
     position: { ...defaultPosition, availableMoves: {} },
 };
@@ -146,13 +132,14 @@ export const defaultMatch: Types.Match = {
     gameTheme: "",
     variantId: "",
     startPosition: "",
+    autoguiStartPosition: "",
     firstPlayer: {name: "Player 1", isComputer: false},
     secondPlayer: {name: "Player 2", isComputer: false},
     rounds: [],
     moveHistory: "",
     round: { ...defaultRound, position: { ...defaultPosition, availableMoves: {} } },
-    created: 0,
-    lastPlayed: 0,
+    // created: 0,
+    // lastPlayed: 0,
     backgroundLoading: false,
     computerMoving: false,
     animationPlaying: false
@@ -165,7 +152,7 @@ export const defaultApp: Types.App = {
     version: <string>import.meta.env.PACKAGE_VERSION || "",
     preferences: { ...defaultPreferences },
     dataSources: { ...defaultDataSources },
-    gameTypes: { puzzles: { ...defaultGames, games: {} }, games: { ...defaultGames, games: {} } },
+    games: {},
     commits: { ...defaultUpdate, commits: {} },
     options: { ...defaultOptions },
     matches: {},
@@ -176,6 +163,7 @@ export const defaultApp: Types.App = {
         variantId: "",
         gameTheme: "",
         startPosition: "",
+        autoguiStartPosition: "",
         firstPlayer: {name: "Player 1", isComputer: false},
         secondPlayer: {name: "Player 2", isComputer: false},
         rounds: [],
@@ -184,8 +172,8 @@ export const defaultApp: Types.App = {
         round: {
             ...defaultRound,
             position: { ...defaultPosition, availableMoves: {} } },
-            created: 0,
-            lastPlayed: 0,
+            // created: 0,
+            // lastPlayed: 0,
             backgroundLoading: false,
             computerMoving: false
     },
diff --git a/src/scripts/apis/gamesCrafters/index.ts b/src/scripts/apis/gamesCrafters/index.ts
index a8fca01d..8d6551d8 100644
--- a/src/scripts/apis/gamesCrafters/index.ts
+++ b/src/scripts/apis/gamesCrafters/index.ts
@@ -1,8 +1,8 @@
 import axios from "axios";
 import type * as Types from "./types";
 
-export const loadData = async <DataType extends Types.Status>(dataSource: string) => {
-    let data: DataType | Types.Error;
+export const loadData = async <DataType>(dataSource: string) => {
+    let data: object;
     try {
         data = (await axios.get(dataSource)).data;
     } catch (errorMessage) {
@@ -10,7 +10,7 @@ export const loadData = async <DataType extends Types.Status>(dataSource: string
         console.error(`Error: Failed to load data from ${dataSource}.`);
         return undefined;
     }
-    if (data.status === "error") {
+    if ("error" in data) {
         console.error((<Types.Error>data).error);
         console.error(`Error: Returned error from ${dataSource}`);
         return undefined;
@@ -21,12 +21,10 @@ export const loadData = async <DataType extends Types.Status>(dataSource: string
 
 export const loadInstructions = async (dataSource: string): Promise<Types.Instructions | undefined> => await loadData<Types.Instructions>(dataSource);
 
-export const loadGames = async (dataSource: string, payload: { gameType: string }): Promise<Types.OnePlayerGames | Types.TwoPlayerGames | undefined> => (payload.gameType === "puzzles" ? await loadData<Types.OnePlayerGames>(dataSource) : await loadData<Types.TwoPlayerGames>(dataSource));
+export const loadGames = async (dataSource: string): Promise<Types.Games | undefined> => await loadData<Types.Games>(dataSource);
 
-export const loadVariants = async (dataSource: string, payload: { gameType: string }): Promise<Types.OnePlayerGameVariants | Types.TwoPlayerGameVariants | undefined> => (payload.gameType === "puzzles" ? await loadData<Types.OnePlayerGameVariants>(dataSource) : await loadData<Types.TwoPlayerGameVariants>(dataSource));
+export const loadGame = async (dataSource: string): Promise<Types.Game | undefined> => await loadData<Types.Game>(dataSource);
 
-export const loadVariant = async (dataSource: string, payload: { gameType: string }): Promise<Types.GameVariant | undefined> => await loadData<Types.GameVariant>(dataSource);
+export const loadVariant = async (dataSource: string): Promise<Types.Variant | undefined> => await loadData<Types.Variant>(dataSource);
 
-export const loadPosition = async (dataSource: string) => await loadData<Types.Position>(dataSource);
-
-export const loadRandomPosition = async (dataSource: string) => await loadData<Types.RandomPosition>(dataSource);
+export const loadPosition = async (dataSource: string) => await loadData<Types.Position>(dataSource);
\ No newline at end of file
diff --git a/src/scripts/apis/gamesCrafters/types.ts b/src/scripts/apis/gamesCrafters/types.ts
index 1ecce527..0af4443c 100644
--- a/src/scripts/apis/gamesCrafters/types.ts
+++ b/src/scripts/apis/gamesCrafters/types.ts
@@ -7,71 +7,37 @@ export type Error = Status & {
     error: string;
 };
 
-export type Instructions = Status & {
-    response: Status & {
-        instructions: string;
-    };
+export type Instructions = {
+    instructions: string;
 }
 
-export type OnePlayerGames = Status & {
-    response: Array<Status & {
-        gameId: string;
-        name: string;
-    }>;
-};
-
-export type OnePlayerGameVariants = Status & {
-    response: {
-        author: string;
-        dateCreated: string;
-        description: string;
-        gameId: string;
-        instructions: string;
-        name: string;
-        variants: Array<Status & {
-            description: string;
-            startPosition: string;
-            variantId: string;
-            imageAutoGUIData: ImageAutoGUIData;
-        }>;
-        custom: string;
-        
-    };
-};
+export type Games = Array<{
+    id: string;
+    name: string;
+    type: string;
+    gui: string;
+}>;
 
-export type TwoPlayerGames = Status & {
-    response: Array<Status & {
-        gameId: string;
+export type Game = {
+    id: string;
+    name: string;
+    variants: Array<{
+        id: string;
         name: string;
+        gui: string;
     }>;
+    allowCustomVariantCreation: boolean;
+    supportsWinBy: boolean;
+    instructions: string;
 };
 
-export type TwoPlayerGameVariants = Status & {
-    response: {
-        gameId: string;
-        instructions: string;
-        name: string;
-        supportsWinBy: number;
-        variants: Array<Status & {
-            description: string;
-            startPosition: string;
-            variantId: string;
-            imageAutoGUIData: ImageAutoGUIData;
-        }>;
-        custom: string;
-    };
-};
-
-export type GameVariant = Status & {
-    response: {
-        variant: Array<{
-            description: string;
-            startPosition: string;
-            variantId: string;
-            imageAutoGUIData: ImageAutoGUIData;
-            gui_status: string;
-        }>;
-    };
+export type Variant = {
+    id: string;
+    name: string;
+    startPosition: string;
+    autoguiStartPosition: string;
+    imageAutoGUIData: ImageAutoGUIData;
+    gui: string;
 };
 
 export type ImageAutoGUIData = {
@@ -80,8 +46,8 @@ export type ImageAutoGUIData = {
 };
 
 export type ImageAutoGUITheme = {
-    space: ImageAutoGUICoordinate;
-    centers: Array<ImageAutoGUICoordinate>;
+    space: Array<number>;
+    centers: Array<Array<number>>;
     background: string;
     foreground: string;
     entities: Record<string, ImageAutoGUIEntity>;
@@ -96,41 +62,34 @@ export type ImageAutoGUITheme = {
     defaultAnimationWindow: Array<number>;
 };
 
-export type ImageAutoGUICoordinate =
-    [x: number, y: number];
-
 export type ImageAutoGUIEntity = {
     image: string;
     scale: number;
 };
 
-export type Position = Status & {
-    response: {
-        moves: Array<{
-            deltaRemoteness: number;
-            move: string;
-            moveName: string;
-            moveValue: string;
-            position: string;
-            positionValue: string;
-            remoteness: number;
-            winby: number;
-            mex: string;
-            drawLevel: number;
-            drawRemoteness: number;
-        }>;
-        position: string;
-        positionValue: string;
-        remoteness: number;
-        winby: number;
-        mex: string;
-        drawLevel: number;
-        drawRemoteness: number;
-    };
+export type Move = {
+    move: string;
+    autoguiMove: string;
+    position: string;
+    autoguiPosition: string;
+    deltaRemoteness: number;
+    moveValue: string;
+    positionValue: string;
+    remoteness: number;
+    winby: number;
+    mex: string;
+    drawLevel: number;
+    drawRemoteness: number;
 };
 
-export type RandomPosition = Status & {
-    response: {
-        position: string;
-    }
-};
+export type Position = {
+    moves: Array<Move>;
+    position: string;
+    autoguiPosition: string;
+    positionValue: string;
+    remoteness: number;
+    winby: number;
+    mex: string;
+    drawLevel: number;
+    drawRemoteness: number;
+};
\ No newline at end of file
diff --git a/src/scripts/gamesmanUni/audio.ts b/src/scripts/gamesmanUni/audio.ts
index c9b5002e..5752115a 100644
--- a/src/scripts/gamesmanUni/audio.ts
+++ b/src/scripts/gamesmanUni/audio.ts
@@ -29,8 +29,7 @@ export const playMoveSFX = (path: string) => {
 
 export const playGameAmbience = () => {
     const store = useStore();
-    const imageAutoGUIData = store.getters.imageAutoGUIData(store.getters.currentGameType, 
-        store.getters.currentGameId, store.getters.currentVariantId);
+    const imageAutoGUIData = store.getters.imageAutoGUIData(store.getters.currentGameId, store.getters.currentVariantId);
     if (imageAutoGUIData && "ambience" in imageAutoGUIData) {
         ambience = new Audio(sfx['../../models/sounds/kayles/ambience.mp3'].default);
         ambience.volume = ambienceVolume;
diff --git a/src/scripts/gamesmanUni/index.ts b/src/scripts/gamesmanUni/index.ts
index b171dd5a..c9fb7042 100644
--- a/src/scripts/gamesmanUni/index.ts
+++ b/src/scripts/gamesmanUni/index.ts
@@ -12,283 +12,211 @@ const deepcopy = (obj: Object) => {
     return JSON.parse(JSON.stringify(obj));
 };
 
-export const loadGames = async (app: Types.App, payload: { gameType: string; force?: boolean }) => {
-    if (!payload.force && Object.keys(app.gameTypes[payload.gameType].games).length && (new Date().getTime() - app.gameTypes[payload.gameType].lastUpdated) / (1000 * 60 * 60 * 24) < 3 * (1000 * 60 * 60 * 24)) return app;
-    const dataSource = payload.gameType === "puzzles" ? app.dataSources.onePlayerGameAPI : app.dataSources.twoPlayerGameAPI;
-    const games = await GCTAPI.loadGames(dataSource, payload);
+export const loadGames = async (app: Types.App) => {
+    const games = await GCTAPI.loadGames(app.dataSources.gameAPI);
     if (!games) return undefined;
-    app.gameTypes[payload.gameType].status = games.status;
-    for (const game of games.response) {
-        app.gameTypes[payload.gameType].games[game.gameId] = {
+    for (const game of games) {
+        app.games[game.id] = {
             ...Defaults.defaultGame,
-            id: game.gameId,
+            id: game.id,
             name: game.name,
-            type: payload.gameType,
-            status: game.status,
-            gui_status: game.gui_status,
-            variants: { ...Defaults.defaultVariants },
+            type: game.type,
+            gui: game.gui,
+            variants: {},
         };
     }
-    app.gameTypes[payload.gameType].lastUpdated = new Date().getTime();
     return app;
 };
 
-export const addInstructions = async (app: Types.App, payload: {gameType: string, gameId: string}) => {
-    const instructions = await GCTAPI.loadInstructions(app.dataSources.twoPlayerGameAPI + `/instructions/${app.currentMatch.gameType}/${app.currentMatch.gameId}/${app.preferences.locale}`);
-    app.gameTypes[payload.gameType].games[payload.gameId].instructions[app.preferences.locale] = instructions ? instructions.response.instructions : "";
+export const addInstructions = async (app: Types.App, payload: {gameId: string, variantId: string}) => {
+    const instructions = await GCTAPI.loadInstructions(`${app.dataSources.gameAPI}${app.currentMatch.gameId}/${app.currentMatch.variantId}/instructions?lang=${app.preferences.locale}`);
+    app.games[payload.gameId].instructions[app.preferences.locale] = instructions ? instructions.instructions : "";
     return app;
 }
 
-export const loadVariants = async (app: Types.App, payload: { gameType: string; gameId: string; force?: boolean }) => {
-    if (!Object.keys(app.gameTypes[payload.gameType].games).length) {
-        const updatedApp = await loadGames(app, payload);
+export const loadGame = async (app: Types.App, payload: { gameId: string; force?: boolean }) => {
+    if (!Object.keys(app.games).length) {
+        const updatedApp = await loadGames(app);
         if (!updatedApp) return undefined;
     }
-    if (!payload.force && app.gameTypes[payload.gameType].games[payload.gameId] && Object.keys(app.gameTypes[payload.gameType].games[payload.gameId].variants.variants).length && (new Date().getTime() - app.gameTypes[payload.gameType].games[payload.gameId].variants.lastUpdated) / (1000 * 60 * 60 * 24) < 3 * (1000 * 60 * 60 * 24)) return app;
-    const baseDataSource = payload.gameType === "puzzles" ? app.dataSources.onePlayerGameAPI : app.dataSources.twoPlayerGameAPI;
-    const instructions = await GCTAPI.loadInstructions(app.dataSources.twoPlayerGameAPI + `/instructions/${payload.gameType}/${payload.gameId}/${app.preferences.locale}`);
-    const variants = await GCTAPI.loadVariants(baseDataSource + `/${payload.gameId}`, payload);
-    if (!variants) return undefined;
-    app.gameTypes[payload.gameType].games[payload.gameId].variants.status = variants.status;
-    app.gameTypes[payload.gameType].games[payload.gameId].variants.lastUpdated = new Date().getTime();
-    if (payload.gameType === "puzzles") app.gameTypes[payload.gameType].games[payload.gameId].author = (<GCTAPITypes.OnePlayerGameVariants>variants).response.author;
-    app.gameTypes[payload.gameType].games[payload.gameId].dateCreated = (<GCTAPITypes.OnePlayerGameVariants>variants).response.dateCreated;
-    app.gameTypes[payload.gameType].games[payload.gameId].description = (<GCTAPITypes.OnePlayerGameVariants>variants).response.description;
-    app.gameTypes[payload.gameType].games[payload.gameId].instructions = {};
-    app.gameTypes[payload.gameType].games[payload.gameId].instructions[app.preferences.locale] = instructions ? instructions.response.instructions : "";
-    app.gameTypes[payload.gameType].games[payload.gameId].custom = variants.response.custom === "true";
-    app.gameTypes[payload.gameType].games[payload.gameId].variants.variants = {};
-    for (const variant of variants.response.variants) {
-        app.gameTypes[payload.gameType].games[payload.gameId].variants.variants[variant.variantId] = {
-            id: variant.variantId,
-            description: variant.description,
-            startPosition: variant.startPosition,
-            positions: { ...Defaults.defaultPositions },
-            imageAutoGUIData: variant.imageAutoGUIData,
-            status: variant.status,
-            gui_status: variant.gui_status
+    const game = await GCTAPI.loadGame(`${app.dataSources.gameAPI}${payload.gameId}/`);
+    if (!game) return undefined;
+    app.games[payload.gameId].instructions = {};
+    app.games[payload.gameId].allowCustomVariantCreation = game.allowCustomVariantCreation;
+    app.games[payload.gameId].variants = {};
+    app.games[payload.gameId].supportsWinBy = game.supportsWinBy;
+    for (const variant of game.variants) {
+        app.games[payload.gameId].variants[variant.id] = {
+            id: variant.id,
+            name: variant.name,
+            gui: variant.gui,
+            startPosition: '',
+            autoguiStartPosition: '',
+            imageAutoGUIData: {} as GCTAPITypes.ImageAutoGUIData,
+            positions: {},
         };
     }
-    app.gameTypes[payload.gameType].games[payload.gameId].supportsWinBy = payload.gameType === "games" ? (<GCTAPITypes.TwoPlayerGameVariants>variants).response.supportsWinBy : Defaults.defaultGame.supportsWinBy;
     return app;
 };
 
-const formatMoveNames = (source: Array<{
-    deltaRemoteness: number;
-    move: string;
-    moveName: string;
-    moveValue: string;
-    position: string;
-    positionValue: string;
-    remoteness: number
-}>) => {
-    const target: Types.MoveNames = { ...Defaults.defaultAvailableMoveNames };
-    for (let i = 0; i < source.length; i++) {
-        target[source[i].moveName ? source[i].moveName : source[i].move] = source[i].move;
-    }
-    return target;
-};
+const loadVariant = async (app: Types.App, payload: { gameId: string; variantId: string; force?: boolean }) => {
+    const variant = await GCTAPI.loadVariant(`${app.dataSources.gameAPI}${payload.gameId}/${payload.variantId}/`);
+    if (!variant) return Defaults.defaultVariant;
 
-const formatMoves = (source: Array<{
-        deltaRemoteness: number;
-        move: string;
-        moveName: string;
-        moveValue: string;
-        position: string;
-        positionValue: string;
-        remoteness: number;
-        winby: number;
-        mex: string;
-        drawLevel: number;
-        drawRemoteness: number;
-    }>) => {
-    const target: Types.Moves = { ...Defaults.defaultAvailableMoves };
-    if (source.length) target[source[0].move] = { ...source[0], moveValueOpacity: 1 };
-    for (let i = 1; i < source.length; i++) {
-        target[source[i].move] = { ...source[i], moveValueOpacity: 1 };
-        const previousMove = target[source[i - 1].move];
-        const currentMove = target[source[i].move];
-        if (previousMove.moveValue !== currentMove.moveValue) continue;
-        if (previousMove.moveValueOpacity === 0.5) currentMove.moveValueOpacity = 0.5;
-        else if (previousMove.deltaRemoteness !== currentMove.deltaRemoteness) currentMove.moveValueOpacity = previousMove.moveValueOpacity - 0.25;
-        else currentMove.moveValueOpacity = previousMove.moveValueOpacity;
-    }
-    return target;
+    return {
+        id: variant.id,
+        name: variant.name,
+        gui: variant.gui,
+        startPosition: variant.startPosition,
+        autoguiStartPosition: variant.autoguiStartPosition,
+        imageAutoGUIData: variant.imageAutoGUIData,
+        positions: {},
+    };
 };
 
-const loadPosition = async (app: Types.App, payload: { gameType: string; gameId: string; variantId: string; position: string; force?: boolean }) => {
-    const positions = app.gameTypes[payload.gameType].games[payload.gameId].variants.variants[payload.variantId].positions;
-    if (!payload.force && positions[payload.position] && (new Date().getTime() - positions[payload.position].lastUpdated) / (1000 * 60 * 60 * 24) < 3 * (1000 * 60 * 60 * 24)) return app;
-    const dataSource = payload.gameType === "puzzles" ? `${app.dataSources.onePlayerGameAPI}/${payload.gameId}/${payload.variantId}/${payload.position}` : `${app.dataSources.twoPlayerGameAPI}/${payload.gameId}/variants/${payload.variantId}/positions/${payload.position}`;
-    const updatedPosition = await GCTAPI.loadPosition(dataSource);
-    if (!updatedPosition || updatedPosition.response.positionValue === "undecided") {
+const loadPosition = async (app: Types.App, payload: { gameId: string; variantId: string; position: string; force?: boolean }) => {
+    const positions = app.games[payload.gameId].variants[payload.variantId].positions;
+    const updatedPosition = await GCTAPI.loadPosition(`${app.dataSources.gameAPI}${payload.gameId}/${payload.variantId}/positions/${payload.position}/`);
+    if (!updatedPosition) {
         return undefined;
     }
     positions[payload.position] = {
-        status: updatedPosition.status,
-        lastUpdated: new Date().getTime(),
-        availableMoveNames: formatMoveNames(updatedPosition.response.moves),
-        availableMoves: formatMoves(updatedPosition.response.moves),
-        position: updatedPosition.response.position,
-        positionValue: updatedPosition.response.positionValue,
-        remoteness: updatedPosition.response.remoteness,
-        winby: updatedPosition.response.winby,
-        mex: updatedPosition.response["mex"] || "",
-        drawLevel: "drawLevel" in updatedPosition.response ? updatedPosition.response["drawLevel"] : -1,
-        drawRemoteness: "drawRemoteness" in updatedPosition.response ? updatedPosition.response["drawRemoteness"] : -1
+        position: updatedPosition.position,
+        autoguiPosition: updatedPosition.autoguiPosition,
+        availableMoves: formatMoves(updatedPosition.moves),
+        availableMoveNames: formatMoveNames(updatedPosition.moves),
+        positionValue: updatedPosition.positionValue,
+        remoteness: updatedPosition.remoteness,
+        winby: updatedPosition.winby,
+        mex: updatedPosition["mex"] || "",
+        drawLevel: "drawLevel" in updatedPosition ? updatedPosition["drawLevel"] : -1,
+        drawRemoteness: "drawRemoteness" in updatedPosition ? updatedPosition["drawRemoteness"] : -1
     };
     return app;
 };
 
-export const preFetchNextPositions = async (app: Types.App, payload: { gameType: string; gameId: string; variantId: string; position: string }) => {
-    const positions = app.gameTypes[payload.gameType].games[payload.gameId].variants.variants[payload.variantId].positions;
-    for (const move of Object.values(positions[payload.position].availableMoves)) {
-        if (!(move.position in positions)) {
-            await loadPosition(app, { ...payload, position: move.position });
-        }
-    }
-    return app;
-};
-
-const generateMatchId = (app: Types.App) => {
-    const reservedIds = new Set(Object.keys(app.matches));
-    let newId: number;
-    do {
-        newId = Math.floor(Math.random() * 10000);
-    } while (newId in reservedIds);
-    return newId;
-};
-
 export const initiateMatch = async (app: Types.App, payload: {
-        gameType: string;
-        gameId: string;
-        variantId: string;
-        startPosition?: string;
-        firstPlayerIsComputer?: boolean;
-        secondPlayerIsComputer?: boolean;
+    gameId: string;
+    variantId: string;
+    startPosition?: string;
+    firstPlayerIsComputer?: boolean;
+    secondPlayerIsComputer?: boolean;
 }) => {
-    const cachedGames = app.gameTypes[payload.gameType].games;
-    if (!Object.keys(cachedGames).length ||
-        !Object.keys(cachedGames[payload.gameId].variants.variants).length) {
+    const cachedGames = app.games;
+    if (!Object.keys(cachedGames).length || !Object.keys(cachedGames[payload.gameId].variants).length) {
         /* Load available variants if not found in cache. */
-        const updatedApp = await loadVariants(app, payload);
+        const updatedApp = await loadGame(app, payload);
         if (!updatedApp) return undefined;
     }
 
     const game = cachedGames[payload.gameId];
-    let gameVariant = game.variants.variants[payload.variantId];
-    const hasCustom = game.custom;
-    if (!gameVariant && hasCustom) {
-        /* Load the selected custom variant if not found in cache. */
-        gameVariant = await loadVariant(app, payload);
-        game.variants.variants[payload.variantId] = gameVariant;
-    }
+    const variant = await loadVariant(app, payload);
+    game.variants[payload.variantId] = variant;
 
-    let startPosition: string;
-    if (!payload.startPosition) {
-        /* Start Position not specified in payload, use default. */
-        startPosition = gameVariant.startPosition;
-    } else if (payload.startPosition === "random") {
-        /* Requesting a random start position for puzzles. */
-        const ds = (payload.gameType == "puzzles") ? `${app.dataSources.onePlayerGameAPI}` : `${app.dataSources.twoPlayerGameAPI}`
-        const loaded = await GCTAPI.loadRandomPosition(
-            `${ds}/${payload.gameId}/${payload.variantId}/randpos`
-        );
-        startPosition = loaded ? loaded.response.position : gameVariant.startPosition;
-    } else {
-        /* Start position specified and assumed to be valid. */
-        startPosition = payload.startPosition;
-    }
-    const posArr = startPosition.split('_');
+    const startPosition = payload.startPosition ? payload.startPosition : variant.startPosition;
 
     const updatedApp = await loadPosition(app, { ...payload, position: startPosition });
     if (!updatedApp) return undefined;
 
     if (!game.supportsWinBy) app.CPUsStrategy = Defaults.defaultCPUsStrategy;
-    app.currentMatch.gameTheme = gameVariant.imageAutoGUIData ? gameVariant.imageAutoGUIData.defaultTheme : "";
+    app.currentMatch.gameTheme = variant.imageAutoGUIData ? variant.imageAutoGUIData.defaultTheme : "";
     app.currentMatch.startPosition = startPosition;
     app.currentMatch.moveHistory = game.name + moveHistoryDelim + startPosition;
-    app.currentMatch.created = new Date().getTime();
-    app.currentMatch.gameType = payload.gameType;
+    app.currentMatch.gameType = game.type === "onePlayer" ? "puzzles" : "games";
     app.currentMatch.gameId = payload.gameId;
     app.currentMatch.variantId = payload.variantId;
     app.currentMatch.id = generateMatchId(app);
     if (!(payload.firstPlayerIsComputer === undefined)) app.currentMatch.firstPlayer.isComputer = payload.firstPlayerIsComputer;
     if (!(payload.secondPlayerIsComputer === undefined)) app.currentMatch.secondPlayer.isComputer = payload.secondPlayerIsComputer;
+    
+    const autoguiStartPosition = app.games[payload.gameId].variants[payload.variantId].positions[startPosition].autoguiPosition;
     app.currentMatch.round = {
         id: 1,
-        /* Unfortunately, there is no generic way to determine whose 
-           turn it is from an AutoGUI v0 position string.
-           In this case we always assume it's the first player's turn. */
-        firstPlayerTurn: (posArr.length >= 5 ? posArr[1] === 'A' : true),
+        firstPlayerTurn: autoguiStartPosition.charAt(0) == '1',
         move: "",
-        moveName: "",
+        autoguiMove: "",
         moveValue: "",
-        position: deepcopy(gameVariant.positions[startPosition])
+        position: deepcopy(variant.positions[startPosition]),
     };
     app.currentMatch.rounds = [
         deepcopy(Defaults.defaultRound),
         deepcopy(app.currentMatch.round)
     ];
     playGameAmbience();
-    app.currentMatch.lastPlayed = new Date().getTime();
+    await addInstructions(app, payload);
+    return app;
+};
+
+const formatMoveNames = (moves: Array<GCTAPITypes.Move>) => {
+    const target: Types.MoveNames = { ...Defaults.defaultAvailableMoveNames };
+    for (const move in moves) {
+        target[moves[move].move] = moves[move].move;
+    }
+    return target;
+};
+
+const formatMoves = (moves: Array<GCTAPITypes.Move>) => {
+    const target: Types.Moves = { ...Defaults.defaultAvailableMoves };
+    if (moves.length) target[moves[0].move] = { ...moves[0], moveValueOpacity: 1 };
+    for (let i = 1; i < moves.length; i++) {
+        target[moves[i].move] = { ...moves[i], moveValueOpacity: 1 };
+        const previousMove = target[moves[i - 1].move];
+        const currentMove = target[moves[i].move];
+        if (previousMove.moveValue !== currentMove.moveValue) continue;
+        if (previousMove.moveValueOpacity === 0.5) currentMove.moveValueOpacity = 0.5;
+        else if (previousMove.deltaRemoteness !== currentMove.deltaRemoteness) currentMove.moveValueOpacity = previousMove.moveValueOpacity - 0.25;
+        else currentMove.moveValueOpacity = previousMove.moveValueOpacity;
+    }
+    return target;
+};
+
+export const preFetchNextPositions = async (app: Types.App, payload: { gameType: string; gameId: string; variantId: string; position: string }) => {
+    const positions = app.games[payload.gameId].variants[payload.variantId].positions;
+    for (const move of Object.values(positions[payload.position].availableMoves)) {
+        if (!(move.position in positions)) {
+            await loadPosition(app, { ...payload, position: move.position });
+        }
+    }
     return app;
 };
 
+const generateMatchId = (app: Types.App) => {
+    const reservedIds = new Set(Object.keys(app.matches));
+    let newId: number;
+    do {
+        newId = Math.floor(Math.random() * 10000);
+    } while (newId in reservedIds);
+    return newId;
+};
+
 export const restartMatch = async (app: Types.App) => {
-    const posArr = app.currentMatch.startPosition.split('_');
-    const gameType = app.currentMatch.gameType;
     const gameId = app.currentMatch.gameId;
     const variantId = app.currentMatch.variantId
-    const game = app.gameTypes[gameType].games[gameId];
+    const game = app.games[gameId];
     const startPosition = app.currentMatch.startPosition;
 
     /* Reset round id to 1 and delete all existing rounds. */
+    const autoguiStartPosition = app.games[gameId].variants[variantId].positions[startPosition].autoguiPosition;
+
     app.currentMatch.round = {
         id: 1,
-        firstPlayerTurn: (posArr.length >= 5 ? posArr[1] === 'A' : true),
+        firstPlayerTurn: autoguiStartPosition.charAt(0) == '1',
         move: "",
-        moveName: "",
+        autoguiMove: "",
         moveValue: "",
-        position: deepcopy(game.variants.variants[variantId].positions[startPosition])
+        position: deepcopy(game.variants[variantId].positions[startPosition])
     };
     app.currentMatch.round.move = "";
-    app.currentMatch.round.moveName = "";
+    app.currentMatch.round.autoguiMove = "";
     app.currentMatch.round.moveValue = "";
     app.currentMatch.rounds = [
         deepcopy(Defaults.defaultRound),
         deepcopy(app.currentMatch.round)
     ];
     app.currentMatch.moveHistory = game.name + moveHistoryDelim + startPosition;
-    app.currentMatch.lastPlayed = new Date().getTime();
     return app;
 };
 
-// This function is for custom variants.
-const loadVariant = async (app: Types.App, payload: { gameType: string; gameId: string; variantId: string; force?: boolean }) => {
-    const baseDataSource = payload.gameType === "puzzles" ? app.dataSources.onePlayerGameAPI : app.dataSources.twoPlayerGameAPI;
-    const variant_response = await GCTAPI.loadVariant(baseDataSource + `/${payload.gameId}/variants/${payload.variantId}`, payload);
-    if (!variant_response) return {
-        id: "",
-        description: "",
-        startPosition: "",
-        positions: {},
-        imageAutoGUIData: {} as GCTAPITypes.ImageAutoGUIData,
-        status: "",
-        gui_status: "v0"
-    };
-
-    return {
-        id: payload.variantId,
-        description: variant_response.response.variant[0].description,
-        startPosition: variant_response.response.variant[0].startPosition,
-        positions: { ...Defaults.defaultPositions },
-        imageAutoGUIData: variant_response.response.variant[0].imageAutoGUIData,
-        status: variant_response.status,
-        gui_status: variant_response.response.variant[0].gui_status
-    };
-};
-
 /** 
  * Determines the maximum Remoteness value between rounds payload.from to payload.to. If there is no Remoteness value greater
  * than the threshold of 5, then returns the threshold.
@@ -340,13 +268,12 @@ export const getMaximumWinBy = (app: Types.App, payload: { from: number; to: num
 };
 
 export const isEndOfMatch = (app: Types.App) =>
-    !app.currentMatch.round.position.remoteness ||
+    app.currentMatch.round.position.remoteness == 0 ||
     !Object.keys(app.currentMatch.round.position.availableMoves).length;
 
 export const exitMatch = (app: Types.App) => {
     pauseAllGameSounds();
     if (app.currentMatch.rounds.length > 2) { 
-        app.currentMatch.lastPlayed = new Date().getTime();
         app.currentMatch.rounds[app.currentMatch.round.id] = deepcopy(app.currentMatch.round);
         app.matches[app.currentMatch.id] = deepcopy(app.currentMatch);
     }
@@ -371,9 +298,8 @@ export const generateComputerMove = (round: Types.Round) => {
     const store = useStore();
     const currentPlayerTurn = store.getters.currentValuedRounds[round.id].firstPlayerTurn ? 1 : 2;
     const CPUStrategy = store.getters.currentCPUStrategy(currentPlayerTurn - 1);
-    const gameType = store.getters.currentGameType;
     const gameId = store.getters.currentGameId;
-    const supportsWinBy = store.getters.supportsWinBy(gameType, gameId);
+    const supportsWinBy = store.getters.supportsWinBy(gameId);
     const availableMoves = Object.values(round.position.availableMoves);
     const currentPositionValue = round.position.positionValue;
 
@@ -425,11 +351,11 @@ export const runMove = async (app: Types.App, payload: { move: string }) => {
     app.currentMatch.round.move = payload.move;
     const moveObj = app.currentMatch.round.position.availableMoves[payload.move];
     const animationDuration = handleMoveAnimation(app.preferences.volume, app.currentMatch, moveObj);
-    if (animationDuration != 0) {
+    if (animationDuration > 0) {
         app.currentMatch.animationPlaying = true;
     }
     app.currentMatch.round.moveValue = moveObj.moveValue;
-    app.currentMatch.round.moveName = moveObj.moveName !== undefined ? moveObj.moveName : moveObj.move;
+    app.currentMatch.round.autoguiMove = moveObj.autoguiMove;
 
     // Rewrite history by deleting all subsequent moves made earlier.
     app.currentMatch.rounds.splice(
@@ -440,7 +366,6 @@ export const runMove = async (app: Types.App, payload: { move: string }) => {
     var updatedApp = null;
     for (var attempts = 0; attempts < 5; attempts++) {
         updatedApp = await loadPosition(app, {
-            gameType: app.currentMatch.gameType,
             gameId: app.currentMatch.gameId,
             variantId: app.currentMatch.variantId,
             position: moveObj.position
@@ -456,11 +381,9 @@ export const runMove = async (app: Types.App, payload: { move: string }) => {
     }
 
     const updatedPosition = { 
-        ...updatedApp.
-        gameTypes[app.currentMatch.gameType].
-        games[app.currentMatch.gameId].
-        variants.
-        variants[app.currentMatch.variantId].
+        ...updatedApp
+        .games[app.currentMatch.gameId]
+        .variants[app.currentMatch.variantId].
         positions[
             app.
             currentMatch.
@@ -470,18 +393,17 @@ export const runMove = async (app: Types.App, payload: { move: string }) => {
             position
         ]
     };
-    app.currentMatch.moveHistory += moveHistoryDelim + (moveObj.moveName ? moveObj.moveName : moveObj.move);
-    let posArr = updatedPosition.position.split('_');
-    if (posArr.length === 5 && posArr[0] === 'R') {
-        app.currentMatch.round.firstPlayerTurn = posArr[1] === 'A'
+    app.currentMatch.moveHistory += moveHistoryDelim + (moveObj.move ? moveObj.move : moveObj.move);
+    let autoguiPosition = updatedPosition.autoguiPosition;
+    if ((autoguiPosition.charAt(0) == '1' || autoguiPosition.charAt(0) == '2') && autoguiPosition.charAt(1) == '_') { // in proper autogui format
+        app.currentMatch.round.firstPlayerTurn = autoguiPosition.charAt(0) == '1';
     } else if (app.currentMatch.gameType === "puzzles") {
         app.currentMatch.round.firstPlayerTurn = true;
-    } else {
+    } else { // not in proper autogui format
         app.currentMatch.round.firstPlayerTurn = !app.currentMatch.round.firstPlayerTurn;
     }
     app.currentMatch.round.move = "";
     app.currentMatch.round.moveValue = "";
-    app.currentMatch.lastPlayed = new Date().getTime();
     app.currentMatch.round.id += 1;
     app.currentMatch.round.position = updatedPosition;
     app.currentMatch.rounds.push(deepcopy(app.currentMatch.round));
@@ -531,7 +453,6 @@ const gotoRoundId = (app: Types.App, roundId: number) => {
     app.currentMatch.round = deepcopy(app.currentMatch.rounds[roundId]);
     app.currentMatch.round.move = "";
     app.currentMatch.round.moveValue = "";
-    app.currentMatch.lastPlayed = new Date().getTime();
     return app;
 };
 
@@ -559,8 +480,6 @@ export const redoMove = (app: Types.App) => {
     // Modify move history before changing current round id.
     for (let i = currRoundId; i < toRoundId; ++i) {
         app.currentMatch.moveHistory += moveHistoryDelim + (
-            app.currentMatch.rounds[i].moveName ?
-            app.currentMatch.rounds[i].moveName :
             app.currentMatch.rounds[i].move
         );
     }
@@ -607,10 +526,9 @@ export const updateGameTheme = (app: Types.App, payload: { gameTheme : string })
 };
 
 export const updateMatchStartPosition = async (app: Types.App, payload: { position: string }) => {
-    // Check if position is valid
+    // // Check if position is valid
     payload.position = payload.position.replace(/(\r\n|\n|\r)/gm, "");
     const updatedApp = await loadPosition(app, {
-        gameType: app.currentMatch.gameType,
         gameId: app.currentMatch.gameId,
         variantId: app.currentMatch.variantId,
         position: payload.position
@@ -657,7 +575,6 @@ export const loadMoveHistory = async (app: Types.App, payload: { history: string
     }
     exitMatch(newApp);
     let updatedApp = await initiateMatch(newApp, {
-        gameType: app.currentMatch.gameType,
         gameId: app.currentMatch.gameId,
         variantId: app.currentMatch.variantId,
         startPosition: parsed[1]
diff --git a/src/scripts/gamesmanUni/moveAnimation.ts b/src/scripts/gamesmanUni/moveAnimation.ts
index ae8dcadd..b74f5f68 100644
--- a/src/scripts/gamesmanUni/moveAnimation.ts
+++ b/src/scripts/gamesmanUni/moveAnimation.ts
@@ -23,8 +23,8 @@ const spawnImageEntity = (char: string, i: number, centers: number[][], entities
 
 /* All animation functions should return the animation duration in milliseconds. */
 const animateTTT = (volume: number, moveObj: Types.Move): number => {
-    const diffIdx = Number(moveObj.move[4]);
-    const turn = moveObj.move[2];
+    const diffIdx = Number(moveObj.autoguiMove[4]);
+    const turn = moveObj.autoguiMove[2];
     const xOff = (diffIdx % 3) * 22;
     const yOff = Math.floor(diffIdx / 3) * 22;
     if (turn === 'x') {
@@ -41,18 +41,18 @@ const animateTTT = (volume: number, moveObj: Types.Move): number => {
 const animateSim = (volume: number, moveObj: Types.Move): number => {
     const vertices = [[4, 0], [2, 3.4641], [-2, 3.4641], [-4, 0], [-2, -3.4641], [2, -3.4641]];
     playMoveSFX('ttt/O.mp3');
-    const d = Number(moveObj.moveName[1]) - 1;    
-    gsap.to("#simline" + moveObj.moveName, {duration: 0.5, attr: {"x2": vertices[d][0], "y2": vertices[d][1]}});
+    const d = Number(moveObj.move[1]) - 1;    
+    gsap.to("#simline" + moveObj.move, {duration: 0.5, attr: {"x2": vertices[d][0], "y2": vertices[d][1]}});
     return 500;
 }
 
 const animateQuarto = (volume: number, currPosition: string, nextPosition: string): number => {
     var duration = 0;
     var delay = 0;
-    if (currPosition !== "R_A_17_1_-----------------") { // If currPosition is not the initial position
+    if (currPosition !== "1_-----------------") { // If currPosition is not the initial position
         var to = -1;
         for (var i = 0; i < 16; i++) {
-            if (currPosition.split("_")[4][i] != nextPosition.split("_")[4][i]) {
+            if (currPosition.split("_")[1][i] != nextPosition.split("_")[1][i]) {
                 to = i;
                 break;
             }
@@ -61,7 +61,7 @@ const animateQuarto = (volume: number, currPosition: string, nextPosition: strin
         gsap.fromTo("#toPlace", {x: 58, y: 113}, {duration: 0.5, x: toCoords[0], y: toCoords[1]});
         duration += 500;
         delay = 0.5
-        if (nextPosition[25] != '-') {
+        if (nextPosition[18] != '-') {
             playMoveSFX('general/slideThenRemove.mp3');
         } else {
             playMoveSFX('general/slide.mp3');
@@ -69,7 +69,7 @@ const animateQuarto = (volume: number, currPosition: string, nextPosition: strin
     } else {
         playMoveSFX('general/remove.mp3');
     }
-    if (nextPosition[25] != '-') { // i.e. if there is a piece-to-place
+    if (nextPosition[18] != '-') { // i.e. if there is a piece-to-place
         const store = useStore();
         var svg = document.getElementById('custom-gui-quarto'); //Get svg element
         var g = document.createElementNS("http://www.w3.org/2000/svg", 'g');
@@ -79,7 +79,7 @@ const animateQuarto = (volume: number, currPosition: string, nextPosition: strin
 
         var newElement = document.createElementNS("http://www.w3.org/2000/svg", 'use'); //Create a path in SVG's namespace
         newElement.setAttribute("class", "appearingPiece");
-        newElement.setAttribute("href", "#" + gameTheme + nextPosition[25]);
+        newElement.setAttribute("href", "#" + gameTheme + nextPosition[18]);
         newElement.setAttribute("transform", "translate(58 113)");
         newElement.setAttribute("opacity", "0.001");
         g.appendChild(newElement);
@@ -101,9 +101,9 @@ const animateQuarto = (volume: number, currPosition: string, nextPosition: strin
 }
 
 const animateImageAutoGUI = (currPosition: string, nextPosition: string): number => {
-    const currEntityStringParts = currPosition.split("_")[4].split("~");
+    const currEntityStringParts = currPosition.split("_")[1].split("~");
     var currBoard = currEntityStringParts[0];
-    const nextEntityStringParts = nextPosition.split("_")[4].split("~");
+    const nextEntityStringParts = nextPosition.split("_")[1].split("~");
     var nextBoard = nextEntityStringParts[0];
 
     // Append dashes to make currBoard and nextBoard have same length, if one of them is shorter
@@ -115,7 +115,7 @@ const animateImageAutoGUI = (currPosition: string, nextPosition: string): number
     }
 
     const store = useStore();
-    const imageAutoGUIData = store.getters.imageAutoGUIData(store.getters.currentGameType, store.getters.currentGameId, store.getters.currentVariantId);
+    const imageAutoGUIData = store.getters.imageAutoGUIData(store.getters.currentGameId, store.getters.currentVariantId);
     const theTheme = imageAutoGUIData.themes[store.getters.currentGameTheme];
     const scaledWidth = 100;
     const backgroundGeometry = theTheme.space;
@@ -123,7 +123,7 @@ const animateImageAutoGUI = (currPosition: string, nextPosition: string): number
     const scaledHeight = backgroundGeometry[1] * widthFactor;
     const animationType = theTheme.animationType || "";
     const entities = theTheme.entities;
-    const centers = theTheme.centers.map((a: [number, number]) => a.map((b: number) => b * widthFactor));
+    const centers = theTheme.centers.map((a: Array<number>) => a.map((b: number) => b * widthFactor));
     const foregroundImagePath = theTheme.foreground || "";
     const animationWindow = theTheme.defaultAnimationWindow || [0, currBoard.length];
     const textEntityFontSize = theTheme.textEntityFontSize * widthFactor || 10;
@@ -255,8 +255,8 @@ const animateImageAutoGUI = (currPosition: string, nextPosition: string): number
 }
 
 export const handleMoveAnimation = (volume: number, currentMatch: Types.Match, moveObj: Types.Move) => {
-    const currPosition = currentMatch.round.position.position;
-    const nextPosition = moveObj.position;
+    const currPosition = currentMatch.round.position.autoguiPosition;
+    const nextPosition = moveObj.autoguiPosition;
     if (currentMatch.gameId === 'tictactoe') {
         return animateTTT(volume, moveObj);
     } else if (currentMatch.gameId === 'sim') {
@@ -265,14 +265,13 @@ export const handleMoveAnimation = (volume: number, currentMatch: Types.Match, m
         return animateQuarto(volume, currPosition, nextPosition);
     } else {
         const store = useStore();
-        const imageAutoGUIData = store.getters.imageAutoGUIData(store.getters.currentGameType, 
-            store.getters.currentGameId, store.getters.currentVariantId);
+        const imageAutoGUIData = store.getters.imageAutoGUIData(store.getters.currentGameId, store.getters.currentVariantId);
         if (imageAutoGUIData != null) {
             var theTheme = imageAutoGUIData.themes[store.getters.currentGameTheme];
             const sounds = theTheme.sounds || {} as Record<string, string>;
             var duration = animateImageAutoGUI(currPosition, nextPosition);
             let matches;
-            if (matches = moveObj.move.match(/^([AMLT])_([a-zA-Z0-9-]+)_([a-zA-Z0-9-]+)_([a-zA-Z0-9-]+)*/)) {
+            if (matches = moveObj.autoguiMove.match(/^([AMLT])_([a-zA-Z0-9-]+)_([a-zA-Z0-9-]+)_([a-zA-Z0-9-]+)*/)) {
                 if (matches[4] in sounds) {
                     playMoveSFX(sounds[matches[4]]);
                 }
@@ -302,8 +301,7 @@ export const animationEpilogue = (currentMatch: Types.Match) => {
         }
     } else {
         const store = useStore();
-        const imageAutoGUIData = store.getters.imageAutoGUIData(store.getters.currentGameType, 
-            store.getters.currentGameId, store.getters.currentVariantId);
+        const imageAutoGUIData = store.getters.imageAutoGUIData(store.getters.currentGameId, store.getters.currentVariantId);
         if (imageAutoGUIData != null) {
             // Note: gsap.set() is unreliable (only achieves the reset as intended
             // 50% of the time for some reason) so we use fromTo instead 
diff --git a/src/scripts/gamesmanUni/types.ts b/src/scripts/gamesmanUni/types.ts
index 5cf6c744..f870b680 100644
--- a/src/scripts/gamesmanUni/types.ts
+++ b/src/scripts/gamesmanUni/types.ts
@@ -9,7 +9,7 @@ export type App = Update & {
     version: string;
     preferences: Preferences;
     dataSources: DataSources;
-    gameTypes: GameTypes;
+    games: Record<string, Game>;
     commits: Commits;
     options: Options;
     matches: Matches;
@@ -34,51 +34,37 @@ export type Preferences = {
 
 export type DataSources = {
     gitHubRepositoryAPI: string;
-    onePlayerGameAPI: string;
-    twoPlayerGameAPI: string;
-};
-
-export type GameTypes = Record<string, Games>;
-
-export type Games = Update & {
-    games: Record<string, Game>;
+    gameAPI: string;
 };
 
 export type Game = {
     id: string;
     name: string;
-    author: string;
-    description: string;
-    dateCreated: string;
     instructions: Record<string, string>;
     type: string;
-    variants: Variants;
-    status: string;
-    gui_status: string;
-    custom: boolean;
-    supportsWinBy: number;
-};
-
-export type Variants = Update & {
     variants: Record<string, Variant>;
+    gui: string;
+    allowCustomVariantCreation: boolean;
+    supportsWinBy: boolean;
 };
 
 export type Variant = {
     id: string;
-    description: string;
+    name: string;
     startPosition: string;
+    autoguiStartPosition: string;
     positions: Positions;
     imageAutoGUIData: ImageAutoGUIData;
-    status: string;
-    gui_status: string;
+    gui: string;
 };
 
 export type Positions = Record<string, Position>;
 
-export type Position = Update & {
+export type Position = {
     availableMoveNames: MoveNames;
     availableMoves: Moves;
     position: string;
+    autoguiPosition: string;
     positionValue: string;
     remoteness: number;
     winby: number;
@@ -94,10 +80,11 @@ export type MoveNames = Record<string, string>;
 export type Move = {
     deltaRemoteness: number;
     move: string;
-    moveName: string;
+    autoguiMove: string;
     moveValue: string;
     moveValueOpacity: number;
     position: string;
+    autoguiPosition: string;
     positionValue: string;
     remoteness: number;
     winby: number;
@@ -144,13 +131,14 @@ export type Match = {
     gameTheme: string;
     variantId: string;
     startPosition: string;
+    autoguiStartPosition: string;
     firstPlayer: Player;
     secondPlayer: Player;
     rounds: Rounds;
     moveHistory: string;
     round: Round;
-    created: number;
-    lastPlayed: number;
+    // created: number;
+    // lastPlayed: number;
     backgroundLoading: boolean;
     computerMoving: boolean;
     animationPlaying: boolean;
@@ -162,7 +150,7 @@ export type Round = {
     id: number;
     firstPlayerTurn: boolean;
     move: string;
-    moveName: string;
+    autoguiMove: string;
     moveValue: string;
     position: Position;
 };
diff --git a/src/scripts/plugins/store/index.ts b/src/scripts/plugins/store/index.ts
index dc873304..c4540e21 100644
--- a/src/scripts/plugins/store/index.ts
+++ b/src/scripts/plugins/store/index.ts
@@ -15,15 +15,16 @@ type Getters = {
     ambienceVolume(state: State): number;
     animationPlaying(state: State): boolean;
     availableMove(state: State):
-        (gameType: string, gameId: string, variantId: string, position: string, move: string) =>
+        (gameId: string, variantId: string, position: string, move: string) =>
             GMUTypes.Move;
     availableMoves(state: State):
-        (gameType: string, gameId: string, variantId: string, position: string) =>
+        (gameId: string, variantId: string, position: string) =>
             GMUTypes.Moves;
     backgroundLoading(state: State): boolean;
     commit(state: State): (sha: string) => GMUTypes.Commit;
     commits(state: State): GMUTypes.Commits;
     computerMoving(state: State): boolean;
+    currentAutoguiPosition(state: State): string;
     currentAvailableMove(state: State): (move: string) => GMUTypes.Move;
     currentAvailableMoves(state: State): GMUTypes.Moves;
     currentGameId(state: State): string;
@@ -51,16 +52,14 @@ type Getters = {
     currentVariantId(state: State): string;
     dataSources(state: State): GMUTypes.DataSources;
     fallbackLocale(state: State): string;
-    game(state: State): (gameType: string, gameId: string) => GMUTypes.Game;
-    games(state: State): (gameType: string) => GMUTypes.Games;
+    game(state: State): (gameId: string) => GMUTypes.Game;
+    games(state: State): Record<string, GMUTypes.Game>;
     gitHubRepositoryAPI(state: State): string;
-    imageAutoGUIData(state: State): 
-        (gameType: string, gameId: string, variantId: string) => ImageAutoGUIData;
+    imageAutoGUIData(state: State): (gameId: string, variantId: string) => ImageAutoGUIData;
     isEndOfMatch(state: State): boolean;
     locale(state: State): string;
     maximumRemoteness(state: State): (from: number, to: number) => number;
     moveHistory(state: State): string;
-    onePlayerGameAPI(state: State): string;
     position(state: State):
         (gameType: string, gameId: string, variantId: string, position: string) =>
             GMUTypes.Position;
@@ -70,18 +69,14 @@ type Getters = {
     redoMoveAvailable(state: State): boolean;
     rootFontSize(state: State): string;
     theme(state: State): string;
-    twoPlayerGameAPI(state: State): string;
+    gameAPI(state: State): string;
     options(state: State): GMUTypes.Options;
     undoMoveAvailable(state: State): boolean;
-    variant(state: State):
-        (gameType: string, gameId: string, variantId: string) =>
-            GMUTypes.Variant;
-    variants(state: State): (gameType: string, gameId: string) =>
-        GMUTypes.Variants;
+    variant(state: State): (gameId: string, variantId: string) => GMUTypes.Variant;
+    variants(state: State): (gameId: string) => Record<string, GMUTypes.Variant>;
     version(state: State): string;
     volume(state: State): number;
-    supportsWinBy(state: State): 
-        (gameType: string, gameId: string) => boolean;
+    supportsWinBy(state: State): (gameId: string) => boolean;
     currentWinBy(state: State): number;
     maximumWinBy(state: State): 
         (from: number, to: number) => number;
@@ -93,12 +88,12 @@ const getters: Vuex.GetterTree<State, State> & Getters = {
     ambienceVolume: (state: State) => state.app.preferences.ambienceVolume,
     animationPlaying: (state: State) => state.app.currentMatch.animationPlaying,
     availableMove: (state: State) =>
-        (gameType: string, gameId: string, variantId: string, position: string, move: string) =>
-            state.app.gameTypes[gameType].games[gameId].variants.variants[variantId].
+        (gameId: string, variantId: string, position: string, move: string) =>
+            state.app.games[gameId].variants[variantId].
             positions[position].availableMoves[move],
     availableMoves: (state: State) =>
-        (gameType: string, gameId: string, variantId: string, position: string) =>
-            state.app.gameTypes[gameType].games[gameId].variants.variants[variantId].
+        (gameId: string, variantId: string, position: string) =>
+            state.app.games[gameId].variants[variantId].
             positions[position].availableMoves,
     backgroundLoading: (state: State) =>
         state.app.currentMatch.backgroundLoading,
@@ -108,6 +103,7 @@ const getters: Vuex.GetterTree<State, State> & Getters = {
         state.app.commits,
     computerMoving: (state: State) =>
         state.app.currentMatch.computerMoving,
+    currentAutoguiPosition: (state: State) => state.app.currentMatch.round.position.autoguiPosition,
     currentAvailableMove: (state: State) =>
         (move: string) =>
             state.app.currentMatch.round.position.availableMoves[move],
@@ -116,7 +112,7 @@ const getters: Vuex.GetterTree<State, State> & Getters = {
     currentGameId: (state: State) =>
         state.app.currentMatch.gameId,
     currentGameName: (state: State) =>
-        state.app.gameTypes[state.app.currentMatch.gameType].games[state.app.currentMatch.gameId].name,
+        state.app.games[state.app.currentMatch.gameId].name,
     currentGameTheme: (state: State) =>
         state.app.currentMatch.gameTheme,
     currentGameType: (state: State) =>
@@ -169,16 +165,15 @@ const getters: Vuex.GetterTree<State, State> & Getters = {
     fallbackLocale: (state: State) =>
         state.app.preferences.fallbackLocale,
     game: (state: State) =>
-        (gameType: string, gameId: string) =>
-            state.app.gameTypes[gameType].games[gameId],
-    games: (state: State) =>
-        (gameType: string) =>
-            state.app.gameTypes[gameType],
+        (gameId: string) =>
+            state.app.games[gameId],
+    gameAPI: (state: State) => state.app.dataSources.gameAPI,
+    games: (state: State) => state.app.games,
     gitHubRepositoryAPI: (state: State) =>
         state.app.dataSources.gitHubRepositoryAPI,
     imageAutoGUIData: (state: State)  =>
-        (gameType: string, gameId: string, variantId: string) =>
-            state.app.gameTypes[gameType].games[gameId].variants.variants[variantId].imageAutoGUIData,
+        (gameId: string, variantId: string) =>
+            state.app.games[gameId].variants[variantId].imageAutoGUIData,
     isEndOfMatch: (state: State) =>
         GMU.isEndOfMatch(state.app),
     locale: (state: State) =>
@@ -188,15 +183,13 @@ const getters: Vuex.GetterTree<State, State> & Getters = {
             GMU.getMaximumRemoteness(state.app, { from, to }),
     moveHistory: (state: State) =>
         state.app.currentMatch.moveHistory,
-    onePlayerGameAPI: (state: State) =>
-        state.app.dataSources.onePlayerGameAPI,
     position: (state: State) =>
-        (gameType: string, gameId: string, variantId: string, position: string) =>
-            state.app.gameTypes[gameType].games[gameId].variants.variants[variantId].
+        (gameId: string, variantId: string, position: string) =>
+            state.app.games[gameId].variants[variantId].
             positions[position],
     positions: (state: State) =>
-        (gameType: string, gameId: string, variantId: string) =>
-            state.app.gameTypes[gameType].games[gameId].variants.variants[variantId].
+        (gameId: string, variantId: string) =>
+            state.app.games[gameId].variants[variantId].
             positions,
     preferences: (state: State) =>
         state.app.preferences,
@@ -206,25 +199,23 @@ const getters: Vuex.GetterTree<State, State> & Getters = {
         state.app.preferences.rootFontSize,
     theme: (state: State) =>
         state.app.preferences.theme,
-    twoPlayerGameAPI: (state: State) =>
-        state.app.dataSources.twoPlayerGameAPI,
     options: (state: State) =>
         state.app.options,
     undoMoveAvailable: (state: State) =>
         GMU.undoMoveAvailable(state.app),
     variant: (state: State) =>
-        (gameType: string, gameId: string, variantId: string) =>
-            state.app.gameTypes[gameType].games[gameId].variants.variants[variantId],
+        (gameId: string, variantId: string) =>
+            state.app.games[gameId].variants[variantId],
     variants: (state: State) =>
-        (gameType: string, gameId: string) =>
-            state.app.gameTypes[gameType].games[gameId].variants,
+        (gameId: string) =>
+            state.app.games[gameId].variants,
     version: (state: State) =>
         state.app.version,
     volume: (state: State) =>
         state.app.preferences.volume,
     supportsWinBy: (state: State) =>
-        (gameType: string, gameId: string) => 
-            state.app.gameTypes[gameType] && state.app.gameTypes[gameType].games[gameId].supportsWinBy === 1 ? true : false,
+        (gameId: string) => 
+            state.app.games[gameId].supportsWinBy,
     currentWinBy: (state: State) =>
         state.app.currentMatch.round.position.winby,
     maximumWinBy: (state: State) =>
@@ -340,16 +331,12 @@ export enum actionTypes {
 }
 
 type Actions = {
-    [actionTypes.addInstructions](context: ActionContext, payload: {gameType: string, gameId: string}): Promise<void>;
+    [actionTypes.addInstructions](context: ActionContext, payload: {gameId: string, variantId: string}): Promise<void>;
     [actionTypes.loadGames](context: ActionContext, payload: {
         type: string
     }): Promise<void>;
-    [actionTypes.loadVariants](context: ActionContext, payload: {
-        type: string;
-        gameId: string
-    }): Promise<void>;
+    [actionTypes.loadVariants](context: ActionContext, payload: {gameId: string}): Promise<void>;
     [actionTypes.initiateMatch](context: ActionContext, payload: {
-        gameType: string;
         gameId: string;
         variantId: string;
         startPosition?: string;
@@ -380,23 +367,21 @@ type Actions = {
 };
 
 const actions: Vuex.ActionTree<State, State> & Actions = {
-    addInstructions: async (context: ActionContext, payload: {gameType: string, gameId: string}) => {
-        const updatedApp = await GMU.addInstructions(context.state.app, {gameType: payload.gameType, gameId: payload.gameId})
+    addInstructions: async (context: ActionContext, payload: {gameId: string, variantId: string}) => {
+        const updatedApp = await GMU.addInstructions(context.state.app, {gameId: payload.gameId, variantId: payload.variantId})
         if (updatedApp) context.commit(mutationTypes.setApp, updatedApp);
     },
     loadGames: async (context: ActionContext, payload: { type: string }) => {
-        const updatedApp = await GMU.loadGames(context.state.app, { gameType: payload.type });
+        const updatedApp = await GMU.loadGames(context.state.app);
         if (updatedApp) context.commit(mutationTypes.setApp, updatedApp);
     },
-    loadVariants: async (context: ActionContext, payload: { type: string; gameId: string }) => {
-        const updatedApp = await GMU.loadVariants(context.state.app, {
-            gameType: payload.type,
+    loadVariants: async (context: ActionContext, payload: { gameId: string }) => {
+        const updatedApp = await GMU.loadGame(context.state.app, {
             gameId: payload.gameId
         });
         if (updatedApp) context.commit(mutationTypes.setApp, updatedApp);
     },
     initiateMatch: async (context: ActionContext, payload: {
-        gameType: string;
         gameId: string;
         variantId: string;
         startPosition?: string;