mtg-web/analyzer/models.py

import re
from django.db import models
from mtgweb.lib.mtg import mtg, analyze

# Create your models here.
class CardType(models.Model):
    name = models.CharField(max_length=200, unique=True, db_index=True)
    def __unicode__(self):
        return self.name
class Attribute(models.Model):
    name = models.CharField(max_length=200, unique=True, db_index=True)
    def __unicode__(self):
        return self.name
class Card(models.Model, mtg.Card):
    name = models.CharField(max_length=200, unique=True)
    type = models.ForeignKey(CardType)
    attributes = models.ManyToManyField(Attribute)
    cost = models.CharField(max_length=80)
    converted_cost = models.IntegerField(default=0)
    power = models.CharField(max_length=10)
    toughness = models.CharField(max_length=10)
    rarity = models.CharField(max_length=1)
    text = models.TextField()

    def __unicode__(self):
        return self.name
    def get_cost(self):
        return mtg.ManaCost(self.cost)
class Deck(models.Model):
    name = models.CharField(max_length=80)
    cards = models.ManyToManyField(Card, through='Included')
    def __unicode__(self):
        return self.name
    def get_cards(self):
        return self.included_set.all().order_by('card__type__name')
    def card_count(self):
        return sum([i.count for i in self.included_set.all()])
    def lands(self):
        symbols = {}
        for symbol in mtg.Mana.types.keys():
            symbols[symbol] = 0
        for included in self.included_set.all():
            card = included.card
            types = card.type.name.split(' ')
            attributes = [a.name for a in card.attributes.all()]
            if 'land' not in types:
                continue
            if 'forest' in attributes:
                symbols['G'] += included.count
            if 'mountain' in attributes:
                symbols['R'] += included.count
            if 'island' in attributes:
                symbols['U'] += included.count
            if 'plains' in attributes:
                symbols['W'] += included.count
            if 'swamp' in attributes:
                symbols['B'] += included.count

            # Get symbols from abilities
            pattern = '{%s}' % mtg.ManaCost.symbolPattern
            costs = [mtg.ManaCost(cost) for cost in re.findall(pattern, str(card.text))]
            for cost in costs:
                for color, count in cost.mana.mana.iteritems():
                    symbols[color] += count * included.count
        return symbols
    def symbols(self):
        symbols = {}
        for symbol in mtg.Mana.types.keys():
            symbols[symbol] = 0
        for included in self.included_set.all():
            card = included.card
            # Get symbols from card cost
            cost = mtg.ManaCost(card.cost)
            for color, count in cost.mana.mana.iteritems():
                symbols[color] += count * included.count

            # Get symbols from abilities
            pattern = '{%s}' % mtg.ManaCost.symbolPattern
            costs = [mtg.ManaCost(cost) for cost in re.findall(pattern, str(card.text))]
            for cost in costs:
                for color, count in cost.mana.mana.iteritems():
                    symbols[color] += count * included.count
        return symbols
    def mana_curve(self):
        curve = {}
        for included in self.included_set.all():
            card = included.card
            if 'land' in card.type.name.split(' '):
                continue
            cost = mtg.ManaCost(card.cost).converted()
            if cost not in curve:
                curve[cost] = included.count
            else:
                curve[cost] += included.count
        return curve
    def ramp(self, type=None):
        ramp = {}
        deck_size = sum([i.count for i in self.included_set.all()])
        lands = sum([i.count for i in self.included_set.all() if 'land' in i.card.type.name.split(' ')])
        if type:
            cards = [i for i in self.included_set.all() if type in i.card.type.name.split(' ')]
        else:
            cards = [i for i in self.included_set.all() if 'land' not in i.card.type.name.split(' ')]
        card_count = sum([i.count for i in cards])
        card_costs = sum([i.count * mtg.ManaCost(i.card.cost).converted() for i in cards])
        max_cost = max([mtg.ManaCost(i.card.cost).converted() for i in cards])
        avg_cost = card_costs / float(card_count)
        avg_cost = int(round(avg_cost))
        turns = [] 
        for turn in range(avg_cost, max_cost + 1):
            castable = sum([i.count for i in cards if mtg.ManaCost(i.card.cost).converted() <= turn])
            p_land = 1 -  analyze.draw_probability(lands, deck_size, avg_cost, turn)
            p_spell = 1 - analyze.draw_probability(castable, deck_size, 1, turn, avg_cost)
            probability = 1 - p_land - p_spell
            turns.append({'turn': turn, 'probability': probability * 100})
        return turns

class Included(models.Model):
    card = models.ForeignKey(Card)
    deck = models.ForeignKey(Deck)
    count = models.IntegerField(default=0)
    def __unicode__(self):
        return '{0}x {1}'.format(self.count, self.card)