Créez un simulateur de gacha rare avec Flask

Hier a créé un système de réponse simple avec le framework Web Python Flask. Cela seul est trop ennuyeux, alors j'aimerais utiliser NumPy pour créer quelque chose que je puisse apprécier un peu.

"Gacha" est un mécanisme qui vous permet d'obtenir des objets au hasard, etc. en payant une fois pour les jeux sociaux et les jeux en ligne qui sont populaires de nos jours. 10 gachas consécutifs est un mécanisme permettant de dessiner 10 gachas rares dans un essai. Dans les jeux sociaux qui prétendent être gratuits, c'est un mécanisme pour profiter de la facturation de ces articles.

Le but de la simulation est, côté gestion, d'inspirer l'esprit de jeu qui donne envie au joueur de facturer beaucoup Vérifier si le gacha peut être fourni, le joueur du côté il y a le but, comme ressenti ou pour réussir à l'avance combien de probabilité avant de tourner sur l'argent réel dit argent réel (le résultat en refroidissant la tête).

Jusqu'à présent, la population a été sélectionnée à partir de certains spécimens en utilisant des statistiques de supposition et visualisation. J'ai deviné, mais cela vaut également la peine d'essayer les parties difficiles à imaginer à partir de la théorie seule.

Spécifications Gacha

Les spécifications du gacha à implémenter sont les suivantes.

Type et prix

Il existe deux types de gacha, «gacha rare» et «10 gacha rare consécutif». La gacha rare coûte 300 yens par fois et 10 gacha rares consécutives coûtent 3000 yens par fois. Vous recevrez une carte pour chaque tirage.

Rareté

La rareté se traduit par la rareté. Plus la rareté est élevée, plus la valeur est élevée.

En passant, le mot rareté semble être prononcé comme religion.

Probabilité de gagner

La probabilité de gagner du gacha rare est la suivante.

La probabilité de gain de 10 gachas rares consécutifs est la suivante.

Cependant, dans 10 gachas rares consécutifs, SR remportera toujours le dernier en bonus. À première vue, cela semble être un traitement préférentiel, mais à l'inverse, cela signifie que l'UR ne gagnera jamais au tour final.

De plus, la notation probabiliste ne donne pas 100%. C'est parce qu'il y a un troisième chiffre sous le point décimal et qu'il est "arrondi". La raison pour laquelle on suppose l'arrondi au lieu de l'arrondi est que le total pour 10 stations est de 100,02%, mais si l'on suppose que le troisième chiffre des trois types de rareté est arrondi, une telle valeur totale ne peut pas être obtenue. Parce qu'il n'y en a pas.

Types de prix

Le but de l'utilisateur est d'obtenir l'UR. Il existe 12 types de cartes pour cette UR, du cadeau 1 au cadeau 12. Si l'UR gagne, l'un de ces prix sera [probabilité égale](http://ja.wikipedia.org/wiki/%E7%AD%89%E7%A2%BA%E7%8E%87% Il doit être disponible à E3% 81% AE% E5% 8E% 9F% E7% 90% 86).

Implémentation Gacha

Génération aléatoire

NumPy génère des nombres aléatoires par Mersenne Twister. Pour Génération aléatoire avec NumPy, voir Ici Et ici a un article en japonais.

Pour le moment, créez une fonction d'extraction pour chaque rareté. Mettez en œuvre l'extracteur pondéré comme suit.

Processus d'éjection de la carte par pondération

def turn_rare():
    """Tourner le gacha rare"""
    result = []
    #Arrondissez le troisième chiffre à 94.85%, 5.04%, 0.12%
    weight = [0.94849, 0.0504, 0.00111]
    result.append(pickup_rare(weight))
    return result

def turn_10rare():
    """Tournez 10 gachas rares consécutifs"""
    result = []
    #Arrondissez le troisième chiffre à 90.28%, 9.29%, 0.45%
    weight = [0.90278, 0.09281, 0.00441]
    #9 loterie
    for v in range(0, 9):
        result.append(pickup_rare(weight))
    #SR gagne toujours le dernier
    result.append("SR")
    return result

Ce qui précède suppose la valeur la plus avantageuse pour la direction parmi les valeurs arrondies au troisième chiffre supérieur.

Ensuite, décrivez le processus d'éjection de la carte en fonction du poids donné.

def pickup_rare(weight):
    """Éjecter la gacha rare en fonction du poids"""
    rarities = ["R", "SR", "UR"]
    picked_rarity = np.random.choice(rarities, p=weight)

    #Si l'UR gagne, décidez quel prix donner
    if picked_rarity == "UR":
        picked_rarity = "".join((picked_rarity, "(", pickup_premium(), ")"))

    return picked_rarity

def pickup_premium():
    """Décharger les prix UR en supposant une probabilité égale"""
    ur = ["Freebie 1", "Freebie 2", "Freebie 3", "Gratuit 4", "Gratuit 5", "Gratuit 6", "Gratuit 7",
          "Gratuit 8", "Gratuit 9", "Gratuit 10", "Gratuit 11", "Gratuit 12"]
    return np.random.choice(ur)

