Cleric Spells.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import json\n",
    "import re\n",
    "import csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "expected_tempest_filename = 'expected-tempest-spells.csv'\n",
    "expected_base_filename = 'expected-base-spells.csv'\n",
    "\n",
    "input_filename = 'hardcodex-cleric-all.csv'\n",
    "col_names = ['level', 'title', 'type', 'casting_time', 'range', 'components', 'duration', 'orig_description', 'orig_class']\n",
    "\n",
    "output_filename = 'cleric-tempest-5.json'\n",
    "\n",
    "overrides_filename = 'overrides.txt'\n",
    "\n",
    "\n",
    "subclass_reg = re.compile('(\\w+)\\s+\\((\\w+)\\)')\n",
    "def parse_class(input_str):\n",
    "    m = subclass_reg.match(input_str)\n",
    "    if m:\n",
    "        data = m.groups()\n",
    "    else:\n",
    "        data = (input_str, None)\n",
    "\n",
    "    return pd.Series(data=data)\n",
    "\n",
    "ritual_reg = re.compile('(.+)\\s+\\([Rr]itual\\)')\n",
    "def parse_ritual(input_str):\n",
    "    m = ritual_reg.match(input_str)\n",
    "    if m:\n",
    "        data = (m.group(1), True)\n",
    "    else:\n",
    "        data = (input_str, False)\n",
    "\n",
    "    return pd.Series(data=data)\n",
    "\n",
    "\n",
    "orig_df = pd.read_csv(input_filename, sep=';', header=None, names=col_names)\n",
    "orig_df[['klass','subclass']] = orig_df['orig_class'].apply(parse_class)\n",
    "orig_df[['title', 'is_ritual']] = orig_df['title'].apply(parse_ritual)\n",
    "\n",
    "orig_expected = pd.read_csv(expected_base_filename, sep=',', header=None, names=['level', 'title', 'subclass'])\n",
    "orig_expected['subclass'] = orig_expected['subclass'].apply(lambda x: None if pd.isnull(x) else x)\n",
    "\n",
    "orig_expected_tempest = pd.read_csv(expected_tempest_filename, sep=',', header=None, names=['level', 'title', 'subclass'])\n",
    "\n",
    "# format data\n",
    "orig_df = orig_df.set_index(['title'], drop=False)\n",
    "\n",
    "orig_expected = orig_expected.set_index(['title'], drop=False)\n",
    "\n",
    "orig_expected_tempest = orig_expected_tempest.set_index(['title'], drop=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Calculate expected cards\n",
    "df = orig_df.copy()\n",
    "expected = orig_expected.copy()\n",
    "expected_tempest = orig_expected_tempest.copy()\n",
    "\n",
    "# combine expected\n",
    "all_expected = expected.append(expected_tempest)\n",
    "all_expected = all_expected.groupby(['title', 'level'])['subclass'].apply(lambda x: next((a for a in x if a), None)).reset_index()\n",
    "all_expected = all_expected[all_expected['level'] < 5]\n",
    "all_expected = all_expected.sort_values(by=['level', 'title'])\n",
    "all_expected = all_expected.set_index(['title'], drop=False)\n",
    "lvl_4 = all_expected[all_expected['level'] == 4]\n",
    "\n",
    "assert len(lvl_4) == 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#print(df[df['title'].isin(['Augury', 'Bless', 'Control Water'])]['subclass'])\n",
    "wtf = pd.merge(df, all_expected, on=['level', 'title'], left_index=True, right_index=True)\n",
    "wtf = wtf.drop('subclass_x', axis=1)\n",
    "wtf = wtf.rename(columns={'subclass_y': 'subclass'})\n",
    "\n",
    "wtf = wtf[(wtf.klass == 'Cleric') & wtf.subclass.isin(['Tempest', None]) & (wtf.level <= 4)]\n",
    "\n",
    "assert len(wtf) == len(all_expected), 'Expected %d but got %d' % (len(all_expected), len(wtf))\n",
    "\n",
    "wtf = wtf.sort_values(by=['level', 'title'])\n",
    "\n",
    "flavor_reg = re.compile('\\(([\\w ]+)\\)(.*)')    \n",
    "def parse_flavor(desc):\n",
    "    m = flavor_reg.match(desc)\n",
    "    if m:\n",
    "        data = m.groups()\n",
    "    else:\n",
    "        data = (None, desc)\n",
    "\n",
    "    return pd.Series(data=data)\n",
    "\n",
    "at_higher_reg = re.compile('(.*)At Higher Levels:\\s+?(.*)')    \n",
    "def parse_at_higher(desc):\n",
    "    m = at_higher_reg.match(desc)\n",
    "    if m:\n",
    "        data = m.groups()\n",
    "    else:\n",
    "        data = (desc, None)\n",
    "\n",
    "    return pd.Series(data=data)\n",
    "\n",
    "\n",
    "wtf[['flavor', 'description']] = wtf['orig_description'].apply(parse_flavor)\n",
    "wtf[['description', 'at_higher']] = wtf['description'].apply(parse_at_higher)\n",
    "\n",
    "spells = wtf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "with open(overrides_filename) as fp:\n",
    "    overrides = {}\n",
    "    current = None\n",
    "    destination = 'description'\n",
    "    for line in fp:\n",
    "        line = line.strip()\n",
    "        if not line:\n",
    "            continue\n",
    "        if line.find('----at higher levels') == 0:\n",
    "            destination = 'at_higher'\n",
    "            continue\n",
    "\n",
    "        if line.find('---') == 0:\n",
    "            title = line[3:]\n",
    "            overrides[title] = current = {'description': '', 'at_higher': ''}\n",
    "            destination = 'description'\n",
    "            continue\n",
    "            \n",
    "        current[destination] += line\n",
    "            \n",
    "\n",
    "data = []\n",
    "for idx, spell in spells.iterrows():\n",
    "    if spell.subclass:\n",
    "        title = '{0} ({1})'.format(spell.title, spell.subclass)\n",
    "    else:\n",
    "        title = spell.title\n",
    "    contents = []\n",
    "    contents.append('subtitle | {}'.format(spell.type))\n",
    "    if False:\n",
    "        contents.append('property | Casting time | {}'.format(spell.casting_time))\n",
    "        contents.append('property | Range | {}'.format(spell.range))\n",
    "        if False:  # include components?\n",
    "            contents.append('property | Components | {}'.format(spell.components))\n",
    "        contents.append('property | Duration | {}'.format(spell.duration))\n",
    "\n",
    "    else:\n",
    "        components = ','.join(map(lambda x: x.strip(), spell.components.split(',')))\n",
    "        casting_time = spell.casting_time\n",
    "        duration = spell.duration.replace('Concentration,', 'CONC')\n",
    "        combined_stats = '({}) {}, {}'.format(components, casting_time, duration)\n",
    "        contents.append('text | ' + combined_stats)\n",
    "        contents.append('property | Range | {}'.format(spell.range))\n",
    "\n",
    "    contents.append('rule')\n",
    "\n",
    "    override_description = overrides.get(spell.title, {}).get('description')\n",
    "    description_chunks = (override_description or spell.description).split('<br>')\n",
    "\n",
    "\n",
    "    for chunk in description_chunks:\n",
    "        chunk = chunk.strip()\n",
    "\n",
    "        # get rid of component details that show up sometimes\n",
    "        if chunk.find('(') == 0:\n",
    "            chunk = chunk[chunk.find(')')+1:]\n",
    "\n",
    "        if not chunk:\n",
    "            continue\n",
    "\n",
    "        contents.append('text | {}'.format(chunk))\n",
    "\n",
    "    override_at_higher = overrides.get(spell.title, {}).get('at_higher')\n",
    "    at_higher = override_at_higher or spell.at_higher\n",
    "    if at_higher:\n",
    "        at_higher_chunks = at_higher.split('<br>')\n",
    "        at_higher_chunks = map(lambda x: x.strip(), at_higher_chunks)\n",
    "        if at_higher_chunks:\n",
    "            contents.append('rule')\n",
    "            for chunk in at_higher_chunks:\n",
    "                chunk = chunk.strip()\n",
    "                if not chunk:\n",
    "                    continue\n",
    "                contents.append('text | {}'.format(chunk))\n",
    "    result = {\n",
    "        'count': 1,\n",
    "        'color': '',\n",
    "        'icon_back': '',\n",
    "        'icon': '',\n",
    "        'title': title,\n",
    "        'contents': contents,\n",
    "    }\n",
    "    data.append(result)\n",
    "with open(output_filename, 'w') as fd:\n",
    "    json.dump(data, fd, indent=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(all_expected['title']) - set(spells['title'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}