Gacha geschrieben in Python-Übung 3 ・ Hinzufügen von Step-up-Gacha-Funktionen-

Inhalt

Letztes Mal habe ich eine Step-up-Gacha erstellt. Dieses Mal werden wir der Step-up-Gacha eine Steuerungsverarbeitung hinzufügen und sie so modifizieren, dass sie praktischer verwendet werden kann.

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

Gacha geschrieben in Python-Übung 2 / Grundlagen der Step-up-Gacha-

Reparatur von Step-up-Gacha

Bei dieser Renovierung wird der Step-up-Gacha die folgende Kontrollverarbeitung hinzugefügt.

--Wiederholen

• zurücksetzen

Wiederholung

Letztes Mal Die von mir erstellte Step-up-Gacha sollte enden, wenn sie zum letzten Schritt übergeht. Im eigentlichen Spiel gibt es eine Gacha, mit der Sie den letzten Schritt nach dem letzten Schritt wiederholt zeichnen können. Um dies zu erreichen, müssen wir die Kontrolle für "Wiederholung" hinzufügen. Lassen Sie uns dieses Mal darüber nachdenken, wie die folgenden drei Arten von Step-up-Gacha hergestellt werden.

--step_up_N: Grundlegende Aufstockung (im letzten Schritt abgeschlossen) --step_up_S1: Schritt wiederholen (nach dem letzten Schritt zu Schritt 1 zurückkehren) --step_up_S2: Step-up-Endwiederholung (den Endschritt für immer wiederholen)

Hinzufügen einer Gacha-Typ-Einstellung (wiederholt)

Definieren von ** Wiederholungsschritten ** für Gacha-Zeichnungseinstellungen (gacha_lottery) Erstellen Sie eine Tabelle mit dem Namen Gacha Type Setting (gacha_type).

gacha_type

Das Element rotation_step_no gibt die Schritte an, zu denen nach dem letzten Schritt übergegangen werden soll. Im Fall von "0" wird definiert, dass es im letzten Schritt endet.

Reparatur der Gacha-Zieheinstellung

Ersetzen Sie das Element "gacha_type" in der Einstellung für die Gacha-Zeichnung (gacha_lottery) durch die oben festgelegte ID für die Einstellung des Gacha-Typs (gacha_type_id).

gacha_lottery

Reparatur der Einstellung der Gacha-Periode

Ersetzen Sie in ähnlicher Weise das Element "gacha_type" in der Einstellung für die Gacha-Periode (gacha) durch die ID für die Einstellung des Gacha-Typs (gacha_type_id), damit die Zuordnung zwischen der Einstellung für die Gacha-Zeichenmethode (gacha_lottery) und der Einstellung für den Gacha-Typ (gacha_type) verknüpft wird. Ich werde.

gacha

zurücksetzen

Hinzufügen (Zurücksetzen) der Gacha-Typeinstellung

Abhängig von der Operation möchten Sie möglicherweise zu einem bestimmten Zeitpunkt in den Ausgangszustand zurückkehren. Fügen Sie daher die Reset-Definition zur Einstellung für den Gacha-Typ (gacha_type) hinzu.

Abhängig von der diesmal hinzugefügten Reset-Definition wird diese je nach Zeitraum automatisch zurückgesetzt.

reset_type Es sind zwei * reset_type * zu definieren.

--daily: Kehren Sie jeden Tag beim ersten Zugriff zum Ausgangszustand (Schritt 1) zurück --monatlich: Kehren Sie jeden Monat beim ersten Zugriff zum Ausgangszustand (Schritt 1) zurück

"Monatlich ist nicht praktikabel, aber es soll den Unterschied verstehen"

gacha_type

Setzen Sie diesmal gacha_type gemäß der Einstellung für die Gacha-Periode (gacha). ** step_up_S2 ** hat keine Reset-Einstellung, da reset_type leer ist.

Implementierung

Die Implementierungsspezifikationen sind unten zusammengefasst.

Wiederholen (wenn bis zum letzten Schritt ausgeführt)

• ** Wenn in rotation_step_no 0 gesetzt ist **
• Inkrementiere (+1) und aktualisiere ** step_no ** der Benutzer-Gacha-Schrittinformationen (Gacha-Endzustand)
• ** Wenn rotation_step_no ** auf etwas anderes als "0" gesetzt ist --Update ** step_no ** der Benutzer-Gacha-Schrittinformationen mit ** rotation_step_no **

