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

Inhalt

Im eigentlichen Spiel gibt es verschiedene Arten von Gacha, Dieses Mal werden wir eine Art "Step-up-Gacha" kreieren.

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

Gacha geschrieben in Python-Übung 1-

Was ist eine Step-up-Gacha?

Eine Step-up-Gacha ist eine Gacha, bei der sich ** Lotteriezielgegenstände ** und ** Lotterieeinstellungen ** abhängig von der "Ausführungsanzahl" der Zielgacha ändern. Der Grund für den Namen "step up" ist, dass er im Grunde genommen dazu dient, "bessere Gegenstände zugänglicher" zu machen, wenn die Anzahl der Ausführungen zunimmt. Danach werden wir das Wort "step up" verwenden, um die Häufigkeit zu beschreiben.

Datenstruktur der Step-up-Gacha

Entscheiden Sie zunächst, was sich ändern soll, wenn Sie "aufsteigen". Diesmal [vorherige](https://qiita.com/saib-ryo/items/cb792f90cc24259da7fa#%E3%82%AC%E3%83%81%E3%83%A3%E6%83%85%E5% A0% B1% E3% 83% 87% E3% 83% BC% E3% 82% BF% E6% A7% 8B% E9% 80% A0% E3% 81% AE% E5% A4% 89% E6% 9B% Basierend auf der Datenstruktur von B4) werden wir Änderungen vornehmen, damit die Einstellung zum Zeichnen von Gacha (** gacha_lottery **) erhöht wird.

Um die Idee verständlicher zu machen, führen wir "Reparaturen in" Schritten (Schritten) durch.

Sanierungsschritt 1

Fügen Sie zunächst die Einstellung ** step_up ** als gacha_type hinzu.

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
10 2020-05-01 00:00:00 2020-05-31 23:59:59 A step_up

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
step_up step_up 0 1 0 0 0 10

Sanierungsschritt 2

Fügen Sie den Punkt ** step_no ** zu ** gacha_lottery ** hinzu, damit Sie "jeden Schritt nach oben" und "jeden" Schritt "einstellen können.

gacha_lottery

id gacha_type step_no 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
step_up_1 step_up 1 0 1 0 0 0 10
step_up_2 step_up 2 0 2 0 1 3 30
step_up_3 step_up 3 0 3 0 2 3 50
step_up_4 step_up 4 0 10 0 1 5 100

Reparaturschritt 3

Für Gachas mit "gacha_type" von normal wird step_no auf ** 0 ** gesetzt und "es gibt keine Step-up-Einstellung".

gacha_lottery

id gacha_type step_no item_type times rarity omake_times omake_rarity cost
normal_1 normal 0 0 1 0 0 0 10
normal_11 normal 0 0 10 0 1 3 100
step_up_1 step_up 1 0 1 0 0 0 10
step_up_2 step_up 2 0 2 0 1 3 30
step_up_3 step_up 3 0 3 0 2 3 50
step_up_4 step_up 4 0 10 0 1 5 100

Diese Step-up-Gacha endet, wenn Sie Schritt 4 ausgeführt haben (Sie können nicht mehr ausführen).

図2.png

Gacha-Geschichte erstellen

Der Zustand (Wahrscheinlichkeit usw.) der Step-up-Gacha ändert sich in Abhängigkeit davon, wie oft der Benutzer sie ausführt. Das heißt, Sie müssen aufzeichnen, wie oft ein Benutzer diese Ziel-Gacha ausgeführt hat. ``

Erstellen Sie daher einen Ort (Tabelle), an dem der Verlauf der Anzahl der Gachas für jeden Benutzer aufgezeichnet werden kann, und einen Prozess zum Aufzeichnen.

Benutzerinformationen (Benutzer)

id nick_name created_time
u001 taro 2020-05-31 23:59:59
u002 hana 2020-05-31 23:59:59

Informationen zum Gacha-Zählverlauf des Benutzers (gacha_user_times)

user_id gacha_id gacha_type times updated_time
u001 10 step_up 1 2020-05-11 22:00:00
u002 10 step_up 2 2020-05-12 09:00:00

Es ist in mehreren Spalten von user_id + gacha_id + gacha_type eindeutig und die Häufigkeit wird bei jeder Ausführung um +1 (Aktualisierung) erhöht. Bei der ersten (ersten) Ausführung wird die Anzahl auf 1 gesetzt und ein Datensatz erstellt (Einfügen).

Implementierung

Die Implementierungsspezifikationen sind unten zusammengefasst.

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 = {
        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"},
        10: {"start_time": "2020-05-01 00:00:00", "end_time": "2020-05-31 23:59:59", "gacha_group": "A",
            "gacha_type": "step_up"},
    }

    return convert_values(items)

#【Sanierung】
def get_gacha_lottery():
    items = {
        "normal_1":  {"gacha_type": "normal", "step_no": 0, "item_type": 0, "times": 1, "rarity": 0, "omake_times": 0, "omake_rarity": 0, "cost":10},
        "normal_11":  {"gacha_type": "normal", "step_no": 0, "item_type": 0, "times": 10, "rarity": 0, "omake_times": 1, "omake_rarity": 3, "cost":100},
        "fighter":  {"gacha_type": "fighter", "step_no": 0, "item_type": 0, "times": 2, "rarity": 0, "omake_times": 0, "omake_rarity": 0, "cost":30},
        "omake_2":  {"gacha_type": "omake_2", "step_no": 0, "item_type": 0, "times": 9, "rarity": 2, "omake_times": 2, "omake_rarity": 3, "cost":150},
        "omake_fighter":  {"gacha_type": "omake_fighter", "step_no": 0, "item_type": 2, "times": 5, "rarity": 0, "omake_times": 1, "omake_rarity": 3, "cost":100},
        "step_up_1": {"gacha_type": "step_up", "step_no": 1, "item_type": 0, "times": 1, "rarity": 0, "omake_times": 0,
                     "omake_rarity": 0, "cost": 10},
        "step_up_2": {"gacha_type": "step_up", "step_no": 2, "item_type": 0, "times": 2, "rarity": 0, "omake_times": 1,
                      "omake_rarity": 3, "cost": 30},
        "step_up_3": {"gacha_type": "step_up", "step_no": 3, "item_type": 0, "times": 3, "rarity": 0, "omake_times": 2,
                      "omake_rarity": 3, "cost": 50},
        "step_up_4": {"gacha_type": "step_up", "step_no": 4, "item_type": 0, "times": 10, "rarity": 0, "omake_times": 1,
                      "omake_rarity": 5, "cost": 100},
    }

    return convert_values(items)

#【hinzufügen】
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")

    cursor.execute(
        """CREATE TABLE gacha 
          (id INTEGER PRIMARY KEY AUTOINCREMENT
          ,start_time DATETIME
          ,end_time DATETIME
          ,gacha_group VARCHAR(32)
          ,gacha_type 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
          )
        """
    )

    #【Sanierung】
    cursor.execute("DROP TABLE IF EXISTS gacha_lottery")
    cursor.execute(
        """CREATE TABLE gacha_lottery 
          (id VARCHAR(32) PRIMARY KEY
          ,gacha_type 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
          )
        """
    )

    #【hinzufügen】
    cursor.execute("DROP TABLE IF EXISTS users")
    cursor.execute(
        """CREATE TABLE users 
          (id VARCHAR(16) PRIMARY KEY
          ,nick_name VARCHAR(64)
          )
        """
    )

    #【hinzufügen】
    cursor.execute("DROP TABLE IF EXISTS gacha_user_times")
    cursor.execute(
        """CREATE TABLE gacha_user_times 
          (user_id VARCHAR(16) 
          ,gacha_id INTEGER
          ,gacha_type VARCHAR(32)
          ,times INTEGER
          ,updated_time DATETIME          
          ,PRIMARY KEY(user_id,gacha_id,gacha_type)
          )
        """
    )


    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)

    #【hinzufügen】
    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

