Gacha geschrieben in Python-Übung 1-

Inhalt

Bisher habe ich nur die Gacha-Verarbeitung in Betracht gezogen, aber im eigentlichen Spiel

Berücksichtigen Sie das oben erwähnte Daten-Design und die Modifikation, die die Verarbeitung übernehmen können. Ab diesem Zeitpunkt wird die Datenbank auch zum Speichern von Daten verwendet, die sich auf Gacha beziehen.

** Die folgenden Quellen wurden geändert und implementiert **

Gacha geschrieben in Python-Addition der Periodeneinstellungsfunktion-

Sammeln Sie redundante Einstellungsinformationen

Gacha Informationen

id start_time end_time gacha_group gacha_lottery_id
1 2020-05-01 00:00:00 2020-05-31 23:59:59 A normal_1
2 2020-05-01 00:00:00 2020-05-31 23:59:59 A normal_11
6 2020-06-01 00:00:00 2020-06-30 23:59:59 C normal_1
7 2020-06-01 00:00:00 2020-06-30 23:59:59 C normal_11

Elemente der Gacha-Information

Die Rolle von ** Gacha-Informationen ** besteht darin, während des "Implementierungszeitraums" eine "Gruppe von Ziel-Gacha-Elementen" festzulegen und diese mit dem "Zeichnen einer Gacha" zu verknüpfen. Der einzige Unterschied zwischen den IDs ** 1 ** und ** 2 ** (oder ** 6 ** und ** 7 **) besteht darin, dass das "Zeichnen der Gacha" einmalig (einmal) oder 11 Mal hintereinander erfolgt. ist. Das Einstellen redundanter Informationen erhöht Zeit und Aufwand und führt zu Einstellungsfehlern während des Betriebs. Wenn möglich, möchte ich vermeiden, dass dieselben Informationen mehrmals festgelegt werden, daher werde ich die Datenstruktur ändern.

Änderung der Gacha-Informationsdatenstruktur

Fügen Sie aus den ** gacha ** -Informationen das Element gacha_type anstelle von gacha_lottery_id hinzu. Fügen Sie gacha_type zu ** gacha_lottery ** hinzu, um Gacha-Informationen und Gacha-Methodendefinitionsinformationen zu verknüpfen.

gacha

id start_time end_time gacha_group gacha_type
1 2020-05-01 00:00:00 2020-05-31 23:59:59 A normal
6 2020-06-01 00:00:00 2020-06-30 23:59:59 C normal

gacha_lottery

id gacha_type item_type times rarity omake_times omake_rarity cost
normal_1 normal 0 1 0 0 0 10
normal_11 normal 0 10 0 1 3 100

Stellen Sie sich Folgendes vor, das auf dem tatsächlichen Gacha-Bildschirm im Spiel angezeigt wird.

gacha_2.png

Implementierung

Da aus dieser Implementierung verschiedene Informationen aus der Datenbank abgerufen werden, erstellen Sie zunächst eine Tabelle und legen Sie die Daten fest.

Gacha DB-Informationen (werden ausgeführt, wenn sich Struktur oder Daten ändern)

gacha_db


# -*- coding: utf-8 -*-
import sqlite3
import random