zurücksetzen

• ** Wenn "täglich" in reset_type gesetzt ist ** --Wenn ** update_time ** der Benutzer-Gacha-Schrittinformationen das Datum des Vortages ist, aktualisieren Sie mit step_no = 1

• ** Wenn in reset_type "monatlich" eingestellt ist ** --Wenn ** update_time ** der Benutzer-Gacha-Schrittinformationen das Datum des Vormonats ist, aktualisieren Sie mit step_no = 1

Gacha DB Informationen

Wenn Sie die Struktur / Daten ändern oder den Verlauf zurücksetzen möchten, führen Sie diesen Vorgang erneut aus.

gacha_db.py

# -*- 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},
        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},
        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 = {
        10: {"start_time": "2020-05-01 00:00:00", "end_time": "2020-05-31 23:59:59", "gacha_group": "A",
            "gacha_type_id": "step_up_N"},
        11: {"start_time": "2020-06-01 00:00:00", "end_time": "2020-06-30 23:59:59", "gacha_group": "C",
             "gacha_type_id": "step_up_N"},
        12: {"start_time": "2020-05-01 00:00:00", "end_time": "2020-07-31 23:59:59", "gacha_group": "A",
             "gacha_type_id": "step_up_S1"},
        13: {"start_time": "2020-05-01 00:00:00", "end_time": "2020-05-31 23:59:59", "gacha_group": "A",
             "gacha_type_id": "step_up_S2"},
        14: {"start_time": "2020-06-01 00:00:00", "end_time": "2020-06-30 23:59:59", "gacha_group": "C",
             "gacha_type_id": "step_up_S2"},
    }

    return convert_values(items)

def get_gacha_type():
    items = {
        "step_up_N":  {"rotation_step_no": 0, "kind": "step_up", "reset_type": "daily"},
        "step_up_S1": {"rotation_step_no": 1, "kind": "step_up", "reset_type": "monthly"},
        "step_up_S2": {"rotation_step_no": 4, "kind": "step_up", "reset_type": None},
    }

    return convert_values(items)


def get_gacha_lottery():
    items = {
        "normal_1":  {"gacha_type_id": "normal", "step_no": 0, "item_type": 0, "times": 1, "rarity": 0, "omake_times": 0, "omake_rarity": 0, "cost":10},
        "normal_11":  {"gacha_type_id": "normal", "step_no": 0, "item_type": 0, "times": 10, "rarity": 0, "omake_times": 1, "omake_rarity": 3, "cost":100},
        "fighter":  {"gacha_type_id": "fighter", "step_no": 0, "item_type": 0, "times": 2, "rarity": 0, "omake_times": 0, "omake_rarity": 0, "cost":30},
        "omake_2":  {"gacha_type_id": "omake_2", "step_no": 0, "item_type": 0, "times": 9, "rarity": 2, "omake_times": 2, "omake_rarity": 3, "cost":150},
        "omake_fighter":  {"gacha_type_id": "omake_fighter", "step_no": 0, "item_type": 2, "times": 5, "rarity": 0, "omake_times": 1, "omake_rarity": 3, "cost":100},
        "step_up_N_1": {"gacha_type_id": "step_up_N", "step_no": 1, "item_type": 0, "times": 1, "rarity": 0, "omake_times": 0,
                     "omake_rarity": 0, "cost": 10},
        "step_up_N_2": {"gacha_type_id": "step_up_N", "step_no": 2, "item_type": 0, "times": 2, "rarity": 0, "omake_times": 1,
                      "omake_rarity": 3, "cost": 30},
        "step_up_N_3": {"gacha_type_id": "step_up_N", "step_no": 3, "item_type": 0, "times": 3, "rarity": 0, "omake_times": 2,
                      "omake_rarity": 3, "cost": 50},
        "step_up_N_4": {"gacha_type_id": "step_up_N", "step_no": 4, "item_type": 0, "times": 4, "rarity": 0, "omake_times": 1,
                      "omake_rarity": 4, "cost": 50},
        "step_up_S1_1": {"gacha_type_id": "step_up_S1", "step_no": 1, "item_type": 0, "times": 1, "rarity": 0,
                        "omake_times": 0, "omake_rarity": 0, "cost": 10},
        "step_up_S1_2": {"gacha_type_id": "step_up_S1", "step_no": 2, "item_type": 0, "times": 2, "rarity": 0,
                        "omake_times": 1, "omake_rarity": 3, "cost": 30},
        "step_up_S1_3": {"gacha_type_id": "step_up_S1", "step_no": 3, "item_type": 0, "times": 1, "rarity": 0,
                        "omake_times": 2, "omake_rarity": 3, "cost": 30},
        "step_up_S1_4": {"gacha_type_id": "step_up_S1", "step_no": 4, "item_type": 0, "times": 3, "rarity": 0,
                        "omake_times": 2, "omake_rarity": 4, "cost": 50},
        "step_up_S2_1": {"gacha_type_id": "step_up_S2", "step_no": 1, "item_type": 0, "times": 1, "rarity": 0,
                        "omake_times": 0, "omake_rarity": 0, "cost": 10},
        "step_up_S2_2": {"gacha_type_id": "step_up_S2", "step_no": 2, "item_type": 0, "times": 2, "rarity": 0,
                        "omake_times": 1, "omake_rarity": 3, "cost": 30},
        "step_up_S2_3": {"gacha_type_id": "step_up_S2", "step_no": 3, "item_type": 0, "times": 4, "rarity": 0,
                        "omake_times": 1, "omake_rarity": 5, "cost": 50},
        "step_up_S2_4": {"gacha_type_id": "step_up_S2", "step_no": 4, "item_type": 0, "times": 4, "rarity": 0,
                        "omake_times": 1, "omake_rarity": 3, "cost": 50},
    }

    return convert_values(items)