def convert_row2dict(row) -> dict:
    if row is None:
        return {}
    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

#【Sanierung】
#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"])
        gacha_user = get_gacha_user_times(cursor, user_id, gacha_id, info["gacha_type"])

        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["times"] + 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_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


#【Sanierung】
def get_gacha_info(cursor, gacha_id: int, gacha_lottery_id: str, now_time: int, user_id: str):
    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"] != gacha_lottery["gacha_type"]:
        print("===gacha_Typ ist anders:%s,%s===" % (gacha["gacha_type"],gacha_lottery["gacha_type"]))
        return None, None

    # step_bis Gacha Check
    if gacha_lottery["step_no"] > 0:
        max_step_no = get_max_step_no(cursor, gacha["gacha_type"])
        gacha_user = get_gacha_user_times(cursor, user_id, gacha_id, gacha["gacha_type"])
        step_no = 1
        if len(gacha_user) > 0:
            step_no = gacha_user["times"] + 1
        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


#【hinzufügen】
def get_gacha_user_times(cursor, user_id: str, gacha_id: int, gacha_type: str) -> dict:
    select_sql = "SELECT * FROM gacha_user_times WHERE user_id = ? AND gacha_id = ? AND gacha_type = ?"
    cursor.execute(select_sql, (user_id,gacha_id,gacha_type))
    row = cursor.fetchone()

    return convert_row2dict(row)