def get_items():
    items = {
        5101: {"rarity": 5, "item_name": "UR_Mutig", "item_type": 1, "hp": 1200},
        4201: {"rarity": 4, "item_name": "SSR_Krieger", "item_type": 2, "hp": 1000},
        4301: {"rarity": 4, "item_name": "SSR_Magier", "item_type": 3, "hp": 800},
        4401: {"rarity": 4, "item_name": "SSR_Priester", "item_type": 4, "hp": 800},
        3201: {"rarity": 3, "item_name": "SR_Krieger", "item_type": 2, "hp": 600},
        3301: {"rarity": 3, "item_name": "SR_Magier", "item_type": 3, "hp": 500},
        3401: {"rarity": 3, "item_name": "SR_Priester", "item_type": 4, "hp": 500},
        2201: {"rarity": 2, "item_name": "R_Krieger", "item_type": 2, "hp": 400},
        2301: {"rarity": 2, "item_name": "R_Magier", "item_type": 3, "hp": 300},
        2401: {"rarity": 2, "item_name": "R_Priester", "item_type": 4, "hp": 300},
        3199: {"rarity": 3, "item_name": "SR_Mutig", "item_type": 1, "hp": 600},
        #Unten hinzugefügt
        4101: {"rarity": 4, "item_name": "SSR_Mutig", "item_type": 1, "hp": 1000},
        5201: {"rarity": 5, "item_name": "UR_Krieger", "item_type": 2, "hp": 1300},
        5301: {"rarity": 5, "item_name": "UR_Magier", "item_type": 3, "hp": 1000},
    }

    return convert_values(items)

def get_gacha_items():
    items = {
        1:  {"gacha_group": "A", "weight": 3, "item_id": 5101},
        2:  {"gacha_group": "A", "weight": 9, "item_id": 4201},
        3:  {"gacha_group": "A", "weight": 9, "item_id": 4301},
        4:  {"gacha_group": "A", "weight": 9, "item_id": 4401},
        5:  {"gacha_group": "A", "weight": 20, "item_id": 3201},
        6:  {"gacha_group": "A", "weight": 20, "item_id": 3301},
        7:  {"gacha_group": "A", "weight": 20, "item_id": 3401},
        8:  {"gacha_group": "A", "weight": 40, "item_id": 2201},
        9:  {"gacha_group": "A", "weight": 40, "item_id": 2301},
        10: {"gacha_group": "A", "weight": 40, "item_id": 2401},
        11: {"gacha_group": "B", "weight": 15, "item_id": 4201},
        12: {"gacha_group": "B", "weight": 30, "item_id": 3201},
        13: {"gacha_group": "B", "weight": 55, "item_id": 2201},
        #Unten hinzugefügt
        14: {"gacha_group": "C", "weight": 1, "item_id": 5101},
        15: {"gacha_group": "C", "weight": 1, "item_id": 5201},
        16: {"gacha_group": "C", "weight": 1, "item_id": 5301},
        17: {"gacha_group": "C", "weight": 9, "item_id": 4101},
        18: {"gacha_group": "C", "weight": 6, "item_id": 4201},
        19: {"gacha_group": "C", "weight": 6, "item_id": 4301},
        20: {"gacha_group": "C", "weight": 6, "item_id": 4401},
        21: {"gacha_group": "C", "weight": 20, "item_id": 3201},
        22: {"gacha_group": "C", "weight": 20, "item_id": 3301},
        23: {"gacha_group": "C", "weight": 20, "item_id": 3401},
        24: {"gacha_group": "C", "weight": 40, "item_id": 2201},
        25: {"gacha_group": "C", "weight": 40, "item_id": 2301},
        26: {"gacha_group": "C", "weight": 40, "item_id": 2401},
    }

    return convert_values(items)

def get_gacha():
    items = {
        1: {"start_time": "2020-05-01 00:00:00", "end_time": "2020-05-31 23:59:59", "gacha_group": "A",
            "gacha_type": "normal"},
        3: {"start_time": "2020-05-25 00:00:00", "end_time": "2020-05-31 23:59:59", "gacha_group": "B",
            "gacha_type": "fighter"},
        4: {"start_time": "2020-06-01 00:00:00", "end_time": "2020-06-04 23:59:59", "gacha_group": "C",
            "gacha_type": "omake_2"},
        5: {"start_time": "2020-05-20 00:00:00", "end_time": "2020-05-31 23:59:59", "gacha_group": "A",
            "gacha_type": "omake_fighter"},
        6: {"start_time": "2020-06-01 00:00:00", "end_time": "2020-06-30 23:59:59", "gacha_group": "C",
            "gacha_type": "normal"},
    }

    return convert_values(items)

