Gacha écrit en python-Practice 2 ・ Bases du step-up gacha-

Contenu

Dans le jeu actuel, il existe différents types de gacha, Cette fois, nous allons créer une sorte de "step-up gacha".

** Les sources suivantes ont été modifiées et mises en œuvre **

Gacha écrit en python-Practice 1-

Qu'est-ce qu'une gacha step-up?

Un gacha progressif est un gacha dans lequel ** les éléments cibles de loterie ** et les ** paramètres de loterie ** changent en fonction du «nombre d'exécution» du gacha cible. La raison du nom «step up» est qu'il est fondamentalement configuré pour rendre les meilleurs éléments plus accessibles lorsque le nombre d'exécutions augmente. Après cela, nous utiliserons le mot «intensifier» pour décrire le nombre de fois.

Structure de données de step-up gacha

Tout d'abord, décidez de ce qui changera si vous `` montez ''. Cette fois, [précédent](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% Sur la base de la structure de données de B4), nous apporterons des modifications afin que le réglage de la façon de dessiner gacha (** gacha_lottery **) soit intensifié.

Pour rendre l'idée plus facile à comprendre, nous effectuerons des «réparations en» étapes (étapes).

Rénovation étape 1

Tout d'abord, ajoutez le paramètre ** step_up ** comme gacha_type.

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

Rénovation étape 2

Ajoutez l'élément ** step_no ** à ** gacha_lottery ** afin de pouvoir définir «chaque étape», et définir «chaque» étape ».

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

Réparation étape 3

Pour les gachas avec gacha_type de normal, step_no est mis à ** 0 ** et il n'y a pas de réglage progressif.

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

Ce step-up gacha se terminera lorsque vous aurez exécuté l'étape 4 (vous ne pouvez plus exécuter).

図2.png

Créer l'histoire du gacha

L'état (probabilité, etc.) du gacha progressif change en fonction du «nombre d'exécutions de l'utilisateur». Autrement dit, `vous devez enregistrer le nombre de fois qu'un utilisateur a exécuté cette cible gacha. ''

Par conséquent, créez un endroit (table) où l'historique du nombre de gachas pour chaque utilisateur peut être enregistré et un processus d'enregistrement.

Informations utilisateur (utilisateur)

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

Informations sur l'historique du compte gacha de l'utilisateur (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

Il est unique dans plusieurs colonnes de user_id + gacha_id + gacha_type, et le nombre de fois est incrémenté de +1 (mise à jour) à chaque fois qu'il est exécuté. Dans le cas de la première (première) exécution, le nombre de fois est mis à 1 et un enregistrement est créé (insertion).

la mise en oeuvre

Les spécifications de mise en œuvre sont résumées ci-dessous.

--Différence de comportement du step-up gacha (par opposition au gacha normal)

Informations sur la base de données Gacha

Si vous souhaitez modifier la structure / les données ou réinitialiser l'historique, veuillez réexécuter ce processus.

gacha_db.py


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

def get_items():
    items = {
        5101: {"rarity": 5, "item_name": "UR_Courageux", "item_type": 1, "hp": 1200},
        4201: {"rarity": 4, "item_name": "SSR_guerrier", "item_type": 2, "hp": 1000},
        4301: {"rarity": 4, "item_name": "SSR_sorcier", "item_type": 3, "hp": 800},
        4401: {"rarity": 4, "item_name": "SSR_Prêtre", "item_type": 4, "hp": 800},
        3201: {"rarity": 3, "item_name": "SR_guerrier", "item_type": 2, "hp": 600},
        3301: {"rarity": 3, "item_name": "SR_sorcier", "item_type": 3, "hp": 500},
        3401: {"rarity": 3, "item_name": "SR_Prêtre", "item_type": 4, "hp": 500},
        2201: {"rarity": 2, "item_name": "R_guerrier", "item_type": 2, "hp": 400},
        2301: {"rarity": 2, "item_name": "R_sorcier", "item_type": 3, "hp": 300},
        2401: {"rarity": 2, "item_name": "R_Prêtre", "item_type": 4, "hp": 300},
        3199: {"rarity": 3, "item_name": "SR_Courageux", "item_type": 1, "hp": 600},
        4101: {"rarity": 4, "item_name": "SSR_Courageux", "item_type": 1, "hp": 1000},
        5201: {"rarity": 5, "item_name": "UR_guerrier", "item_type": 2, "hp": 1300},
        5301: {"rarity": 5, "item_name": "UR_sorcier", "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)

#【Remise à neuf】
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)

#【ajouter à】
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
          )
        """
    )

    #【Remise à neuf】
    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
          )
        """
    )

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

    #【ajouter à】
    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)

    #【ajouter à】
    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()