#【hinzufügen】
def get_max_step_no(cursor, gacha_type: str) -> dict:
    select_sql = "SELECT MAX(step_no) AS max_step_no FROM gacha_lottery WHERE gacha_type = ?"
    cursor.execute(select_sql, (gacha_type,))
    row = cursor.fetchone()

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


#【hinzufügen】
def update_gacha_user_times(cursor, user_id: str, gacha_id: int, gacha_type: str, update_time: int):
    row = get_gacha_user_times(cursor, user_id, gacha_id, gacha_type)
    dt = datetime.fromtimestamp(update_time)
    if len(row) == 0:
        keys = ("user_id","gacha_id","gacha_type","times","updated_time")
        sql = "insert into {0}({1}) values({2})".format('gacha_user_times', ','.join(keys), ','.join(['?'] * len(keys)))
        cursor.execute(sql, (user_id,gacha_id,gacha_type,1,dt))
    else:
        sql = "UPDATE gacha_user_times SET times = times + 1, updated_time = ? WHERE user_id = ? AND gacha_id = ? AND gacha_type = ?"
        cursor.execute(sql, (dt,user_id,gacha_id,gacha_type))


#【Sanierung】
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):
        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:
            update_gacha_user_times(cursor, user_id, exec_gacha_id, gacha_info["gacha_type"], now_time)

        return ids

    return exec


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

    #【hinzufügen】
    #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())

    #【hinzufügen】
    #Ausführbare Gacha_lottery
    available_list = get_available_gacha_info_list(cursor,now_time,user_id)
    for gacha_id,available in available_list.items():
        print(gacha_id,available)

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


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

    #【hinzufügen】
    #Step-up Gacha
    for i in [1, 2, 3, 4, 5]:
        gacha_lottery_id = "step_up_{0}".format(str(i))
        ids = func_gacha(10,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"]))

    #【hinzufügen】
    con.commit()


    con.close()


if __name__ == '__main__':
    main()

Ausführungsergebnis

1. Mal

1 {'id': 1, 'start_time': '2020-05-01 00:00:00', 'end_time': '2020-05-31 23:59:59', 'gacha_group': 'A', 'gacha_type': 'normal', 'gacha_lottery_list': [{'id': 'normal_1', 'gacha_type': 'normal', 'step_no': 0, 'item_type': 0, 'times': 1, 'rarity': 0, 'omake_times': 0, 'omake_rarity': 0, 'cost': 10}, {'id': 'normal_11', 'gacha_type': 'normal', 'step_no': 0, 'item_type': 0, 'times': 10, 'rarity': 0, 'omake_times': 1, 'omake_rarity': 3, 'cost': 100}]}
10 {'id': 10, 'start_time': '2020-05-01 00:00:00', 'end_time': '2020-05-31 23:59:59', 'gacha_group': 'A', 'gacha_type': 'step_up', 'gacha_lottery_list': [{'id': 'step_up_1', 'gacha_type': 'step_up', 'step_no': 1, 'item_type': 0, 'times': 1, 'rarity': 0, 'omake_times': 0, 'omake_rarity': 0, 'cost': 10}]}
==normal_1==:gacha_group:A
ID:9, R, R_Magier
==normal_11==:gacha_group:A
ID:1, UR, UR_Mutig
ID:10, R, R_Priester
ID:9, R, R_Magier
ID:5, SR, SR_Krieger
ID:5, SR, SR_Krieger
ID:8, R, R_Krieger
ID:9, R, R_Magier
ID:10, R, R_Priester
ID:10, R, R_Priester
ID:9, R, R_Magier
ID:5, SR, SR_Krieger
==step_up_1==:gacha_group:A
ID:2, SSR, SSR_Krieger
==step_up_2==:gacha_group:A
ID:9, R, R_Magier
ID:4, SSR, SSR_Priester
ID:3, SSR, SSR_Magier
==step_up_3==:gacha_group:A
ID:9, R, R_Magier
ID:2, SSR, SSR_Krieger
ID:2, SSR, SSR_Krieger
ID:3, SSR, SSR_Magier
ID:7, SR, SR_Priester
==step_up_4==:gacha_group:A
ID:9, R, R_Magier
ID:10, R, R_Priester
ID:6, SR, SR_Magier
ID:9, R, R_Magier
ID:2, SSR, SSR_Krieger
ID:7, SR, SR_Priester
ID:10, R, R_Priester
ID:8, R, R_Krieger
ID:10, R, R_Priester
ID:7, SR, SR_Priester
ID:1, UR, UR_Mutig
===Gacha, die es nicht gibt_lottery_id:step_up_5===

Zweites Mal

1 {'id': 1, 'start_time': '2020-05-01 00:00:00', 'end_time': '2020-05-31 23:59:59', 'gacha_group': 'A', 'gacha_type': 'normal', 'gacha_lottery_list': [{'id': 'normal_1', 'gacha_type': 'normal', 'step_no': 0, 'item_type': 0, 'times': 1, 'rarity': 0, 'omake_times': 0, 'omake_rarity': 0, 'cost': 10}, {'id': 'normal_11', 'gacha_type': 'normal', 'step_no': 0, 'item_type': 0, 'times': 10, 'rarity': 0, 'omake_times': 1, 'omake_rarity': 3, 'cost': 100}]}
10 {'id': 10, 'start_time': '2020-05-01 00:00:00', 'end_time': '2020-05-31 23:59:59', 'gacha_group': 'A', 'gacha_type': 'step_up', 'gacha_lottery_list': []}
==normal_1==:gacha_group:A
ID:7, SR, SR_Priester
==normal_11==:gacha_group:A
ID:9, R, R_Magier
ID:4, SSR, SSR_Priester
ID:2, SSR, SSR_Krieger
ID:8, R, R_Krieger
ID:8, R, R_Krieger
ID:5, SR, SR_Krieger
ID:10, R, R_Priester
ID:7, SR, SR_Priester
ID:10, R, R_Priester
ID:7, SR, SR_Priester
ID:5, SR, SR_Krieger
===Bis zum Maximalschritt wurde ausgeführt (Maximalschritt):4, der Schritt, den Sie ausführen werden:1）===
===Bis zum Maximalschritt wurde ausgeführt (Maximalschritt):4, der Schritt, den Sie ausführen werden:2）===
===Bis zum Maximalschritt wurde ausgeführt (Maximalschritt):4, der Schritt, den Sie ausführen werden:3）===
===Bis zum Maximalschritt wurde ausgeführt (Maximalschritt):4, der Schritt, den Sie ausführen werden:4）===
===Gacha, die es nicht gibt_lottery_id:step_up_5===

Erwägung

Beim ersten Mal werden die Schritte 1 bis 4 ausgeführt. Sie können auch sehen, dass sich das "Zeichnen der Gacha" je nach Schritt ändert und Sie "aufsteigen". Beim zweiten Mal, da das Ergebnis der ersten Ausführung aufgezeichnet wird (Festschreiben), können Sie sehen, dass die Step-up-Gacha beendet wurde, ohne ausgeführt werden zu können. Abhängig vom Status der Anzahl der Schritte zum Zeitpunkt der Ausführung wird eine entsprechende Fehlermeldung angezeigt. Wenn Sie also die aufrufende Methode bearbeiten und den Prozess ausprobieren, können Sie die Verhaltensänderung spüren.

Die diesmal erstellte ist auf die Implementierung der "grundlegenden Verarbeitung" beschränkt, um den Mechanismus der Step-up-Gacha zu verstehen, und implementiert keine "komplizierte Steuerung". Indem Sie das Verhalten von Step-up-Gachas in verschiedenen Spielen beobachten und darüber nachdenken, welche Art von Kontrolle fehlt, können Sie sehen, was Sie tun können, indem Sie "Step-up-Gachas" anwenden.

Recommended Posts

Gacha geschrieben in Python-Übung 2 ・ Grundlagen der Step-up-Gacha-
Gacha geschrieben in Python-Übung 3 ・ Hinzufügen von Step-up-Gacha-Funktionen-
Gacha geschrieben in Python-Übung 1-
Gacha geschrieben in Python-Addition der Periodeneinstellungsfunktion-
Gacha geschrieben in Python-Data Design-
Gacha geschrieben in Python -BOX Gacha-
Einfache Gacha-Logik in Python geschrieben
Gacha in Python-Rarity geschrieben mit Bonus bestätigt
Grundlagen zum Ausführen von NoxPlayer in Python
Gacha geschrieben in Python-Implementierung in grundlegende Datenstruktur-
Einfache Simulation einer Virusinfektion
Simulation des Inhalts der Brieftasche
Vollständiges Verständnis der asynchronen Python-Programmierung
Vollständiges Verständnis der objektorientierten Programmierung von Python
Vervollständige alles mit Jupyter ~ Einführung von nbdev ~
Gacha geschrieben in Python-Übung 2 ・ Grundlagen der Step-up-Gacha-
Python-Grundlagen ①
Grundlagen von Python ①
Grundlagen des Eingabe- / Ausgabebildschirms mit tkinter in python3
Grundlagen der Python-Scraping-Grundlagen
# 4 [Python] Grundlagen der Funktionen
Grundlagen von Netzwerkprogrammen?
Die Gründung der Perceptron-Stiftung
Grundlagen der Regressionsanalyse
Grundlagen von Python: Ausgabe
Vergleich des in Python geschriebenen EMA-Codes (Exponential Moving Average)