def get_users():
    items = {
        "u001": {"nick_name": "taro"},
        "u002": {"nick_name": "hana"},
    }

    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()

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

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

    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
          )
        """
    )

    #hinzufügen
    cursor.execute("DROP TABLE IF EXISTS gacha_type")
    cursor.execute(
        """CREATE TABLE gacha_type 
          (id VARCHAR(32) PRIMARY KEY
          ,kind VARCHAR(32)
          ,rotation_step_no INTEGER
          ,reset_type VARCHAR(32)
          )
        """
    )

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

    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
          )
        """
    )

    cursor.execute("DROP TABLE IF EXISTS users")
    cursor.execute(
        """CREATE TABLE users 
          (id VARCHAR(16) PRIMARY KEY
          ,nick_name VARCHAR(64)
          )
        """
    )

    #Sanierung
    cursor.execute("DROP TABLE IF EXISTS gacha_user_step")
    cursor.execute(
        """CREATE TABLE gacha_user_step 
          (user_id VARCHAR(16) 
          ,gacha_id INTEGER
          ,gacha_type_id VARCHAR(32)
          ,step_no INTEGER DEFAULT 2
          ,updated_time DATETIME          
          ,PRIMARY KEY(user_id,gacha_id,gacha_type_id)
          )
        """
    )


    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_type()
    sql = "insert into {0}({1}) values({2})".format('gacha_type', ','.join(keys), ','.join(['?'] * len(keys)))
    cursor.executemany(sql,values)
    select_sql = "SELECT * FROM gacha_type ORDER BY id"
    result = cursor.execute(select_sql)
    print("===gach_type===")
    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)

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

    con.commit()
    con.close()

if __name__ == '__main__':
    main()

Gacha-Verarbeitung

gacha.py

import random
import sqlite3
from datetime import datetime
from typing import Dict, List, Tuple, Optional

def convert_row2dict(row) -> Dict:
    if row is None:
        return {}
    return {key: row[key] for key in row.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, user_id:str) -> 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_id"])
        gacha_user = get_gacha_user_step(cursor, user_id, gacha_id, info["gacha_type_id"])

        set_list = []
        for lottery_info in lottery_info_list:
            if lottery_info["step_no"] > 0:
                now_step_no = 1
                if len(gacha_user) > 0:
                    now_step_no = gacha_user["step_no"] + 1
                if now_step_no == lottery_info["step_no"]:
                    set_list.append(lottery_info)
            else:
                set_list.append(lottery_info)
        gacha_list[gacha_id]["gacha_lottery_list"] = set_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_type(cursor, gacha_type_id: str) -> Dict:
    select_sql = "SELECT * FROM gacha_type WHERE id = ? ORDER BY id"
    cursor.execute(select_sql, (gacha_type_id,))
    return convert_row2dict(cursor.fetchone())

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,))
    return convert_row2dict(cursor.fetchone())


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

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

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,))
    return {
        row["id"]: convert_row2dict(row)
        for row in rows
    }

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