Traitement Gacha

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]

#Liste d'informations gacha exécutable
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())
        #Affinez les informations gacha cible dans la plage de la date et de l'heure
        if start_time <= now_time <= end_time:
            results[row["id"]] = convert_row2dict(row)

    return results

#【Remise à neuf】
#Liste d'informations gacha exécutable (gacha_(Y compris les informations de loterie)
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())
    #Affinez les informations gacha cible dans la plage de la date et de l'heure
    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


#【Remise à neuf】
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 qui ne peut pas être exécuté_id:%s===" % (gacha_id))
        return None, None

    if len(gacha_lottery) == 0:
        print("===Gacha qui n'existe pas_lottery_id:%s===" % (gacha_lottery_id))
        return None, None

    if gacha["gacha_type"] != gacha_lottery["gacha_type"]:
        print("===gacha_le type est différent:%s,%s===" % (gacha["gacha_type"],gacha_lottery["gacha_type"]))
        return None, None

    # step_contrôle de gacha
    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("===Jusqu'à l'étape maximale a été exécutée (étape maximale):%s, l'étape que vous allez effectuer:%s）===" %(max_step_no,gacha_lottery["step_no"]))
            return None, None

        if gacha_lottery["step_no"] != step_no:
            print("===Différent des étapes pouvant être effectuées (étape en cours:%s, l'étape que vous allez effectuer:%s）===" %(step_no, gacha_lottery["step_no"]))
            return None, None

    return gacha, gacha_lottery


#【ajouter à】
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)


#【ajouter à】
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"]


#【ajouter à】
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))


#【Remise à neuf】
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)

    #Extraire la liste des cibles de loterie
    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

    #Exécution de Gacha
    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"]))

        #Dans le cas du step-up gacha, mettre à jour le nombre d'exécutions
        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()

    #【ajouter à】
    #En fait, l'ID utilisateur sera obtenu à partir des informations d'authentification.
    user_id = "u001"

    #Spécifiez la date et l'heure d'exécution de gacha pour vérifier l'opération
    now_time = int(datetime.strptime("2020-05-01 00:00:00", '%Y-%m-%d %H:%M:%S').timestamp())

    #【ajouter à】
    #Gacha exécutable_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)

    #Initialisation (définir la date et l'heure d'exécution, les éléments, etc.)
    func_gacha = set_gacha(cursor, now_time, user_id)


    items = get_items_all(cursor)
    gacha_items = get_gacha_items_all(cursor)
    #Exécuter du gacha à un seul coup
    # gacha_id et gacha_lottery_id passé lors de l'exécution
    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"]))

    #Exécuter 11 gachas consécutifs
    # gacha_id et gacha_lottery_id passé lors de l'exécution
    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"]))

    #【ajouter à】
    #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"]))

    #【ajouter à】
    con.commit()


    con.close()


if __name__ == '__main__':
    main()

Résultat d'exécution

