Merge branch 'develop' into finale

2023-06-25 18:35:12 -04:00 · 2023-06-25 18:35:12 -04:00 · b1968fe320
commit b1968fe320
parent 02078080a8 03f91d18c9
72 changed files with 24042 additions and 347 deletions
--- a/core/allnet.py
+++ b/core/allnet.py
@ -112,6 +112,8 @@ class AllnetServlet:
                )
                resp.uri = f"http://{self.config.title.hostname}:{self.config.title.port}/{req.game_id}/{req.ver.replace('.', '')}/"
                resp.host = f"{self.config.title.hostname}:{self.config.title.port}"
+                
+                self.logger.debug(f"Allnet response: {vars(resp)}")
                return self.dict_to_http_form_string([vars(resp)])

        resp.uri, resp.host = self.uri_registry[req.game_id]
@ -204,16 +206,17 @@ class AllnetServlet:

        else:  # TODO: Keychip check
            if path.exists(
-                f"{self.config.allnet.update_cfg_folder}/{req.game_id}-{req.ver}-app.ini"
+                f"{self.config.allnet.update_cfg_folder}/{req.game_id}-{req.ver.replace('.', '')}-app.ini"
            ):
                resp.uri = f"http://{self.config.title.hostname}:{self.config.title.port}/dl/ini/{req.game_id}-{req.ver.replace('.', '')}-app.ini"

            if path.exists(
-                f"{self.config.allnet.update_cfg_folder}/{req.game_id}-{req.ver}-opt.ini"
+                f"{self.config.allnet.update_cfg_folder}/{req.game_id}-{req.ver.replace('.', '')}-opt.ini"
            ):
                resp.uri += f"|http://{self.config.title.hostname}:{self.config.title.port}/dl/ini/{req.game_id}-{req.ver.replace('.', '')}-opt.ini"

            self.logger.debug(f"Sending download uri {resp.uri}")
+            self.data.base.log_event("allnet", "DLORDER_REQ_SUCCESS", logging.INFO, f"{Utils.get_ip_addr(request)} requested DL Order for {req.serial} {req.game_id} v{req.ver}")
            return self.dict_to_http_form_string([vars(resp)])

    def handle_dlorder_ini(self, request: Request, match: Dict) -> bytes:
@ -223,6 +226,8 @@ class AllnetServlet:
        req_file = match["file"].replace("%0A", "")

        if path.exists(f"{self.config.allnet.update_cfg_folder}/{req_file}"):
+            self.logger.info(f"Request for DL INI file {req_file} from {Utils.get_ip_addr(request)} successful")
+            self.data.base.log_event("allnet", "DLORDER_INI_SENT", logging.INFO, f"{Utils.get_ip_addr(request)} successfully recieved {req_file}")
            return open(
                f"{self.config.allnet.update_cfg_folder}/{req_file}", "rb"
            ).read()
@ -410,8 +415,8 @@ class AllnetPowerOnResponse3:
        self.uri = ""
        self.host = ""
        self.place_id = "123"
-        self.name = ""
-        self.nickname = ""
+        self.name = "ARTEMiS"
+        self.nickname = "ARTEMiS"
        self.region0 = "1"
        self.region_name0 = "W"
        self.region_name1 = ""
@ -435,8 +440,8 @@ class AllnetPowerOnResponse2:
        self.uri = ""
        self.host = ""
        self.place_id = "123"
-        self.name = "Test"
-        self.nickname = "Test123"
+        self.name = "ARTEMiS"
+        self.nickname = "ARTEMiS"
        self.region0 = "1"
        self.region_name0 = "W"
        self.region_name1 = "X"
--- a/core/data/database.py
+++ b/core/data/database.py
@ -333,3 +333,8 @@ class Data:

            if not failed:
                self.base.set_schema_ver(latest_ver, game)
+    
+    def show_versions(self) -> None:
+        all_game_versions = self.base.get_all_schema_vers()
+        for ver in all_game_versions:
+            self.logger.info(f"{ver['game']} -> v{ver['version']}")
--- a/core/data/schema/user.py
+++ b/core/data/schema/user.py
@ -79,6 +79,9 @@ class UserData(BaseData):

        if usr["password"] is None:
            return False
+        
+        if passwd is None or not passwd:
+            return False

        return bcrypt.checkpw(passwd, usr["password"].encode())

--- a/core/data/schema/versions/SDBT_3_rollback.sql
+++ b/core/data/schema/versions/SDBT_3_rollback.sql
@ -0,0 +1,30 @@
+SET FOREIGN_KEY_CHECKS = 0;
+
+ALTER TABLE chuni_score_playlog
+    DROP COLUMN regionId,
+    DROP COLUMN machineType;
+
+ALTER TABLE chuni_static_events
+    DROP COLUMN startDate;
+
+ALTER TABLE chuni_profile_data
+    DROP COLUMN rankUpChallengeResults;
+
+ALTER TABLE chuni_static_login_bonus
+    DROP FOREIGN KEY chuni_static_login_bonus_ibfk_1;
+
+ALTER TABLE chuni_static_login_bonus_preset
+    DROP PRIMARY KEY;
+
+ALTER TABLE chuni_static_login_bonus_preset
+    CHANGE COLUMN presetId id INT NOT NULL;
+ALTER TABLE chuni_static_login_bonus_preset
+    ADD PRIMARY KEY(id);
+ALTER TABLE chuni_static_login_bonus_preset
+    ADD CONSTRAINT chuni_static_login_bonus_preset_uk UNIQUE(id, version);
+
+ALTER TABLE chuni_static_login_bonus
+    ADD CONSTRAINT chuni_static_login_bonus_ibfk_1 FOREIGN KEY(presetId)
+    REFERENCES chuni_static_login_bonus_preset(id) ON UPDATE CASCADE ON DELETE CASCADE;
+
+SET FOREIGN_KEY_CHECKS = 1;
--- a/core/data/schema/versions/SDBT_4_upgrade.sql
+++ b/core/data/schema/versions/SDBT_4_upgrade.sql
@ -0,0 +1,29 @@
+SET FOREIGN_KEY_CHECKS = 0;
+
+ALTER TABLE chuni_score_playlog
+    ADD COLUMN regionId INT,
+    ADD COLUMN machineType INT;
+
+ALTER TABLE chuni_static_events
+    ADD COLUMN startDate TIMESTAMP NOT NULL DEFAULT current_timestamp();
+
+ALTER TABLE chuni_profile_data
+    ADD COLUMN rankUpChallengeResults JSON;
+
+ALTER TABLE chuni_static_login_bonus
+    DROP FOREIGN KEY chuni_static_login_bonus_ibfk_1;
+
+ALTER TABLE chuni_static_login_bonus_preset
+    CHANGE COLUMN id presetId INT NOT NULL;
+ALTER TABLE chuni_static_login_bonus_preset
+    DROP PRIMARY KEY;
+ALTER TABLE chuni_static_login_bonus_preset
+    DROP INDEX chuni_static_login_bonus_preset_uk;
+ALTER TABLE chuni_static_login_bonus_preset
+    ADD CONSTRAINT chuni_static_login_bonus_preset_pk PRIMARY KEY (presetId, version);
+
+ALTER TABLE chuni_static_login_bonus
+    ADD CONSTRAINT chuni_static_login_bonus_ibfk_1 FOREIGN KEY (presetId, version)
+    REFERENCES chuni_static_login_bonus_preset(presetId, version) ON UPDATE CASCADE ON DELETE CASCADE;
+
+SET FOREIGN_KEY_CHECKS = 1;
--- a/core/data/schema/versions/SDEZ_4_rollback.sql
+++ b/core/data/schema/versions/SDEZ_4_rollback.sql
@ -1,26 +1,3 @@
-DELETE FROM mai2_static_event WHERE version < 13;
-UPDATE mai2_static_event SET version = version - 13 WHERE version >= 13;
-
-DELETE FROM mai2_static_music WHERE version < 13;
-UPDATE mai2_static_music SET version = version - 13 WHERE version >= 13;
-
-DELETE FROM mai2_static_ticket WHERE version < 13;
-UPDATE mai2_static_ticket SET version = version - 13 WHERE version >= 13;
-
-DELETE FROM mai2_static_cards WHERE version < 13;
-UPDATE mai2_static_cards SET version = version - 13 WHERE version >= 13;
-
-DELETE FROM mai2_profile_detail WHERE version < 13;
-UPDATE mai2_profile_detail SET version = version - 13 WHERE version >= 13;
-
-DELETE FROM mai2_profile_extend WHERE version < 13;
-UPDATE mai2_profile_extend SET version = version - 13 WHERE version >= 13;
-
-DELETE FROM mai2_profile_option WHERE version < 13;
-UPDATE mai2_profile_option SET version = version - 13 WHERE version >= 13;
-
-DELETE FROM mai2_profile_ghost WHERE version < 13;
-UPDATE mai2_profile_ghost SET version = version - 13 WHERE version >= 13;
-
-DELETE FROM mai2_profile_rating WHERE version < 13;
-UPDATE mai2_profile_rating SET version = version - 13 WHERE version >= 13;
+ALTER TABLE mai2_item_card 
+    CHANGE COLUMN startDate startDate TIMESTAMP DEFAULT "2018-01-01 00:00:00.0",
+    CHANGE COLUMN endDate endDate TIMESTAMP DEFAULT "2038-01-01 00:00:00.0";
--- a/core/data/schema/versions/SDEZ_5_upgrade.sql
+++ b/core/data/schema/versions/SDEZ_5_upgrade.sql
@ -1,17 +1,3 @@
-UPDATE mai2_static_event SET version = version + 13 WHERE version < 1000;
-
-UPDATE mai2_static_music SET version = version + 13 WHERE version < 1000;
-
-UPDATE mai2_static_ticket SET version = version + 13 WHERE version < 1000;
-
-UPDATE mai2_static_cards SET version = version + 13 WHERE version < 1000;
-
-UPDATE mai2_profile_detail  SET version = version + 13 WHERE version < 1000;
-
-UPDATE mai2_profile_extend  SET version = version + 13 WHERE version < 1000;
-
-UPDATE mai2_profile_option  SET version = version + 13 WHERE version < 1000;
-
-UPDATE mai2_profile_ghost  SET version = version + 13 WHERE version < 1000;
-
-UPDATE mai2_profile_rating  SET version = version + 13 WHERE version < 1000;
+ALTER TABLE mai2_item_card 
+    CHANGE COLUMN startDate startDate TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    CHANGE COLUMN endDate endDate TIMESTAMP NOT NULL;
--- a/core/frontend.py
+++ b/core/frontend.py
@ -182,7 +182,7 @@ class FE_Gate(FE_Base):
            access_code: str = request.args[b"access_code"][0].decode()
            username: str = request.args[b"username"][0]
            email: str = request.args[b"email"][0].decode()
-            passwd: str = request.args[b"passwd"][0]
+            passwd: bytes = request.args[b"passwd"][0]

            uid = self.data.card.get_user_id_from_card(access_code)
            if uid is None:
@ -197,7 +197,7 @@ class FE_Gate(FE_Base):
            if result is None:
                return redirectTo(b"/gate?e=3", request)

-            if not self.data.user.check_password(uid, passwd.encode()):
+            if not self.data.user.check_password(uid, passwd):
                return redirectTo(b"/gate", request)

            return redirectTo(b"/user", request)
@ -227,9 +227,22 @@ class FE_User(FE_Base):
        usr_sesh = IUserSession(sesh)
        if usr_sesh.userId == 0:
            return redirectTo(b"/gate", request)
+        
+        cards = self.data.card.get_user_cards(usr_sesh.userId)
+        user = self.data.user.get_user(usr_sesh.userId)
+        card_data = []
+        for c in cards:
+            if c['is_locked']:
+                status = 'Locked'
+            elif c['is_banned']:
+                status = 'Banned'
+            else:
+                status = 'Active'
+            
+            card_data.append({'access_code': c['access_code'], 'status': status})

        return template.render(
-            title=f"{self.core_config.server.name} | Account", sesh=vars(usr_sesh)
+            title=f"{self.core_config.server.name} | Account", sesh=vars(usr_sesh), cards=card_data, username=user['username']
        ).encode("utf-16")


--- a/core/frontend/user/index.jinja
+++ b/core/frontend/user/index.jinja
@ -1,4 +1,31 @@
 {% extends "core/frontend/index.jinja" %}
 {% block content %}
-<h1>testing</h1>
+<h1>Management for {{ username }}</h1>
+<h2>Cards <button class="btn btn-success" data-bs-toggle="modal" data-bs-target="#card_add">Add</button></h2>
+<ul>
+{% for c in cards %}
+<li>{{ c.access_code }}: {{ c.status }} <button class="btn-danger btn">Delete</button></li>
+{% endfor %}
+</ul>
+<div class="modal fade" id="card_add" tabindex="-1" aria-labelledby="card_add_label" aria-hidden="true">
+  <div class="modal-dialog">
+    <div class="modal-content">
+      <div class="modal-header">
+        <h1 class="modal-title fs-5" id="card_add_label">Add Card</h1>
+        <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+      </div>
+      <div class="modal-body">
+        HOW TO:<br>
+        Scan your card on any networked game and press the "View Access Code" button (varies by game) and enter the 20 digit code below.<br>
+        !!FOR AMUSEIC CARDS: DO NOT ENTER THE CODE SHOWN ON THE BACK OF THE CARD ITSELF OR IT WILL NOT WORK!!
+        <p /><label for="card_add_frm_access_code">Access Code:&nbsp;</label><input id="card_add_frm_access_code" maxlength="20" type="text" required> 
+      </div>
+      <div class="modal-footer">
+        <button type="button" class="btn btn-primary">Add</button>
+        <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Close</button>
+      </div>
+    </div>
+  </div>
+</div>
+
 {% endblock content %}
--- a/core/frontend/widgets/topbar.jinja
+++ b/core/frontend/widgets/topbar.jinja
@ -4,7 +4,7 @@
 <div style="background: #333; color: #f9f9f9; width: 80%; height: 50px; line-height: 50px; padding-left: 10px; float: left;">
    <a href=/><button class="btn btn-primary">Home</button></a>&nbsp;
    {% for game in game_list %}    
-    <a href=game/{{ game.url }}><button class="btn btn-success">{{ game.name }}</button></a>&nbsp;
+    <a href=/game/{{ game.url }}><button class="btn btn-success">{{ game.name }}</button></a>&nbsp;
    {% endfor %}
 </div>
 </div>
--- a/core/mucha.py
+++ b/core/mucha.py
@ -33,8 +33,8 @@ class MuchaServlet:
        self.logger.addHandler(fileHandler)
        self.logger.addHandler(consoleHandler)

-        self.logger.setLevel(logging.INFO)
-        coloredlogs.install(level=logging.INFO, logger=self.logger, fmt=log_fmt_str)
+        self.logger.setLevel(cfg.mucha.loglevel)
+        coloredlogs.install(level=cfg.mucha.loglevel, logger=self.logger, fmt=log_fmt_str)

        all_titles = Utils.get_all_titles()

--- a/core/title.py
+++ b/core/title.py
@ -84,7 +84,7 @@ class TitleServlet:
            request.setResponseCode(405)
            return b""

-        return index.render_GET(request, endpoints["version"], endpoints["endpoint"])
+        return index.render_GET(request, int(endpoints["version"]), endpoints["endpoint"])

    def render_POST(self, request: Request, endpoints: dict) -> bytes:
        code = endpoints["game"]
--- a/dbutils.py
+++ b/dbutils.py
@ -84,5 +84,8 @@ if __name__ == "__main__":

    elif args.action == "cleanup":
        data.delete_hanging_users()
+    
+    elif args.action == "version":
+        data.show_versions()

    data.logger.info("Done")