def get_gacha_info(cursor, gacha_id: int, gacha_lottery_id: str, now_time: int, user_id: str) -> Tuple[Optional[Dict], Optional[Dict]]:
    gacha = get_gacha(cursor, gacha_id, now_time)
    gacha_lottery = get_gacha_lottery(cursor, gacha_lottery_id)

    if len(gacha) == 0:
        print("===Gacha, die nicht ausgeführt werden kann_id:%s===" % (gacha_id))
        return None, None

    if len(gacha_lottery) == 0:
        print("===Gacha, die es nicht gibt_lottery_id:%s===" % (gacha_lottery_id))
        return None, None

    if gacha["gacha_type_id"] != gacha_lottery["gacha_type_id"]:
        print("===gacha_type_ID ist anders:%s,%s===" % (gacha["gacha_type_id"],gacha_lottery["gacha_type_id"]))
        return None, None

    # step_bis Gacha Check
    if gacha_lottery["step_no"] > 0:
        # user_Schritt zurücksetzen
        reset_gacha_user_step(cursor, user_id, gacha_id, gacha["gacha_type_id"], now_time)

        max_step_no = get_max_step_no(cursor, gacha["gacha_type_id"])
        gacha_user = get_gacha_user_step(cursor, user_id, gacha_id, gacha["gacha_type_id"])
        step_no = 1
        if len(gacha_user) > 0:
            step_no = gacha_user["step_no"]
        if max_step_no < step_no:
            print("===Bis zum Maximalschritt wurde ausgeführt (Maximalschritt):%s, der Schritt, den Sie ausführen werden:%s）===" %(max_step_no,gacha_lottery["step_no"]))
            return None, None

        if gacha_lottery["step_no"] != step_no:
            print("===Anders als die Schritte, die ausgeführt werden können (aktueller Schritt:%s, der Schritt, den Sie ausführen werden:%s）===" %(step_no, gacha_lottery["step_no"]))
            return None, None

    return gacha, gacha_lottery


def get_gacha_user_step(cursor, user_id: str, gacha_id: int, gacha_type_id: str) -> Dict:
    select_sql = "SELECT * FROM gacha_user_step WHERE user_id = ? AND gacha_id = ? AND gacha_type_id = ?"
    cursor.execute(select_sql, (user_id,gacha_id,gacha_type_id))
    row = cursor.fetchone()

    return convert_row2dict(row)

def get_max_step_no(cursor, gacha_type_id: str) -> Dict:
    select_sql = "SELECT MAX(step_no) AS max_step_no FROM gacha_lottery WHERE gacha_type_id = ?"
    cursor.execute(select_sql, (gacha_type_id,))
    row = cursor.fetchone()

    row_dict = convert_row2dict(row)
    return row_dict["max_step_no"]

def insert_gacha_user_step(cursor, step_no: int, user_id: str, gacha_id: int, gacha_type_id: str, update_time: int) -> None:
    dt = datetime.fromtimestamp(update_time)
    keys = ("user_id", "gacha_id", "gacha_type_id", "updated_time", "step_no")
    sql = "insert into {0}({1}) values({2})".format('gacha_user_step', ','.join(keys), ','.join(['?'] * len(keys)))
    cursor.execute(sql, (user_id, gacha_id, gacha_type_id, dt, step_no))

def update_gacha_user_step(cursor, step_no: int, user_id: str, gacha_id: int, gacha_type_id: str, update_time: int) -> None:
    dt = datetime.fromtimestamp(update_time)
    sql = "UPDATE gacha_user_step SET step_no = ?, updated_time = ? WHERE user_id = ? AND gacha_id = ? AND gacha_type_id = ?"
    cursor.execute(sql, (step_no, dt, user_id, gacha_id, gacha_type_id))

def next_gacha_user_step(cursor, user_id: str, gacha_id: int, gacha_type_id: str, update_time: int) -> None:
    row = get_gacha_user_step(cursor, user_id, gacha_id, gacha_type_id)
    if len(row) == 0:
        insert_gacha_user_step(
            cursor,
            rotation_gacha_user_step(cursor, gacha_type_id, 1),
            user_id, gacha_id, gacha_type_id, update_time
        )
    else:
        update_gacha_user_step(
            cursor,
            rotation_gacha_user_step(cursor, gacha_type_id, row["step_no"]),
            user_id, gacha_id, gacha_type_id, update_time
        )