def get_gacha_lottery():
    items = {
        "normal_1":  {"gacha_type": "normal", "item_type": 0, "times": 1, "rarity": 0, "omake_times": 0, "omake_rarity": 0, "cost":10},
        "normal_11":  {"gacha_type": "normal", "item_type": 0, "times": 10, "rarity": 0, "omake_times": 1, "omake_rarity": 3, "cost":100},
        "fighter":  {"gacha_type": "fighter", "item_type": 0, "times": 2, "rarity": 0, "omake_times": 0, "omake_rarity": 0, "cost":30},
        "omake_2":  {"gacha_type": "omake_2", "item_type": 0, "times": 9, "rarity": 2, "omake_times": 2, "omake_rarity": 3, "cost":150},
        "omake_fighter":  {"gacha_type": "omake_fighter", "item_type": 2, "times": 5, "rarity": 0, "omake_times": 1, "omake_rarity": 3, "cost":100}
    }

    return convert_values(items)


def convert_values(items: dict):
    values = []
    keys = []
    for id,info in items.items():
        if len(keys) == 0 :
            keys = list(info.keys())
            keys.insert(0,'id')

        value = list(info.values())
        value.insert(0,id)
        values.append(tuple(value))
    return keys,values

def print_rows(rows, keys: list):
    for row in rows:
        result = []
        for key in keys:
            result.append(str(row[key]))
        print(",".join(result))


def main():
    con = sqlite3.connect("data.db")
    con.row_factory = sqlite3.Row
    cursor = con.cursor()

    # gacha
    cursor.execute("DROP TABLE IF EXISTS gacha")

    #id
    #start_time
    #end_time
    #gacha_group
    #gacha_lottery_id
    cursor.execute(
        """CREATE TABLE gacha 
          (id INTEGER PRIMARY KEY AUTOINCREMENT
          ,start_time DATETIME
          ,end_time DATETIME
          ,gacha_group VARCHAR(32)
          ,gacha_type VARCHAR(32)
          )
        """
    )

    #         1:  {"gacha_group": "A", "weight": 3, "item_id": 5101},

    cursor.execute("DROP TABLE IF EXISTS gacha_items")
    cursor.execute(
        """CREATE TABLE gacha_items 
          (id INTEGER PRIMARY KEY AUTOINCREMENT
          ,gacha_group VARCHAR(32)
          ,weight INTEGER
          ,item_id INTEGER
          )
        """
    )

    #  "normal_1":  {"item_type": 0, "times": 1, "rarity": 0, "omake_times": 0, "omake_rarity": 0, "cost":10},

    cursor.execute("DROP TABLE IF EXISTS gacha_lottery")
    cursor.execute(
        """CREATE TABLE gacha_lottery 
          (id VARCHAR(32) PRIMARY KEY
          ,gacha_type VARCHAR(32)
          ,item_type INTEGER
          ,times INTEGER
          ,rarity INTEGER
          ,omake_times INTEGER
          ,omake_rarity INTEGER
          ,cost INTEGER
          )
        """
    )

    #        5101: {"rarity": 5, "item_name": "UR_Mutig", "item_type": 1, "hp": 1200},
    cursor.execute("DROP TABLE IF EXISTS items")
    cursor.execute(
        """CREATE TABLE items 
          (id INTEGER PRIMARY KEY AUTOINCREMENT
          ,rarity INTEGER
          ,item_name VARCHAR(64)
          ,item_type INTEGER
          ,hp INTEGER
          )
        """
    )

    keys, values = get_items()
    sql = "insert into {0}({1}) values({2})".format('items', ','.join(keys), ','.join(['?'] * len(keys)))
    cursor.executemany(sql,values)
    select_sql = "SELECT * FROM items ORDER BY id"
    result = cursor.execute(select_sql)
    print("===items===")
    print_rows(result, keys)

    keys, values = get_gacha_items()
    sql = "insert into {0}({1}) values({2})".format('gacha_items', ','.join(keys), ','.join(['?'] * len(keys)))
    cursor.executemany(sql,values)
    select_sql = "SELECT * FROM gacha_items ORDER BY id"
    result = cursor.execute(select_sql)
    print("===gacha_items===")
    print_rows(result, keys)


    keys, values = get_gacha()
    sql = "insert into {0}({1}) values({2})".format('gacha', ','.join(keys), ','.join(['?'] * len(keys)))
    cursor.executemany(sql,values)
    select_sql = "SELECT * FROM gacha ORDER BY id"
    result = cursor.execute(select_sql)
    print("===gacha===")
    print_rows(result, keys)

    keys, values = get_gacha_lottery()
    sql = "insert into {0}({1}) values({2})".format('gacha_lottery', ','.join(keys), ','.join(['?'] * len(keys)))
    cursor.executemany(sql,values)
    select_sql = "SELECT * FROM gacha_lottery ORDER BY id"
    result = cursor.execute(select_sql)
    print("===gacha_lottery===")
    print_rows(result, keys)


    con.commit()
    con.close()