Objet de valeur contenant le prix et le nombre de fois

L'objet de valeur est un objet qui contient une valeur.

Cette fois, nous garderons le nombre de fois où le gacha a été retourné et le montant facturé. C'est un problème, alors combinez-les en un seul objet.

class VO(object):
    def __init__(self):
        self._count = 0 #Nombre de fois
        self._price = 0 #Montant facturé

    def getcount(self):
        return self._count

    def setcount(self, count):
        self._count = count

    def getprice(self):
        return self._price

    def setprice(self, price):
        self._price = price

    count = property(getcount, setcount)
    price = property(getprice, setprice)

Routage du processus de tournage du gacha

Le reste consiste à implémenter le routage Flask.

@app.route('/')
def index():
    title = "Bienvenue"
    message = "Cliquez sur le bouton pour tourner le gacha"
    return render_template('index.html',
                           message=message, title=title)

@app.route('/post', methods=['POST', 'GET'])
def post():
    time = datetime.datetime.today().strftime("%H:%M:%S")
    message = ""
    if request.method == 'POST':
        result = []
        if 'rare' in request.form:
            title = "J'ai tourné le gacha!"
            vo.price = vo.price + 300
            vo.count = vo.count + 1
            result = turn_rare()
        if '10rare' in request.form:
            title = "J'ai tourné le gacha!"
            vo.price = vo.price + 3000
            vo.count = vo.count + 1
            result = turn_10rare()
        if 'reset' in request.form:
            title = "Réinitialiser"
            vo.price = 0
            vo.count = 0
            result = ""
            message = "Réinitialiser"
        return render_template('index.html',
                               result=result, title=title,
                               time=time, vo=vo,
                               message=message)
    else:
        return redirect(url_for('index'))

Vue

Enfin, préparez l'écran.

<div class="form">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <p class="lead">
          {% if result %}
            {{ time }}J'ai tourné le gacha!<br>
            {{ vo.count }}Montant total d'argent{{ vo.price }}Cercle<br>
Le résultat est
            {% for v in result %}
              {{ v }}
            {% endfor %}
était!
          {% else %}
            {{ message }}
          {% endif %}
        </p>
        <form action="/post" method="post" name="rare" class="form-inline">
          <button type="submit" name="rare" class="btn btn-default">Tourner le gacha rare</button>
        </form>
        <form action="/post" method="post" name="10rare" class="form-inline">
          <button type="submit" name="10rare" class="btn btn-default">Tournez 10 gachas rares consécutifs</button>
        </form>
        <form action="/post" method="post" name="reset" class="form-inline">
          <button type="submit" name="reset" class="btn btn-default">Réinitialiser</button>
        </form>
      </div>
    </div>
  </div>
</div>

C'est tout ce qu'on peut en dire.

Essayez de tourner le gacha

Démarrez l'application en tant que python app.py comme dans Dernière fois.

Accédez au port 5000 sur localhost avec votre navigateur.

Dans cet état, si vous appuyez sur le gacha rare, vous pouvez payer 300 yens, et si vous appuyez sur le gacha rare de la série 10, vous pouvez payer 3000 yens pour tourner le gacha. Lorsque j'ai appuyé sur 10 stations en guise d'essai, j'ai obtenu 2 SR comme indiqué ci-dessous.

Combien d'essais pouvez-vous obtenir l'UR? Veuillez essayer.

D'ailleurs, dans cette simulation, j'ai pu obtenir 16 fois UR pour 10 gachas rares consécutifs pour une charge totale de 48 000 yens.

C'est une bonne idée de reconsidérer si cette charge vaut vraiment le prix.

Précédemment [Comp Gacha](http://ja.wikipedia.org/wiki/%E3%82%B3%E3%83%B3%E3%83%97%E3%83%AA%E3%83%BC%E3 % 83% 88% E3% 82% AC% E3% 83% 81% E3% 83% A3) est devenu un problème, mais par exemple, afin d'utiliser cette simulation pour préparer les 12 types de Gacha UR Il peut être intéressant d'essayer combien cela coûtera.

De plus, la probabilité de publication de gacha cette fois est une valeur fixée arbitrairement et n'a rien à voir avec les services réels.

Résumé

Cette fois, j'ai utilisé le jeu social gacha comme thème, mais il est très significatif de pouvoir vérifier facilement le calcul basé sur la ** théorie économique ** de cette manière.

La théorie économique, par exemple, dans la théorie microéconomique, est hypothétiquement dérivée du comportement humain. Pour vérifier objectivement que la théorie explique bien l'économie réelle, utilisez des formules mathématiques pour construire un ** modèle économique **.

Le modèle quantifié est appelé le ** modèle économétrique ** et fait l'objet d'une analyse empirique.

La combinaison de Python + Flask, qui rend facile et hautement fonctionnelle la mise en œuvre d'un système de simulation, sera une aide puissante pour faire progresser l'analyse empirique.

Le code source de cet article est disponible sur ici.