#Nächste Schrittnummer mit wiederholter Beurteilung hinzugefügt
def rotation_gacha_user_step(cursor, gacha_type_id: str, step_no: int) -> int:
    if step_no == get_max_step_no(cursor, gacha_type_id):
        row = get_gacha_type(cursor, gacha_type_id)
        if row["rotation_step_no"] > 0:
            print("check:{0},{1},{2}".format(gacha_type_id, step_no,row["rotation_step_no"]))
            return row["rotation_step_no"]
        else:
            print("check:{0},{1},{2}".format(gacha_type_id, step_no,step_no + 1))
            return step_no + 1
    else:
        print("check:{0},{1},{2}".format(gacha_type_id, step_no, step_no + 1))
        return step_no + 1

#Prozess zurücksetzen
def reset_gacha_user_step(cursor, user_id: str, gacha_id: int, gacha_type_id: str, now_time: int) -> None:
    user_step = get_gacha_user_step(cursor, user_id, gacha_id, gacha_type_id)
    if len(user_step) == 0:
        return

    dt = datetime.fromtimestamp(now_time)
    gacha_type = get_gacha_type(cursor, gacha_type_id)
    if gacha_type["reset_type"] == "daily":
        if dt.day != datetime.strptime(user_step["updated_time"], '%Y-%m-%d %H:%M:%S').day:
            update_gacha_user_step(cursor,1,user_id, gacha_id, gacha_type_id, now_time)
    elif gacha_type["reset_type"] == "monthly":
        if dt.month != datetime.strptime(user_step["updated_time"], '%Y-%m-%d %H:%M:%S').month:
            update_gacha_user_step(cursor,1,user_id, gacha_id, gacha_type_id, now_time)

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

    #Extrahieren Sie die Lotteriezielliste
    def get_lots(gacha_group: str, lottery_info: dict) -> Tuple[Dict,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, user_id)
        if gacha_info is None or gacha_lottery_info is None:
            return []

        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"]))

        #Aktualisieren Sie im Fall von Step-up-Gacha die Anzahl der Ausführungen
        if len(ids) > 0 and gacha_lottery_info["step_no"] > 0:
            next_gacha_user_step(cursor, user_id, exec_gacha_id, gacha_info["gacha_type_id"], now_time)

        return ids

    return exec

def test_step(cursor, user_id, now_time, gacha_id, gacha_type_id, step_no_list):
    print("[TEST:{0}]".format(gacha_type_id))

    #Ausführbare Gacha_lottery
    available_list = get_available_gacha_info_list(cursor,now_time,user_id)
    for available_gacha_id,available in available_list.items():
        print(available_gacha_id,available)

    func_gacha = set_gacha(cursor, now_time, user_id)
    items = get_items_all(cursor)
    gacha_items = get_gacha_items_all(cursor)

    #Step-up Gacha
    for step_no in step_no_list:
        gacha_lottery_id = "{0}_{1}".format(gacha_type_id,str(step_no))
        ids = func_gacha(gacha_id,gacha_lottery_id)
        if len(ids) > 0:
            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"]))

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

    #Tatsächlich wird die Benutzer-ID aus den Authentifizierungsinformationen erhalten.
    user_id = "u001"

    #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())

    # step_up_N Test
    test_step(cursor, user_id, now_time, 10, "step_up_N", [1,2,3,4,1,])

    print("\n [Bestätigung, dass es durch Vorverlegen des Datums zurückgesetzt und ausgeführt werden kann]")
    now_time = int(datetime.strptime("2020-05-02 00:00:00", '%Y-%m-%d %H:%M:%S').timestamp())
    test_step(cursor, user_id, now_time, 10, "step_up_N", [1,2,3,4,])

    # step_up_S1 Test
    print("\n [Bestätigen Sie, um zu Schritt 1 zurückzukehren]")
    test_step(cursor, user_id, now_time, 12, "step_up_S1", [1,2,3,4,1,2,])
    print("\n [Bestätigung, dass das Datum vorverlegt und zurückgesetzt wird: Der Vormonat wurde bis Schritt 2 abgeschlossen]")
    now_time = int(datetime.strptime("2020-06-01 00:00:00", '%Y-%m-%d %H:%M:%S').timestamp())
    test_step(cursor, user_id, now_time, 12, "step_up_S1", [1,2,3,4,])

    # step_up_S2 Test
    print("\n [Bestätigen Sie, dass es in Schritt 4 wiederholt ausgeführt werden kann]")
    test_step(cursor, user_id, now_time, 14, "step_up_S2", [1,2,3,4,4,])

    con.commit()
    con.close()