1ère fois

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_sorcier
==normal_11==:gacha_group:A
ID:1, UR, UR_Courageux
ID:10, R, R_Prêtre
ID:9, R, R_sorcier
ID:5, SR, SR_guerrier
ID:5, SR, SR_guerrier
ID:8, R, R_guerrier
ID:9, R, R_sorcier
ID:10, R, R_Prêtre
ID:10, R, R_Prêtre
ID:9, R, R_sorcier
ID:5, SR, SR_guerrier
==step_up_1==:gacha_group:A
ID:2, SSR, SSR_guerrier
==step_up_2==:gacha_group:A
ID:9, R, R_sorcier
ID:4, SSR, SSR_Prêtre
ID:3, SSR, SSR_sorcier
==step_up_3==:gacha_group:A
ID:9, R, R_sorcier
ID:2, SSR, SSR_guerrier
ID:2, SSR, SSR_guerrier
ID:3, SSR, SSR_sorcier
ID:7, SR, SR_Prêtre
==step_up_4==:gacha_group:A
ID:9, R, R_sorcier
ID:10, R, R_Prêtre
ID:6, SR, SR_sorcier
ID:9, R, R_sorcier
ID:2, SSR, SSR_guerrier
ID:7, SR, SR_Prêtre
ID:10, R, R_Prêtre
ID:8, R, R_guerrier
ID:10, R, R_Prêtre
ID:7, SR, SR_Prêtre
ID:1, UR, UR_Courageux
===Gacha qui n'existe pas_lottery_id:step_up_5===

Deuxième fois

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_Prêtre
==normal_11==:gacha_group:A
ID:9, R, R_sorcier
ID:4, SSR, SSR_Prêtre
ID:2, SSR, SSR_guerrier
ID:8, R, R_guerrier
ID:8, R, R_guerrier
ID:5, SR, SR_guerrier
ID:10, R, R_Prêtre
ID:7, SR, SR_Prêtre
ID:10, R, R_Prêtre
ID:7, SR, SR_Prêtre
ID:5, SR, SR_guerrier
===Jusqu'à l'étape maximale a été exécutée (étape maximale):4, l'étape que vous allez effectuer:1）===
===Terminé jusqu'à l'étape maximale (étape maximale):4, l'étape que vous allez effectuer:2）===
===Jusqu'à l'étape maximale a été exécutée (étape maximale):4, l'étape que vous allez effectuer:3）===
===Terminé jusqu'à l'étape maximale (étape maximale):4, l'étape que vous allez effectuer:4）===
===Gacha qui n'existe pas_lottery_id:step_up_5===

Considération

La première fois, les étapes 1 à 4 sont exécutées. En outre, vous pouvez voir que le "comment dessiner le gacha" change en fonction de l'étape, et vous "intensifiez". La deuxième fois, comme le résultat de la première exécution est enregistré (commit), vous pouvez voir que le step-up gacha s'est terminé sans pouvoir s'exécuter. En fonction de l'état du nombre d'étapes au moment de l'exécution, un message d'erreur s'affiche en fonction de celui-ci, donc si vous éditez la méthode appelante et essayez le processus, vous pouvez ressentir le changement de comportement.

Celui créé cette fois-ci est limité à la mise en œuvre du "traitement de base" dans le but de comprendre le mécanisme de step-up gacha, et ne met pas en œuvre un "contrôle compliqué". En observant le comportement des gachas step-up dans divers jeux et en réfléchissant au type de contrôle qui manque, vous pouvez voir ce que vous pouvez faire en appliquant des step-up gachas.

Recommended Posts

Gacha écrit en python-Practice 2 ・ Bases du step-up gacha-
Gacha écrit en python-Practice 3 ・ Ajout de fonctions gacha step-up-
Gacha écrit en python-Practice 1-
Gacha écrit en python - Ajout d'une fonction de réglage de période -
Gacha écrit en Python-Data design-
Gacha écrit en Python -BOX Gacha-
Logique gacha simple écrite en Python
Gacha écrit en python-Rareté confirmée avec bonus-
Principes de base pour exécuter NoxPlayer en Python
Gacha écrit en python-Implémentation dans la structure de données de base-
Simulation simple de l'infection virale
Simulation du contenu du portefeuille
Compréhension complète de la programmation asynchrone Python
Compréhension complète de la programmation orientée objet de Python
Complétez tout avec Jupyter ~ Introduction de nbdev ~
Gacha écrit en python-Practice 2 ・ Bases du step-up gacha-
Les bases de Python ①
Bases de python ①
Bases de l'écran d'entrée / sortie en utilisant tkinter en python3
Principes de base du grattage Python
# 4 [python] Bases des fonctions
Bases des programmes réseau?
La fondation de la fondation Perceptron
Bases de l'analyse de régression
Bases de python: sortie
Comparaison du code de moyenne mobile exponentielle (EMA) écrit en Python