if __name__ == '__main__':
    main()

Gacha-Verarbeitung

gacha.py


import random
import sqlite3
from datetime import datetime

def convert_row2dict(row) -> dict:
    keys = row.keys()
    return {key: row[key] for key in keys}


def gacha(lots, times: int=1) -> list:
    return random.choices(tuple(lots), weights=lots.values(), k=times)

def get_rarity_name(rarity: int) -> str:
    rarity_names = {5: "UR", 4: "SSR", 3: "SR", 2: "R", 1: "N"}
    return rarity_names[rarity]

#Ausführbare Gacha-Informationsliste
def get_gacha_list(cursor, now_time: int) -> dict:
    select_sql = "SELECT * FROM gacha ORDER BY id"
    rows = cursor.execute(select_sql)
    results = {}
    for row in rows:
        start_time = int(datetime.strptime(row["start_time"], '%Y-%m-%d %H:%M:%S').timestamp())
        end_time = int(datetime.strptime(row["end_time"], '%Y-%m-%d %H:%M:%S').timestamp())
        #Grenzen Sie die Ziel-Gacha-Informationen im Bereich von Datum und Uhrzeit ein
        if start_time <= now_time <= end_time:
            results[row["id"]] = convert_row2dict(row)

    return results

#Ausführbare Gacha-Informationsliste (Gacha_(Einschließlich Lotterieinformationen)
def get_available_gacha_info_list(cursor, now_time: int) -> dict:
    gacha_list = get_gacha_list(cursor, now_time)
    for gacha_id, info in gacha_list.items():
        lottery_info_list = get_gacha_lottery_by_type(cursor, info["gacha_type"])
        gacha_list[gacha_id]["gacha_lottery_list"] = lottery_info_list
    return gacha_list

def get_gacha(cursor, gacha_id: int, now_time: int) -> dict:
    select_sql = "SELECT * FROM gacha WHERE id = ? ORDER BY id"
    cursor.execute(select_sql, (gacha_id,))
    row = cursor.fetchone()
    start_time = int(datetime.strptime(row["start_time"], '%Y-%m-%d %H:%M:%S').timestamp())
    end_time = int(datetime.strptime(row["end_time"], '%Y-%m-%d %H:%M:%S').timestamp())
    #Grenzen Sie die Ziel-Gacha-Informationen im Bereich von Datum und Uhrzeit ein
    if start_time <= now_time <= end_time:
        return convert_row2dict(row)

    return {}


def get_gacha_lottery(cursor, gacha_lottery_id: str) -> dict:
    select_sql = "SELECT * FROM gacha_lottery WHERE id = ? ORDER BY id"
    cursor.execute(select_sql, (gacha_lottery_id,))
    row = cursor.fetchone()
    return convert_row2dict(row)


def get_gacha_lottery_by_type(cursor, gacha_type: str) -> list:
    select_sql = "SELECT * FROM gacha_lottery WHERE gacha_type = ? ORDER BY id"
    rows = cursor.execute(select_sql, (gacha_type,))
    results = []
    for row in rows:
        row_dict = convert_row2dict(row)
        results.append(row_dict)
    return results