if __name__ == '__main__':
    main()

Ausführungsergebnis

[TEST:step_up_N]
10 {'id': 10, 'start_time': '2020-05-01 00:00:00', 'end_time': '2020-05-31 23:59:59', 'gacha_group': 'A', 'gacha_type_id': 'step_up_N', 'gacha_lottery_list': []}
12 {'id': 12, 'start_time': '2020-05-01 00:00:00', 'end_time': '2020-07-31 23:59:59', 'gacha_group': 'A', 'gacha_type_id': 'step_up_S1', 'gacha_lottery_list': [{'id': 'step_up_S1_2', 'gacha_type_id': 'step_up_S1', 'step_no': 2, 'item_type': 0, 'times': 1, 'rarity': 0, 'omake_times': 1, 'omake_rarity': 3, 'cost': 20}]}
13 {'id': 13, 'start_time': '2020-05-01 00:00:00', 'end_time': '2020-05-31 23:59:59', 'gacha_group': 'A', 'gacha_type_id': 'step_up_S2', 'gacha_lottery_list': [{'id': 'step_up_S2_1', 'gacha_type_id': 'step_up_S2', 'step_no': 1, 'item_type': 0, 'times': 1, 'rarity': 0, 'omake_times': 0, 'omake_rarity': 0, 'cost': 10}]}
==step_up_N_1==:gacha_group:A
check:step_up_N,1,2
ID:9, R, R_Magier
==step_up_N_2==:gacha_group:A
check:step_up_N,2,3
ID:10, R, R_Priester
ID:9, R, R_Magier
ID:4, SSR, SSR_Priester
==step_up_N_3==:gacha_group:A
check:step_up_N,3,4
ID:9, R, R_Magier
ID:10, R, R_Priester
ID:9, R, R_Magier
ID:7, SR, SR_Priester
ID:5, SR, SR_Krieger
==step_up_N_4==:gacha_group:A
check:step_up_N,4,5
ID:9, R, R_Magier
ID:9, R, R_Magier
ID:10, R, R_Priester
ID:5, SR, SR_Krieger
ID:1, UR, UR_Mutig
===Bis zum Maximalschritt wurde ausgeführt (Maximalschritt):4, der Schritt, den Sie ausführen werden:1）===

[Bestätigung, dass es zurückgesetzt und ausführbar ist, indem das Datum vorverlegt wird]
[TEST:step_up_N]
10 {'id': 10, 'start_time': '2020-05-01 00:00:00', 'end_time': '2020-05-31 23:59:59', 'gacha_group': 'A', 'gacha_type_id': 'step_up_N', 'gacha_lottery_list': []}
12 {'id': 12, 'start_time': '2020-05-01 00:00:00', 'end_time': '2020-07-31 23:59:59', 'gacha_group': 'A', 'gacha_type_id': 'step_up_S1', 'gacha_lottery_list': [{'id': 'step_up_S1_2', 'gacha_type_id': 'step_up_S1', 'step_no': 2, 'item_type': 0, 'times': 1, 'rarity': 0, 'omake_times': 1, 'omake_rarity': 3, 'cost': 20}]}
13 {'id': 13, 'start_time': '2020-05-01 00:00:00', 'end_time': '2020-05-31 23:59:59', 'gacha_group': 'A', 'gacha_type_id': 'step_up_S2', 'gacha_lottery_list': [{'id': 'step_up_S2_1', 'gacha_type_id': 'step_up_S2', 'step_no': 1, 'item_type': 0, 'times': 1, 'rarity': 0, 'omake_times': 0, 'omake_rarity': 0, 'cost': 10}]}
==step_up_N_1==:gacha_group:A
check:step_up_N,1,2
ID:7, SR, SR_Priester
==step_up_N_2==:gacha_group:A
check:step_up_N,2,3
ID:10, R, R_Priester
ID:5, SR, SR_Krieger
ID:6, SR, SR_Magier
==step_up_N_3==:gacha_group:A
check:step_up_N,3,4
ID:10, R, R_Priester
ID:8, R, R_Krieger
ID:5, SR, SR_Krieger
ID:4, SSR, SSR_Priester
ID:7, SR, SR_Priester
==step_up_N_4==:gacha_group:A
check:step_up_N,4,5
ID:9, R, R_Magier
ID:8, R, R_Krieger
ID:7, SR, SR_Priester
ID:5, SR, SR_Krieger
ID:3, SSR, SSR_Magier

