from flask import Flask from flask_cors import CORS from flask_restx import Api, Resource from models import dice_model, ability_model, hp_model, character_model, encounter_model, ma_model, mutation_model from schemas import DiceSchema, CharacterSchema, EncounterSchema, MentalAttackSchema, AbilitySchema, HPSchema, \ MutationSchema from encounters import EncounterTable from mentattack import MentalAttackMatrix from mutations import Mutations from cybermods import CyberMods import random app = Flask(__name__) CORS(app) app.config.SWAGGER_UI_JSONEDITOR = True app.config['SWAGGER_UI_JSONEDITOR'] = True api = Api(app, version='1.0', title='Gamma World Dice', description='Rolled Dice As A Service') dice = api.namespace('dice', description='Dice operations') ability = api.namespace('ability', description='Ability operations') hp = api.namespace('hp', description='HP operations') ma = api.namespace('ma', description='Mental Attack operations') mut = api.namespace('mut', description='Mutation operations') character = api.namespace('character', description='Character operations') encounter = api.namespace('encounter', description='Encounter operations') ability_model = ability.model('Ability', ability_model) ability_schema = AbilitySchema() mutation_model = mut.model('Mutation', mutation_model) mutation_schema = MutationSchema() hp_model = hp.model('HP', hp_model) hp_schema = HPSchema() dice_model = dice.model('Dice', dice_model) dice_schema = DiceSchema() ma_model = ma.model('MA', ma_model) ma_schema = MentalAttackSchema() character_model = character.model('Character', character_model) character_schema = CharacterSchema() encounter_model = encounter.model('Encounter', encounter_model) encounter_schema = EncounterSchema() @api.route('/roll/dice', methods=['POST']) class RollDice(Resource): @dice.expect(dice_model) def post(self): data = api.payload errors = dice_schema.validate(data) if errors: return errors, 400 quantity = data.get('quantity') geometry = data.get('geometry') discard_lowest = data.get('discard_lowest') if quantity is None or geometry is None: return {"message": "Required dice data not provided"}, 400 return roll_dices(quantity, geometry, discard_lowest), 200 @api.route('/roll/ability', methods=['POST']) class RollAbility(Resource): @ability.expect(ability_model) def post(self): data = api.payload errors = ability_schema.validate(data) if errors: return errors, 400 chartype = data.get('chartype') attribute = data.get('ability') return roll_ability_scores(chartype, attribute), 200 @api.route('/roll/hp', methods=['POST']) class RollHP(Resource): @hp.expect(hp_model) def post(self): data = api.payload errors = hp_schema.validate(data) if errors: return errors, 400 chartype = data.get('chartype') conscore = data.get('conscore') if conscore is None: return {"message": "A constitution score is required"}, 400 if chartype == 'human': geometry = 8 else: geometry = 6 return roll_dices(conscore, geometry, False), 200 @api.route('/roll/encounter', methods=['POST']) class RollEncounter(Resource): @encounter.expect(encounter_model) def post(self): data = api.payload errors = encounter_schema.validate(data) if errors: return errors, 400 terrain = data.get('terrain').lower() roll = roll_dices(1, 20, False).get('result') et = EncounterTable() creature = et.get_encounter(roll, terrain) if creature is None: creature = "All clear!" return {"encounter": creature}, 200 @api.route('/roll/attack/mental', methods=['POST']) class RollMentalAttack(Resource): @ma.expect(ma_model) def post(self): data = api.payload errors = ma_schema.validate(data) if errors: return errors, 400 ams = data.get('ams') dms = data.get('dms') modifier = data.get('modifier') result = {} mam = MentalAttackMatrix() needed = mam.get_attack_score(ams, dms) result["needed"] = needed outcome = None if needed < 2: outcome = "Automatic Success!" elif needed > 20: outcome = "Absolutely No Chance!" else: raw_roll = roll_dices(1, 20, False).get('result') if modifier != 0: result["original-roll"] = raw_roll result["modifier"] = modifier rolled = raw_roll + modifier # negative modifiers will subtract themselves naturally result["adjusted-roll"] = rolled else: rolled = raw_roll result["original-roll"] = rolled if (rolled >= 20) and (needed <= 16): outcome = "Devastating Success!" elif needed <= rolled: outcome = "Attack Successful!" elif needed > rolled: outcome = "Attack Failed!" result["outcome"] = outcome return result, 200 @api.route('/roll/tohit', methods=['GET']) class RollToHit(Resource): @staticmethod def get(): return roll_dices(1, 20, False), 200 @api.route('/roll/chance', methods=['GET']) class RollChance(Resource): @staticmethod def get(): return roll_dices(1, 100, False), 200 @api.route('/coinflip', methods=['GET']) class RollCoinflip(Resource): @staticmethod def get(): return random.choice(['Heads', 'Tails']), 200 @api.route('/roll/mutations', methods=['POST']) class RollMutations(Resource): @mut.expect(mutation_model) def post(self): data = api.payload errors = mutation_schema.validate(data) if errors: return errors, 400 conscore = data.get('conscore') intscore = data.get('intscore') return roll_mutations(conscore, intscore), 200 @api.route('/character/generate', methods=['POST']) class GenerateCharacter(Resource): @character.expect(character_model) def post(self): data = api.payload errors = character_schema.validate(data) if errors: return errors, 400 chartype = data.get('chartype') character_sheet = {} if chartype == 'mutant': character_sheet['animal-stock'] = (roll_mutant_animal()) ability_scores = roll_ability_scores(chartype) character_sheet['abilities'] = ability_scores character_sheet['hp'] = roll_hp(chartype, ability_scores['constitution']) character_sheet['gold'] = roll_dices(4, 4, False).get('result') * 10 character_sheet['domar'] = roll_dices(2, 4, False).get('result') * 5 if chartype == 'humanoid' or chartype == 'mutant': character_sheet['mutations'] = ( roll_mutations(ability_scores['constitution'], ability_scores['intelligence']) ) if chartype == 'cyborg': character_sheet['cybermods'] = ( roll_cybermods() ) return character_sheet, 200 def roll_dices(dice_count, dice_sides, discard_lowest): roll_results = [] discarded = [] for _ in range(dice_count): roll_results.append(random.randint(1, dice_sides)) if discard_lowest and len(roll_results) > 0: discarded.append(min(roll_results)) roll_results.remove(min(roll_results)) if discarded: net_dice_count = dice_count - 1 mnemonic = str(dice_count) + "(-1)d" + str(dice_sides) else: mnemonic = str(dice_count) + 'd' + str(dice_sides) net_dice_count = dice_count result = { 'dice-set': { 'mnemonic': mnemonic, 'min-roll': net_dice_count, 'max-roll': dice_sides * net_dice_count }, 'rolls': roll_results, 'result': sum(roll_results) } if discarded: result['discarded'] = discarded return result def roll_ability_scores(chartype, attribute=None): if attribute is None or attribute == "all": ability_list = ['p-strength', 'm-strength', 'constitution', 'dexterity', 'charisma', 'intelligence'] else: ability_list = [attribute] ability_scores = {} for abil in ability_list: if ((chartype == 'human') and ((abil == 'intelligence') or (abil == 'charisma') or (abil == 'constitution'))): roll = roll_dices(4, 6, False) # humans are special if (abil == 'constitution') and roll["result"] > 18: roll["capped"] = True roll["result"] = 18 if (abil == 'intelligence' or abil == 'charisma') and roll["result"] > 21: roll["capped"] = True roll["result"] = 21 ability_scores[abil] = roll["result"] else: roll = roll_dices(4, 6, True) # nothing else is special ability_scores[abil] = roll["result"] return ability_scores def roll_hp(chartype, conscore): if chartype == 'human': geometry = 8 else: geometry = 6 return roll_dices(conscore, geometry, False).get('result') def roll_cybermods(): """ Cybermods are similar to mutations, except that they are artificial changes to the body, where mutations are 'natural' changes to the body. Fewer cybermods are possible than with mutations. So, you make one roll of 1d4, and then parse up the score between the two types of mods, as you see fit. If no emphasis is specified, the score will be split as evenly as possible. If the score is 1, then a physical mod will be the default. :return: table of cybermods (in json format) """ cybermods_table = {} cybermods_count = roll_dices(1, 4, False)["result"] phys_cnt = split_number(cybermods_count)[1] # This ends up being the higher of the two numbers ment_cnt = split_number(cybermods_count)[0] cybermods_table['count'] = {'mental': ment_cnt, 'physical': phys_cnt} mental_cybermods_scores = [] physical_cybermods_scores = [] for _ in range(ment_cnt): mscore = roll_dices(1, 10, False).get('result') if mscore in mental_cybermods_scores: mscore = roll_dices(1, 10, False).get('result') mental_cybermods_scores.append(mscore) for _ in range(phys_cnt): pscore = roll_dices(1, 10, False).get('result') if pscore in physical_cybermods_scores: pscore = roll_dices(1, 10, False).get('result') physical_cybermods_scores.append(pscore) cyb = CyberMods() mcyb = [] pcyb = [] for score in mental_cybermods_scores: modification = cyb.get_mental_cybermod(score) mcyb.append(modification) if len(mcyb) != 0: cybermods_table['mental'] = mcyb for score in physical_cybermods_scores: modification = cyb.get_physical_cybermod(score) pcyb.append(modification) if len(pcyb) != 0: cybermods_table['physical'] = pcyb return cybermods_table def roll_mutations(conscore, intscore): """ :param conscore: modifier for physical mutation determination :param intscore: modifier for mental mutation determination :return: table of mutations (in json form) """ mutations_table = {} mental_mutations_cnt = roll_dices(1, 4, False).get('result') physical_mutations_cnt = roll_dices(1, 4, False).get('result') mutations_table['count'] = {'mental': mental_mutations_cnt, 'physical': physical_mutations_cnt} mental_mutations_scores = get_score_list(mental_mutations_cnt, intscore) mutations_table['mental'] = get_mutations(mental_mutations_scores) physical_mutations_scores = get_score_list(physical_mutations_cnt, conscore) mutations_table['physical'] = get_mutations(physical_mutations_scores) return mutations_table def get_mutations(scorelist): mut_table = Mutations() mut_list = [] for score in scorelist: mutation = mut_table.get_mental_mutation(score) mut_list.append(mutation) return mut_list def get_score_list(count, modifier): tmp_scores = [] for _ in range(count): roll = roll_dices(1, 100, False).get('result') + modifier if roll in tmp_scores: roll = roll_dices(1, 100, False).get('result') + modifier if roll > 100: roll = 100 tmp_scores.append(roll) return tmp_scores def roll_mutant_animal(): creature = dict() animal_stock = ['badger', 'racoon', 'hound', 'wolf', 'big-cat', 'fox', 'spider', 'lizard', 'ant', 'hornet', 'hawk', 'ostrich', 'emu', 'crocodile', 'snake', 'rabbit', 'rat', 'bear', 'elephant', 'platypus', 'bull', 'horse', 'goat', 'bat', 'silverfish', 'cockroach', 'turtle', 'gibbon', 'penguin', 'orangutan', 'chimpanzee', 'housefly', 'lobster', 'crab', 'prawn', 'pig', 'chicken', 'duck', 'parrot', 'mouse', 'heron', 'weasel', 'squirrel', 'pigeon', 'crow', 'house-cat', 'shark', 'dolphin', 'narwhal', 'buffalo'] posture = ['upright', 'prone', 'mixed'] creature['stock'] = random.choice(animal_stock) creature['posture'] = random.choice(posture) if creature['posture'] == 'upright' or creature['posture'] == 'mixed': creature['arms'] = random.choice(list(range(2, 4, 2))) # if you're upright 4 is the limit creature['legs'] = random.choice(list(range(2, 6, 2))) # same with legs if creature['posture'] == 'prone': creature['legs'] = random.choice(list(range(4, 8, 2))) # if you're prone, you only get legs return creature def split_number(n): first_split = n // 2 # this will split the number in two equal parts, if it is even second_split = n % 2 + first_split # this will add one to one part if the number is odd return first_split, second_split if __name__ == '__main__': app.run()