def get_items_all(cursor) -> dict:
    select_sql = "SELECT * FROM items ORDER BY id"
    rows = cursor.execute(select_sql)
    results = {}
    for row in rows:
        row_dict = convert_row2dict(row)
        results[row["id"]] = row_dict
    return results


def get_gacha_items(cursor, gacha_group: str) -> dict:
    select_sql = "SELECT * FROM gacha_items WHERE gacha_group = ? ORDER BY id"
    rows = cursor.execute(select_sql, (gacha_group,))
    results = {}
    for row in rows:
        row_dict = convert_row2dict(row)
        results[row["id"]] = row_dict
    return results


def get_gacha_items_all(cursor) -> dict:
    select_sql = "SELECT * FROM gacha_items ORDER BY id"
    rows = cursor.execute(select_sql)
    results = {}
    for row in rows:
        row_dict = convert_row2dict(row)
        results[row["id"]] = row_dict
    return results



def get_gacha_info(cursor, gacha_id: int, gacha_lottery_id: str, now_time: int):
    gacha = get_gacha(cursor, gacha_id, now_time)
    gacha_lottery = get_gacha_lottery(cursor, gacha_lottery_id)

    if gacha["gacha_type"] != gacha_lottery["gacha_type"]:
        return None, None

    return gacha, gacha_lottery


def set_gacha(cursor, now_time: int):
    cursor = cursor
    now_time = now_time
    items = get_items_all(cursor)

    #Extrahieren Sie die Lotteriezielliste
    def get_lots(gacha_group: str, lottery_info: dict):
        gacha_items = get_gacha_items(cursor, gacha_group)
        dic_gacha_items = {}
        for gacha_item_id, gacha_item in gacha_items.items():
            gacha_item["item_info"] = items[gacha_item["item_id"]]
            dic_gacha_items[gacha_item_id] = gacha_item

        lots = {}
        omake_lots = {}
        for id, info in dic_gacha_items.items():
            if lottery_info["item_type"] and lottery_info["item_type"] != info["item_info"]["item_type"]:
                continue

            if not(lottery_info["rarity"]) or lottery_info["rarity"] <= info["item_info"]["rarity"]:
                lots[id] = info["weight"]

            if lottery_info["omake_times"]:
                if not(lottery_info["omake_rarity"]) or lottery_info["omake_rarity"] <= info["item_info"]["rarity"]:
                    omake_lots[id] = info["weight"]

        return lots, omake_lots

    #Gacha Hinrichtung
    def exec(exec_gacha_id: int, exec_gacha_lottery_id: str) -> list:
        gacha_info, gacha_lottery_info = get_gacha_info(cursor, exec_gacha_id, exec_gacha_lottery_id, now_time)

        print("==%s==:gacha_group:%s" % (gacha_lottery_info["id"], gacha_info["gacha_group"]))
        lots, omake_lots = get_lots(gacha_info["gacha_group"], gacha_lottery_info)
        ids = gacha(lots, gacha_lottery_info["times"])
        if len(omake_lots) > 0:
            ids.extend(gacha(omake_lots, gacha_lottery_info["omake_times"]))

        return ids

    return exec