--- a/docs/game_specific_info.md
+++ b/docs/game_specific_info.md
@ -9,42 +9,44 @@ using the megaime database. Clean installations always create the latest databas
 # Table of content

 - [Supported Games](#supported-games)
-    - [Chunithm](#chunithm)
+    - [CHUNITHM](#chunithm)
    - [crossbeats REV.](#crossbeats-rev)
    - [maimai DX](#maimai-dx)
    - [O.N.G.E.K.I.](#o-n-g-e-k-i)
    - [Card Maker](#card-maker)
    - [WACCA](#wacca)
+    - [Sword Art Online Arcade](#sao)


 # Supported Games

 Games listed below have been tested and confirmed working.

-## Chunithm
+## CHUNITHM

 ### SDBT

-| Version ID | Version Name       |
-|------------|--------------------|
-| 0          | Chunithm           |
-| 1          | Chunithm+          |
-| 2          | Chunithm Air       |
-| 3          | Chunithm Air +     |
-| 4          | Chunithm Star      |
-| 5          | Chunithm Star +    |
-| 6          | Chunithm Amazon    |
-| 7          | Chunithm Amazon +  |
-| 8          | Chunithm Crystal   |
-| 9          | Chunithm Crystal + |
-| 10         | Chunithm Paradise  |
+| Version ID | Version Name          |
+|------------|-----------------------|
+| 0          | CHUNITHM              |
+| 1          | CHUNITHM PLUS         |
+| 2          | CHUNITHM AIR          |
+| 3          | CHUNITHM AIR PLUS     |
+| 4          | CHUNITHM STAR         |
+| 5          | CHUNITHM STAR PLUS    |
+| 6          | CHUNITHM AMAZON       |
+| 7          | CHUNITHM AMAZON PLUS  |
+| 8          | CHUNITHM CRYSTAL      |
+| 9          | CHUNITHM CRYSTAL PLUS |
+| 10         | CHUNITHM PARADISE     |

 ### SDHD/SDBT

-| Version ID | Version Name    |
-|------------|-----------------|
-| 11         | Chunithm New!!  |
-| 12         | Chunithm New!!+ |
+| Version ID | Version Name        |
+|------------|---------------------|
+| 11         | CHUNITHM NEW!!      |
+| 12         | CHUNITHM NEW PLUS!! |
+| 13         | CHUNITHM SUN        |


 ### Importer
@ -60,13 +62,33 @@ The importer for Chunithm will import: Events, Music, Charge Items and Avatar Ac
 ### Database upgrade

 Always make sure your database (tables) are up-to-date, to do so go to the `core/data/schema/versions` folder and see
-which version is the latest, f.e. `SDBT_3_upgrade.sql`. In order to upgrade to version 3 in this case you need to
+which version is the latest, f.e. `SDBT_4_upgrade.sql`. In order to upgrade to version 4 in this case you need to
 perform all previous updates as well:

 ```shell
 python dbutils.py --game SDBT upgrade
 ```

+### Online Battle
+
+**Only matchmaking (with your imaginary friends) is supported! Online Battle does not (yet?) work!**
+
+The first person to start the Online Battle (now called host) will create a "matching room" with a given `roomId`, after that max 3 other people can join the created room.
+Non used slots during the matchmaking will be filled with CPUs after the timer runs out.
+As soon as a new member will join the room the timer will jump back to 60 secs again.
+Sending those 4 messages to all other users is also working properly.
+In order to use the Online Battle every user needs the same ICF, same rom version and same data version!
+If a room is full a new room will be created if another user starts an Online Battle.
+After a failed Online Battle the room will be deleted. The host is used for the timer countdown, so if the connection failes to the host the timer will stop and could create a "frozen" state.
+
+#### Information/Problems:
+
+- Online Battle uses UDP hole punching and opens port 50201?
+- `reflectorUri` seems related to that?
+- Timer countdown should be handled globally and not by one user
+- Game can freeze or can crash if someone (especially the host) leaves the matchmaking
+
+
 ## crossbeats REV.

 ### SDCA
@ -253,20 +275,20 @@ python dbutils.py --game SDDT upgrade

 | Version ID | Version Name    |
 |------------|-----------------|
-| 0          | Card Maker 1.34 |
+| 0          | Card Maker 1.30 |
 | 1          | Card Maker 1.35 |


 ### Support status

-* Card Maker 1.34:
-  * Chunithm New!!: Yes
-  * maimai DX Universe: Yes
+* Card Maker 1.30:
+  * CHUNITHM NEW!!: Yes
+  * maimai DX UNiVERSE: Yes
  * O.N.G.E.K.I. Bright: Yes

 * Card Maker 1.35:
-  * Chunithm New!!+: Yes
-  * maimai DX Universe PLUS: Yes
+  * CHUNITHM SUN: Yes (NEW PLUS!! up to A032)
+  * maimai DX FESTiVAL: Yes (up to A035) (UNiVERSE PLUS up to A031)
  * O.N.G.E.K.I. Bright Memory: Yes


@ -285,19 +307,46 @@ python read.py --series SDED --version <version ID> --binfolder titles/cm/cm_dat
 python read.py --series SDDT --version <version ID> --binfolder /path/to/game/folder --optfolder /path/to/game/option/folder
 ```

-Also make sure to import all maimai and Chunithm data as well:
+Also make sure to import all maimai DX and CHUNITHM data as well:

 ```shell
 python read.py --series SDED --version <version ID> --binfolder /path/to/cardmaker/CardMaker_Data
 ```

-The importer for Card Maker will import all required Gachas (Banners) and cards (for maimai/Chunithm) and the hardcoded
+The importer for Card Maker will import all required Gachas (Banners) and cards (for maimai DX/CHUNITHM) and the hardcoded
 Cards for each Gacha (O.N.G.E.K.I. only).

 **NOTE: Without executing the importer Card Maker WILL NOT work!**


-### O.N.G.E.K.I. Gachas
+### Config setup
+
+Make sure to update your `config/cardmaker.yaml` with the correct version for each game. To get the current version required to run a specific game, open every opt (Axxx) folder descending until you find all three folders:
+
+- `MU3`: O.N.G.E.K.I.
+- `MAI`: maimai DX
+- `CHU`: CHUNITHM
+
+Inside each folder is a `DataConfig.xml` file, for example:
+
+`MU3/DataConfig.xml`:
+```xml
+  <cardMakerVersion>
+    <major>1</major>
+    <minor>35</minor>
+    <release>3</release>
+  </cardMakerVersion>
+```
+
+Now update your `config/cardmaker.yaml` with the correct version number, for example:
+
+```yaml
+version:
+  1: # Card Maker 1.35
+    ongeki: 1.35.03
+```	 
+
+### O.N.G.E.K.I.

 Gacha "無料ガチャ" can only pull from the free cards with the following probabilities: 94%: R, 5% SR and 1% chance of
 getting an SSR card
@ -310,20 +359,24 @@ and 3% chance of getting an SSR card
 All other (limited) gachas can pull from every card added to ongeki_static_cards but with the promoted cards
 (click on the green button under the banner) having a 10 times higher chance to get pulled

-### Chunithm Gachas
+### CHUNITHM

-All cards in Chunithm (basically just the characters) have the same rarity to it just pulls randomly from all cards
+All cards in CHUNITHM (basically just the characters) have the same rarity to it just pulls randomly from all cards
 from a given gacha but made sure you cannot pull the same card twice in the same 5 times gacha roll.

+### maimai DX
+
+Printed maimai DX cards: Freedom (`cardTypeId=6`) or Gold Pass (`cardTypeId=4`) can now be selected during the login process. You can only have ONE Freedom and ONE Gold Pass active at a given time. The cards will expire after 15 days.
+
+Thanks GetzeAvenue for the `selectedCardList` rarity hint!
+
 ### Notes

-Card Maker 1.34 will only load an O.N.G.E.K.I. Bright profile (1.30). Card Maker 1.35 will only load an O.N.G.E.K.I.
+Card Maker 1.30-1.34 will only load an O.N.G.E.K.I. Bright profile (1.30). Card Maker 1.35+ will only load an O.N.G.E.K.I.
 Bright Memory profile (1.35).
-The gachas inside the `ongeki.yaml` will make sure only the right gacha ids for the right CM version will be loaded.
+The gachas inside the `config/ongeki.yaml` will make sure only the right gacha ids for the right CM version will be loaded.
 Gacha IDs up to 1140 will be loaded for CM 1.34 and all gachas will be loaded for CM 1.35.

-**NOTE: There is currently no way to load/use the (printed) maimai DX cards!**
-
 ## WACCA

 ### SDFE
@ -366,3 +419,52 @@ Always make sure your database (tables) are up-to-date, to do so go to the `core
 ```shell
 python dbutils.py --game SDFE upgrade
 ```
+
+## SAO
+
+### SDEW
+
+| Version ID | Version Name  |
+|------------|---------------|
+| 0          | SAO           |
+
+
+### Importer
+
+In order to use the importer locate your game installation folder and execute:
+
+```shell
+python read.py --series SDEW --version <version ID> --binfolder /path/to/game/extractedassets
+```
+
+The importer for SAO will import all items, heroes, support skills and titles data.
+
+### Config
+
+Config file is located in `config/sao.yaml`.
+
+| Option             | Info                                                                        |
+|--------------------|-----------------------------------------------------------------------------|
+| `hostname`         | Changes the server listening address for Mucha                              |
+| `port`             | Changes the listing port                                                    |
+| `auto_register`    | Allows the game to handle the automatic registration of new cards           |
+
+
+### Database upgrade
+
+Always make sure your database (tables) are up-to-date, to do so go to the `core/data/schema/versions` folder and see which version is the latest, f.e. `SDEW_1_upgrade.sql`. In order to upgrade to version 3 in this case you need to perform all previous updates as well:
+
+```shell
+python dbutils.py --game SDEW upgrade
+```
+
+### Notes
+- Co-Op (matching) is not supported
+- Shop is not functionnal
+- Player title is currently static and cannot be changed in-game
+
+### Credits for SAO support:
+
+- Midorica - Limited Network Support
+- Dniel97 - Helping with network base
+- tungnotpunk - Source
--- a/example_config/cardmaker.yaml
+++ b/example_config/cardmaker.yaml
@ -1,3 +1,13 @@
 server:
  enable: True
  loglevel: "info"
+
+version:
+  0:
+    ongeki: 1.30.01
+    chuni: 2.00.00
+    maimai: 1.20.00
+  1:
+    ongeki: 1.35.03
+    chuni: 2.10.00
+    maimai: 1.30.00
--- a/example_config/chuni.yaml
+++ b/example_config/chuni.yaml
@ -15,6 +15,9 @@ version:
  12:
    rom: 2.05.00
    data: 2.05.00
+  13:
+    rom: 2.10.00
+    data: 2.10.00

 crypto:
  encrypted_only: False
--- a/example_config/pokken.yaml
+++ b/example_config/pokken.yaml
@ -2,8 +2,11 @@ server:
  hostname: "localhost"
  enable: True
  loglevel: "info"
-  port: 9000
-  port_stun: 9001
-  port_turn: 9002
-  port_admission: 9003
-  auto_register: True
+  auto_register: True
+  enable_matching: False
+  stun_server_host: "stunserver.stunprotocol.org"
+  stun_server_port: 3478
+
+ports:
+  game: 9000
+  admission: 9001
--- a/example_config/sao.yaml
+++ b/example_config/sao.yaml
@ -0,0 +1,6 @@
+server:
+  hostname: "localhost"
+  enable: True
+  loglevel: "info"
+  port: 9000
+  auto_register: True
--- a/readme.md
+++ b/readme.md
@ -3,32 +3,36 @@ A network service emulator for games running SEGA'S ALL.NET service, and similar

 # Supported games
 Games listed below have been tested and confirmed working. Only game versions older then the version currently active in arcades, or games versions that have not recieved a major update in over one year, are supported.
-+ Chunithm
-    + All versions up to New!! Plus

-+ Crossbeats Rev
+ CHUNITHM
+    + All versions up to SUN
+
+ crossbeats REV.
    + All versions + omnimix

 + maimai DX
-    + All versions up to Festival
+    + All versions up to FESTiVAL

-+ Hatsune Miku Arcade
+ Hatsune Miku: Project DIVA Arcade
    + All versions

 + Card Maker
-    + 1.34.xx
-    + 1.35.xx
+    + 1.30
+    + 1.35

-+ Ongeki
+ O.N.G.E.K.I.
    + All versions up to Bright Memory

-+ Wacca
+ WACCA
    + Lily R
    + Reverse

-+ Pokken
+ POKKÉN TOURNAMENT
    + Final Online

+ Sword Art Online Arcade (partial support)
+    + Final
+
 ## Requirements
 - python 3 (tested working with 3.9 and 3.10, other versions YMMV)
 - pip
--- a/requirements.txt
+++ b/requirements.txt
@ -16,3 +16,4 @@ Routes
 bcrypt
 jinja2
 protobuf
+autobahn
--- a/titles/chuni/init.py
+++ b/titles/chuni/init.py
@ -7,4 +7,4 @@ index = ChuniServlet
 database = ChuniData
 reader = ChuniReader
 game_codes = [ChuniConstants.GAME_CODE, ChuniConstants.GAME_CODE_NEW]
-current_schema_version = 3
+current_schema_version = 4
--- a/titles/chuni/base.py
+++ b/titles/chuni/base.py
@ -44,13 +44,15 @@ class ChuniBase:
            # check if a user already has some pogress and if not add the
            # login bonus entry
            user_login_bonus = self.data.item.get_login_bonus(
-                user_id, self.version, preset["id"]
+                user_id, self.version, preset["presetId"]
            )
            if user_login_bonus is None:
-                self.data.item.put_login_bonus(user_id, self.version, preset["id"])
+                self.data.item.put_login_bonus(
+                    user_id, self.version, preset["presetId"]
+                )
                # yeah i'm lazy
                user_login_bonus = self.data.item.get_login_bonus(
-                    user_id, self.version, preset["id"]
+                    user_id, self.version, preset["presetId"]
                )

            # skip the login bonus entirely if its already finished
@ -66,13 +68,13 @@ class ChuniBase:
                last_update_date = datetime.now()

                all_login_boni = self.data.static.get_login_bonus(
-                    self.version, preset["id"]
+                    self.version, preset["presetId"]
                )

                # skip the current bonus preset if no boni were found
                if all_login_boni is None or len(all_login_boni) < 1:
                    self.logger.warn(
-                        f"No bonus entries found for bonus preset {preset['id']}"
+                        f"No bonus entries found for bonus preset {preset['presetId']}"
                    )
                    continue

@ -83,14 +85,14 @@ class ChuniBase:
                if bonus_count > max_needed_days:
                    # assume that all login preset ids under 3000 needs to be
                    # looped, like 30 and 40 are looped, 40 does not work?
-                    if preset["id"] < 3000:
+                    if preset["presetId"] < 3000:
                        bonus_count = 1
                    else:
                        is_finished = True

                # grab the item for the corresponding day
                login_item = self.data.static.get_login_bonus_by_required_days(
-                    self.version, preset["id"], bonus_count
+                    self.version, preset["presetId"], bonus_count
                )
                if login_item is not None:
                    # now add the present to the database so the
@ -108,7 +110,7 @@ class ChuniBase:
                self.data.item.put_login_bonus(
                    user_id,
                    self.version,
-                    preset["id"],
+                    preset["presetId"],
                    bonusCount=bonus_count,
                    lastUpdateDate=last_update_date,
                    isWatched=False,
@ -156,12 +158,18 @@ class ChuniBase:

        event_list = []
        for evt_row in game_events:
-            tmp = {}
-            tmp["id"] = evt_row["eventId"]
-            tmp["type"] = evt_row["type"]
-            tmp["startDate"] = "2017-12-05 07:00:00.0"
-            tmp["endDate"] = "2099-12-31 00:00:00.0"
-            event_list.append(tmp)
+            event_list.append(
+                {
+                    "id": evt_row["eventId"],
+                    "type": evt_row["type"],
+                    # actually use the startDate from the import so it
+                    # properly shows all the events when new ones are imported
+                    "startDate": datetime.strftime(
+                        evt_row["startDate"], "%Y-%m-%d %H:%M:%S"
+                    ),
+                    "endDate": "2099-12-31 00:00:00",
+                }
+            )

        return {
            "type": data["type"],
@ -228,29 +236,36 @@ class ChuniBase:
    def handle_get_user_character_api_request(self, data: Dict) -> Dict:
        characters = self.data.item.get_characters(data["userId"])
        if characters is None:
-            return {}
-        next_idx = -1
+            return {
+                "userId": data["userId"],
+                "length": 0,
+                "nextIndex": -1,
+                "userCharacterList": [],
+            }

-        characterList = []
-        for x in range(int(data["nextIndex"]), len(characters)):
+        character_list = []
+        next_idx = int(data["nextIndex"])
+        max_ct = int(data["maxCount"])
+
+        for x in range(next_idx, len(characters)):
            tmp = characters[x]._asdict()
            tmp.pop("user")
            tmp.pop("id")
-            characterList.append(tmp)
+            character_list.append(tmp)

-            if len(characterList) >= int(data["maxCount"]):
+            if len(character_list) >= max_ct:
                break

-        if len(characterList) >= int(data["maxCount"]) and len(characters) > int(
-            data["maxCount"]
-        ) + int(data["nextIndex"]):
-            next_idx = int(data["maxCount"]) + int(data["nextIndex"]) + 1
+        if len(characters) >= next_idx + max_ct:
+            next_idx += max_ct
+        else:
+            next_idx = -1

        return {
            "userId": data["userId"],
-            "length": len(characterList),
+            "length": len(character_list),
            "nextIndex": next_idx,
-            "userCharacterList": characterList,
+            "userCharacterList": character_list,
        }

    def handle_get_user_charge_api_request(self, data: Dict) -> Dict:
@ -292,8 +307,8 @@ class ChuniBase:
            if len(user_course_list) >= max_ct:
                break

-        if len(user_course_list) >= max_ct:
-            next_idx = next_idx + max_ct
+        if len(user_course_list) >= next_idx + max_ct:
+            next_idx += max_ct
        else:
            next_idx = -1

@ -347,12 +362,23 @@ class ChuniBase:
        }

    def handle_get_user_favorite_item_api_request(self, data: Dict) -> Dict:
+        user_fav_item_list = []
+
+        # still needs to be implemented on WebUI
+        # 1: Music, 3: Character
+        fav_list = self.data.item.get_all_favorites(
+            data["userId"], self.version, fav_kind=int(data["kind"])
+        )
+        if fav_list is not None:
+            for fav in fav_list:
+                user_fav_item_list.append({"id": fav["favId"]})
+
        return {
            "userId": data["userId"],
-            "length": 0,
+            "length": len(user_fav_item_list),
            "kind": data["kind"],
            "nextIndex": -1,
-            "userFavoriteItemList": [],
+            "userFavoriteItemList": user_fav_item_list,
        }

    def handle_get_user_favorite_music_api_request(self, data: Dict) -> Dict:
@ -387,13 +413,13 @@ class ChuniBase:
        xout = kind * 10000000000 + next_idx + len(items)

        if len(items) < int(data["maxCount"]):
-            nextIndex = 0
+            next_idx = 0
        else:
-            nextIndex = xout
+            next_idx = xout

        return {
            "userId": data["userId"],
-            "nextIndex": nextIndex,
+            "nextIndex": next_idx,
            "itemKind": kind,
            "length": len(items),
            "userItemList": items,
@ -452,6 +478,7 @@ class ChuniBase:
                "nextIndex": -1,
                "userMusicList": [],  # 240
            }
+
        song_list = []
        next_idx = int(data["nextIndex"])
        max_ct = int(data["maxCount"])
@ -474,10 +501,10 @@ class ChuniBase:
            if len(song_list) >= max_ct:
                break

-        if len(song_list) >= max_ct:
+        if len(song_list) >= next_idx + max_ct:
            next_idx += max_ct
        else:
-            next_idx = 0
+            next_idx = -1

        return {
            "userId": data["userId"],
@ -623,12 +650,15 @@ class ChuniBase:
            self.data.profile.put_profile_data(
                user_id, self.version, upsert["userData"][0]
            )
+
        if "userDataEx" in upsert:
            self.data.profile.put_profile_data_ex(
                user_id, self.version, upsert["userDataEx"][0]
            )
+
        if "userGameOption" in upsert:
            self.data.profile.put_profile_option(user_id, upsert["userGameOption"][0])
+
        if "userGameOptionEx" in upsert:
            self.data.profile.put_profile_option_ex(
                user_id, upsert["userGameOptionEx"][0]
@ -672,6 +702,10 @@ class ChuniBase:

        if "userPlaylogList" in upsert:
            for playlog in upsert["userPlaylogList"]:
+                # convert the player names to utf-8
+                playlog["playedUserName1"] = self.read_wtf8(playlog["playedUserName1"])
+                playlog["playedUserName2"] = self.read_wtf8(playlog["playedUserName2"])
+                playlog["playedUserName3"] = self.read_wtf8(playlog["playedUserName3"])
                self.data.score.put_playlog(user_id, playlog)

        if "userTeamPoint" in upsert:
--- a/titles/chuni/const.py
+++ b/titles/chuni/const.py
@ -17,21 +17,23 @@ class ChuniConstants:
    VER_CHUNITHM_PARADISE = 10
    VER_CHUNITHM_NEW = 11
    VER_CHUNITHM_NEW_PLUS = 12
+    VER_CHUNITHM_SUN = 13

    VERSION_NAMES = [
-        "Chunithm",
-        "Chunithm+",
-        "Chunithm Air",
-        "Chunithm Air+",
-        "Chunithm Star",
-        "Chunithm Star+",
-        "Chunithm Amazon",
-        "Chunithm Amazon+",
-        "Chunithm Crystal",
-        "Chunithm Crystal+",
-        "Chunithm Paradise",
-        "Chunithm New!!",
-        "Chunithm New!!+",
+        "CHUNITHM",
+        "CHUNITHM PLUS",
+        "CHUNITHM AIR",
+        "CHUNITHM AIR PLUS",
+        "CHUNITHM STAR",
+        "CHUNITHM STAR  PLUS",
+        "CHUNITHM AMAZON",
+        "CHUNITHM AMAZON PLUS",
+        "CHUNITHM CRYSTAL",
+        "CHUNITHM CRYSTAL PLUS",
+        "CHUNITHM PARADISE",
+        "CHUNITHM NEW!!",
+        "CHUNITHM NEW PLUS!!",
+        "CHUNITHM SUN"
    ]

    @classmethod
--- a/titles/chuni/index.py
+++ b/titles/chuni/index.py
@ -29,6 +29,7 @@ from titles.chuni.crystalplus import ChuniCrystalPlus
 from titles.chuni.paradise import ChuniParadise
 from titles.chuni.new import ChuniNew
 from titles.chuni.newplus import ChuniNewPlus
+from titles.chuni.sun import ChuniSun


 class ChuniServlet:
@ -55,6 +56,7 @@ class ChuniServlet:
            ChuniParadise,
            ChuniNew,
            ChuniNewPlus,
+            ChuniSun,
        ]

        self.logger = logging.getLogger("chuni")
@ -96,15 +98,18 @@ class ChuniServlet:
            ]
            for method in method_list:
                method_fixed = inflection.camelize(method)[6:-7]
+                # number of iterations was changed to 70 in SUN
+                iter_count = 70 if version >= ChuniConstants.VER_CHUNITHM_SUN else 44
                hash = PBKDF2(
                    method_fixed,
                    bytes.fromhex(keys[2]),
                    128,
-                    count=44,
+                    count=iter_count,
                    hmac_hash_module=SHA1,
                )

-                self.hash_table[version][hash.hex()] = method_fixed
+                hashed_name = hash.hex()[:32] # truncate unused bytes like the game does
+                self.hash_table[version][hashed_name] = method_fixed

                self.logger.debug(
                    f"Hashed v{version} method {method_fixed} with {bytes.fromhex(keys[2])} to get {hash.hex()}"
@ -145,30 +150,32 @@ class ChuniServlet:

        if version < 105:  # 1.0
            internal_ver = ChuniConstants.VER_CHUNITHM
-        elif version >= 105 and version < 110:  # Plus
+        elif version >= 105 and version < 110:  # PLUS
            internal_ver = ChuniConstants.VER_CHUNITHM_PLUS
-        elif version >= 110 and version < 115:  # Air
+        elif version >= 110 and version < 115:  # AIR
            internal_ver = ChuniConstants.VER_CHUNITHM_AIR
-        elif version >= 115 and version < 120:  # Air Plus
+        elif version >= 115 and version < 120:  # AIR PLUS
            internal_ver = ChuniConstants.VER_CHUNITHM_AIR_PLUS
-        elif version >= 120 and version < 125:  # Star
+        elif version >= 120 and version < 125:  # STAR
            internal_ver = ChuniConstants.VER_CHUNITHM_STAR
-        elif version >= 125 and version < 130:  # Star Plus
+        elif version >= 125 and version < 130:  # STAR PLUS
            internal_ver = ChuniConstants.VER_CHUNITHM_STAR_PLUS
-        elif version >= 130 and version < 135:  # Amazon
+        elif version >= 130 and version < 135:  # AMAZON
            internal_ver = ChuniConstants.VER_CHUNITHM_AMAZON
-        elif version >= 135 and version < 140:  # Amazon Plus
+        elif version >= 135 and version < 140:  # AMAZON PLUS
            internal_ver = ChuniConstants.VER_CHUNITHM_AMAZON_PLUS
-        elif version >= 140 and version < 145:  # Crystal
+        elif version >= 140 and version < 145:  # CRYSTAL
            internal_ver = ChuniConstants.VER_CHUNITHM_CRYSTAL
-        elif version >= 145 and version < 150:  # Crystal Plus
+        elif version >= 145 and version < 150:  # CRYSTAL PLUS
            internal_ver = ChuniConstants.VER_CHUNITHM_CRYSTAL_PLUS
-        elif version >= 150 and version < 200:  # Paradise
+        elif version >= 150 and version < 200:  # PARADISE
            internal_ver = ChuniConstants.VER_CHUNITHM_PARADISE
-        elif version >= 200 and version < 205:  # New
+        elif version >= 200 and version < 205:  # NEW!!
            internal_ver = ChuniConstants.VER_CHUNITHM_NEW
-        elif version >= 205 and version < 210:  # New Plus
+        elif version >= 205 and version < 210:  # NEW PLUS!!
            internal_ver = ChuniConstants.VER_CHUNITHM_NEW_PLUS
+        elif version >= 210:  # SUN
+            internal_ver = ChuniConstants.VER_CHUNITHM_SUN

        if all(c in string.hexdigits for c in endpoint) and len(endpoint) == 32:
            # If we get a 32 character long hex string, it's a hash and we're
--- a/titles/chuni/new.py
+++ b/titles/chuni/new.py
@ -23,41 +23,44 @@ class ChuniNew(ChuniBase):
        self.version = ChuniConstants.VER_CHUNITHM_NEW

    def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
+        # use UTC time and convert it to JST time by adding +9
+        # matching therefore starts one hour before and lasts for 8 hours
        match_start = datetime.strftime(
-            datetime.now() - timedelta(hours=10), self.date_time_format
+            datetime.utcnow() + timedelta(hours=8), self.date_time_format
        )
        match_end = datetime.strftime(
-            datetime.now() + timedelta(hours=10), self.date_time_format
+            datetime.utcnow() + timedelta(hours=16), self.date_time_format
        )
        reboot_start = datetime.strftime(
-            datetime.now() - timedelta(hours=11), self.date_time_format
+            datetime.utcnow() + timedelta(hours=6), self.date_time_format
        )
        reboot_end = datetime.strftime(
-            datetime.now() - timedelta(hours=10), self.date_time_format
+            datetime.utcnow() + timedelta(hours=7), self.date_time_format
        )
        return {
            "gameSetting": {
-                "isMaintenance": "false",
+                "isMaintenance": False,
                "requestInterval": 10,
                "rebootStartTime": reboot_start,
                "rebootEndTime": reboot_end,
-                "isBackgroundDistribute": "false",
+                "isBackgroundDistribute": False,
                "maxCountCharacter": 300,
                "maxCountItem": 300,
                "maxCountMusic": 300,
                "matchStartTime": match_start,
                "matchEndTime": match_end,
-                "matchTimeLimit": 99,
+                "matchTimeLimit": 60,
                "matchErrorLimit": 9999,
                "romVersion": self.game_cfg.version.version(self.version)["rom"],
                "dataVersion": self.game_cfg.version.version(self.version)["data"],
                "matchingUri": f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/200/ChuniServlet/",
                "matchingUriX": f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/200/ChuniServlet/",
+                # might be really important for online battle to connect the cabs via UDP port 50201
                "udpHolePunchUri": f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/200/ChuniServlet/",
                "reflectorUri": f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/200/ChuniServlet/",
            },
-            "isDumpUpload": "false",
-            "isAou": "false",
+            "isDumpUpload": False,
+            "isAou": False,
        }

    def handle_remove_token_api_request(self, data: Dict) -> Dict:
@ -468,3 +471,162 @@ class ChuniNew(ChuniBase):
            self.data.item.put_user_print_state(user_id, id=order_id, hasCompleted=True)

        return {"returnCode": "1", "apiName": "CMUpsertUserPrintCancelApi"}
+
+    def handle_ping_request(self, data: Dict) -> Dict:
+        # matchmaking ping request
+        return {"returnCode": "1"}
+
+    def handle_begin_matching_api_request(self, data: Dict) -> Dict:
+        room_id = 1
+        # check if there is a free matching room
+        matching_room = self.data.item.get_oldest_free_matching(self.version)
+
+        if matching_room is None:
+            # grab the latest roomId and add 1 for the new room
+            newest_matching = self.data.item.get_newest_matching(self.version)
+            if newest_matching is not None:
+                room_id = newest_matching["roomId"] + 1
+
+            # fix userName WTF8
+            new_member = data["matchingMemberInfo"]
+            new_member["userName"] = self.read_wtf8(new_member["userName"])
+
+            # create the new room with room_id and the current user id (host)
+            # user id is required for the countdown later on
+            self.data.item.put_matching(
+                self.version, room_id, [new_member], user_id=new_member["userId"]
+            )
+
+            # get the newly created matching room
+            matching_room = self.data.item.get_matching(self.version, room_id)
+        else:
+            # a room already exists, so just add the new member to it
+            matching_member_list = matching_room["matchingMemberInfoList"]
+            # fix userName WTF8
+            new_member = data["matchingMemberInfo"]
+            new_member["userName"] = self.read_wtf8(new_member["userName"])
+            matching_member_list.append(new_member)
+
+            # add the updated room to the database, make sure to set isFull correctly!
+            self.data.item.put_matching(
+                self.version,
+                matching_room["roomId"],
+                matching_member_list,
+                user_id=matching_room["user"],
+                is_full=True if len(matching_member_list) >= 4 else False,
+            )
+
+        matching_wait = {
+            "isFinish": False,
+            "restMSec": matching_room["restMSec"],  # in sec
+            "pollingInterval": 1,  # in sec
+            "matchingMemberInfoList": matching_room["matchingMemberInfoList"],
+        }
+
+        return {"roomId": 1, "matchingWaitState": matching_wait}
+
+    def handle_end_matching_api_request(self, data: Dict) -> Dict:
+        matching_room = self.data.item.get_matching(self.version, data["roomId"])
+        members = matching_room["matchingMemberInfoList"]
+
+        # only set the host user to role 1 every other to 0?
+        role_list = [
+            {"role": 1} if m["userId"] == matching_room["user"] else {"role": 0}
+            for m in members
+        ]
+
+        self.data.item.put_matching(
+            self.version,
+            matching_room["roomId"],
+            members,
+            user_id=matching_room["user"],
+            rest_sec=0,  # make sure to always set 0
+            is_full=True,  # and full, so no one can join
+        )
+
+        return {
+            "matchingResult": 1,  # needs to be 1 for successful matching
+            "matchingMemberInfoList": members,
+            # no idea, maybe to differentiate between CPUs and real players?
+            "matchingMemberRoleList": role_list,
+            # TCP/UDP connection?
+            "reflectorUri": f"{self.core_cfg.title.hostname}",
+        }
+
+    def handle_remove_matching_member_api_request(self, data: Dict) -> Dict:
+        # get all matching rooms, because Chuni only returns the userId
+        # not the actual roomId
+        matching_rooms = self.data.item.get_all_matchings(self.version)
+        if matching_rooms is None:
+            return {"returnCode": "1"}
+
+        for room in matching_rooms:
+            old_members = room["matchingMemberInfoList"]
+            new_members = [m for m in old_members if m["userId"] != data["userId"]]
+
+            # if nothing changed go to the next room
+            if len(old_members) == len(new_members):
+                continue
+
+            # if the last user got removed, delete the matching room
+            if len(new_members) <= 0:
+                self.data.item.delete_matching(self.version, room["roomId"])
+            else:
+                # remove the user from the room
+                self.data.item.put_matching(
+                    self.version,
+                    room["roomId"],
+                    new_members,
+                    user_id=room["user"],
+                    rest_sec=room["restMSec"],
+                )
+
+        return {"returnCode": "1"}
+
+    def handle_get_matching_state_api_request(self, data: Dict) -> Dict:
+        polling_interval = 1
+        # get the current active room
+        matching_room = self.data.item.get_matching(self.version, data["roomId"])
+        members = matching_room["matchingMemberInfoList"]
+        rest_sec = matching_room["restMSec"]
+
+        # grab the current member
+        current_member = data["matchingMemberInfo"]
+
+        # only the host user can decrease the countdown
+        if matching_room["user"] == int(current_member["userId"]):
+            # cap the restMSec to 0
+            if rest_sec > 0:
+                rest_sec -= polling_interval
+            else:
+                rest_sec = 0
+
+        # update the members in order to recieve messages
+        for i, member in enumerate(members):
+            if member["userId"] == current_member["userId"]:
+                # replace the old user data with the current user data,
+                # also parse WTF-8 everytime
+                current_member["userName"] = self.read_wtf8(current_member["userName"])
+                members[i] = current_member
+
+        self.data.item.put_matching(
+            self.version,
+            data["roomId"],
+            members,
+            rest_sec=rest_sec,
+            user_id=matching_room["user"],
+        )
+
+        # only add the other members to the list
+        diff_members = [m for m in members if m["userId"] != current_member["userId"]]
+
+        matching_wait = {
+            # makes no difference? Always use False?
+            "isFinish": True if rest_sec == 0 else False,
+            "restMSec": rest_sec,
+            "pollingInterval": polling_interval,
+            # the current user needs to be the first one?
+            "matchingMemberInfoList": [current_member] + diff_members,
+        }
+
+        return {"matchingWaitState": matching_wait}
--- a/titles/chuni/newplus.py
+++ b/titles/chuni/newplus.py
@ -36,6 +36,6 @@ class ChuniNewPlus(ChuniNew):
    def handle_cm_get_user_preview_api_request(self, data: Dict) -> Dict:
        user_data = super().handle_cm_get_user_preview_api_request(data)

-        # hardcode lastDataVersion for CardMaker 1.35
+        # hardcode lastDataVersion for CardMaker 1.35 A028
        user_data["lastDataVersion"] = "2.05.00"
        return user_data
--- a/titles/chuni/schema/item.py
+++ b/titles/chuni/schema/item.py
@ -1,5 +1,12 @@
 from typing import Dict, List, Optional
-from sqlalchemy import Table, Column, UniqueConstraint, PrimaryKeyConstraint, and_
+from sqlalchemy import (
+    Table,
+    Column,
+    UniqueConstraint,
+    PrimaryKeyConstraint,
+    and_,
+    delete,
+)
 from sqlalchemy.types import Integer, String, TIMESTAMP, Boolean, JSON
 from sqlalchemy.engine.base import Connection
 from sqlalchemy.schema import ForeignKey
@ -203,8 +210,141 @@ login_bonus = Table(
    mysql_charset="utf8mb4",
 )

+favorite = Table(
+    "chuni_item_favorite",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("version", Integer, nullable=False),
+    Column("favId", Integer, nullable=False),
+    Column("favKind", Integer, nullable=False, server_default="1"),
+    UniqueConstraint("version", "user", "favId", name="chuni_item_favorite_uk"),
+    mysql_charset="utf8mb4",
+)
+
+matching = Table(
+    "chuni_item_matching",
+    metadata,
+    Column("roomId", Integer, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("version", Integer, nullable=False),
+    Column("restMSec", Integer, nullable=False, server_default="60"),
+    Column("isFull", Boolean, nullable=False, server_default="0"),
+    PrimaryKeyConstraint("roomId", "version", name="chuni_item_matching_pk"),
+    Column("matchingMemberInfoList", JSON, nullable=False),
+    mysql_charset="utf8mb4",
+)
+

 class ChuniItemData(BaseData):
+    def get_oldest_free_matching(self, version: int) -> Optional[Row]:
+        sql = matching.select(
+            and_(
+                matching.c.version == version,
+                matching.c.isFull == False
+            )
+        ).order_by(matching.c.roomId.asc())
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def get_newest_matching(self, version: int) -> Optional[Row]:
+        sql = matching.select(
+            and_(
+                matching.c.version == version
+            )
+        ).order_by(matching.c.roomId.desc())
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def get_all_matchings(self, version: int) -> Optional[List[Row]]:
+        sql = matching.select(
+            and_(
+                matching.c.version == version
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def get_matching(self, version: int, room_id: int) -> Optional[Row]:
+        sql = matching.select(
+            and_(matching.c.version == version, matching.c.roomId == room_id)
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def put_matching(
+        self,
+        version: int,
+        room_id: int,
+        matching_member_info_list: list,
+        user_id: int = None,
+        rest_sec: int = 60,
+        is_full: bool = False
+    ) -> Optional[int]:
+        sql = insert(matching).values(
+            roomId=room_id,
+            version=version,
+            restMSec=rest_sec,
+            user=user_id,
+            isFull=is_full,
+            matchingMemberInfoList=matching_member_info_list,
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            restMSec=rest_sec, matchingMemberInfoList=matching_member_info_list
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            return None
+        return result.lastrowid
+
+    def delete_matching(self, version: int, room_id: int):
+        sql = delete(matching).where(
+            and_(matching.c.roomId == room_id, matching.c.version == version)
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.lastrowid
+
+    def get_all_favorites(
+        self, user_id: int, version: int, fav_kind: int = 1
+    ) -> Optional[List[Row]]:
+        sql = favorite.select(
+            and_(
+                favorite.c.version == version,
+                favorite.c.user == user_id,
+                favorite.c.favKind == fav_kind,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
    def put_login_bonus(
        self, user_id: int, version: int, preset_id: int, **login_bonus_data
    ) -> Optional[int]:
--- a/titles/chuni/schema/profile.py
+++ b/titles/chuni/schema/profile.py
@ -89,8 +89,6 @@ profile = Table(
        Integer,
        ForeignKey("chuni_profile_team.id", ondelete="SET NULL", onupdate="SET NULL"),
    ),
-    Column("avatarBack", Integer, server_default="0"),
-    Column("avatarFace", Integer, server_default="0"),
    Column("eliteRankPoint", Integer, server_default="0"),
    Column("stockedGridCount", Integer, server_default="0"),
    Column("netBattleLoseCount", Integer, server_default="0"),
@ -98,10 +96,8 @@ profile = Table(
    Column("netBattle4thCount", Integer, server_default="0"),
    Column("overPowerRate", Integer, server_default="0"),
    Column("battleRewardStatus", Integer, server_default="0"),
-    Column("avatarPoint", Integer, server_default="0"),
    Column("netBattle1stCount", Integer, server_default="0"),
    Column("charaIllustId", Integer, server_default="0"),
-    Column("avatarItem", Integer, server_default="0"),
    Column("userNameEx", String(8), server_default=""),
    Column("netBattleWinCount", Integer, server_default="0"),
    Column("netBattleCorrection", Integer, server_default="0"),
@ -112,7 +108,6 @@ profile = Table(
    Column("netBattle3rdCount", Integer, server_default="0"),
    Column("netBattleConsecutiveWinCount", Integer, server_default="0"),
    Column("overPowerLowerRank", Integer, server_default="0"),
-    Column("avatarWear", Integer, server_default="0"),
    Column("classEmblemBase", Integer, server_default="0"),
    Column("battleRankPoint", Integer, server_default="0"),
    Column("netBattle2ndCount", Integer, server_default="0"),
@ -120,13 +115,19 @@ profile = Table(
    Column("skillId", Integer, server_default="0"),
    Column("lastCountryCode", String(5), server_default="JPN"),
    Column("isNetBattleHost", Boolean, server_default="0"),
-    Column("avatarFront", Integer, server_default="0"),
-    Column("avatarSkin", Integer, server_default="0"),
    Column("battleRewardCount", Integer, server_default="0"),
    Column("battleRewardIndex", Integer, server_default="0"),
    Column("netBattlePlayCount", Integer, server_default="0"),
    Column("exMapLoopCount", Integer, server_default="0"),
    Column("netBattleEndState", Integer, server_default="0"),
+    Column("rankUpChallengeResults", JSON),
+    Column("avatarBack", Integer, server_default="0"),
+    Column("avatarFace", Integer, server_default="0"),
+    Column("avatarPoint", Integer, server_default="0"),
+    Column("avatarItem", Integer, server_default="0"),
+    Column("avatarWear", Integer, server_default="0"),
+    Column("avatarFront", Integer, server_default="0"),
+    Column("avatarSkin", Integer, server_default="0"),
    Column("avatarHead", Integer, server_default="0"),
    UniqueConstraint("user", "version", name="chuni_profile_profile_uk"),
    mysql_charset="utf8mb4",
@ -417,8 +418,8 @@ class ChuniProfileData(BaseData):
        sql = (
            select([profile, option])
            .join(option, profile.c.user == option.c.user)
-            .filter(and_(profile.c.user == aime_id, profile.c.version == version))
-        )
+            .filter(and_(profile.c.user == aime_id, profile.c.version <= version))
+        ).order_by(profile.c.version.desc())

        result = self.execute(sql)
        if result is None:
@ -429,9 +430,9 @@ class ChuniProfileData(BaseData):
        sql = select(profile).where(
            and_(
                profile.c.user == aime_id,
-                profile.c.version == version,
+                profile.c.version <= version,
            )
-        )
+        ).order_by(profile.c.version.desc())

        result = self.execute(sql)
        if result is None:
@ -461,9 +462,9 @@ class ChuniProfileData(BaseData):
        sql = select(profile_ex).where(
            and_(
                profile_ex.c.user == aime_id,
-                profile_ex.c.version == version,
+                profile_ex.c.version <= version,
            )
-        )
+        ).order_by(profile_ex.c.version.desc())

        result = self.execute(sql)
        if result is None:
--- a/titles/chuni/schema/score.py
+++ b/titles/chuni/schema/score.py
@ -134,7 +134,9 @@ playlog = Table(
    Column("charaIllustId", Integer),
    Column("romVersion", String(255)),
    Column("judgeHeaven", Integer),
-    mysql_charset="utf8mb4",
+    Column("regionId", Integer),
+    Column("machineType", Integer),
+    mysql_charset="utf8mb4"
 )


--- a/titles/chuni/schema/static.py
+++ b/titles/chuni/schema/static.py
@ -1,11 +1,19 @@
 from typing import Dict, List, Optional
-from sqlalchemy import Table, Column, UniqueConstraint, PrimaryKeyConstraint, and_
+from sqlalchemy import (
+    ForeignKeyConstraint,
+    Table,
+    Column,
+    UniqueConstraint,
+    PrimaryKeyConstraint,
+    and_,
+)
 from sqlalchemy.types import Integer, String, TIMESTAMP, Boolean, JSON, Float
 from sqlalchemy.engine.base import Connection
 from sqlalchemy.engine import Row
 from sqlalchemy.schema import ForeignKey
 from sqlalchemy.sql import func, select
 from sqlalchemy.dialects.mysql import insert
+from datetime import datetime

 from core.data.schema import BaseData, metadata

@ -17,6 +25,7 @@ events = Table(
    Column("eventId", Integer),
    Column("type", Integer),
    Column("name", String(255)),
+    Column("startDate", TIMESTAMP, server_default=func.now()),
    Column("enabled", Boolean, server_default="1"),
    UniqueConstraint("version", "eventId", name="chuni_static_events_uk"),
    mysql_charset="utf8mb4",
@ -125,11 +134,13 @@ gacha_cards = Table(
 login_bonus_preset = Table(
    "chuni_static_login_bonus_preset",
    metadata,
-    Column("id", Integer, primary_key=True, nullable=False),
+    Column("presetId", Integer, nullable=False),
    Column("version", Integer, nullable=False),
    Column("presetName", String(255), nullable=False),
    Column("isEnabled", Boolean, server_default="1"),
-    UniqueConstraint("version", "id", name="chuni_static_login_bonus_preset_uk"),
+    PrimaryKeyConstraint(
+        "presetId", "version", name="chuni_static_login_bonus_preset_pk"
+    ),
    mysql_charset="utf8mb4",
 )

@ -138,15 +149,7 @@ login_bonus = Table(
    metadata,
    Column("id", Integer, primary_key=True, nullable=False),
    Column("version", Integer, nullable=False),
-    Column(
-        "presetId",
-        ForeignKey(
-            "chuni_static_login_bonus_preset.id",
-            ondelete="cascade",
-            onupdate="cascade",
-        ),
-        nullable=False,
-    ),
+    Column("presetId", Integer, nullable=False),
    Column("loginBonusId", Integer, nullable=False),
    Column("loginBonusName", String(255), nullable=False),
    Column("presentId", Integer, nullable=False),
@ -157,6 +160,16 @@ login_bonus = Table(
    UniqueConstraint(
        "version", "presetId", "loginBonusId", name="chuni_static_login_bonus_uk"
    ),
+    ForeignKeyConstraint(
+        ["presetId", "version"],
+        [
+            "chuni_static_login_bonus_preset.presetId",
+            "chuni_static_login_bonus_preset.version",
+        ],
+        onupdate="CASCADE",
+        ondelete="CASCADE",
+        name="chuni_static_login_bonus_ibfk_1",
+    ),
    mysql_charset="utf8mb4",
 )

@ -236,7 +249,7 @@ class ChuniStaticData(BaseData):
        self, version: int, preset_id: int, preset_name: str, is_enabled: bool
    ) -> Optional[int]:
        sql = insert(login_bonus_preset).values(
-            id=preset_id,
+            presetId=preset_id,
            version=version,
            presetName=preset_name,
            isEnabled=is_enabled,
@ -416,6 +429,14 @@ class ChuniStaticData(BaseData):
            return None
        return result.fetchall()

+    def get_music(self, version: int) -> Optional[List[Row]]:
+        sql = music.select(music.c.version <= version)
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
    def get_music_chart(
        self, version: int, song_id: int, chart_id: int
    ) -> Optional[List[Row]]:
--- a/titles/chuni/sun.py
+++ b/titles/chuni/sun.py
@ -0,0 +1,37 @@
+from typing import Dict, Any
+
+from core.config import CoreConfig
+from titles.chuni.newplus import ChuniNewPlus
+from titles.chuni.const import ChuniConstants
+from titles.chuni.config import ChuniConfig
+
+
+class ChuniSun(ChuniNewPlus):
+    def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
+        super().__init__(core_cfg, game_cfg)
+        self.version = ChuniConstants.VER_CHUNITHM_SUN
+
+    def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
+        ret = super().handle_get_game_setting_api_request(data)
+        ret["gameSetting"]["romVersion"] = self.game_cfg.version.version(self.version)["rom"]
+        ret["gameSetting"]["dataVersion"] = self.game_cfg.version.version(self.version)["data"]
+        ret["gameSetting"][
+            "matchingUri"
+        ] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/210/ChuniServlet/"
+        ret["gameSetting"][
+            "matchingUriX"
+        ] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/210/ChuniServlet/"
+        ret["gameSetting"][
+            "udpHolePunchUri"
+        ] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/210/ChuniServlet/"
+        ret["gameSetting"][
+            "reflectorUri"
+        ] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/210/ChuniServlet/"
+        return ret
+
+    def handle_cm_get_user_preview_api_request(self, data: Dict) -> Dict:
+        user_data = super().handle_cm_get_user_preview_api_request(data)
+
+        # hardcode lastDataVersion for CardMaker 1.35 A032
+        user_data["lastDataVersion"] = "2.10.00"
+        return user_data
--- a/titles/cm/base.py
+++ b/titles/cm/base.py
@ -23,19 +23,40 @@ class CardMakerBase:
        self.game = CardMakerConstants.GAME_CODE
        self.version = CardMakerConstants.VER_CARD_MAKER

+    @staticmethod
+    def _parse_int_ver(version: str) -> str:
+        return version.replace(".", "")[:3]
+
    def handle_get_game_connect_api_request(self, data: Dict) -> Dict:
        if self.core_cfg.server.is_develop:
            uri = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}"
        else:
            uri = f"http://{self.core_cfg.title.hostname}"

-        # CHUNITHM = 0, maimai = 1, ONGEKI = 2
+        # grab the dict with all games version numbers from user config
+        games_ver = self.game_cfg.version.version(self.version)
+
        return {
            "length": 3,
            "gameConnectList": [
-                {"modelKind": 0, "type": 1, "titleUri": f"{uri}/SDHD/200/"},
-                {"modelKind": 1, "type": 1, "titleUri": f"{uri}/SDEZ/120/"},
-                {"modelKind": 2, "type": 1, "titleUri": f"{uri}/SDDT/130/"},
+                # CHUNITHM
+                {
+                    "modelKind": 0,
+                    "type": 1,
+                    "titleUri": f"{uri}/SDHD/{self._parse_int_ver(games_ver['chuni'])}/",
+                },
+                # maimai DX
+                {
+                    "modelKind": 1,
+                    "type": 1,
+                    "titleUri": f"{uri}/SDEZ/{self._parse_int_ver(games_ver['maimai'])}/",
+                },
+                # ONGEKI
+                {
+                    "modelKind": 2,
+                    "type": 1,
+                    "titleUri": f"{uri}/SDDT/{self._parse_int_ver(games_ver['ongeki'])}/",
+                },
            ],
        }

@ -47,12 +68,15 @@ class CardMakerBase:
            datetime.now() + timedelta(hours=4), self.date_time_format
        )

+        # grab the dict with all games version numbers from user config
+        games_ver = self.game_cfg.version.version(self.version)
+
        return {
            "gameSetting": {
                "dataVersion": "1.30.00",
-                "ongekiCmVersion": "1.30.01",
-                "chuniCmVersion": "2.00.00",
-                "maimaiCmVersion": "1.20.00",
+                "ongekiCmVersion": games_ver["ongeki"],
+                "chuniCmVersion": games_ver["chuni"],
+                "maimaiCmVersion": games_ver["maimai"],
                "requestInterval": 10,
                "rebootStartTime": reboot_start,
                "rebootEndTime": reboot_end,
--- a/titles/cm/cm135.py
+++ b/titles/cm/cm135.py
@ -1,8 +1,4 @@
-from datetime import date, datetime, timedelta
-from typing import Any, Dict, List
-import json
-import logging
-from enum import Enum
+from typing import Dict

 from core.config import CoreConfig
 from core.data.cache import cached
@ -16,23 +12,7 @@ class CardMaker135(CardMakerBase):
        super().__init__(core_cfg, game_cfg)
        self.version = CardMakerConstants.VER_CARD_MAKER_135

-    def handle_get_game_connect_api_request(self, data: Dict) -> Dict:
-        ret = super().handle_get_game_connect_api_request(data)
-        if self.core_cfg.server.is_develop:
-            uri = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}"
-        else:
-            uri = f"http://{self.core_cfg.title.hostname}"
-
-        ret["gameConnectList"][0]["titleUri"] = f"{uri}/SDHD/205/"
-        ret["gameConnectList"][1]["titleUri"] = f"{uri}/SDEZ/125/"
-        ret["gameConnectList"][2]["titleUri"] = f"{uri}/SDDT/135/"
-
-        return ret
-
    def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
        ret = super().handle_get_game_setting_api_request(data)
        ret["gameSetting"]["dataVersion"] = "1.35.00"
-        ret["gameSetting"]["ongekiCmVersion"] = "1.35.03"
-        ret["gameSetting"]["chuniCmVersion"] = "2.05.00"
-        ret["gameSetting"]["maimaiCmVersion"] = "1.25.00"
        return ret
--- a/titles/cm/config.py
+++ b/titles/cm/config.py
@ -1,3 +1,4 @@
+from typing import Dict
 from core.config import CoreConfig


@ -20,6 +21,21 @@ class CardMakerServerConfig:
        )


+class CardMakerVersionConfig:
+    def __init__(self, parent_config: "CardMakerConfig") -> None:
+        self.__config = parent_config
+
+    def version(self, version: int) -> Dict:
+        """
+        in the form of:
+        1: {"ongeki": 1.30.01, "chuni": 2.00.00, "maimai": 1.20.00}
+        """
+        return CoreConfig.get_config_field(
+            self.__config, "cardmaker", "version", default={}
+        )[version]
+
+
 class CardMakerConfig(dict):
    def __init__(self) -> None:
        self.server = CardMakerServerConfig(self)
+        self.version = CardMakerVersionConfig(self)
--- a/titles/cm/const.py
+++ b/titles/cm/const.py
@ -6,7 +6,7 @@ class CardMakerConstants:
    VER_CARD_MAKER = 0
    VER_CARD_MAKER_135 = 1

-    VERSION_NAMES = ("Card Maker 1.34", "Card Maker 1.35")
+    VERSION_NAMES = ("Card Maker 1.30", "Card Maker 1.35")

    @classmethod
    def game_ver_to_string(cls, ver: int):
--- a/titles/cm/index.py
+++ b/titles/cm/index.py
@ -30,7 +30,7 @@ class CardMakerServlet:

        self.versions = [
            CardMakerBase(core_cfg, self.game_cfg),
-            CardMaker135(core_cfg, self.game_cfg),
+            CardMaker135(core_cfg, self.game_cfg)
        ]

        self.logger = logging.getLogger("cardmaker")
@ -89,7 +89,7 @@ class CardMakerServlet:

        if version >= 130 and version < 135:  # Card Maker
            internal_ver = CardMakerConstants.VER_CARD_MAKER
-        elif version >= 135 and version < 136:  # Card Maker 1.35
+        elif version >= 135 and version < 140:  # Card Maker 1.35
            internal_ver = CardMakerConstants.VER_CARD_MAKER_135

        if all(c in string.hexdigits for c in endpoint) and len(endpoint) == 32:
--- a/titles/cxb/index.py
+++ b/titles/cxb/index.py
@ -103,7 +103,7 @@ class CxbServlet(resource.Resource):
            else:
                self.logger.info(f"Ready on port {self.game_cfg.server.port}")

-    def render_POST(self, request: Request):
+    def render_POST(self, request: Request, version: int, endpoint: str):
        version = 0
        internal_ver = 0
        func_to_find = ""
--- a/titles/idz/userdb.py
+++ b/titles/idz/userdb.py
@ -83,7 +83,13 @@ class IDZUserDBProtocol(Protocol):
    def dataReceived(self, data: bytes) -> None:
        self.logger.debug(f"Receive data {data.hex()}")
        crypt = AES.new(self.static_key, AES.MODE_ECB)
-        data_dec = crypt.decrypt(data)
+        
+        try:
+            data_dec = crypt.decrypt(data)
+        
+        except Exception as e:
+            self.logger.error(f"Failed to decrypt UserDB request from {self.transport.getPeer().host} because {e} - {data.hex()}")
+        
        self.logger.debug(f"Decrypt data {data_dec.hex()}")

        magic = struct.unpack_from("<I", data_dec, 0)[0]
--- a/titles/mai2/init.py
+++ b/titles/mai2/init.py
@ -16,4 +16,4 @@ game_codes = [
    Mai2Constants.GAME_CODE_GREEN,
    Mai2Constants.GAME_CODE,
 ]
-current_schema_version = 4
+current_schema_version = 5
--- a/titles/mai2/base.py
+++ b/titles/mai2/base.py
@ -632,21 +632,38 @@ class Mai2Base:
        return {"userId": data["userId"], "length": 0, "userRegionList": []}

    def handle_get_user_music_api_request(self, data: Dict) -> Dict:
-        songs = self.data.score.get_best_scores(data["userId"])
+        user_id = data.get("userId", 0)        
+        next_index = data.get("nextIndex", 0)
+        max_ct = data.get("maxCount", 50)
+        upper_lim = next_index + max_ct
        music_detail_list = []
-        next_index = 0

-        if songs is not None:
-            for song in songs:
-                tmp = song._asdict()
-                tmp.pop("id")
-                tmp.pop("user")
-                music_detail_list.append(tmp)
+        if user_id <= 0:
+            self.logger.warn("handle_get_user_music_api_request: Could not find userid in data, or userId is 0")
+            return {}
+        
+        songs = self.data.score.get_best_scores(user_id)
+        if songs is None:
+            self.logger.debug("handle_get_user_music_api_request: get_best_scores returned None!")
+            return {
+            "userId": data["userId"],
+            "nextIndex": 0,
+            "userMusicList": [],
+        }

-                if len(music_detail_list) == data["maxCount"]:
-                    next_index = data["maxCount"] + data["nextIndex"]
-                    break
+        num_user_songs = len(songs)

+        for x in range(next_index, upper_lim):
+            if num_user_songs <= x:
+                break
+
+            tmp = songs[x]._asdict()
+            tmp.pop("id")
+            tmp.pop("user")
+            music_detail_list.append(tmp)
+
+        next_index = 0 if len(music_detail_list) < max_ct or num_user_songs == upper_lim else upper_lim
+        self.logger.info(f"Send songs {next_index}-{upper_lim} ({len(music_detail_list)}) out of {num_user_songs} for user {user_id} (next idx {next_index})")
        return {
            "userId": data["userId"],
            "nextIndex": next_index,
--- a/titles/mai2/const.py
+++ b/titles/mai2/const.py
@ -71,9 +71,9 @@ class Mai2Constants:
        "maimai DX PLUS",
        "maimai DX Splash",
        "maimai DX Splash PLUS",
-        "maimai DX Universe",
-        "maimai DX Universe PLUS",
-        "maimai DX Festival",
+        "maimai DX UNiVERSE",
+        "maimai DX UNiVERSE PLUS",
+        "maimai DX FESTiVAL",
    )

    @classmethod
--- a/titles/mai2/schema/item.py
+++ b/titles/mai2/schema/item.py
@ -39,8 +39,8 @@ card = Table(
    Column("cardTypeId", Integer, nullable=False),
    Column("charaId", Integer, nullable=False),
    Column("mapId", Integer, nullable=False),
-    Column("startDate", TIMESTAMP, server_default="2018-01-01 00:00:00.0"),
-    Column("endDate", TIMESTAMP, server_default="2038-01-01 00:00:00.0"),
+    Column("startDate", TIMESTAMP, nullable=False, server_default=func.now()),
+    Column("endDate", TIMESTAMP, nullable=False),
    UniqueConstraint("user", "cardId", "cardTypeId", name="mai2_item_card_uk"),
    mysql_charset="utf8mb4",
 )
@ -444,6 +444,8 @@ class Mai2ItemData(BaseData):
        card_kind: int,
        chara_id: int,
        map_id: int,
+        start_date: datetime,
+        end_date: datetime,
    ) -> Optional[Row]:
        sql = insert(card).values(
            user=user_id,
@ -451,9 +453,13 @@ class Mai2ItemData(BaseData):
            cardTypeId=card_kind,
            charaId=chara_id,
            mapId=map_id,
+            startDate=start_date,
+            endDate=end_date,
        )

-        conflict = sql.on_duplicate_key_update(charaId=chara_id, mapId=map_id)
+        conflict = sql.on_duplicate_key_update(
+            charaId=chara_id, mapId=map_id, startDate=start_date, endDate=end_date
+        )

        result = self.execute(conflict)
        if result is None:
--- a/titles/mai2/schema/score.py
+++ b/titles/mai2/schema/score.py
@ -7,6 +7,7 @@ from sqlalchemy.engine import Row
 from sqlalchemy.dialects.mysql import insert

 from core.data.schema import BaseData, metadata
+from core.data import cached

 best_score = Table(
    "mai2_score_best",
@ -190,6 +191,7 @@ class Mai2ScoreData(BaseData):
            return None
        return result.lastrowid

+    @cached(2)
    def get_best_scores(self, user_id: int, song_id: int = None) -> Optional[List[Row]]:
        sql = best_score.select(
            and_(
--- a/titles/mai2/universe.py
+++ b/titles/mai2/universe.py
@ -14,3 +14,202 @@ class Mai2Universe(Mai2DX):
    def __init__(self, cfg: CoreConfig, game_cfg: Mai2Config) -> None:
        super().__init__(cfg, game_cfg)
        self.version = Mai2Constants.VER_MAIMAI_DX_UNIVERSE
+
+    def handle_cm_get_user_preview_api_request(self, data: Dict) -> Dict:
+        p = self.data.profile.get_profile_detail(data["userId"], self.version)
+        if p is None:
+            return {}
+
+        return {
+            "userName": p["userName"],
+            "rating": p["playerRating"],
+            # hardcode lastDataVersion for CardMaker 1.34
+            "lastDataVersion": "1.20.00",
+            "isLogin": False,
+            "isExistSellingCard": False,
+        }
+
+    def handle_cm_get_user_data_api_request(self, data: Dict) -> Dict:
+        # user already exists, because the preview checks that already
+        p = self.data.profile.get_profile_detail(data["userId"], self.version)
+
+        cards = self.data.card.get_user_cards(data["userId"])
+        if cards is None or len(cards) == 0:
+            # This should never happen
+            self.logger.error(
+                f"handle_get_user_data_api_request: Internal error - No cards found for user id {data['userId']}"
+            )
+            return {}
+
+        # get the dict representation of the row so we can modify values
+        user_data = p._asdict()
+
+        # remove the values the game doesn't want
+        user_data.pop("id")
+        user_data.pop("user")
+        user_data.pop("version")
+
+        return {"userId": data["userId"], "userData": user_data}
+
+    def handle_cm_login_api_request(self, data: Dict) -> Dict:
+        return {"returnCode": 1}
+
+    def handle_cm_logout_api_request(self, data: Dict) -> Dict:
+        return {"returnCode": 1}
+
+    def handle_cm_get_selling_card_api_request(self, data: Dict) -> Dict:
+        selling_cards = self.data.static.get_enabled_cards(self.version)
+        if selling_cards is None:
+            return {"length": 0, "sellingCardList": []}
+
+        selling_card_list = []
+        for card in selling_cards:
+            tmp = card._asdict()
+            tmp.pop("id")
+            tmp.pop("version")
+            tmp.pop("cardName")
+            tmp.pop("enabled")
+
+            tmp["startDate"] = datetime.strftime(tmp["startDate"], "%Y-%m-%d %H:%M:%S")
+            tmp["endDate"] = datetime.strftime(tmp["endDate"], "%Y-%m-%d %H:%M:%S")
+            tmp["noticeStartDate"] = datetime.strftime(
+                tmp["noticeStartDate"], "%Y-%m-%d %H:%M:%S"
+            )
+            tmp["noticeEndDate"] = datetime.strftime(
+                tmp["noticeEndDate"], "%Y-%m-%d %H:%M:%S"
+            )
+
+            selling_card_list.append(tmp)
+
+        return {"length": len(selling_card_list), "sellingCardList": selling_card_list}
+
+    def handle_cm_get_user_card_api_request(self, data: Dict) -> Dict:
+        user_cards = self.data.item.get_cards(data["userId"])
+        if user_cards is None:
+            return {"returnCode": 1, "length": 0, "nextIndex": 0, "userCardList": []}
+
+        max_ct = data["maxCount"]
+        next_idx = data["nextIndex"]
+        start_idx = next_idx
+        end_idx = max_ct + start_idx
+
+        if len(user_cards[start_idx:]) > max_ct:
+            next_idx += max_ct
+        else:
+            next_idx = 0
+
+        card_list = []
+        for card in user_cards:
+            tmp = card._asdict()
+            tmp.pop("id")
+            tmp.pop("user")
+
+            tmp["startDate"] = datetime.strftime(
+                tmp["startDate"], Mai2Constants.DATE_TIME_FORMAT
+            )
+            tmp["endDate"] = datetime.strftime(
+                tmp["endDate"], Mai2Constants.DATE_TIME_FORMAT
+            )
+            card_list.append(tmp)
+
+        return {
+            "returnCode": 1,
+            "length": len(card_list[start_idx:end_idx]),
+            "nextIndex": next_idx,
+            "userCardList": card_list[start_idx:end_idx],
+        }
+
+    def handle_cm_get_user_item_api_request(self, data: Dict) -> Dict:
+        super().handle_get_user_item_api_request(data)
+
+    def handle_cm_get_user_character_api_request(self, data: Dict) -> Dict:
+        characters = self.data.item.get_characters(data["userId"])
+
+        chara_list = []
+        for chara in characters:
+            chara_list.append(
+                {
+                    "characterId": chara["characterId"],
+                    # no clue why those values are even needed
+                    "point": 0,
+                    "count": 0,
+                    "level": chara["level"],
+                    "nextAwake": 0,
+                    "nextAwakePercent": 0,
+                    "favorite": False,
+                    "awakening": chara["awakening"],
+                    "useCount": chara["useCount"],
+                }
+            )
+
+        return {
+            "returnCode": 1,
+            "length": len(chara_list),
+            "userCharacterList": chara_list,
+        }
+
+    def handle_cm_get_user_card_print_error_api_request(self, data: Dict) -> Dict:
+        return {"length": 0, "userPrintDetailList": []}
+
+    def handle_cm_upsert_user_print_api_request(self, data: Dict) -> Dict:
+        user_id = data["userId"]
+        upsert = data["userPrintDetail"]
+
+        # set a random card serial number
+        serial_id = "".join([str(randint(0, 9)) for _ in range(20)])
+
+        # calculate start and end date of the card
+        start_date = datetime.utcnow()
+        end_date = datetime.utcnow() + timedelta(days=15)
+
+        user_card = upsert["userCard"]
+        self.data.item.put_card(
+            user_id,
+            user_card["cardId"],
+            user_card["cardTypeId"],
+            user_card["charaId"],
+            user_card["mapId"],
+            # add the correct start date and also the end date in 15 days
+            start_date,
+            end_date,
+        )
+
+        # get the profile extend to save the new bought card
+        extend = self.data.profile.get_profile_extend(user_id, self.version)
+        if extend:
+            extend = extend._asdict()
+            # parse the selectedCardList
+            # 6 = Freedom Pass, 4 = Gold Pass (cardTypeId)
+            selected_cards: list = extend["selectedCardList"]
+
+            # if no pass is already added, add the corresponding pass
+            if not user_card["cardTypeId"] in selected_cards:
+                selected_cards.insert(0, user_card["cardTypeId"])
+
+            extend["selectedCardList"] = selected_cards
+            self.data.profile.put_profile_extend(user_id, self.version, extend)
+
+        # properly format userPrintDetail for the database
+        upsert.pop("userCard")
+        upsert.pop("serialId")
+        upsert["printDate"] = datetime.strptime(upsert["printDate"], "%Y-%m-%d")
+
+        self.data.item.put_user_print_detail(user_id, serial_id, upsert)
+
+        return {
+            "returnCode": 1,
+            "orderId": 0,
+            "serialId": serial_id,
+            "startDate": datetime.strftime(start_date, Mai2Constants.DATE_TIME_FORMAT),
+            "endDate": datetime.strftime(end_date, Mai2Constants.DATE_TIME_FORMAT),
+        }
+
+    def handle_cm_upsert_user_printlog_api_request(self, data: Dict) -> Dict:
+        return {
+            "returnCode": 1,
+            "orderId": 0,
+            "serialId": data["userPrintlog"]["serialId"],
+        }
+
+    def handle_cm_upsert_buy_card_api_request(self, data: Dict) -> Dict:
+        return {"returnCode": 1}
--- a/titles/pokken/base.py
+++ b/titles/pokken/base.py
@ -1,6 +1,6 @@
 from datetime import datetime, timedelta
 import json, logging
-from typing import Any, Dict
+from typing import Any, Dict, List
 import random

 from core.data import Data
@ -44,19 +44,19 @@ class PokkenBase:
        biwa_setting = {
            "MatchingServer": {
                "host": f"https://{self.game_cfg.server.hostname}",
-                "port": self.game_cfg.server.port,
+                "port": self.game_cfg.ports.game,
                "url": "/SDAK/100/matching",
            },
            "StunServer": {
-                "addr": self.game_cfg.server.hostname,
-                "port": self.game_cfg.server.port_stun,
+                "addr": self.game_cfg.server.stun_server_host,
+                "port": self.game_cfg.server.stun_server_port,
            },
            "TurnServer": {
-                "addr": self.game_cfg.server.hostname,
-                "port": self.game_cfg.server.port_turn,
+                "addr": self.game_cfg.server.stun_server_host,
+                "port": self.game_cfg.server.stun_server_port,
            },
-            "AdmissionUrl": f"ws://{self.game_cfg.server.hostname}:{self.game_cfg.server.port_admission}",
-            "locationId": 123,
+            "AdmissionUrl": f"ws://{self.game_cfg.server.hostname}:{self.game_cfg.ports.admission}",
+            "locationId": 123, # FIXME: Get arcade's ID from the database
            "logfilename": "JackalMatchingLibrary.log",
            "biwalogfilename": "./biwa.log",
        }
@ -94,6 +94,7 @@ class PokkenBase:
        res.type = jackal_pb2.MessageType.LOAD_CLIENT_SETTINGS
        settings = jackal_pb2.LoadClientSettingsResponseData()

+        # TODO: Make configurable
        settings.money_magnification = 1
        settings.continue_bonus_exp = 100
        settings.continue_fight_money = 100
@ -274,6 +275,60 @@ class PokkenBase:
        res.result = 1
        res.type = jackal_pb2.MessageType.SAVE_USER

+        req = request.save_user
+        user_id = req.banapass_id
+        
+        tut_flgs: List[int] = []
+        ach_flgs: List[int] = []
+        evt_flgs: List[int] = []
+        evt_params: List[int] = []
+
+        get_rank_pts: int = req.get_trainer_rank_point if req.get_trainer_rank_point else 0
+        get_money: int = req.get_money
+        get_score_pts: int = req.get_score_point if req.get_score_point else 0
+        grade_max: int = req.grade_max_num
+        extra_counter: int = req.extra_counter
+        evt_reward_get_flg: int = req.event_reward_get_flag
+        num_continues: int = req.continue_num
+        total_play_days: int = req.total_play_days
+        awake_num: int = req.awake_num  # ?
+        use_support_ct: int = req.use_support_num
+        beat_num: int = req.beat_num # ?
+        evt_state: int = req.event_state
+        aid_skill: int = req.aid_skill
+        last_evt: int = req.last_play_event_id
+
+        battle = req.battle_data
+        mon = req.pokemon_data
+
+        self.data.profile.update_support_team(user_id, 1, req.support_set_1[0], req.support_set_1[1])
+        self.data.profile.update_support_team(user_id, 2, req.support_set_2[0], req.support_set_2[1])
+        self.data.profile.update_support_team(user_id, 3, req.support_set_3[0], req.support_set_3[1])
+
+        if req.trainer_name_pending: # we're saving for the first time
+            self.data.profile.set_profile_name(user_id, req.trainer_name_pending, req.avatar_gender if req.avatar_gender else None)
+
+        for tut_flg in req.tutorial_progress_flag:
+            tut_flgs.append(tut_flg)
+        
+        self.data.profile.update_profile_tutorial_flags(user_id, tut_flgs)
+
+        for ach_flg in req.achievement_flag:
+            ach_flgs.append(ach_flg)
+        
+        self.data.profile.update_profile_tutorial_flags(user_id, ach_flg)
+
+        for evt_flg in req.event_achievement_flag:
+            evt_flgs.append(evt_flg)
+
+        for evt_param in req.event_achievement_param:
+            evt_params.append(evt_param)
+
+        self.data.profile.update_profile_event(user_id, evt_state, evt_flgs, evt_params, )
+        
+        for reward in req.reward_data:
+            self.data.item.add_reward(user_id, reward.get_category_id, reward.get_content_id, reward.get_type_id)
+
        return res.SerializeToString()

    def handle_save_ingame_log(self, data: jackal_pb2.Request) -> bytes:
@ -302,16 +357,35 @@ class PokkenBase:
        self, data: Dict = {}, client_ip: str = "127.0.0.1"
    ) -> Dict:
        """
-        "sessionId":"12345678",
+                "sessionId":"12345678",
+                "A":{
+                    "pcb_id": data["data"]["must"]["pcb_id"],
+                    "gip": client_ip
+                },
+        """
+        return {
+            "data": {
+                "sessionId":"12345678",
                "A":{
                    "pcb_id": data["data"]["must"]["pcb_id"],
                    "gip": client_ip
                },
                "list":[]
-        """
-        return {}
+            }
+        }

    def handle_matching_stop_matching(
        self, data: Dict = {}, client_ip: str = "127.0.0.1"
    ) -> Dict:
        return {}
+
+    def handle_admission_noop(self, data: Dict, req_ip: str = "127.0.0.1") -> Dict:
+        return {}
+    
+    def handle_admission_joinsession(self, data: Dict, req_ip: str = "127.0.0.1") -> Dict:
+        self.logger.info(f"Admission: JoinSession from {req_ip}")
+        return {
+            'data': {
+                "id": 12345678
+            }
+        }
--- a/titles/pokken/config.py
+++ b/titles/pokken/config.py
@ -25,30 +25,6 @@ class PokkenServerConfig:
            )
        )

-    @property
-    def port(self) -> int:
-        return CoreConfig.get_config_field(
-            self.__config, "pokken", "server", "port", default=9000
-        )
-
-    @property
-    def port_stun(self) -> int:
-        return CoreConfig.get_config_field(
-            self.__config, "pokken", "server", "port_stun", default=9001
-        )
-
-    @property
-    def port_turn(self) -> int:
-        return CoreConfig.get_config_field(
-            self.__config, "pokken", "server", "port_turn", default=9002
-        )
-
-    @property
-    def port_admission(self) -> int:
-        return CoreConfig.get_config_field(
-            self.__config, "pokken", "server", "port_admission", default=9003
-        )
-
    @property
    def auto_register(self) -> bool:
        """
@ -59,7 +35,51 @@ class PokkenServerConfig:
            self.__config, "pokken", "server", "auto_register", default=True
        )

+    @property
+    def enable_matching(self) -> bool:
+        """
+        If global matching should happen
+        """
+        return CoreConfig.get_config_field(
+            self.__config, "pokken", "server", "enable_matching", default=False
+        )
+    
+    @property
+    def stun_server_host(self) -> str:
+        """
+        Hostname of the EXTERNAL stun server the game should connect to. This is not handled by artemis.
+        """
+        return CoreConfig.get_config_field(
+            self.__config, "pokken", "server", "stun_server_host", default="stunserver.stunprotocol.org"
+        )
+
+    @property
+    def stun_server_port(self) -> int:
+        """
+        Port of the EXTERNAL stun server the game should connect to. This is not handled by artemis.
+        """
+        return CoreConfig.get_config_field(
+            self.__config, "pokken", "server", "stun_server_port", default=3478
+        )
+
+class PokkenPortsConfig:
+    def __init__(self, parent_config: "PokkenConfig"):
+        self.__config = parent_config
+    
+    @property
+    def game(self) -> int:
+        return CoreConfig.get_config_field(
+            self.__config, "pokken", "ports", "game", default=9000
+        )
+
+    @property
+    def admission(self) -> int:
+        return CoreConfig.get_config_field(
+            self.__config, "pokken", "ports", "admission", default=9001
+        )
+    

 class PokkenConfig(dict):
    def __init__(self) -> None:
        self.server = PokkenServerConfig(self)
+        self.ports = PokkenPortsConfig(self)
--- a/titles/pokken/const.py
+++ b/titles/pokken/const.py
@ -11,14 +11,14 @@ class PokkenConstants:
    VERSION_NAMES = "Pokken Tournament"

    class BATTLE_TYPE(Enum):
-        BATTLE_TYPE_TUTORIAL = 1
-        BATTLE_TYPE_AI = 2
-        BATTLE_TYPE_LAN = 3
-        BATTLE_TYPE_WAN = 4
+        TUTORIAL = 1
+        AI = 2
+        LAN = 3
+        WAN = 4

    class BATTLE_RESULT(Enum):
-        BATTLE_RESULT_WIN = 1
-        BATTLE_RESULT_LOSS = 2
+        WIN = 1
+        LOSS = 2

    @classmethod
    def game_ver_to_string(cls, ver: int):
--- a/titles/pokken/frontend.py
+++ b/titles/pokken/frontend.py
@ -2,8 +2,9 @@ import yaml
 import jinja2
 from twisted.web.http import Request
 from os import path
+from twisted.web.server import Session

-from core.frontend import FE_Base
+from core.frontend import FE_Base, IUserSession
 from core.config import CoreConfig
 from .database import PokkenData
 from .config import PokkenConfig
@ -27,7 +28,12 @@ class PokkenFrontend(FE_Base):
        template = self.environment.get_template(
            "titles/pokken/frontend/pokken_index.jinja"
        )
+
+        sesh: Session = request.getSession()
+        usr_sesh = IUserSession(sesh)
+
        return template.render(
            title=f"{self.core_config.server.name} | {self.nav_name}",
            game_list=self.environment.globals["game_list"],
+            sesh=vars(usr_sesh)
        ).encode("utf-16")
--- a/titles/pokken/index.py
+++ b/titles/pokken/index.py
@ -1,6 +1,7 @@
 from typing import Tuple
 from twisted.web.http import Request
 from twisted.web import resource
+from twisted.internet import reactor
 import json, ast
 from datetime import datetime
 import yaml
@ -11,10 +12,11 @@ from os import path
 from google.protobuf.message import DecodeError

 from core import CoreConfig, Utils
-from titles.pokken.config import PokkenConfig
-from titles.pokken.base import PokkenBase
-from titles.pokken.const import PokkenConstants
-from titles.pokken.proto import jackal_pb2
+from .config import PokkenConfig
+from .base import PokkenBase
+from .const import PokkenConstants
+from .proto import jackal_pb2
+from .services import PokkenAdmissionFactory


 class PokkenServlet(resource.Resource):
@ -69,7 +71,7 @@ class PokkenServlet(resource.Resource):

        return (
            True,
-            f"https://{game_cfg.server.hostname}:{game_cfg.server.port}/{game_code}/$v/",
+            f"https://{game_cfg.server.hostname}:{game_cfg.ports.game}/{game_code}/$v/",
            f"{game_cfg.server.hostname}/SDAK/$v/",
        )

@ -90,8 +92,10 @@ class PokkenServlet(resource.Resource):
        return (True, "PKF1")

    def setup(self) -> None:
-        # TODO: Setup stun, turn (UDP) and admission (WSS) servers
-        pass
+        if self.game_cfg.server.enable_matching:
+            reactor.listenTCP(
+                self.game_cfg.ports.admission, PokkenAdmissionFactory(self.core_cfg, self.game_cfg)
+            )

    def render_POST(
        self, request: Request, version: int = 0, endpoints: str = ""
@ -128,6 +132,9 @@ class PokkenServlet(resource.Resource):
        return ret

    def handle_matching(self, request: Request) -> bytes:
+        if not self.game_cfg.server.enable_matching:
+            return b""
+        
        content = request.content.getvalue()
        client_ip = Utils.get_ip_addr(request)

--- a/titles/pokken/schema/item.py
+++ b/titles/pokken/schema/item.py
@ -31,4 +31,16 @@ class PokkenItemData(BaseData):
    Items obtained as rewards
    """

-    pass
+    def add_reward(self, user_id: int, category: int, content: int, item_type: int) -> Optional[int]:
+        sql = insert(item).values(
+            user=user_id,
+            category=category,
+            content=content,
+            type=item_type,
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            self.logger.warn(f"Failed to insert reward for user {user_id}: {category}-{content}-{item_type}")
+            return None
+        return result.lastrowid
--- a/titles/pokken/schema/profile.py
+++ b/titles/pokken/schema/profile.py
@ -1,4 +1,4 @@
-from typing import Optional, Dict, List
+from typing import Optional, Dict, List, Union
 from sqlalchemy import Table, Column, UniqueConstraint, PrimaryKeyConstraint, and_, case
 from sqlalchemy.types import Integer, String, TIMESTAMP, Boolean, JSON
 from sqlalchemy.schema import ForeignKey
@ -125,7 +125,7 @@ pokemon_data = Table(
    Column("win_vs_lan", Integer),
    Column("battle_num_vs_cpu", Integer),  # 2
    Column("win_cpu", Integer),
-    Column("battle_all_num_tutorial", Integer),
+    Column("battle_all_num_tutorial", Integer), # ???
    Column("battle_num_tutorial", Integer),  # 1?
    Column("bp_point_atk", Integer),
    Column("bp_point_res", Integer),
@ -147,11 +147,10 @@ class PokkenProfileData(BaseData):
            return None
        return result.lastrowid

-    def set_profile_name(self, user_id: int, new_name: str) -> None:
-        sql = (
-            update(profile)
-            .where(profile.c.user == user_id)
-            .values(trainer_name=new_name)
+    def set_profile_name(self, user_id: int, new_name: str, gender: Union[int, None] = None) -> None:
+        sql = update(profile).where(profile.c.user == user_id).values(
+            trainer_name=new_name,
+            avatar_gender=gender if gender is not None else profile.c.avatar_gender
        )
        result = self.execute(sql)
        if result is None:
@ -159,8 +158,38 @@ class PokkenProfileData(BaseData):
                f"Failed to update pokken profile name for user {user_id}!"
            )

-    def update_profile_tutorial_flags(self, user_id: int, tutorial_flags: Dict) -> None:
-        pass
+    def update_profile_tutorial_flags(self, user_id: int, tutorial_flags: List) -> None:
+        sql = update(profile).where(profile.c.user == user_id).values(
+            tutorial_progress_flag=tutorial_flags,
+        )
+        result = self.execute(sql)
+        if result is None:
+            self.logger.error(
+                f"Failed to update pokken profile tutorial flags for user {user_id}!"
+            )
+
+    def update_profile_achievement_flags(self, user_id: int, achievement_flags: List) -> None:
+        sql = update(profile).where(profile.c.user == user_id).values(
+            achievement_flag=achievement_flags,
+        )
+        result = self.execute(sql)
+        if result is None:
+            self.logger.error(
+                f"Failed to update pokken profile achievement flags for user {user_id}!"
+            )
+
+    def update_profile_event(self, user_id: int, event_state: List, event_flags: List[int], event_param: List[int], last_evt: int = None) -> None:
+        sql = update(profile).where(profile.c.user == user_id).values(
+            event_state=event_state,
+            event_achievement_flag=event_flags,
+            event_achievement_param=event_param,
+            last_play_event_id=last_evt if last_evt is not None else profile.c.last_play_event_id,
+        )
+        result = self.execute(sql)
+        if result is None:
+            self.logger.error(
+                f"Failed to update pokken profile event state for user {user_id}!"
+            )

    def add_profile_points(
        self, user_id: int, rank_pts: int, money: int, score_pts: int
@ -174,18 +203,53 @@ class PokkenProfileData(BaseData):
            return None
        return result.fetchone()

-    def put_pokemon_data(
+    def put_pokemon(
        self,
        user_id: int,
        pokemon_id: int,
        illust_no: int,
-        get_exp: int,
        atk: int,
        res: int,
        defe: int,
-        sp: int,
+        sp: int
    ) -> Optional[int]:
-        pass
+        sql = insert(pokemon_data).values(
+            user=user_id,
+            char_id=pokemon_id,
+            illustration_book_no=illust_no,
+            bp_point_atk=atk,
+            bp_point_res=res,
+            bp_point_defe=defe,
+            bp_point_sp=sp,
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            illustration_book_no=illust_no,
+            bp_point_atk=atk,
+            bp_point_res=res,
+            bp_point_defe=defe,
+            bp_point_sp=sp,
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            self.logger.warn(f"Failed to insert pokemon ID {pokemon_id} for user {user_id}")
+            return None
+        return result.lastrowid
+
+    def add_pokemon_xp(
+        self,
+        user_id: int,
+        pokemon_id: int,
+        xp: int
+    ) -> None:
+        sql = update(pokemon_data).where(and_(pokemon_data.c.user==user_id, pokemon_data.c.char_id==pokemon_id)).values(
+            pokemon_exp=pokemon_data.c.pokemon_exp + xp
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            self.logger.warn(f"Failed to add {xp} XP to pokemon ID {pokemon_id} for user {user_id}")

    def get_pokemon_data(self, user_id: int, pokemon_id: int) -> Optional[Row]:
        pass
@ -193,13 +257,29 @@ class PokkenProfileData(BaseData):
    def get_all_pokemon_data(self, user_id: int) -> Optional[List[Row]]:
        pass

-    def put_results(
-        self, user_id: int, pokemon_id: int, match_type: int, match_result: int
+    def put_pokemon_battle_result(
+        self, user_id: int, pokemon_id: int, match_type: PokkenConstants.BATTLE_TYPE, match_result: PokkenConstants.BATTLE_RESULT
    ) -> None:
        """
        Records the match stats (type and win/loss) for the pokemon and profile
        """
-        pass
+        sql = update(pokemon_data).where(and_(pokemon_data.c.user==user_id, pokemon_data.c.char_id==pokemon_id)).values(
+            battle_num_tutorial=pokemon_data.c.battle_num_tutorial + 1 if match_type==PokkenConstants.BATTLE_TYPE.TUTORIAL else pokemon_data.c.battle_num_tutorial,
+            battle_all_num_tutorial=pokemon_data.c.battle_all_num_tutorial + 1 if match_type==PokkenConstants.BATTLE_TYPE.TUTORIAL else pokemon_data.c.battle_all_num_tutorial,
+
+            battle_num_vs_cpu=pokemon_data.c.battle_num_vs_cpu + 1 if match_type==PokkenConstants.BATTLE_TYPE.AI else pokemon_data.c.battle_num_vs_cpu,
+            win_cpu=pokemon_data.c.win_cpu + 1 if match_type==PokkenConstants.BATTLE_TYPE.AI and match_result==PokkenConstants.BATTLE_RESULT.WIN else pokemon_data.c.win_cpu,
+
+            battle_num_vs_lan=pokemon_data.c.battle_num_vs_lan + 1 if match_type==PokkenConstants.BATTLE_TYPE.LAN else pokemon_data.c.battle_num_vs_lan,
+            win_vs_lan=pokemon_data.c.win_vs_lan + 1 if match_type==PokkenConstants.BATTLE_TYPE.LAN and match_result==PokkenConstants.BATTLE_RESULT.WIN else pokemon_data.c.win_vs_lan,
+
+            battle_num_vs_wan=pokemon_data.c.battle_num_vs_wan + 1 if match_type==PokkenConstants.BATTLE_TYPE.WAN else pokemon_data.c.battle_num_vs_wan,
+            win_vs_wan=pokemon_data.c.win_vs_wan + 1 if match_type==PokkenConstants.BATTLE_TYPE.WAN and match_result==PokkenConstants.BATTLE_RESULT.WIN else pokemon_data.c.win_vs_wan,
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            self.logger.warn(f"Failed to record match stats for user {user_id}'s pokemon {pokemon_id} (type {match_type.name} | result {match_result.name})")

    def put_stats(
        self,
@ -215,3 +295,17 @@ class PokkenProfileData(BaseData):
        Records profile stats
        """
        pass
+
+    def update_support_team(self, user_id: int, support_id: int, support1: int = 4294967295, support2: int = 4294967295) -> None:
+        sql = update(profile).where(profile.c.user==user_id).values(
+            support_set_1_1=support1 if support_id == 1 else profile.c.support_set_1_1,
+            support_set_1_2=support2 if support_id == 1 else profile.c.support_set_1_2,
+            support_set_2_1=support1 if support_id == 2 else profile.c.support_set_2_1,
+            support_set_2_2=support2 if support_id == 2 else profile.c.support_set_2_2,
+            support_set_3_1=support1 if support_id == 3 else profile.c.support_set_3_1,
+            support_set_3_2=support2 if support_id == 3 else profile.c.support_set_3_2,
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            self.logger.warn(f"Failed to update support team {support_id} for user {user_id}")
--- a/titles/pokken/services.py
+++ b/titles/pokken/services.py
@ -0,0 +1,66 @@
+from twisted.internet.interfaces import IAddress
+from twisted.internet.protocol import Protocol
+from autobahn.twisted.websocket import WebSocketServerProtocol, WebSocketServerFactory
+from autobahn.websocket.types import ConnectionRequest
+from typing import Dict
+import logging
+import json
+
+from core.config import CoreConfig
+from .config import PokkenConfig
+from .base import PokkenBase
+
+class PokkenAdmissionProtocol(WebSocketServerProtocol):
+    def __init__(self, cfg: CoreConfig, game_cfg: PokkenConfig):
+        super().__init__()
+        self.core_config = cfg
+        self.game_config = game_cfg
+        self.logger = logging.getLogger("pokken")
+
+        self.base = PokkenBase(cfg, game_cfg)
+    
+    def onConnect(self, request: ConnectionRequest) -> None:
+        self.logger.debug(f"Admission: Connection from {request.peer}")
+    
+    def onClose(self, wasClean: bool, code: int, reason: str) -> None:
+        self.logger.debug(f"Admission: Connection with {self.transport.getPeer().host} closed {'cleanly ' if wasClean else ''}with code {code} - {reason}")
+
+    def onMessage(self, payload, isBinary: bool) -> None:
+        msg: Dict = json.loads(payload)
+        self.logger.debug(f"Admission: Message from {self.transport.getPeer().host}:{self.transport.getPeer().port} - {msg}")
+        
+        api = msg.get("api", "noop")
+        handler = getattr(self.base, f"handle_admission_{api.lower()}")
+        resp = handler(msg, self.transport.getPeer().host)
+        
+        if resp is None:
+            resp = {}
+
+        if "type" not in resp:
+            resp['type'] = "res"
+        if "data" not in resp:
+            resp['data'] = {}
+        if "api" not in resp:
+            resp['api'] = api
+        if "result" not in resp:
+            resp['result'] = 'true'
+        
+        self.logger.debug(f"Websocket response: {resp}")
+        self.sendMessage(json.dumps(resp).encode(), isBinary)
+
+class PokkenAdmissionFactory(WebSocketServerFactory):
+    protocol = PokkenAdmissionProtocol
+
+    def __init__(
+        self,
+        cfg: CoreConfig,
+        game_cfg: PokkenConfig
+    ) -> None:
+        self.core_config = cfg
+        self.game_config = game_cfg
+        super().__init__(f"ws://{self.game_config.server.hostname}:{self.game_config.ports.admission}")
+    
+    def buildProtocol(self, addr: IAddress) -> Protocol:
+        p = self.protocol(self.core_config, self.game_config)
+        p.factory = self
+        return p
--- a/titles/sao/init.py
+++ b/titles/sao/init.py
@ -0,0 +1,10 @@
+from .index import SaoServlet
+from .const import SaoConstants
+from .database import SaoData
+from .read import SaoReader
+
+index = SaoServlet
+database = SaoData
+reader = SaoReader
+game_codes = [SaoConstants.GAME_CODE]
+current_schema_version = 1
--- a/titles/sao/base.py
+++ b/titles/sao/base.py
--- a/titles/sao/config.py
+++ b/titles/sao/config.py
@ -0,0 +1,47 @@
+from core.config import CoreConfig
+
+
+class SaoServerConfig:
+    def __init__(self, parent_config: "SaoConfig"):
+        self.__config = parent_config
+
+    @property
+    def hostname(self) -> str:
+        return CoreConfig.get_config_field(
+            self.__config, "sao", "server", "hostname", default="localhost"
+        )
+
+    @property
+    def enable(self) -> bool:
+        return CoreConfig.get_config_field(
+            self.__config, "sao", "server", "enable", default=True
+        )
+
+    @property
+    def loglevel(self) -> int:
+        return CoreConfig.str_to_loglevel(
+            CoreConfig.get_config_field(
+                self.__config, "sao", "server", "loglevel", default="info"
+            )
+        )
+
+    @property
+    def port(self) -> int:
+        return CoreConfig.get_config_field(
+            self.__config, "sao", "server", "port", default=9000
+        )
+
+    @property
+    def auto_register(self) -> bool:
+        """
+        Automatically register users in `aime_user` on first carding in with sao
+        if they don't exist already. Set to false to display an error instead.
+        """
+        return CoreConfig.get_config_field(
+            self.__config, "sao", "server", "auto_register", default=True
+        )
+
+
+class SaoConfig(dict):
+    def __init__(self) -> None:
+        self.server = SaoServerConfig(self)
--- a/titles/sao/const.py
+++ b/titles/sao/const.py
@ -0,0 +1,15 @@
+from enum import Enum
+
+
+class SaoConstants:
+    GAME_CODE = "SDEW"
+
+    CONFIG_NAME = "sao.yaml"
+
+    VER_SAO = 0
+
+    VERSION_NAMES = ("Sword Art Online Arcade")
+
+    @classmethod
+    def game_ver_to_string(cls, ver: int):
+        return cls.VERSION_NAMES[ver]
--- a/titles/sao/data/EquipmentLevel.csv
+++ b/titles/sao/data/EquipmentLevel.csv
@ -0,0 +1,121 @@
+EquipmentLevelId,RequireExp
+1,200,
+2,400,
+3,600,
+4,800,
+5,1000,
+6,1200,
+7,1400,
+8,1600,
+9,1800,
+10,2000,
+11,2200,
+12,2400,
+13,2600,
+14,2800,
+15,3000,
+16,3200,
+17,3400,
+18,3600,
+19,3800,
+20,4000,
+21,4200,
+22,4400,
+23,4600,
+24,4800,
+25,5000,
+26,5200,
+27,5400,
+28,5600,
+29,5800,
+30,6000,
+31,6200,
+32,6400,
+33,6600,
+34,6800,
+35,7000,
+36,7200,
+37,7400,
+38,7600,
+39,7800,
+40,8000,
+41,8200,
+42,8400,
+43,8600,
+44,8800,
+45,9000,
+46,9200,
+47,9400,
+48,9600,
+49,9800,
+50,10000,
+51,10200,
+52,10400,
+53,10600,
+54,10800,
+55,11000,
+56,11200,
+57,11400,
+58,11600,
+59,11800,
+60,12000,
+61,12200,
+62,12400,
+63,12600,
+64,12800,
+65,13000,
+66,13200,
+67,13400,
+68,13600,
+69,13800,
+70,14000,
+71,14200,
+72,14400,
+73,14600,
+74,14800,
+75,15000,
+76,15200,
+77,15400,
+78,15600,
+79,15800,
+80,16000,
+81,16200,
+82,16400,
+83,16600,
+84,16800,
+85,17000,
+86,17200,
+87,17400,
+88,17600,
+89,17800,
+90,18000,
+91,18200,
+92,18400,
+93,18600,
+94,18800,
+95,19000,
+96,19200,
+97,19400,
+98,19600,
+99,19800,
+100,100000,
+101,150000,
+102,200000,
+103,250000,
+104,300000,
+105,350000,
+106,400000,
+107,450000,
+108,500000,
+109,550000,
+110,600000,
+111,650000,
+112,700000,
+113,750000,
+114,800000,
+115,850000,
+116,900000,
+117,950000,
+118,1000000,
+119,1000000,
+120,1000000,
--- a/titles/sao/data/HeroLogLevel.csv
+++ b/titles/sao/data/HeroLogLevel.csv
@ -0,0 +1,121 @@
+HeroLogLevelId,RequireExp
+1,0,
+2,1000,
+3,1200,
+4,1400,
+5,1600,
+6,1900,
+7,2200,
+8,2500,
+9,2800,
+10,3100,
+11,3500,
+12,3900,
+13,4300,
+14,4700,
+15,5100,
+16,5550,
+17,6000,
+18,6450,
+19,6900,
+20,7350,
+21,7850,
+22,8350,
+23,8850,
+24,9350,
+25,9850,
+26,10450,
+27,11050,
+28,11650,
+29,12250,
+30,12850,
+31,13550,
+32,14250,
+33,14950,
+34,15650,
+35,16350,
+36,17150,
+37,17950,
+38,18750,
+39,19550,
+40,20350,
+41,21250,
+42,22150,
+43,23050,
+44,23950,
+45,24850,
+46,25850,
+47,26850,
+48,27850,
+49,28850,
+50,29850,
+51,30950,
+52,32050,
+53,33150,
+54,34250,
+55,35350,
+56,36550,
+57,37750,
+58,38950,
+59,40150,
+60,41350,
+61,42650,
+62,43950,
+63,45250,
+64,46550,
+65,47850,
+66,49250,
+67,50650,
+68,52050,
+69,53450,
+70,54850,
+71,56350,
+72,57850,
+73,59350,
+74,60850,
+75,62350,
+76,63950,
+77,65550,
+78,67150,
+79,68750,
+80,70350,
+81,72050,
+82,73750,
+83,75450,
+84,77150,
+85,78850,
+86,80650,
+87,82450,
+88,84250,
+89,86050,
+90,87850,
+91,89750,
+92,91650,
+93,93550,
+94,95450,
+95,97350,
+96,99350,
+97,101350,
+98,103350,
+99,105350,
+100,107350,
+101,200000,
+102,300000,
+103,450000,
+104,600000,
+105,800000,
+106,1000000,
+107,1250000,
+108,1500000,
+109,1800000,
+110,2100000,
+111,2100000,
+112,2100000,
+113,2100000,
+114,2100000,
+115,2100000,
+116,2100000,
+117,2100000,
+118,2100000,
+119,2100000,
+120,2100000,
--- a/titles/sao/data/PlayerRank.csv
+++ b/titles/sao/data/PlayerRank.csv
@ -0,0 +1,301 @@
+PlayerRankId,TotalExp,
+1,0,
+2,100,
+3,300,
+4,500,
+5,800,
+6,1100,
+7,1400,
+8,1800,
+9,2200,
+10,2600,,
+11,3000,,
+12,3500,,
+13,4000,,
+14,4500,,
+15,5000,,
+16,5500,,
+17,6100,,
+18,6700,,
+19,7300,,
+20,7900,,
+21,8500,,
+22,9100,,
+23,9800,,
+24,10500,
+25,11200,
+26,11900,
+27,12600,
+28,13300,
+29,14000,
+30,14800,
+31,15600,
+32,16400,
+33,17200,
+34,18000,
+35,18800,
+36,19600,
+37,20400,
+38,21300,
+39,22200,
+40,23100,
+41,24000,
+42,24900,
+43,25800,
+44,26700,
+45,27600,
+46,28500,
+47,29500,
+48,30600,
+49,31800,
+50,33100,
+51,34500,
+52,36000,
+53,37600,
+54,39300,
+55,41100,
+56,43000,
+57,45000,
+58,47100,
+59,49300,
+60,51600,
+61,54000,
+62,56500,
+63,59100,
+64,61800,
+65,64600,
+66,67500,
+67,70500,
+68,73600,
+69,76800,
+70,80100,
+71,83500,
+72,87000,
+73,90600,
+74,94300,
+75,98100,
+76,102000,
+77,106000,
+78,110100,
+79,114300,
+80,118600,
+81,123000,
+82,127500,
+83,132100,
+84,136800,
+85,141600,
+86,146500,
+87,151500,
+88,156600,
+89,161800,
+90,167100,
+91,172500,
+92,178000,
+93,183600,
+94,189300,
+95,195100,
+96,201000,
+97,207000,
+98,213100,
+99,219300,
+100,225600,
+101,232000,
+102,238500,
+103,245100,
+104,251800,
+105,258600,
+106,265500,
+107,272500,
+108,279600,
+109,286800,
+110,294100,
+111,301500,
+112,309000,
+113,316600,
+114,324300,
+115,332100,
+116,340000,
+117,348000,
+118,356100,
+119,364300,
+120,372600,
+121,381000,
+122,389500,
+123,398100,
+124,406800,
+125,415600,
+126,424500,
+127,433500,
+128,442600,
+129,451800,
+130,461100,
+131,470500,
+132,480000,
+133,489600,
+134,499300,
+135,509100,
+136,519000,
+137,529000,
+138,539100,
+139,549300,
+140,559600,
+141,570000,
+142,580500,
+143,591100,
+144,601800,
+145,612600,
+146,623500,
+147,634500,
+148,645600,
+149,656800,
+150,668100,
+151,679500,
+152,691000,
+153,702600,
+154,714300,
+155,726100,
+156,738000,
+157,750000,
+158,762100,
+159,774300,
+160,786600,
+161,799000,
+162,811500,
+163,824100,
+164,836800,
+165,849600,
+166,862500,
+167,875500,
+168,888600,
+169,901800,
+170,915100,
+171,928500,
+172,942000,
+173,955600,
+174,969300,
+175,983100,
+176,997000,
+177,1011000,
+178,1025100,
+179,1039300,
+180,1053600,
+181,1068000,
+182,1082500,
+183,1097100,
+184,1111800,
+185,1126600,
+186,1141500,
+187,1156500,
+188,1171600,
+189,1186800,
+190,1202100,
+191,1217500,
+192,1233000,
+193,1248600,
+194,1264300,
+195,1280100,
+196,1296000,
+197,1312000,
+198,1328100,
+199,1344300,
+200,1360600,
+201,1377000,
+202,1393500,
+203,1410100,
+204,1426800,
+205,1443600,
+206,1460500,
+207,1477500,
+208,1494600,
+209,1511800,
+210,1529100,
+211,1546500,
+212,1564000,
+213,1581600,
+214,1599300,
+215,1617100,
+216,1635000,
+217,1653000,
+218,1671100,
+219,1689300,
+220,1707600,
+221,1726000,
+222,1744500,
+223,1763100,
+224,1781800,
+225,1800600,
+226,1819500,
+227,1838500,
+228,1857600,
+229,1876800,
+230,1896100,
+231,1915500,
+232,1935000,
+233,1954600,
+234,1974300,
+235,1994100,
+236,2014000,
+237,2034000,
+238,2054100,
+239,2074300,
+240,2094600,
+241,2115000,
+242,2135500,
+243,2156100,
+244,2176800,
+245,2197600,
+246,2218500,
+247,2239500,
+248,2260600,
+249,2281800,
+250,2303100,
+251,2324500,
+252,2346000,
+253,2367600,
+254,2389300,
+255,2411100,
+256,2433000,
+257,2455000,
+258,2477100,
+259,2499300,
+260,2521600,
+261,2544000,
+262,2566500,
+263,2589100,
+264,2611800,
+265,2634600,
+266,2657500,
+267,2680500,
+268,2703600,
+269,2726800,
+270,2750100,
+271,2773500,
+272,2797000,
+273,2820600,
+274,2844300,
+275,2868100,
+276,2892000,
+277,2916000,
+278,2940100,
+279,2964300,
+280,2988600,
+281,3013000,
+282,3037500,
+283,3062100,
+284,3086800,
+285,3111600,
+286,3136500,
+287,3161500,
+288,3186600,
+289,3211800,
+290,3237100,
+291,3262500,
+292,3288000,
+293,3313600,
+294,3339300,
+295,3365100,
+296,3391000,
+297,3417000,
+298,3443100,
+299,3469300,
+300,3495600,
--- a/titles/sao/data/RewardTable.csv
+++ b/titles/sao/data/RewardTable.csv
--- a/titles/sao/database.py
+++ b/titles/sao/database.py
@ -0,0 +1,12 @@
+from core.data import Data
+from core.config import CoreConfig
+
+from .schema import *
+
+
+class SaoData(Data):
+    def __init__(self, cfg: CoreConfig) -> None:
+        super().__init__(cfg)
+
+        self.profile = SaoProfileData(cfg, self.session)
+        self.static = SaoStaticData(cfg, self.session)
--- a/titles/sao/handlers/init.py
+++ b/titles/sao/handlers/init.py
@ -0,0 +1 @@
+from titles.sao.handlers.base import *
--- a/titles/sao/handlers/base.py
+++ b/titles/sao/handlers/base.py
--- a/titles/sao/index.py
+++ b/titles/sao/index.py
@ -0,0 +1,116 @@
+from typing import Tuple
+from twisted.web.http import Request
+from twisted.web import resource
+import json, ast
+from datetime import datetime
+import yaml
+import logging, coloredlogs
+from logging.handlers import TimedRotatingFileHandler
+import inflection
+from os import path
+
+from core import CoreConfig, Utils
+from titles.sao.config import SaoConfig
+from titles.sao.const import SaoConstants
+from titles.sao.base import SaoBase
+from titles.sao.handlers.base import *
+
+
+class SaoServlet(resource.Resource):
+    def __init__(self, core_cfg: CoreConfig, cfg_dir: str) -> None:
+        self.isLeaf = True
+        self.core_cfg = core_cfg
+        self.config_dir = cfg_dir
+        self.game_cfg = SaoConfig()
+        if path.exists(f"{cfg_dir}/sao.yaml"):
+            self.game_cfg.update(yaml.safe_load(open(f"{cfg_dir}/sao.yaml")))
+
+        self.logger = logging.getLogger("sao")
+        if not hasattr(self.logger, "inited"):
+            log_fmt_str = "[%(asctime)s] SAO | %(levelname)s | %(message)s"
+            log_fmt = logging.Formatter(log_fmt_str)
+            fileHandler = TimedRotatingFileHandler(
+                "{0}/{1}.log".format(self.core_cfg.server.log_dir, "sao"),
+                encoding="utf8",
+                when="d",
+                backupCount=10,
+            )
+
+            fileHandler.setFormatter(log_fmt)
+
+            consoleHandler = logging.StreamHandler()
+            consoleHandler.setFormatter(log_fmt)
+
+            self.logger.addHandler(fileHandler)
+            self.logger.addHandler(consoleHandler)
+
+            self.logger.setLevel(self.game_cfg.server.loglevel)
+            coloredlogs.install(
+                level=self.game_cfg.server.loglevel, logger=self.logger, fmt=log_fmt_str
+            )
+            self.logger.inited = True
+
+        self.base = SaoBase(core_cfg, self.game_cfg)
+
+    @classmethod
+    def get_allnet_info(
+        cls, game_code: str, core_cfg: CoreConfig, cfg_dir: str
+    ) -> Tuple[bool, str, str]:
+        game_cfg = SaoConfig()
+
+        if path.exists(f"{cfg_dir}/{SaoConstants.CONFIG_NAME}"):
+            game_cfg.update(
+                yaml.safe_load(open(f"{cfg_dir}/{SaoConstants.CONFIG_NAME}"))
+            )
+
+        if not game_cfg.server.enable:
+            return (False, "", "")
+
+        return (
+            True,
+            f"http://{game_cfg.server.hostname}:{game_cfg.server.port}/{game_code}/$v/",
+            f"{game_cfg.server.hostname}/SDEW/$v/",
+        )
+
+    @classmethod
+    def get_mucha_info(
+        cls, core_cfg: CoreConfig, cfg_dir: str
+    ) -> Tuple[bool, str, str]:
+        game_cfg = SaoConfig()
+
+        if path.exists(f"{cfg_dir}/{SaoConstants.CONFIG_NAME}"):
+            game_cfg.update(
+                yaml.safe_load(open(f"{cfg_dir}/{SaoConstants.CONFIG_NAME}"))
+            )
+
+        if not game_cfg.server.enable:
+            return (False, "")
+
+        return (True, "SAO1")
+
+    def setup(self) -> None:
+        pass
+
+    def render_POST(
+        self, request: Request, version: int = 0, endpoints: str = ""
+    ) -> bytes:
+        req_url = request.uri.decode()
+        if req_url == "/matching":
+            self.logger.info("Matching request")
+        
+        request.responseHeaders.addRawHeader(b"content-type", b"text/html; charset=utf-8")
+
+        sao_request = request.content.getvalue().hex()
+
+        handler = getattr(self.base, f"handle_{sao_request[:4]}", None)
+        if handler is None:
+            self.logger.info(f"Generic Handler for {req_url} - {sao_request[:4]}")
+            self.logger.debug(f"Request: {request.content.getvalue().hex()}")
+            resp = SaoNoopResponse(int.from_bytes(bytes.fromhex(sao_request[:4]), "big")+1)
+            self.logger.debug(f"Response: {resp.make().hex()}")
+            return resp.make()
+
+        self.logger.info(f"Handler {req_url} - {sao_request[:4]} request")
+        self.logger.debug(f"Request: {request.content.getvalue().hex()}")
+        self.logger.debug(f"Response: {handler(sao_request).hex()}")
+        return handler(sao_request)
--- a/titles/sao/read.py
+++ b/titles/sao/read.py
@ -0,0 +1,254 @@
+from typing import Optional, Dict, List
+from os import walk, path
+import urllib
+import csv
+
+from read import BaseReader
+from core.config import CoreConfig
+from titles.sao.database import SaoData
+from titles.sao.const import SaoConstants
+
+
+class SaoReader(BaseReader):
+    def __init__(
+        self,
+        config: CoreConfig,
+        version: int,
+        bin_arg: Optional[str],
+        opt_arg: Optional[str],
+        extra: Optional[str],
+    ) -> None:
+        super().__init__(config, version, bin_arg, opt_arg, extra)
+        self.data = SaoData(config)
+
+        try:
+            self.logger.info(
+                f"Start importer for {SaoConstants.game_ver_to_string(version)}"
+            )
+        except IndexError:
+            self.logger.error(f"Invalid project SAO version {version}")
+            exit(1)
+
+    def read(self) -> None:
+        pull_bin_ram = True
+
+        if not path.exists(f"{self.bin_dir}"):
+            self.logger.warn(f"Couldn't find csv file in {self.bin_dir}, skipping")
+            pull_bin_ram = False
+
+        if pull_bin_ram:
+            self.read_csv(f"{self.bin_dir}")
+
+    def read_csv(self, bin_dir: str) -> None:
+        self.logger.info(f"Read csv from {bin_dir}")
+
+        self.logger.info("Now reading QuestScene.csv")
+        try:
+            fullPath = bin_dir + "/QuestScene.csv"
+            with open(fullPath, encoding="UTF-8") as fp:
+                reader = csv.DictReader(fp)
+                for row in reader:
+                    questSceneId = row["QuestSceneId"]
+                    sortNo = row["SortNo"]
+                    name = row["Name"]
+                    enabled = True
+
+                    self.logger.info(f"Added quest {questSceneId} | Name: {name}")
+                    
+                    try:
+                        self.data.static.put_quest(
+                            questSceneId,
+                            0,
+                            sortNo,
+                            name,
+                            enabled
+                        )
+                    except Exception as err:
+                        print(err)
+        except:
+            self.logger.warn(f"Couldn't read csv file in {self.bin_dir}, skipping")
+        
+        self.logger.info("Now reading HeroLog.csv")
+        try:
+            fullPath = bin_dir + "/HeroLog.csv"
+            with open(fullPath, encoding="UTF-8") as fp:
+                reader = csv.DictReader(fp)
+                for row in reader:
+                    heroLogId = row["HeroLogId"]
+                    name = row["Name"]
+                    nickname = row["Nickname"]
+                    rarity = row["Rarity"]
+                    skillTableSubId = row["SkillTableSubId"]
+                    awakeningExp = row["AwakeningExp"]
+                    flavorText = row["FlavorText"]
+                    enabled = True
+
+                    self.logger.info(f"Added hero {heroLogId} | Name: {name}")
+                    
+                    try:
+                        self.data.static.put_hero(
+                            0,
+                            heroLogId,
+                            name,
+                            nickname,
+                            rarity,
+                            skillTableSubId,
+                            awakeningExp,
+                            flavorText,
+                            enabled
+                        )
+                    except Exception as err:
+                        print(err)
+        except:
+            self.logger.warn(f"Couldn't read csv file in {self.bin_dir}, skipping")
+        
+        self.logger.info("Now reading Equipment.csv")
+        try:
+            fullPath = bin_dir + "/Equipment.csv"
+            with open(fullPath, encoding="UTF-8") as fp:
+                reader = csv.DictReader(fp)
+                for row in reader:
+                    equipmentId = row["EquipmentId"]
+                    equipmentType = row["EquipmentType"]
+                    weaponTypeId = row["WeaponTypeId"]
+                    name = row["Name"]
+                    rarity = row["Rarity"]
+                    flavorText = row["FlavorText"]
+                    enabled = True
+
+                    self.logger.info(f"Added equipment {equipmentId} | Name: {name}")
+                    
+                    try:
+                        self.data.static.put_equipment(
+                            0,
+                            equipmentId,
+                            name,
+                            equipmentType,
+                            weaponTypeId,
+                            rarity,
+                            flavorText,
+                            enabled
+                        )
+                    except Exception as err:
+                        print(err)
+        except:
+            self.logger.warn(f"Couldn't read csv file in {self.bin_dir}, skipping")
+
+        self.logger.info("Now reading Item.csv")
+        try:
+            fullPath = bin_dir + "/Item.csv"
+            with open(fullPath, encoding="UTF-8") as fp:
+                reader = csv.DictReader(fp)
+                for row in reader:
+                    itemId = row["ItemId"]
+                    itemTypeId = row["ItemTypeId"]
+                    name = row["Name"]
+                    rarity = row["Rarity"]
+                    flavorText = row["FlavorText"]
+                    enabled = True
+
+                    self.logger.info(f"Added item {itemId} | Name: {name}")
+                    
+                    try:
+                        self.data.static.put_item(
+                            0,
+                            itemId,
+                            name,
+                            itemTypeId,
+                            rarity,
+                            flavorText,
+                            enabled
+                        )
+                    except Exception as err:
+                        print(err)
+        except:
+            self.logger.warn(f"Couldn't read csv file in {self.bin_dir}, skipping")
+        
+        self.logger.info("Now reading SupportLog.csv")
+        try:
+            fullPath = bin_dir + "/SupportLog.csv"
+            with open(fullPath, encoding="UTF-8") as fp:
+                reader = csv.DictReader(fp)
+                for row in reader:
+                    supportLogId = row["SupportLogId"]
+                    charaId = row["CharaId"]
+                    name = row["Name"]
+                    rarity = row["Rarity"]
+                    salePrice = row["SalePrice"]
+                    skillName = row["SkillName"]
+                    enabled = True
+
+                    self.logger.info(f"Added support log {supportLogId} | Name: {name}")
+                    
+                    try:
+                        self.data.static.put_support_log(
+                            0,
+                            supportLogId,
+                            charaId,
+                            name,
+                            rarity,
+                            salePrice,
+                            skillName,
+                            enabled
+                        )
+                    except Exception as err:
+                        print(err)
+        except:
+            self.logger.warn(f"Couldn't read csv file in {self.bin_dir}, skipping")
+            
+        self.logger.info("Now reading Title.csv")
+        try:
+            fullPath = bin_dir + "/Title.csv"
+            with open(fullPath, encoding="UTF-8") as fp:
+                reader = csv.DictReader(fp)
+                for row in reader:
+                    titleId = row["TitleId"]
+                    displayName = row["DisplayName"]
+                    requirement = row["Requirement"]
+                    rank = row["Rank"]
+                    imageFilePath = row["ImageFilePath"]
+                    enabled = True
+
+                    self.logger.info(f"Added title {titleId} | Name: {displayName}")
+                    
+                    if len(titleId) > 5:
+                        try:
+                            self.data.static.put_title(
+                                0,
+                                titleId,
+                                displayName,
+                                requirement,
+                                rank,
+                                imageFilePath,
+                                enabled
+                            )
+                        except Exception as err:
+                            print(err)
+                    elif len(titleId) < 6: # current server code cannot have multiple lengths for the id
+                        continue
+        except:
+            self.logger.warn(f"Couldn't read csv file in {self.bin_dir}, skipping")
+
+        self.logger.info("Now reading RareDropTable.csv")
+        try:
+            fullPath = bin_dir + "/RareDropTable.csv"
+            with open(fullPath, encoding="UTF-8") as fp:
+                reader = csv.DictReader(fp)
+                for row in reader:
+                    questRareDropId = row["QuestRareDropId"]
+                    commonRewardId = row["CommonRewardId"]
+                    enabled = True
+
+                    self.logger.info(f"Added rare drop {questRareDropId} | Reward: {commonRewardId}")
+                    
+                    try:
+                        self.data.static.put_rare_drop(
+                            0,
+                            questRareDropId,
+                            commonRewardId,
+                            enabled
+                        )
+                    except Exception as err:
+                        print(err)
+        except:
+            self.logger.warn(f"Couldn't read csv file in {self.bin_dir}, skipping")
--- a/titles/sao/schema/init.py
+++ b/titles/sao/schema/init.py
@ -0,0 +1,3 @@
+from .profile import SaoProfileData
+from .static import SaoStaticData
+from .item import SaoItemData
--- a/titles/sao/schema/item.py
+++ b/titles/sao/schema/item.py
@ -0,0 +1,458 @@
+from typing import Optional, Dict, List
+from sqlalchemy import Table, Column, UniqueConstraint, PrimaryKeyConstraint, and_, case
+from sqlalchemy.types import Integer, String, TIMESTAMP, Boolean
+from sqlalchemy.schema import ForeignKey
+from sqlalchemy.sql import func, select, update, delete
+from sqlalchemy.engine import Row
+from sqlalchemy.dialects.mysql import insert
+
+from core.data.schema import BaseData, metadata
+
+equipment_data = Table(
+    "sao_equipment_data",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("equipment_id", Integer, nullable=False),
+    Column("enhancement_value", Integer, nullable=False),
+    Column("enhancement_exp", Integer, nullable=False),
+    Column("awakening_exp", Integer, nullable=False),
+    Column("awakening_stage", Integer, nullable=False),
+    Column("possible_awakening_flag", Integer, nullable=False),
+    Column("get_date", TIMESTAMP, nullable=False, server_default=func.now()),
+    UniqueConstraint("user", "equipment_id", name="sao_equipment_data_uk"),
+    mysql_charset="utf8mb4",
+)
+
+item_data = Table(
+    "sao_item_data",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("item_id", Integer, nullable=False),
+    Column("get_date", TIMESTAMP, nullable=False, server_default=func.now()),
+    UniqueConstraint("user", "item_id", name="sao_item_data_uk"),
+    mysql_charset="utf8mb4",
+)
+
+hero_log_data = Table(
+    "sao_hero_log_data",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("user_hero_log_id", Integer, nullable=False),
+    Column("log_level", Integer, nullable=False),
+    Column("log_exp", Integer, nullable=False),
+    Column("main_weapon", Integer, nullable=False),
+    Column("sub_equipment", Integer, nullable=False),
+    Column("skill_slot1_skill_id", Integer, nullable=False),
+    Column("skill_slot2_skill_id", Integer, nullable=False),
+    Column("skill_slot3_skill_id", Integer, nullable=False),
+    Column("skill_slot4_skill_id", Integer, nullable=False),
+    Column("skill_slot5_skill_id", Integer, nullable=False),
+    Column("get_date", TIMESTAMP, nullable=False, server_default=func.now()),
+    UniqueConstraint("user", "user_hero_log_id", name="sao_hero_log_data_uk"),
+    mysql_charset="utf8mb4",
+)
+
+hero_party = Table(
+    "sao_hero_party",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("user_party_team_id", Integer, nullable=False),
+    Column("user_hero_log_id_1", Integer, nullable=False),
+    Column("user_hero_log_id_2", Integer, nullable=False),
+    Column("user_hero_log_id_3", Integer, nullable=False),
+    UniqueConstraint("user", "user_party_team_id", name="sao_hero_party_uk"),
+    mysql_charset="utf8mb4",
+)
+
+quest = Table(
+    "sao_player_quest",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("episode_id", Integer, nullable=False),
+    Column("quest_clear_flag", Boolean, nullable=False),
+    Column("clear_time", Integer, nullable=False),
+    Column("combo_num", Integer, nullable=False),
+    Column("total_damage", Integer, nullable=False),
+    Column("concurrent_destroying_num", Integer, nullable=False),
+    Column("play_date", TIMESTAMP, nullable=False, server_default=func.now()),
+    UniqueConstraint("user", "episode_id", name="sao_player_quest_uk"),
+    mysql_charset="utf8mb4",
+)
+
+sessions = Table(
+    "sao_play_sessions",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("user_party_team_id", Integer, nullable=False),
+    Column("episode_id", Integer, nullable=False),
+    Column("play_mode", Integer, nullable=False),
+    Column("quest_drop_boost_apply_flag", Integer, nullable=False),
+    Column("play_date", TIMESTAMP, nullable=False, server_default=func.now()),
+    UniqueConstraint("user", "user_party_team_id", "play_date", name="sao_play_sessions_uk"),
+    mysql_charset="utf8mb4",
+)
+
+class SaoItemData(BaseData):
+    def create_session(self, user_id: int, user_party_team_id: int, episode_id: int, play_mode: int, quest_drop_boost_apply_flag: int) -> Optional[int]:
+        sql = insert(sessions).values(
+            user=user_id,
+            user_party_team_id=user_party_team_id,
+            episode_id=episode_id,
+            play_mode=play_mode,
+            quest_drop_boost_apply_flag=quest_drop_boost_apply_flag
+            )
+
+        conflict = sql.on_duplicate_key_update(user=user_id)
+
+        result = self.execute(conflict)
+        if result is None:
+            self.logger.error(f"Failed to create SAO session for user {user_id}!")
+            return None
+        return result.lastrowid
+
+    def put_item(self, user_id: int, item_id: int) -> Optional[int]:
+        sql = insert(item_data).values(
+            user=user_id,
+            item_id=item_id,
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            item_id=item_id,
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            self.logger.error(
+                f"{__name__} failed to insert item! user: {user_id}, item_id: {item_id}"
+            )
+            return None
+
+        return result.lastrowid
+    
+    def put_equipment_data(self, user_id: int, equipment_id: int, enhancement_value: int, enhancement_exp: int, awakening_exp: int, awakening_stage: int, possible_awakening_flag: int) -> Optional[int]:
+        sql = insert(equipment_data).values(
+            user=user_id,
+            equipment_id=equipment_id,
+            enhancement_value=enhancement_value,
+            enhancement_exp=enhancement_exp,
+            awakening_exp=awakening_exp,
+            awakening_stage=awakening_stage,
+            possible_awakening_flag=possible_awakening_flag,
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            enhancement_value=enhancement_value,
+            enhancement_exp=enhancement_exp,
+            awakening_exp=awakening_exp,
+            awakening_stage=awakening_stage,
+            possible_awakening_flag=possible_awakening_flag,
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            self.logger.error(
+                f"{__name__} failed to insert equipment! user: {user_id}, equipment_id: {equipment_id}"
+            )
+            return None
+
+        return result.lastrowid
+
+    def put_hero_log(self, user_id: int, user_hero_log_id: int, log_level: int, log_exp: int, main_weapon: int, sub_equipment: int, skill_slot1_skill_id: int, skill_slot2_skill_id: int, skill_slot3_skill_id: int, skill_slot4_skill_id: int, skill_slot5_skill_id: int) -> Optional[int]:
+        sql = insert(hero_log_data).values(
+            user=user_id,
+            user_hero_log_id=user_hero_log_id,
+            log_level=log_level,
+            log_exp=log_exp,
+            main_weapon=main_weapon,
+            sub_equipment=sub_equipment,
+            skill_slot1_skill_id=skill_slot1_skill_id,
+            skill_slot2_skill_id=skill_slot2_skill_id,
+            skill_slot3_skill_id=skill_slot3_skill_id,
+            skill_slot4_skill_id=skill_slot4_skill_id,
+            skill_slot5_skill_id=skill_slot5_skill_id,
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            log_level=log_level,
+            log_exp=log_exp,
+            main_weapon=main_weapon,
+            sub_equipment=sub_equipment,
+            skill_slot1_skill_id=skill_slot1_skill_id,
+            skill_slot2_skill_id=skill_slot2_skill_id,
+            skill_slot3_skill_id=skill_slot3_skill_id,
+            skill_slot4_skill_id=skill_slot4_skill_id,
+            skill_slot5_skill_id=skill_slot5_skill_id,
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            self.logger.error(
+                f"{__name__} failed to insert hero! user: {user_id}, user_hero_log_id: {user_hero_log_id}"
+            )
+            return None
+
+        return result.lastrowid
+
+    def put_hero_party(self, user_id: int, user_party_team_id: int, user_hero_log_id_1: int, user_hero_log_id_2: int, user_hero_log_id_3: int) -> Optional[int]:
+        sql = insert(hero_party).values(
+            user=user_id,
+            user_party_team_id=user_party_team_id,
+            user_hero_log_id_1=user_hero_log_id_1,
+            user_hero_log_id_2=user_hero_log_id_2,
+            user_hero_log_id_3=user_hero_log_id_3,
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            user_hero_log_id_1=user_hero_log_id_1,
+            user_hero_log_id_2=user_hero_log_id_2,
+            user_hero_log_id_3=user_hero_log_id_3,
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            self.logger.error(
+                f"{__name__} failed to insert hero party! user: {user_id}, user_party_team_id: {user_party_team_id}"
+            )
+            return None
+
+        return result.lastrowid
+
+    def put_player_quest(self, user_id: int, episode_id: int, quest_clear_flag: bool, clear_time: int, combo_num: int, total_damage: int, concurrent_destroying_num: int) -> Optional[int]:
+        sql = insert(quest).values(
+            user=user_id,
+            episode_id=episode_id,
+            quest_clear_flag=quest_clear_flag,
+            clear_time=clear_time,
+            combo_num=combo_num,
+            total_damage=total_damage,
+            concurrent_destroying_num=concurrent_destroying_num
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            quest_clear_flag=quest_clear_flag,
+            clear_time=clear_time,
+            combo_num=combo_num,
+            total_damage=total_damage,
+            concurrent_destroying_num=concurrent_destroying_num
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            self.logger.error(
+                f"{__name__} failed to insert quest! user: {user_id}, episode_id: {episode_id}"
+            )
+            return None
+
+        return result.lastrowid
+
+    def get_user_equipment(self, user_id: int, equipment_id: int) -> Optional[Dict]:
+        sql = equipment_data.select(equipment_data.c.user == user_id and equipment_data.c.equipment_id == equipment_id)
+        
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+    
+    def get_user_equipments(
+        self, user_id: int
+    ) -> Optional[List[Row]]:
+        """
+        A catch-all equipments lookup given a profile
+        """
+        sql = equipment_data.select(
+            and_(
+                equipment_data.c.user == user_id,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def get_user_items(
+        self, user_id: int
+    ) -> Optional[List[Row]]:
+        """
+        A catch-all items lookup given a profile
+        """
+        sql = item_data.select(
+            and_(
+                item_data.c.user == user_id,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def get_hero_log(
+        self, user_id: int, user_hero_log_id: int = None
+    ) -> Optional[List[Row]]:
+        """
+        A catch-all hero lookup given a profile and user_party_team_id and ID specifiers
+        """
+        sql = hero_log_data.select(
+            and_(
+                hero_log_data.c.user == user_id,
+                hero_log_data.c.user_hero_log_id == user_hero_log_id if user_hero_log_id is not None else True,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def get_hero_logs(
+        self, user_id: int
+    ) -> Optional[List[Row]]:
+        """
+        A catch-all hero lookup given a profile
+        """
+        sql = hero_log_data.select(
+            and_(
+                hero_log_data.c.user == user_id,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def get_hero_party(
+        self, user_id: int, user_party_team_id: int = None
+    ) -> Optional[List[Row]]:
+        sql = hero_party.select(
+            and_(
+                hero_party.c.user == user_id,
+                hero_party.c.user_party_team_id == user_party_team_id if user_party_team_id is not None else True,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def get_quest_log(
+        self, user_id: int, episode_id: int = None
+    ) -> Optional[List[Row]]:
+        """
+        A catch-all quest lookup given a profile and episode_id
+        """
+        sql = quest.select(
+            and_(
+                quest.c.user == user_id,
+                quest.c.episode_id == episode_id if episode_id is not None else True,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def get_quest_logs(
+        self, user_id: int
+    ) -> Optional[List[Row]]:
+        """
+        A catch-all quest lookup given a profile
+        """
+        sql = quest.select(
+            and_(
+                quest.c.user == user_id,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def get_session(
+        self, user_id: int = None
+    ) -> Optional[List[Row]]:
+        sql = sessions.select(
+            and_(
+                sessions.c.user == user_id,
+            )
+        ).order_by(
+            sessions.c.play_date.asc()
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def remove_hero_log(self, user_id: int, user_hero_log_id: int) -> None:
+        sql = hero_log_data.delete(
+           and_(
+                hero_log_data.c.user == user_id,
+                hero_log_data.c.user_hero_log_id == user_hero_log_id,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            self.logger.error(
+                f"{__name__} failed to remove hero log! profile: {user_id}, user_hero_log_id: {user_hero_log_id}"
+            )
+        return None
+
+    def remove_equipment(self, user_id: int, equipment_id: int) -> None:
+        sql = equipment_data.delete(
+            and_(equipment_data.c.user == user_id, equipment_data.c.equipment_id == equipment_id)
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            self.logger.error(
+                f"{__name__} failed to remove equipment! profile: {user_id}, equipment_id: {equipment_id}"
+            )
+        return None
+
+    def remove_item(self, user_id: int, item_id: int) -> None:
+        sql = item_data.delete(
+            and_(item_data.c.user == user_id, item_data.c.item_id == item_id)
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            self.logger.error(
+                f"{__name__} failed to remove item! profile: {user_id}, item_id: {item_id}"
+            )
+        return None
--- a/titles/sao/schema/profile.py
+++ b/titles/sao/schema/profile.py
@ -0,0 +1,80 @@
+from typing import Optional, Dict, List
+from sqlalchemy import Table, Column, UniqueConstraint, PrimaryKeyConstraint, and_, case
+from sqlalchemy.types import Integer, String, TIMESTAMP, Boolean, JSON
+from sqlalchemy.schema import ForeignKey
+from sqlalchemy.sql import func, select, update, delete
+from sqlalchemy.engine import Row
+from sqlalchemy.dialects.mysql import insert
+
+from core.data.schema import BaseData, metadata
+from ..const import SaoConstants
+
+profile = Table(
+    "sao_profile",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+        unique=True,
+    ),
+    Column("user_type", Integer, server_default="1"),
+    Column("nick_name", String(16), server_default="PLAYER"),
+    Column("rank_num", Integer, server_default="1"),
+    Column("rank_exp", Integer, server_default="0"),
+    Column("own_col", Integer, server_default="0"),
+    Column("own_vp", Integer, server_default="0"),
+    Column("own_yui_medal", Integer, server_default="0"),
+    Column("setting_title_id", Integer, server_default="20005"),
+)
+
+class SaoProfileData(BaseData):
+    def create_profile(self, user_id: int) -> Optional[int]:
+        sql = insert(profile).values(user=user_id)
+        conflict = sql.on_duplicate_key_update(user=user_id)
+
+        result = self.execute(conflict)
+        if result is None:
+            self.logger.error(f"Failed to create SAO profile for user {user_id}!")
+            return None
+        return result.lastrowid
+
+    def put_profile(self, user_id: int, user_type: int, nick_name: str, rank_num: int, rank_exp: int, own_col: int, own_vp: int, own_yui_medal: int, setting_title_id: int) -> Optional[int]:
+        sql = insert(profile).values(
+            user=user_id,
+            user_type=user_type,
+            nick_name=nick_name,
+            rank_num=rank_num,
+            rank_exp=rank_exp,
+            own_col=own_col,
+            own_vp=own_vp,
+            own_yui_medal=own_yui_medal,
+            setting_title_id=setting_title_id
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            rank_num=rank_num,
+            rank_exp=rank_exp,
+            own_col=own_col,
+            own_vp=own_vp,
+            own_yui_medal=own_yui_medal,
+            setting_title_id=setting_title_id
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            self.logger.error(
+                f"{__name__} failed to insert profile! user: {user_id}"
+            )
+            return None
+
+        print(result.lastrowid)
+        return result.lastrowid
+
+    def get_profile(self, user_id: int) -> Optional[Row]:
+        sql = profile.select(profile.c.user == user_id)
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
--- a/titles/sao/schema/static.py
+++ b/titles/sao/schema/static.py
@ -0,0 +1,360 @@
+from typing import Dict, List, Optional
+from sqlalchemy import Table, Column, UniqueConstraint, PrimaryKeyConstraint, and_
+from sqlalchemy.types import Integer, String, TIMESTAMP, Boolean, JSON, Float
+from sqlalchemy.engine.base import Connection
+from sqlalchemy.engine import Row
+from sqlalchemy.schema import ForeignKey
+from sqlalchemy.sql import func, select
+from sqlalchemy.dialects.mysql import insert
+
+from core.data.schema import BaseData, metadata
+
+quest = Table(
+    "sao_static_quest",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column("version", Integer),
+    Column("questSceneId", Integer),
+    Column("sortNo", Integer),
+    Column("name", String(255)),
+    Column("enabled", Boolean),
+    UniqueConstraint(
+        "version", "questSceneId", name="sao_static_quest_uk"
+    ),
+    mysql_charset="utf8mb4",
+)
+
+hero = Table(
+    "sao_static_hero_list",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column("version", Integer),
+    Column("heroLogId", Integer),
+    Column("name", String(255)),
+    Column("nickname", String(255)),
+    Column("rarity", Integer),
+    Column("skillTableSubId", Integer),
+    Column("awakeningExp", Integer),
+    Column("flavorText", String(255)),
+    Column("enabled", Boolean),
+    UniqueConstraint(
+        "version", "heroLogId", name="sao_static_hero_list_uk"
+    ),
+    mysql_charset="utf8mb4",
+)
+
+equipment = Table(
+    "sao_static_equipment_list",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column("version", Integer),
+    Column("equipmentId", Integer),
+    Column("equipmentType", Integer),
+    Column("weaponTypeId", Integer),
+    Column("name", String(255)),
+    Column("rarity", Integer),
+    Column("flavorText", String(255)),
+    Column("enabled", Boolean),
+    UniqueConstraint(
+        "version", "equipmentId", name="sao_static_equipment_list_uk"
+    ),
+    mysql_charset="utf8mb4",
+)
+
+item = Table(
+    "sao_static_item_list",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column("version", Integer),
+    Column("itemId", Integer),
+    Column("itemTypeId", Integer),
+    Column("name", String(255)),
+    Column("rarity", Integer),
+    Column("flavorText", String(255)),
+    Column("enabled", Boolean),
+    UniqueConstraint(
+        "version", "itemId", name="sao_static_item_list_uk"
+    ),
+    mysql_charset="utf8mb4",
+)
+
+support = Table(
+    "sao_static_support_log_list",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column("version", Integer),
+    Column("supportLogId", Integer),
+    Column("charaId", Integer),
+    Column("name", String(255)),
+    Column("rarity", Integer),
+    Column("salePrice", Integer),
+    Column("skillName", String(255)),
+    Column("enabled", Boolean),
+    UniqueConstraint(
+        "version", "supportLogId", name="sao_static_support_log_list_uk"
+    ),
+    mysql_charset="utf8mb4",
+)
+
+rare_drop = Table(
+    "sao_static_rare_drop_list",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column("version", Integer),
+    Column("questRareDropId", Integer),
+    Column("commonRewardId", Integer),
+    Column("enabled", Boolean),
+    UniqueConstraint(
+        "version", "questRareDropId", "commonRewardId", name="sao_static_rare_drop_list_uk"
+    ),
+    mysql_charset="utf8mb4",
+)
+
+title = Table(
+    "sao_static_title_list",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column("version", Integer),
+    Column("titleId", Integer),
+    Column("displayName", String(255)),
+    Column("requirement", Integer),
+    Column("rank", Integer),
+    Column("imageFilePath", String(255)),
+    Column("enabled", Boolean),
+    UniqueConstraint(
+        "version", "titleId", name="sao_static_title_list_uk"
+    ),
+    mysql_charset="utf8mb4",
+)
+
+class SaoStaticData(BaseData):
+    def put_quest( self, questSceneId: int, version: int, sortNo: int, name: str, enabled: bool ) -> Optional[int]:
+        sql = insert(quest).values(
+            questSceneId=questSceneId,
+            version=version,
+            sortNo=sortNo,
+            name=name,
+            tutorial=tutorial,
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            name=name, questSceneId=questSceneId, version=version
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            return None
+        return result.lastrowid
+    
+    def put_hero( self, version: int, heroLogId: int, name: str, nickname: str, rarity: int, skillTableSubId: int, awakeningExp: int, flavorText: str, enabled: bool ) -> Optional[int]:
+        sql = insert(hero).values(
+            version=version,
+            heroLogId=heroLogId,
+            name=name,
+            nickname=nickname,
+            rarity=rarity,
+            skillTableSubId=skillTableSubId,
+            awakeningExp=awakeningExp,
+            flavorText=flavorText,
+            enabled=enabled
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            name=name, heroLogId=heroLogId
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            return None
+        return result.lastrowid
+    
+    def put_equipment( self, version: int, equipmentId: int, name: str, equipmentType: int, weaponTypeId:int, rarity: int, flavorText: str, enabled: bool ) -> Optional[int]:
+        sql = insert(equipment).values(
+            version=version,
+            equipmentId=equipmentId,
+            name=name,
+            equipmentType=equipmentType,
+            weaponTypeId=weaponTypeId,
+            rarity=rarity,
+            flavorText=flavorText,
+            enabled=enabled
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            name=name, equipmentId=equipmentId
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            return None
+        return result.lastrowid
+    
+    def put_item( self, version: int, itemId: int, name: str, itemTypeId: int, rarity: int, flavorText: str, enabled: bool ) -> Optional[int]:
+        sql = insert(item).values(
+            version=version,
+            itemId=itemId,
+            name=name,
+            itemTypeId=itemTypeId,
+            rarity=rarity,
+            flavorText=flavorText,
+            enabled=enabled
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            name=name, itemId=itemId
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            return None
+        return result.lastrowid
+    
+    def put_support_log( self, version: int, supportLogId: int, charaId: int, name: str, rarity: int, salePrice: int, skillName: str, enabled: bool ) -> Optional[int]:
+        sql = insert(support).values(
+            version=version,
+            supportLogId=supportLogId,
+            charaId=charaId,
+            name=name,
+            rarity=rarity,
+            salePrice=salePrice,
+            skillName=skillName,
+            enabled=enabled
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            name=name, supportLogId=supportLogId
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            return None
+        return result.lastrowid
+
+    def put_rare_drop( self, version: int, questRareDropId: int, commonRewardId: int, enabled: bool ) -> Optional[int]:
+        sql = insert(rare_drop).values(
+            version=version,
+            questRareDropId=questRareDropId,
+            commonRewardId=commonRewardId,
+            enabled=enabled,
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            questRareDropId=questRareDropId, commonRewardId=commonRewardId, version=version
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            return None
+        return result.lastrowid
+    
+    def put_title( self, version: int, titleId: int, displayName: str, requirement: int, rank: int, imageFilePath: str, enabled: bool ) -> Optional[int]:
+        sql = insert(title).values(
+            version=version,
+            titleId=titleId,
+            displayName=displayName,
+            requirement=requirement,
+            rank=rank,
+            imageFilePath=imageFilePath,
+            enabled=enabled
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            displayName=displayName, titleId=titleId
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            return None
+        return result.lastrowid
+
+    def get_quests_ids(self, version: int, enabled: bool) -> Optional[List[Dict]]:
+        sql = quest.select(quest.c.version == version and quest.c.enabled == enabled).order_by(
+            quest.c.questSceneId.asc()
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return [list[2] for list in result.fetchall()]
+    
+    def get_hero_id(self, heroLogId: int) -> Optional[Dict]:
+        sql = hero.select(hero.c.heroLogId == heroLogId)
+        
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+    
+    def get_hero_ids(self, version: int, enabled: bool) -> Optional[List[Dict]]:
+        sql = hero.select(hero.c.version == version and hero.c.enabled == enabled).order_by(
+            hero.c.heroLogId.asc()
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return [list[2] for list in result.fetchall()]
+    
+    def get_equipment_id(self, equipmentId: int) -> Optional[Dict]:
+        sql = equipment.select(equipment.c.equipmentId == equipmentId)
+        
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+    
+    def get_equipment_ids(self, version: int, enabled: bool) -> Optional[List[Dict]]:
+        sql = equipment.select(equipment.c.version == version and equipment.c.enabled == enabled).order_by(
+            equipment.c.equipmentId.asc()
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return [list[2] for list in result.fetchall()]
+
+    def get_item_id(self, itemId: int) -> Optional[Dict]:
+        sql = item.select(item.c.itemId == itemId)
+        
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def get_rare_drop_id(self, questRareDropId: int) -> Optional[Dict]:
+        sql = rare_drop.select(rare_drop.c.questRareDropId == questRareDropId)
+        
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+    
+    def get_item_ids(self, version: int, enabled: bool) -> Optional[List[Dict]]:
+        sql = item.select(item.c.version == version and item.c.enabled == enabled).order_by(
+            item.c.itemId.asc()
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return [list[2] for list in result.fetchall()]
+    
+    def get_support_log_ids(self, version: int, enabled: bool) -> Optional[List[Dict]]:
+        sql = support.select(support.c.version == version and support.c.enabled == enabled).order_by(
+            support.c.supportLogId.asc()
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return [list[2] for list in result.fetchall()]
+    
+    def get_title_ids(self, version: int, enabled: bool) -> Optional[List[Dict]]:
+        sql = title.select(title.c.version == version and title.c.enabled == enabled).order_by(
+            title.c.titleId.asc()
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return [list[2] for list in result.fetchall()]
--- a/titles/wacca/base.py
+++ b/titles/wacca/base.py
@ -624,10 +624,10 @@ class WaccaBase:
        current_wp = profile["wp"]

        tickets = self.data.item.get_tickets(user_id)
-        new_tickets = []
+        new_tickets: List[TicketItem] = []

        for ticket in tickets:
-            new_tickets.append([ticket["id"], ticket["ticket_id"], 9999999999])
+            new_tickets.append(TicketItem(ticket["id"], ticket["ticket_id"], 9999999999))

        for item in req.itemsUsed:
            if (
@ -645,11 +645,11 @@ class WaccaBase:
                and not self.game_config.mods.infinite_tickets
            ):
                for x in range(len(new_tickets)):
-                    if new_tickets[x][1] == item.itemId:
+                    if new_tickets[x].ticketId == item.itemId:
                        self.logger.debug(
-                            f"Remove ticket ID {new_tickets[x][0]} type {new_tickets[x][1]} from {user_id}"
+                            f"Remove ticket ID {new_tickets[x].userTicketId} type {new_tickets[x].ticketId} from {user_id}"
                        )
-                        self.data.item.spend_ticket(new_tickets[x][0])
+                        self.data.item.spend_ticket(new_tickets[x].userTicketId)
                        new_tickets.pop(x)
                        break

@ -1074,17 +1074,17 @@ class WaccaBase:
                        old_score = self.data.score.get_best_score(
                            user_id, item.itemId, item.quantity
                        )
-                    if not old_score:
-                        self.data.score.put_best_score(
-                            user_id,
-                            item.itemId,
-                            item.quantity,
-                            0,
-                            [0] * 5,
-                            [0] * 13,
-                            0,
-                            0,
-                        )
+                        if not old_score:
+                            self.data.score.put_best_score(
+                                user_id,
+                                item.itemId,
+                                item.quantity,
+                                0,
+                                [0] * 5,
+                                [0] * 13,
+                                0,
+                                0,
+                            )

                    if item.quantity == 0:
                        item.quantity = WaccaConstants.Difficulty.HARD.value
--- a/titles/wacca/frontend.py
+++ b/titles/wacca/frontend.py
@ -2,8 +2,9 @@ import yaml
 import jinja2
 from twisted.web.http import Request
 from os import path
+from twisted.web.server import Session

-from core.frontend import FE_Base
+from core.frontend import FE_Base, IUserSession
 from core.config import CoreConfig
 from titles.wacca.database import WaccaData
 from titles.wacca.config import WaccaConfig
@ -27,7 +28,11 @@ class WaccaFrontend(FE_Base):
        template = self.environment.get_template(
            "titles/wacca/frontend/wacca_index.jinja"
        )
+        sesh: Session = request.getSession()
+        usr_sesh = IUserSession(sesh)
+        
        return template.render(
            title=f"{self.core_config.server.name} | {self.nav_name}",
            game_list=self.environment.globals["game_list"],
+            sesh=vars(usr_sesh)
        ).encode("utf-16")
--- a/titles/wacca/handlers/user_music.py
+++ b/titles/wacca/handlers/user_music.py
@ -93,13 +93,10 @@ class UserMusicUnlockRequest(BaseRequest):


 class UserMusicUnlockResponse(BaseResponse):
-    def __init__(self, current_wp: int = 0, tickets_remaining: List = []) -> None:
+    def __init__(self, current_wp: int = 0, tickets_remaining: List[TicketItem] = []) -> None:
        super().__init__()
        self.wp = current_wp
-        self.tickets: List[TicketItem] = []
-
-        for ticket in tickets_remaining:
-            self.tickets.append(TicketItem(ticket[0], ticket[1], ticket[2]))
+        self.tickets = tickets_remaining

    def make(self) -> Dict:
        tickets = []