[Bestätigen Sie, um zu Schritt 1 zurückzukehren]
[TEST:step_up_S1]
10 {'id': 10, 'start_time': '2020-05-01 00:00:00', 'end_time': '2020-05-31 23:59:59', 'gacha_group': 'A', 'gacha_type_id': 'step_up_N', 'gacha_lottery_list': []}
12 {'id': 12, 'start_time': '2020-05-01 00:00:00', 'end_time': '2020-07-31 23:59:59', 'gacha_group': 'A', 'gacha_type_id': 'step_up_S1', 'gacha_lottery_list': [{'id': 'step_up_S1_2', 'gacha_type_id': 'step_up_S1', 'step_no': 2, 'item_type': 0, 'times': 1, 'rarity': 0, 'omake_times': 1, 'omake_rarity': 3, 'cost': 20}]}
13 {'id': 13, 'start_time': '2020-05-01 00:00:00', 'end_time': '2020-05-31 23:59:59', 'gacha_group': 'A', 'gacha_type_id': 'step_up_S2', 'gacha_lottery_list': [{'id': 'step_up_S2_1', 'gacha_type_id': 'step_up_S2', 'step_no': 1, 'item_type': 0, 'times': 1, 'rarity': 0, 'omake_times': 0, 'omake_rarity': 0, 'cost': 10}]}
==step_up_S1_1==:gacha_group:A
check:step_up_S1,1,2
ID:10, R, R_Priester
==step_up_S1_2==:gacha_group:A
check:step_up_S1,2,3
ID:5, SR, SR_Krieger
ID:7, SR, SR_Priester
==step_up_S1_3==:gacha_group:A
check:step_up_S1,3,4
ID:7, SR, SR_Priester
ID:7, SR, SR_Priester
ID:7, SR, SR_Priester
==step_up_S1_4==:gacha_group:A
check:step_up_S1,4,1
ID:2, SSR, SSR_Krieger
ID:10, R, R_Priester
ID:7, SR, SR_Priester
ID:3, SSR, SSR_Magier
ID:1, UR, UR_Mutig
==step_up_S1_1==:gacha_group:A
check:step_up_S1,1,2
ID:9, R, R_Magier
==step_up_S1_2==:gacha_group:A
check:step_up_S1,2,3
ID:10, R, R_Priester
ID:6, SR, SR_Magier

[Bestätigung, dass das Datum vorverlegt und zurückgesetzt wird: Der Vormonat wurde bis Schritt 2 abgeschlossen]
[TEST:step_up_S1]
11 {'id': 11, 'start_time': '2020-06-01 00:00:00', 'end_time': '2020-06-30 23:59:59', 'gacha_group': 'C', 'gacha_type_id': 'step_up_N', 'gacha_lottery_list': [{'id': 'step_up_N_1', 'gacha_type_id': 'step_up_N', 'step_no': 1, 'item_type': 0, 'times': 1, 'rarity': 0, 'omake_times': 0, 'omake_rarity': 0, 'cost': 10}]}
12 {'id': 12, 'start_time': '2020-05-01 00:00:00', 'end_time': '2020-07-31 23:59:59', 'gacha_group': 'A', 'gacha_type_id': 'step_up_S1', 'gacha_lottery_list': [{'id': 'step_up_S1_4', 'gacha_type_id': 'step_up_S1', 'step_no': 4, 'item_type': 0, 'times': 3, 'rarity': 0, 'omake_times': 2, 'omake_rarity': 4, 'cost': 50}]}
14 {'id': 14, 'start_time': '2020-06-01 00:00:00', 'end_time': '2020-06-30 23:59:59', 'gacha_group': 'C', 'gacha_type_id': 'step_up_S2', 'gacha_lottery_list': []}
==step_up_S1_1==:gacha_group:A
check:step_up_S1,1,2
ID:10, R, R_Priester
==step_up_S1_2==:gacha_group:A
check:step_up_S1,2,3
ID:5, SR, SR_Krieger
ID:4, SSR, SSR_Priester
==step_up_S1_3==:gacha_group:A
check:step_up_S1,3,4
ID:8, R, R_Krieger
ID:5, SR, SR_Krieger
ID:6, SR, SR_Magier
==step_up_S1_4==:gacha_group:A
check:step_up_S1,4,1
ID:6, SR, SR_Magier
ID:5, SR, SR_Krieger
ID:7, SR, SR_Priester
ID:2, SSR, SSR_Krieger
ID:3, SSR, SSR_Magier