def main():
    con = sqlite3.connect("data.db")
    con.row_factory = sqlite3.Row
    cursor = con.cursor()


    #Geben Sie das Datum und die Uhrzeit der Gacha-Ausführung an, um den Vorgang zu überprüfen
    now_time = int(datetime.strptime("2020-05-01 00:00:00", '%Y-%m-%d %H:%M:%S').timestamp())

    #Initialisierung (Ausführungsdatum und -zeit, Elemente usw. festlegen)
    func_gacha = set_gacha(cursor, now_time)

    items = get_items_all(cursor)
    gacha_items = get_gacha_items_all(cursor)
    #Single-Shot-Gacha ausführen
    # gacha_id und gacha_lottery_ID zur Laufzeit übergeben
    ids = func_gacha(1,"normal_1")
    for id in ids:
        item_info = items[gacha_items[id]["item_id"]]
        print("ID:%d, %s, %s" % (id, get_rarity_name(item_info["rarity"]), item_info["item_name"]))

    #Führen Sie 11 aufeinanderfolgende Gachas aus
    # gacha_id und gacha_lottery_ID zur Laufzeit übergeben
    ids = func_gacha(1,"normal_11")
    for id in ids:
        item_info = items[gacha_items[id]["item_id"]]
        print("ID:%d, %s, %s" % (id, get_rarity_name(item_info["rarity"]), item_info["item_name"]))

    #con.commit()
    con.close()


if __name__ == '__main__':
    main()

Ausführungsergebnis

==normal_1==:gacha_group:A
ID:8, R, R_Krieger
==normal_11==:gacha_group:A
ID:5, SR, SR_Krieger
ID:8, R, R_Krieger
ID:3, SSR, SSR_Magier
ID:10, R, R_Priester
ID:9, R, R_Magier
ID:9, R, R_Magier
ID:8, R, R_Krieger
ID:1, UR, UR_Mutig
ID:10, R, R_Priester
ID:10, R, R_Priester
ID:7, SR, SR_Priester

Ergänzung

Sie fragen sich möglicherweise, ob Sie ** gacha_id ** und ** gacha_lottery_id ** als Argumente übergeben, wenn Sie die Gacha ausführen. Alles, was Sie brauchen, um eine Gacha auszuführen, ist ** gacha_lottery_id **. Wenn Sie den zugehörigen gacha_type und ** gacha_id ** erhalten, die dem Datum und der Uhrzeit der Verarbeitung entsprechen, gibt es kein Problem mit der Gacha-Verarbeitung. Wenn die Gacha jedoch zum "Schaltzeitpunkt" der Gacha-Ausführungsperiode ausgeführt wird, kann der Benutzer die Gacha des Zielgegenstandes ausführen, die sich von dem Zielgegenstand unterscheidet, den er / sie zeichnen möchte.

Beispiel

Um dies zu vermeiden, wird ** gacha_id ** auch als Argument bei der Ausführung der Gacha übergeben. Wenn diese ** gacha_id ** nicht durch den Implementierungszeitraum abgedeckt ist, ist die Gacha beendet und der Benutzer wird informiert. Benachrichtigen Sie den Gacha-Bildschirm und zeigen Sie ihn erneut an. Gacha ist ein Prozess, bei dem davon ausgegangen wird, dass die Abrechnung erfolgt. Daher muss verhindert werden, dass die Verarbeitung stark von der Absicht des Benutzers abweicht.

In dieser Quelle wird die Fehlerbehandlung ein wenig weggelassen. Berücksichtigen und implementieren Sie daher die für die Anwendung erforderliche Fehlerbehandlung.

Recommended Posts

Gacha geschrieben in Python-Übung 1-
Gacha geschrieben in Python-Übung 2 ・ Grundlagen der Step-up-Gacha-
Gacha geschrieben in Python-Data Design-
Gacha geschrieben in Python-Übung 3 ・ Hinzufügen von Step-up-Gacha-Funktionen-
Gacha geschrieben in Python -BOX Gacha-
Einfache Gacha-Logik in Python geschrieben
Gacha in Python-Rarity geschrieben mit Bonus bestätigt
Gacha geschrieben in Python-Implementierung in grundlegende Datenstruktur-
Gacha geschrieben in Python-Addition der Periodeneinstellungsfunktion-
Cooles Lisp geschrieben in Python: Hy
Kompatibilitätsdiagnoseprogramm in Python geschrieben
In Python geschriebener Fourier-Serien-Verifizierungscode
Stresstest mit Locust in Python geschrieben
Übergangswahrscheinlichkeit der in Python geschriebenen Markov-Kette