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.

type La description
R Juste rare. Le moins précieux.
SR Super rare. La valeur est élevée telle quelle.
UR Ultime rare. C'est le plus précieux et c'est le but du joueur de l'obtenir.

Probabilité de gagner

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

R SR UR
94.85% 5.04% 0.12%

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

R SR UR
90.28% 9.29% 0.45%

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.

1.png

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.

2.png

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.

3.png

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.

Recommended Posts

Créez un simulateur de gacha rare avec Flask
Créez un simple générateur d'images par points avec Flask
Faire un bot d'analyse morphologique de manière lâche avec LINE + Flask
Faites une loterie avec Python
Faire un feu avec kdeplot
Comment créer un BOT Cisco Webex Teams à l'aide de Flask
Faites un son avec le notebook Jupyter
Créer un serveur Flask avec Docker
Faisons une rupture de bloc avec wxPython
Créer un système de recommandation avec python
Créer un filtre avec un modèle django
Faisons un graphe avec python! !!
Faisons un spacon avec xCAT
Créer un itérateur de modèle avec PySide
Faire un joli graphique avec plotly
Faisons une application WEB pour l'annuaire téléphonique avec flacon Partie 1
Faisons une application WEB pour l'annuaire téléphonique avec flacon Partie 2
Faisons une application WEB pour l'annuaire téléphonique avec flacon Partie 3
Faisons une application WEB pour l'annuaire téléphonique avec flacon Partie 4
Faisons un jeu de shiritori avec Python
Créer un lecteur vidéo avec PySimpleGUI + OpenCV
Créez un pipeline de notebook avec Kedro + Papermill
Faire une figure partiellement zoomée avec matplotlib
Créez un quiz de dessin avec kivy + PyTorch
Faisons la voix lentement avec Python
Créez un classificateur en cascade avec Google Colaboratory
Faisons un langage simple avec PLY 1
Créez une application Web simple avec Flask
Faire un circuit logique avec Perceptron (Perceptron multicouche)
Faire Oui Non Popup avec Kivy
Faire une minuterie de lavage-séchage avec Raspberry Pi
Créer une animation GIF avec surveillance des dossiers
Créez un framework Web avec Python! (1)
Créer un service Web avec Docker + Flask
Faisons une IA à trois yeux avec Pylearn 2
Créez une application de bureau avec Python avec Electron
Faisons un bot Twitter avec Python!
Créez un framework Web avec Python! (2)
J'ai fait un simulateur de neurones avec Python
Créons une application Web de conversion A vers B avec Flask! De zéro ...
Créer un bot Twitter Trend avec heroku + Python
Fabriquer un appareil de surveillance avec un capteur infrarouge
Comment créer un dictionnaire avec une structure hiérarchique.
Je veux faire un jeu avec Python
Essayez de créer un code de "décryptage" en Python
Créer un babillard avec Heroku, Flask, SQL Alchemy
Lancer un serveur Web avec Python et Flask
Remplaçons UWSC par Python (5) Faisons un robot
Essayez de créer un groupe de dièdre avec Python
[Chat De Tornado] Créez un chat en utilisant WebSocket dans Tornado
Transformez les données de vacances en une trame de données avec les pandas
Créer un bot LINE WORKS avec Amazon Lex
(Mémorandum) Créer un diagramme de dispersion 3D avec matplodlib
Made Mattermost Bot avec Python (+ Flask)
Combinez des chaînes répétitives en une seule avec des expressions régulières Python.