[Bestätigen Sie, dass es in Schritt 4 wiederholt ausgeführt werden kann]
[TEST:step_up_S2]
11 {'id': 11, 'start_time': '2020-06-01 00:00:00', 'end_time': '2020-06-30 23:59:59', 'gacha_group': 'C', 'gacha_type_id': 'step_up_N', 'gacha_lottery_list': [{'id': 'step_up_N_1', 'gacha_type_id': 'step_up_N', 'step_no': 1, 'item_type': 0, 'times': 1, 'rarity': 0, 'omake_times': 0, 'omake_rarity': 0, 'cost': 10}]}
12 {'id': 12, 'start_time': '2020-05-01 00:00:00', 'end_time': '2020-07-31 23:59:59', 'gacha_group': 'A', 'gacha_type_id': 'step_up_S1', 'gacha_lottery_list': [{'id': 'step_up_S1_2', 'gacha_type_id': 'step_up_S1', 'step_no': 2, 'item_type': 0, 'times': 1, 'rarity': 0, 'omake_times': 1, 'omake_rarity': 3, 'cost': 20}]}
14 {'id': 14, 'start_time': '2020-06-01 00:00:00', 'end_time': '2020-06-30 23:59:59', 'gacha_group': 'C', 'gacha_type_id': 'step_up_S2', 'gacha_lottery_list': []}
===Anders als die Schritte, die ausgeführt werden können (aktueller Schritt:4, der Schritt, den Sie ausführen werden:1）===
===Anders als die Schritte, die ausgeführt werden können (aktueller Schritt:4, der Schritt, den Sie ausführen werden:2）===
===Anders als die Schritte, die ausgeführt werden können (aktueller Schritt:4, der Schritt, den Sie ausführen werden:3）===
==step_up_S2_4==:gacha_group:C
check:step_up_S2,4,4
ID:24, R, R_Krieger
ID:25, R, R_Magier
ID:23, SR, SR_Priester
ID:25, R, R_Magier
ID:23, SR, SR_Priester
==step_up_S2_4==:gacha_group:C
check:step_up_S2,4,4
ID:26, R, R_Priester
ID:25, R, R_Magier
ID:15, UR, UR_Krieger
ID:22, SR, SR_Magier
ID:20, SSR, SSR_Priester

Erwägung

step_up_N (keine Wiederholung, tägliches Zurücksetzen)

Da es keine Wiederholungseinstellung gibt, können Sie nach dem 4. Ausführen bestätigen, dass die Einstellung abgeschlossen ist. Wenn sich das Datum ändert, können Sie bestätigen, dass es möglich ist, ab Schritt 1 erneut auszuführen.

step_up_S1 (wiederholt, monatlich zurückgesetzt)

Da es eine Wiederholungseinstellung gibt, können Sie nach dem vierten Ausführen zu Schritt 1 zurückkehren und bestätigen, dass es ausgeführt werden kann. Wenn sich der Monat ändert, kehren Sie zu Schritt 1 zurück und können sehen, dass dies von dort aus möglich ist.

step_up_S2 (mit Wiederholung, kein Reset)

Da es eine Wiederholungseinstellung gibt, können Sie bestätigen, dass Schritt 4 nach dem 4. Ausführen wiederholt ausgeführt werden kann.

Vorteile von Spezifikationen

Die Steuerelementverarbeitung "Wiederholen" und "Zurücksetzen" wurde zur Logik Letztes Mal hinzugefügt. Es ist etwas schwieriger, aber es wurde nicht so sehr renoviert. (* Das Zusammenstellen des Testcodes dauerte länger ... *)

Mit dieser Funktion ist es möglich, den Fortschritt der Gacha durch "Master-Einstellung" zu steuern. Es ist möglich, verschiedene Muster von Gacha zu erstellen, indem die Einstellungen des Masters kombiniert werden. Im Betrieb ist es notwendig, die Hypothese und Überprüfung eines effektiven Ansatzes für Benutzer zu wiederholen. Ein effizienter Betrieb kann realisiert werden, indem der Master so eingestellt wird, dass der Planer dies tun kann.