Bump version

Possible fix for #2084

.appveyor.yml

@@ -52,8 +52,8 @@ install:
   # pip will build them from source using the MSVC compiler matching the
   # target Python version and architecture
   - ECHO "Install pip requirements:"
-  - "pip install -r requirements.txt"
-  - "pip install PyInstaller"
+  - "python -m pip install -r requirements.txt"
+  - "python -m pip install PyInstaller"
 
 before_build:
     # directory that will contain the built files
@@ -65,6 +65,8 @@ before_build:
 build_script:
   - ECHO "Build pyfa:"
 
+  # Build gamedata DB
+  - "python db_update.py"
   ##########
   # PyInstaller - create binaries for pyfa
   ##########

.travis.yml

@@ -1,5 +1,7 @@
 os: linux
 language: python
+git:
+  depth: 400
 python:
   - 3.6
 matrix:
@@ -11,6 +13,7 @@ matrix:
 before_install:
   - bash scripts/setup-osx.sh
 install:
+  - python3 db_update.py
   - export PYFA_VERSION="$(python3 scripts/dump_version.py)"
   - bash scripts/package-osx.sh
 before_deploy:

CONTRIBUTING.md

@@ -0,0 +1,102 @@
+# Contribution
+
+## Requirements
+
+- Python 3.6
+- Git CLI installed
+- Python, pip and git are all available as command-line commands (add to the path if needed)
+
+Virtual environment will be created in *PyfaEnv* folder. Project will be cloned and run from the *PyfaDEV* folder. Separate virtual environment will be created so required libraries won't clutter the main python installation.
+
+> Commands and screens were created on Windows 10. Please, update all the paths according to your OS.
+
+## Setting up the project manually
+
+Clone the repository
+```
+git clone <repo> PyfaDEV
+```
+
+Create the virtual environment
+```
+python -m venv PyfaEnv
+```
+
+Activate the virtual environment
+
+```
+For cmd.exe: PyfaEnv\scripts\activate.bat
+For bash: source <venv>/Scripts/activate
+```
+> For other OS check [Python documentation](https://docs.python.org/3/library/venv.html)
+
+Install requirements for the project from *requirements.txt*
+```
+pip install -r PyfaDEV\requirements.txt
+```
+> For some Linux distributions, you may need to install separate wxPython bindings, such as `python-matplotlib-wx`
+
+Check that the libs from *requirements.txt* are installed
+```
+pip list
+```
+
+Test that the project is starting properly
+```
+python PyfaDEV\pyfa.py
+```
+
+
+
+## Setting up the project with PyCharm/IntelliJ
+
+Install PyCharm / Other IntelliJ product with Python plugin
+
+After launching - select *Check out from Version Control* -> *GIt*
+
+![welcome](https://user-images.githubusercontent.com/54093496/66862580-d8edab00-ef99-11e9-94e2-e93d7043e620.png)
+
+Login to GitHub, paste the repo URL and select the folder to which to clone the project into, press *Clone*.
+
+![Clone](https://user-images.githubusercontent.com/54093496/66862748-38e45180-ef9a-11e9-9f68-4903baf47385.png)
+
+After process is complete, open *File* -> *Settings* -> *Project* -> *Project Interpreter*. 
+
+![Settings](https://user-images.githubusercontent.com/54093496/66862792-544f5c80-ef9a-11e9-9e0f-f64767f3f1b0.png)
+
+Press on options and add new virtual environment.
+
+![venv](https://user-images.githubusercontent.com/54093496/66862833-67622c80-ef9a-11e9-94fa-47cca0158d29.png)
+
+Open project tree view and double-click on the *requirements.txt*. Press *Install requirements*. Install all requirements.
+
+![Reqs](https://user-images.githubusercontent.com/54093496/66862870-7a74fc80-ef9a-11e9-9b18-e64be42c49b8.png)
+
+Create new *Run Configuration*. Set correct *Script path* and *Python interpreter*.
+
+![Run configuraion](https://user-images.githubusercontent.com/54093496/66862970-b4460300-ef9a-11e9-9fb4-20e24759904b.png)
+
+Check that the project is starting properly.
+
+## Running tests
+
+Switch to the proper virtual environment
+```
+For cmd.exe: PyfaEnv\scripts\activate.bat
+For bash: source <venv>/Scripts/activate
+```
+
+Install pytest 
+```
+pip install pytest  
+```
+
+Switch to pyfa directory.
+
+Run tests (any will do)
+```
+python -m pytest
+py.test
+```
+
+More information on tests can be found on appropriate [Wiki page](https://github.com/pyfa-org/Pyfa/wiki/Developers:-Writing-Tests-for-Pyfa).

README.md

@@ -2,20 +2,19 @@
 
 [![Join us on Slack!](https://pyfainvite.azurewebsites.net/badge.svg)](https://pyfainvite.azurewebsites.net/) [![Build Status](https://travis-ci.org/pyfa-org/Pyfa.svg?branch=master)](https://travis-ci.org/pyfa-org/Pyfa)
 
-![pyfa](https://cloud.githubusercontent.com/assets/3904767/10271512/af385ef2-6ade-11e5-8f67-52b8b1e4c797.PNG)
+![pyfa](https://user-images.githubusercontent.com/275209/66119992-864be080-e5e2-11e9-994a-3a4368c9fad7.png)
 
 ## What is it?
 
-pyfa, short for **py**thon **f**itting **a**ssistant, allows you to create, experiment with, and save ship fittings without being in game. Open source and written in Python, it is available on any platform where Python 2.x and wxWidgets are available, including Windows, Mac OS X, and Linux.
+Pyfa, short for **py**thon **f**itting **a**ssistant, allows you to create, experiment with, and save ship fittings without being in game. Open source and written in Python, it is available on any platform where Python 3 and wxWidgets are available, including Windows, Mac OS X, and Linux.
 
 ## Latest Version and Changelogs
-The latest version along with release notes can always be found on the project's [Releases](https://github.com/DarkFenX/Pyfa/releases) page. pyfa will notify you if you are running an outdated version.
+The latest version along with release notes can always be found on the project's [releases](https://github.com/pyfa-org/Pyfa/releases) page. Pyfa will notify you if you are running an outdated version.
 
 ## Installation
 Windows and OS X users are supplied self-contained builds of pyfa on the [latest releases](https://github.com/pyfa-org/Pyfa/releases/latest) page. An `.exe` installer is also available for Windows builds. Linux users can run pyfa using their distribution's Python interpreter. There is no official self-contained package for Linux, however, there are a number of third-party packages available through distribution-specific repositories.
 
-#### OS X
-
+### OS X
 Apart from the official release, there is also a [Homebrew](http://brew.sh) option for installing pyfa on OS X. Please note this is maintained by a third-party and is not tested by pyfa developers. Simply fire up in terminal:
 ```
 $ brew install Caskroom/cask/pyfa
@@ -24,39 +23,34 @@ $ brew install Caskroom/cask/pyfa
 ### Linux Distro-specific Packages
 The following is a list of pyfa packages available for certain distributions. Please note that these packages are maintained by third-parties and are not evaluated by the pyfa developers.
 
-* Debian/Ubuntu/derivatives: https://github.com/AdamMajer/Pyfa/releases
 * Arch: https://aur.archlinux.org/packages/pyfa/
-* openSUSE: https://build.opensuse.org/package/show/home:rmk2/pyfa
-* FreeBSD: http://www.freshports.org/games/pyfa/ (see [#484](https://github.com/pyfa-org/Pyfa/issues/484) for instructions)
+* Gentoo: https://github.com/ZeroPointEnergy/gentoo-pyfa-overlay
 
-### Dependencies
-If you wish to help with development or simply need to run pyfa through a Python interpreter, the following software is required:
-
-* Python 3.6
-* Requirements as listed in `requirements.txt`
+## Contribution
+If you wish to help with development or you need to run pyfa through a Python interpreter, check out [the instructions](https://github.com/pyfa-org/Pyfa/blob/master/CONTRIBUTING.md).
 
 ## Bug Reporting
-The preferred method of reporting bugs is through the project's [GitHub Issues interface](https://github.com/pyfa-org/Pyfa/issues). Alternatively, posting a report in the [pyfa thread](http://forums.eveonline.com/default.aspx?g=posts&t=247609) on the official EVE Online forums is acceptable. Guidelines for bug reporting can be found on [this wiki page](https://github.com/DarkFenX/Pyfa/wiki/Bug-Reporting). 
+The preferred method of reporting bugs is through the project's [GitHub Issues interface](https://github.com/pyfa-org/Pyfa/issues). Alternatively, posting a report in the [pyfa thread](https://forums.eveonline.com/t/27156) on the official EVE Online forums is acceptable. Guidelines for bug reporting can be found on [this wiki page](https://github.com/pyfa-org/Pyfa/wiki/Bug-Reporting). 
 
 ## License
-pyfa is licensed under the GNU GPL v3.0, see LICENSE
+Pyfa is licensed under the GNU GPL v3.0, see LICENSE
 
 ## Resources
-* Development repository: [https://github.com/pyfa-org/Pyfa](https://github.com/pyfa-org/Pyfa)
+* [Development repository](https://github.com/pyfa-org/Pyfa)
 * [EVE forum thread](https://forums.eveonline.com/t/27156)
-* [EVE University guide using pyfa](http://wiki.eveuniversity.org/Guide_to_using_PYFA)
+* [EVE University guide using pyfa](https://wiki.eveuniversity.org/PYFA)
 * [EVE Online website](http://www.eveonline.com/)
 
 ## Contacts:
-* Sable Blitzmann
-    * GitHub: @blitzmann
-    * [TweetFleet Slack](https://www.fuzzwork.co.uk/tweetfleet-slack-invites/): @blitzmann
-    * [Gitter chat](https://gitter.im/pyfa-org/Pyfa): @ blitzmann
-    * Email: sable.blitzmann@gmail.com
 * Kadesh / DarkPhoenix
     * GitHub: @DarkFenX
     * EVE: Kadesh Priestess
     * Email: phoenix@mail.ru
+* Sable Blitzmann
+    * GitHub: @blitzmann
+    * [TweetFleet Slack](https://www.fuzzwork.co.uk/tweetfleet-slack-invites/): @blitzmann
+    * [Gitter chat](https://gitter.im/pyfa-org/Pyfa): @blitzmann
+    * Email: sable.blitzmann@gmail.com
 
 ## CCP Copyright Notice
 EVE Online, the EVE logo, EVE and all associated logos and designs are the intellectual property of CCP hf. All artwork, screenshots, characters, vehicles, storylines, world facts or other recognizable features of the intellectual property relating to these trademarks are likewise the intellectual property of CCP hf. EVE Online and the EVE logo are the registered trademarks of CCP hf. All rights are reserved worldwide. All other trademarks are the property of their respective owners. CCP hf. has granted permission to pyfa to use EVE Online and all associated logos and designs for promotional and information purposes on its website but does not endorse, and is not in any way affiliated with, pyfa. CCP is in no way responsible for the content on or functioning of this program, nor can it be liable for any damage arising from the use of this program.

_development/helpers.py

@@ -72,7 +72,7 @@ def DBInMemory_test():
     # noinspection PyPep8
     #from eos.db.gamedata import alphaClones, attribute, category, effect, group, icon, item, marketGroup, metaData, metaGroup, queries, traits, unit
     # noinspection PyPep8
-    #from eos.db.saveddata import booster, cargo, character, crest, damagePattern, databaseRepair, drone, fighter, fit, implant, implantSet, loadDefaultDatabaseValues, miscData, module, override, price, queries, skill, targetResists, user
+    #from eos.db.saveddata import booster, cargo, character, crest, damagePattern, databaseRepair, drone, fighter, fit, implant, implantSet, loadDefaultDatabaseValues, miscData, module, override, price, queries, skill, targetProfile, user
 
     # If using in memory saveddata, you'll want to reflect it so the data structure is good.
     if saveddata_connectionstring == "sqlite:///:memory:":

_development/helpers_fits.py

@@ -62,4 +62,4 @@ def HeronFit(DB, Gamedata, Saveddata):
     for _ in range(4):
         fit.modules.append(mod)
 
-    return fit
+    return fit

config.py

@@ -33,11 +33,14 @@ pyfaPath = None
 savePath = None
 saveDB = None
 gameDB = None
+imgsZIP = None
 logPath = None
 loggingLevel = None
 logging_setup = None
 cipher = None
 clientHash = None
+experimentalFeatures = None
+version = None
 
 ESI_CACHE = 'esi_cache'
 
@@ -96,11 +99,13 @@ def defPaths(customSavePath=None):
     global savePath
     global saveDB
     global gameDB
+    global imgsZIP
     global saveInRoot
     global logPath
     global cipher
     global clientHash
     global version
+    global experimentalFeatures
 
     pyfalog.debug("Configuring Pyfa")
 
@@ -155,6 +160,10 @@ def defPaths(customSavePath=None):
     if not gameDB:
         gameDB = os.path.join(pyfaPath, "eve.db")
 
+    imgsZIP = getattr(configforced, "imgsZIP", imgsZIP)
+    if not imgsZIP:
+        imgsZIP = os.path.join(pyfaPath, "imgs.zip")
+
     if debug:
         logFile = "pyfa_debug.log"
     else:
@@ -162,6 +171,10 @@ def defPaths(customSavePath=None):
 
     logPath = os.path.join(savePath, logFile)
 
+    experimentalFeatures = getattr(configforced, "experimentalFeatures", experimentalFeatures)
+    if experimentalFeatures is None:
+        experimentalFeatures = False
+
     # DON'T MODIFY ANYTHING BELOW
     import eos.config
 
@@ -233,7 +246,7 @@ def defLogging():
         ])
 
 
-class LoggerWriter(object):
+class LoggerWriter:
     def __init__(self, level):
         # self.level is really like using log.debug(message)
         # at least in my case

db_update.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #======================================================================
 # Copyright (C) 2012 Diego Duclos
 #
@@ -18,35 +18,70 @@
 # License along with eos.  If not, see <http://www.gnu.org/licenses/>.
 #======================================================================
 
+
 import functools
+import itertools
+import json
 import os
+import sqlite3
 import sys
 
-# Add eos root path to sys.path so we can import ourselves
-path = os.path.dirname(__file__)
-sys.path.insert(0, os.path.realpath(os.path.join(path, '..')))
 
-import json
-import argparse
-import itertools
+ROOT_DIR = os.path.realpath(os.path.dirname(__file__))
+DB_PATH = os.path.join(ROOT_DIR, 'eve.db')
+JSON_DIR = os.path.join(ROOT_DIR, 'staticdata')
+if ROOT_DIR not in sys.path:
+    sys.path.insert(0, ROOT_DIR)
+GAMEDATA_SCHEMA_VERSION = 1
 
 
-CATEGORIES_TO_REMOVE = [
-    30  # Apparel
-]
+def db_needs_update():
+    """True if needs, false if it does not, none if we cannot check it."""
+    try:
+        with open(os.path.join(JSON_DIR, 'phobos', 'metadata.json')) as f:
+            data_version = next((r['field_value'] for r in json.load(f) if r['field_name'] == 'client_build'))
+    except KeyboardInterrupt:
+        raise
+    # If we have no source data - return None; should not update in this case
+    except:
+        return None
+    if not os.path.isfile(DB_PATH):
+        print('Gamedata DB not found')
+        return True
+    db_data_version = None
+    db_schema_version = None
+    try:
+        db = sqlite3.connect(DB_PATH)
+        cursor = db.cursor()
+        cursor.execute('SELECT field_value FROM metadata WHERE field_name = \'client_build\'')
+        for row in cursor:
+            db_data_version = int(row[0])
+        cursor.execute('SELECT field_value FROM metadata WHERE field_name = \'schema_version\'')
+        for row in cursor:
+            db_schema_version = int(row[0])
+        cursor.close()
+        db.close()
+    except KeyboardInterrupt:
+        raise
+    except:
+        print('Error when fetching gamedata DB metadata')
+        return True
+    if data_version != db_data_version:
+        print('Gamedata DB data version mismatch: needed {}, DB has {}'.format(data_version, db_data_version))
+        return True
+    if GAMEDATA_SCHEMA_VERSION != db_schema_version:
+        print('Gamedata DB schema version mismatch: needed {}, DB has {}'.format(GAMEDATA_SCHEMA_VERSION, db_schema_version))
+        return True
+    return False
 
-def main(db, json_path):
-    if os.path.isfile(db):
-        os.remove(db)
 
-    jsonPath = os.path.expanduser(json_path)
+def update_db():
 
-    # Import eos.config first and change it
-    import eos.config
-    eos.config.gamedata_connectionstring = db
-    eos.config.debug = False
+    print('Building gamedata DB...')
+
+    if os.path.isfile(DB_PATH):
+        os.remove(DB_PATH)
 
-    # Now thats done, we can import the eos modules using the config
     import eos.db
     import eos.gamedata
 
@@ -55,60 +90,33 @@ def main(db, json_path):
 
     # Config dict
     tables = {
-        'clonegrades': eos.gamedata.AlphaCloneSkill,
-        'dgmattribs': eos.gamedata.AttributeInfo,
-        'dgmeffects': eos.gamedata.Effect,
-        'dgmtypeattribs': eos.gamedata.Attribute,
-        'dgmtypeeffects': eos.gamedata.ItemEffect,
-        'dgmunits': eos.gamedata.Unit,
-        'evecategories': eos.gamedata.Category,
-        'evegroups': eos.gamedata.Group,
-        'invmetagroups': eos.gamedata.MetaGroup,
-        'invmetatypes': eos.gamedata.MetaType,
-        'evetypes': eos.gamedata.Item,
-        'phbtraits': eos.gamedata.Traits,
-        'phbmetadata': eos.gamedata.MetaData,
-        'mapbulk_marketGroups': eos.gamedata.MarketGroup,
-    }
+        'clonegrades': ('fsd_lite', eos.gamedata.AlphaCloneSkill),
+        'dogmaattributes': ('bulkdata', eos.gamedata.AttributeInfo),
+        'dogmaeffects': ('bulkdata', eos.gamedata.Effect),
+        'dogmatypeattributes': ('bulkdata', eos.gamedata.Attribute),
+        'dogmatypeeffects': ('bulkdata', eos.gamedata.ItemEffect),
+        'dogmaunits': ('bulkdata', eos.gamedata.Unit),
+        'evecategories': ('fsd_lite', eos.gamedata.Category),
+        'evegroups': ('fsd_lite', eos.gamedata.Group),
+        'metagroups': ('fsd_binary', eos.gamedata.MetaGroup),
+        'evetypes': ('fsd_lite', eos.gamedata.Item),
+        'traits': ('phobos', eos.gamedata.Traits),
+        'metadata': ('phobos', eos.gamedata.MetaData),
+        'marketgroups': ('fsd_binary', eos.gamedata.MarketGroup)}
 
     fieldMapping = {
-        'dgmattribs': {
-            'displayName': 'displayName'
-        },
-        'dgmeffects': {
-            'displayName': 'displayName',
-            'description': 'description'
-        },
-        'dgmunits': {
-            'displayName': 'displayName'
-        },
-        #icons???
-        'evecategories': {
-            'categoryName': 'categoryName'
-        },
-        'evegroups': {
-            'groupName': 'groupName'
-        },
-        'invmetagroups': {
-            'metaGroupName': 'metaGroupName'
-        },
-        'evetypes': {
-            'typeName': 'typeName',
-            'description': 'description'
-        },
-        #phbtraits???
-        'mapbulk_marketGroups': {
-            'marketGroupName': 'marketGroupName',
-            'description': 'description'
-        }
-
-    }
+        'marketgroups': {
+            'id': 'marketGroupID',
+            'name': 'marketGroupName'},
+        'metagroups': {
+            'id': 'metaGroupID'}}
 
     rowsInValues = (
         'evetypes',
         'evegroups',
-        'evecategories'
-    )
+        'evecategories',
+        'marketgroups',
+        'metagroups')
 
     def convertIcons(data):
         new = []
@@ -205,13 +213,13 @@ def main(db, json_path):
         # Get data on item effects
         # Format: {type ID: set(effect, IDs)}
         typesEffects = {}
-        for row in tables['dgmtypeeffects']:
+        for row in tables['dogmatypeeffects']:
             typesEffects.setdefault(row['typeID'], set()).add(row['effectID'])
         # Get data on type attributes
         # Format: {type ID: {attribute ID: attribute value}}
         typesNormalAttribs = {}
         typesSkillAttribs = {}
-        for row in tables['dgmtypeattribs']:
+        for row in tables['dogmatypeattributes']:
             attributeID = row['attributeID']
             if attributeID in skillReqAttribsFlat:
                 typeSkillAttribs = typesSkillAttribs.setdefault(row['typeID'], {})
@@ -300,14 +308,21 @@ def main(db, json_path):
     data = {}
 
     # Dump all data to memory so we can easely cross check ignored rows
-    for jsonName, cls in tables.items():
-        with open(os.path.join(jsonPath, '{}.json'.format(jsonName)), encoding='utf-8') as f:
+    for jsonName, (minerName, cls) in tables.items():
+        with open(os.path.join(JSON_DIR, minerName, '{}.json'.format(jsonName)), encoding='utf-8') as f:
             tableData = json.load(f)
         if jsonName in rowsInValues:
-            tableData = list(tableData.values())
+            newTableData = []
+            for k, v in tableData.items():
+                row = {}
+                row.update(v)
+                if 'id' not in row:
+                    row['id'] = int(k)
+                newTableData.append(row)
+            tableData = newTableData
         if jsonName == 'icons':
             tableData = convertIcons(tableData)
-        if jsonName == 'phbtraits':
+        if jsonName == 'traits':
             tableData = convertTraits(tableData)
         if jsonName == 'clonegrades':
             tableData = convertClones(tableData)
@@ -320,22 +335,30 @@ def main(db, json_path):
     # can do it here - just add them to initial set
     eveTypes = set()
     for row in data['evetypes']:
-        if (row['published']
-            or row['groupID'] == 1306  # group Ship Modifiers, for items like tactical t3 ship modes
-            or row['typeName'].startswith('Civilian') # Civilian weapons
-            or row['typeID'] in (41549, 41548, 41551, 41550)  # Micro Bombs (Fighters)
-            or row['groupID'] in (
-                        1882,
-                        1975,
-                        1971,
-                        1983  # the "container" for the abyssal environments
-                )  # Abyssal weather (environment)
+        if (
+            row['published'] or
+            row['typeName'] == 'Capsule' or
+            # group Ship Modifiers, for items like tactical t3 ship modes
+            row['groupID'] == 1306 or
+            # Civilian weapons
+            (row['typeName'].startswith('Civilian') and "Shuttle" not in row['typeName']) or
+            # Micro Bombs (Fighters)
+            row['typeID'] in (41549, 41548, 41551, 41550) or
+            # Abyssal weather (environment)
+            row['groupID'] in (
+                1882,
+                1975,
+                1971,
+                # the "container" for the abyssal environments
+                1983) or
+            # Dark Blood Tracking Disruptor (drops, but rarely)
+            row['typeID'] == 32416
         ):
             eveTypes.add(row['typeID'])
 
     # ignore checker
     def isIgnored(file, row):
-        if file in ('evetypes', 'dgmtypeeffects', 'dgmtypeattribs', 'invmetatypes') and row['typeID'] not in eveTypes:
+        if file in ('evetypes', 'dogmatypeeffects', 'dogmatypeattributes') and row['typeID'] not in eveTypes:
             return True
         return False
 
@@ -349,10 +372,15 @@ def main(db, json_path):
         for row in table:
             # We don't care about some kind of rows, filter it out if so
             if not isIgnored(jsonName, row):
-                if jsonName == 'evetypes' and row['typeName'].startswith('Civilian'):  # Apparently people really want Civilian modules available
+                if (
+                    jsonName == 'evetypes' and (
+                        # Apparently people really want Civilian modules available
+                        (row['typeName'].startswith('Civilian') and "Shuttle" not in row['typeName']) or
+                        row['typeName'] in ('Capsule', 'Dark Blood Tracking Disruptor'))
+                ):
                     row['published'] = True
 
-                instance = tables[jsonName]()
+                instance = tables[jsonName][1]()
                 # fix for issue 80
                 if jsonName is 'icons' and 'res:/ui/texture/icons/' in str(row['iconFile']).lower():
                     row['iconFile'] = row['iconFile'].lower().replace('res:/ui/texture/icons/', '').replace('.png', '')
@@ -380,7 +408,7 @@ def main(db, json_path):
                 eos.db.gamedata_session.add(instance)
 
     # quick and dirty hack to get this data in
-    with open(os.path.join(jsonPath, 'dynamicattributes.json'), encoding='utf-8') as f:
+    with open(os.path.join(JSON_DIR, 'fsd_binary', 'dynamicitemattributes.json'), encoding='utf-8') as f:
         bulkdata = json.load(f)
         for mutaID, data in bulkdata.items():
             muta = eos.gamedata.DynamicItem()
@@ -402,20 +430,25 @@ def main(db, json_path):
                 attr.max = attrData['max']
                 eos.db.gamedata_session.add(attr)
 
+    # Add schema version to prevent further updates
+    metadata_schema_version = eos.gamedata.MetaData()
+    metadata_schema_version.field_name = 'schema_version'
+    metadata_schema_version.field_value = GAMEDATA_SCHEMA_VERSION
+    eos.db.gamedata_session.add(metadata_schema_version)
+
     eos.db.gamedata_session.commit()
 
     # CCP still has 5 subsystems assigned to T3Cs, even though only 4 are available / usable. They probably have some
     # old legacy requirement or assumption that makes it difficult for them to change this value in the data. But for
     # pyfa, we can do it here as a post-processing step
-    eos.db.gamedata_engine.execute('UPDATE dgmtypeattribs SET value = 4.0 WHERE attributeID = ?', (1367,))
+    for attr in eos.db.gamedata_session.query(eos.gamedata.Attribute).filter(eos.gamedata.Attribute.ID == 1367).all():
+        attr.value = 4.0
+    for item in eos.db.gamedata_session.query(eos.gamedata.Item).filter(eos.gamedata.Item.name.like('%abyssal%')).all():
+        item.published = False
 
-    eos.db.gamedata_engine.execute('UPDATE invtypes  SET published = 0 WHERE typeName LIKE \'%abyssal%\'')
-
-    # fix for #1722 until CCP gets their shit together
-    eos.db.gamedata_engine.execute('UPDATE invtypes SET typeName = \'Small Abyssal Energy Nosferatu\' WHERE typeID = ? AND typeName = ?', (48419, ''))
-
-    print()
-    for x in CATEGORIES_TO_REMOVE:
+    for x in [
+        30  # Apparel
+    ]:
         cat = eos.db.gamedata_session.query(eos.gamedata.Category).filter(eos.gamedata.Category.ID == x).first()
         print ('Removing Category: {}'.format(cat.name))
         eos.db.gamedata_session.delete(cat)
@@ -425,11 +458,6 @@ def main(db, json_path):
 
     print('done')
 
+
 if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description='This scripts dumps effects from an sqlite cache dump to mongo')
-    parser.add_argument('-d', '--db', required=True, type=str, help='The sqlalchemy connectionstring, example: sqlite:///c:/tq.db')
-    parser.add_argument('-j', '--json', required=True, type=str, help='The path to the json dump')
-    args = parser.parse_args()
-
-    main(args.db, args.json)
-
+    update_db()

eos/calc.py

@@ -0,0 +1,71 @@
+# =============================================================================
+# Copyright (C) 2019 Ryan Holmes
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+import math
+
+
+# Just copy-paste penalization chain calculation code (with some modifications,
+# as multipliers arrive in different form) in here to not make actual attribute
+# calculations slower than they already are due to extra function calls
+def calculateMultiplier(multipliers):
+    """
+    multipliers: dictionary in format:
+    {stacking group name: [(mult, resist attr ID), (mult, resist attr ID)]}
+    """
+    val = 1
+    for penalizedMultipliers in multipliers.values():
+        # A quick explanation of how this works:
+        # 1: Bonuses and penalties are calculated seperately, so we'll have to filter each of them
+        l1 = [v[0] for v in penalizedMultipliers if v[0] > 1]
+        l2 = [v[0] for v in penalizedMultipliers if v[0] < 1]
+        # 2: The most significant bonuses take the smallest penalty,
+        # This means we'll have to sort
+        abssort = lambda _val: -abs(_val - 1)
+        l1.sort(key=abssort)
+        l2.sort(key=abssort)
+        # 3: The first module doesn't get penalized at all
+        # Any module after the first takes penalties according to:
+        # 1 + (multiplier - 1) * math.exp(- math.pow(i, 2) / 7.1289)
+        for l in (l1, l2):
+            for i in range(len(l)):
+                bonus = l[i]
+                val *= 1 + (bonus - 1) * math.exp(- i ** 2 / 7.1289)
+    return val
+
+
+def calculateRangeFactor(srcOptimalRange, srcFalloffRange, distance, restrictedRange=True):
+    """Range strength/chance factor, applicable to guns, ewar, RRs, etc."""
+    if distance is None:
+        return 1
+    if srcFalloffRange > 0:
+        # Most modules cannot be activated when at 3x falloff range, with few exceptions like guns
+        if restrictedRange and distance > srcOptimalRange + 3 * srcFalloffRange:
+            return 0
+        return 0.5 ** ((max(0, distance - srcOptimalRange) / srcFalloffRange) ** 2)
+    elif distance <= srcOptimalRange:
+        return 1
+    else:
+        return 0
+
+
+def calculateLockTime(srcScanRes, tgtSigRadius):
+    if not srcScanRes or not tgtSigRadius:
+        return None
+    return min(40000 / srcScanRes / math.asinh(tgtSigRadius) ** 2, 30 * 60)

eos/capSim.py

@@ -1,7 +1,7 @@
 import heapq
 import time
 from math import sqrt, exp
-from functools import reduce
+from collections import Counter
 
 DAY = 24 * 60 * 60 * 1000
 
@@ -13,7 +13,7 @@ def lcm(a, b):
     return n / a
 
 
-class CapSimulator(object):
+class CapSimulator:
     """Entity's EVE Capacitor Simulator"""
 
     def __init__(self):
@@ -21,6 +21,7 @@ class CapSimulator(object):
 
         self.capacitorCapacity = 100
         self.capacitorRecharge = 1000
+        self.startingCapacity = 1000
 
         # max simulated time.
         self.t_max = DAY
@@ -41,6 +42,14 @@ class CapSimulator(object):
         # relevant decimal digits of capacitor for LCM period optimization
         self.stability_precision = 1
 
+        # Stores how cap sim changed cap values outside of cap regen time
+        self.saved_changes = ()
+        self.saved_changes_internal = None
+
+        # Reports if sim was stopped due to detecting stability early
+        self.optimize_repeats = True
+        self.result_optimized_repeats = None
+
     def scale_activation(self, duration, capNeed):
         for res in self.scale_resolutions:
             mod = duration % res
@@ -59,7 +68,7 @@ class CapSimulator(object):
         return duration, capNeed
 
     def init(self, modules):
-        """prepare modules. a list of (duration, capNeed, clipSize, disableStagger) tuples is
+        """prepare modules. a list of (duration, capNeed, clipSize, disableStagger, reloadTime, isInjector) tuples is
          expected, with clipSize 0 if the module has infinite ammo.
             """
         self.modules = modules
@@ -67,48 +76,57 @@ class CapSimulator(object):
     def reset(self):
         """Reset the simulator state"""
         self.state = []
+        self.saved_changes_internal = {}
+        self.result_optimized_repeats = False
         mods = {}
         period = 1
         disable_period = False
 
         # Loop over modules, clearing clipSize if applicable, and group modules based on attributes
-        for (duration, capNeed, clipSize, disableStagger, reloadTime) in self.modules:
+        for (duration, capNeed, clipSize, disableStagger, reloadTime, isInjector) in self.modules:
             if self.scale:
                 duration, capNeed = self.scale_activation(duration, capNeed)
 
             # set clipSize to infinite if reloads are disabled unless it's
-            # a cap booster module.
-            if not self.reload and capNeed > 0:
+            # a cap booster module
+            if not self.reload and not isInjector:
                 clipSize = 0
                 reloadTime = 0
 
             # Group modules based on their properties
-            if (duration, capNeed, clipSize, disableStagger, reloadTime) in mods:
-                mods[(duration, capNeed, clipSize, disableStagger, reloadTime)] += 1
+            key = (duration, capNeed, clipSize, disableStagger, reloadTime, isInjector)
+            if key in mods:
+                mods[key] += 1
             else:
-                mods[(duration, capNeed, clipSize, disableStagger, reloadTime)] = 1
+                mods[key] = 1
 
         # Loop over grouped modules, configure staggering and push to the simulation state
-        for (duration, capNeed, clipSize, disableStagger, reloadTime), amount in mods.items():
+        for (duration, capNeed, clipSize, disableStagger, reloadTime, isInjector), amount in mods.items():
+            # period optimization doesn't work when reloads are active.
+            if clipSize:
+                disable_period = True
+            # Just push multiple instances if item is injector. We do not want to stagger them as we will
+            # use them as needed and want them to be available right away
+            if isInjector:
+                for i in range(amount):
+                    heapq.heappush(self.state, [0, duration, capNeed, 0, clipSize, reloadTime, isInjector])
+                continue
             if self.stagger and not disableStagger:
+                # Stagger all mods if they do not need to be reloaded
                 if clipSize == 0:
                     duration = int(duration / amount)
+                # Stagger mods after first
                 else:
                     stagger_amount = (duration * clipSize + reloadTime) / (amount * clipSize)
                     for i in range(1, amount):
-                        heapq.heappush(self.state,
-                                       [i * stagger_amount, duration,
-                                        capNeed, 0, clipSize, reloadTime])
+                        heapq.heappush(self.state, [i * stagger_amount, duration, capNeed, 0, clipSize, reloadTime, isInjector])
+            # If mods are not staggered - just multiply cap use
             else:
                 capNeed *= amount
 
             period = lcm(period, duration)
 
-            # period optimization doesn't work when reloads are active.
-            if clipSize:
-                disable_period = True
-
-            heapq.heappush(self.state, [0, duration, capNeed, 0, clipSize, reloadTime])
+            heapq.heappush(self.state, [0, duration, capNeed, 0, clipSize, reloadTime, isInjector])
 
         if disable_period:
             self.period = self.t_max
@@ -119,7 +137,8 @@ class CapSimulator(object):
         """Run the simulation"""
 
         start = time.time()
-
+        awaitingInjectors = []
+        awaitingInjectorsCounterWrap = Counter()
         self.reset()
 
         push = heapq.heappush
@@ -129,27 +148,36 @@ class CapSimulator(object):
         stability_precision = self.stability_precision
         period = self.period
 
+        activation = None
         iterations = 0
 
         capCapacity = self.capacitorCapacity
         tau = self.capacitorRecharge / 5.0
 
-        cap_wrap = capCapacity  # cap value at last period
-        cap_lowest = capCapacity  # lowest cap value encountered
-        cap_lowest_pre = capCapacity  # lowest cap value before activations
-        cap = capCapacity  # current cap value
+        cap_wrap = self.startingCapacity  # cap value at last period
+        cap_lowest = self.startingCapacity  # lowest cap value encountered
+        cap_lowest_pre = self.startingCapacity  # lowest cap value before activations
+        cap = self.startingCapacity  # current cap value
         t_wrap = self.period  # point in time of next period
-
         t_last = 0
         t_max = self.t_max
 
         while 1:
-            activation = pop(state)
-            t_now, duration, capNeed, shot, clipSize, reloadTime = activation
+            # Nothing to pop - might happen when no mods are activated, or when
+            # only cap injectors are active (and are postponed by code below)
+            try:
+                activation = pop(state)
+            except IndexError:
+                break
+            t_now, duration, capNeed, shot, clipSize, reloadTime, isInjector = activation
+
+            # Max time reached, stop simulation - we're stable
             if t_now >= t_max:
                 break
 
-            cap = ((1.0 + (sqrt(cap / capCapacity) - 1.0) * exp((t_last - t_now) / tau)) ** 2) * capCapacity
+            # Regenerate cap from last time point
+            if t_now > t_last:
+                cap = ((1.0 + (sqrt(cap / capCapacity) - 1.0) * exp((t_last - t_now) / tau)) ** 2) * capCapacity
 
             if t_now != t_last:
                 if cap < cap_lowest_pre:
@@ -157,36 +185,104 @@ class CapSimulator(object):
                 if t_now == t_wrap:
                     # history is repeating itself, so if we have more cap now than last
                     # time this happened, it is a stable setup.
-                    if cap >= cap_wrap:
+                    awaitingInjectorsCounterNow = Counter(awaitingInjectors)
+                    if self.optimize_repeats and cap >= cap_wrap and awaitingInjectorsCounterNow == awaitingInjectorsCounterWrap:
+                        self.result_optimized_repeats = True
                         break
                     cap_wrap = round(cap, stability_precision)
+                    awaitingInjectorsCounterWrap = awaitingInjectorsCounterNow
                     t_wrap += period
 
-            cap -= capNeed
-            if cap > capCapacity:
-                cap = capCapacity
-
+            t_last = t_now
             iterations += 1
 
-            t_last = t_now
+            # If injecting cap will "overshoot" max cap, postpone it
+            if isInjector and cap - capNeed > capCapacity:
+                awaitingInjectors.append((duration, capNeed, shot, clipSize, reloadTime, isInjector))
 
-            if cap < cap_lowest:
-                if cap < 0.0:
-                    break
-                cap_lowest = cap
+            else:
+                # If we will need more cap than we have, but we are not at 100% -
+                # use awaiting cap injectors to top us up until we have enough or
+                # until we're full
+                if capNeed > cap and cap < capCapacity:
+                    while awaitingInjectors and capNeed > cap and capCapacity > cap:
+                        neededInjection = min(capNeed - cap, capCapacity - cap)
+                        # Find injectors which have just enough cap or more
+                        goodInjectors = [i for i in awaitingInjectors if -i[1] >= neededInjection]
+                        if goodInjectors:
+                            # Pick injector which overshoots the least
+                            bestInjector = min(goodInjectors, key=lambda i: -i[1])
+                        else:
+                            # Take the one which provides the most cap
+                            bestInjector = max(goodInjectors, key=lambda i: -i[1])
+                        # Use injector
+                        awaitingInjectors.remove(bestInjector)
+                        inj_duration, inj_capNeed, inj_shot, inj_clipSize, inj_reloadTime, inj_isInjector = bestInjector
+                        cap -= inj_capNeed
+                        if cap > capCapacity:
+                            cap = capCapacity
+                        self.saved_changes_internal[t_now] = cap
+                        # Add injector to regular state tracker
+                        inj_t_now = t_now
+                        inj_t_now += inj_duration
+                        inj_shot += 1
+                        if inj_clipSize:
+                            if inj_shot % inj_clipSize == 0:
+                                inj_shot = 0
+                                inj_t_now += inj_reloadTime
+                        push(state, [inj_t_now, inj_duration, inj_capNeed, inj_shot, inj_clipSize, inj_reloadTime, inj_isInjector])
 
-            # queue the next activation of this module
-            t_now += duration
-            shot += 1
-            if clipSize:
-                if shot % clipSize == 0:
-                    shot = 0
-                    t_now += reloadTime  # include reload time
-            activation[0] = t_now
-            activation[3] = shot
+                # Apply cap modification
+                cap -= capNeed
+                if cap > capCapacity:
+                    cap = capCapacity
+                self.saved_changes_internal[t_now] = cap
 
+                if cap < cap_lowest:
+                    # Negative cap - we're unstable, simulation is over
+                    if cap < 0.0:
+                        break
+                    cap_lowest = cap
+
+                # Try using awaiting injectors to top up the cap after spending some
+                while awaitingInjectors and cap < capCapacity:
+                    neededInjection = capCapacity - cap
+                    # Find injectors which do not overshoot max cap
+                    goodInjectors = [i for i in awaitingInjectors if -i[1] <= neededInjection]
+                    if not goodInjectors:
+                        break
+                    # Take the one which provides the most cap
+                    bestInjector = max(goodInjectors, key=lambda i: -i[1])
+                    # Use injector
+                    awaitingInjectors.remove(bestInjector)
+                    inj_duration, inj_capNeed, inj_shot, inj_clipSize, inj_reloadTime, inj_isInjector = bestInjector
+                    cap -= inj_capNeed
+                    if cap > capCapacity:
+                        cap = capCapacity
+                    self.saved_changes_internal[t_now] = cap
+                    # Add injector to regular state tracker
+                    inj_t_now = t_now
+                    inj_t_now += inj_duration
+                    inj_shot += 1
+                    if inj_clipSize:
+                        if inj_shot % inj_clipSize == 0:
+                            inj_shot = 0
+                            inj_t_now += inj_reloadTime
+                    push(state, [inj_t_now, inj_duration, inj_capNeed, inj_shot, inj_clipSize, inj_reloadTime, inj_isInjector])
+
+                # queue the next activation of this module
+                t_now += duration
+                shot += 1
+                if clipSize:
+                    if shot % clipSize == 0:
+                        shot = 0
+                        t_now += reloadTime  # include reload time
+                activation[0] = t_now
+                activation[3] = shot
+
+                push(state, activation)
+        if activation is not None:
             push(state, activation)
-        push(state, activation)
 
         # update instance with relevant results.
         self.t = t_last
@@ -194,7 +290,7 @@ class CapSimulator(object):
 
         # calculate EVE's stability value
         try:
-            avgDrain = reduce(float.__add__, [x[2] / x[1] for x in self.state], 0.0)
+            avgDrain = sum(x[2] / x[1] for x in self.state)
             self.cap_stable_eve = 0.25 * (1.0 + sqrt(-(2.0 * avgDrain * tau - capCapacity) / capCapacity)) ** 2
         except ValueError:
             self.cap_stable_eve = 0.0
@@ -204,7 +300,9 @@ class CapSimulator(object):
             self.cap_stable_low = cap_lowest
             self.cap_stable_high = cap_lowest_pre
         else:
-            self.cap_stable_low = \
-                self.cap_stable_high = 0.0
+            self.cap_stable_low = self.cap_stable_high = 0.0
+
+        self.saved_changes = tuple((k / 1000, max(0, self.saved_changes_internal[k])) for k in sorted(self.saved_changes_internal))
+        self.saved_changes_internal = None
 
         self.runtime = time.time() - start

eos/const.py

@@ -90,9 +90,12 @@ class FittingHardpoint(IntEnum):
 
 @unique
 class SpoolType(IntEnum):
-    SCALE = 0  # [0..1]
-    TIME = 1  # Expressed via time in seconds since spool up started
-    CYCLES = 2  # Expressed in amount of cycles since spool up started
+    # Spool and cycle scale are different in case if max spool amount cannot
+    # be divided by spool step without remainder
+    SPOOL_SCALE = 0  # [0..1]
+    CYCLE_SCALE = 1  # [0..1]
+    TIME = 2  # Expressed via time in seconds since spool up started
+    CYCLES = 3  # Expressed in amount of cycles since spool up started
 
 
 @unique
@@ -101,3 +104,12 @@ class FitSystemSecurity(IntEnum):
     LOWSEC = 1
     NULLSEC = 2
     WSPACE = 3
+
+
+@unique
+class Operator(IntEnum):
+    PREASSIGN = 0
+    PREINCREASE = 1
+    MULTIPLY = 2
+    POSTINCREASE = 3
+    FORCE = 4

eos/db/__init__.py

@@ -35,6 +35,7 @@ class ReadOnlyException(Exception):
     pass
 
 
+pyfalog.debug('Initializing gamedata')
 gamedata_connectionstring = config.gamedata_connectionstring
 if callable(gamedata_connectionstring):
     gamedata_engine = create_engine("sqlite://", creator=gamedata_connectionstring, echo=config.debug)
@@ -45,6 +46,7 @@ gamedata_meta = MetaData()
 gamedata_meta.bind = gamedata_engine
 gamedata_session = sessionmaker(bind=gamedata_engine, autoflush=False, expire_on_commit=False)()
 
+pyfalog.debug('Getting gamedata version')
 # This should be moved elsewhere, maybe as an actual query. Current, without try-except, it breaks when making a new
 # game db because we haven't reached gamedata_meta.create_all()
 try:
@@ -60,6 +62,7 @@ except Exception as e:
     config.gamedata_version = None
     config.gamedata_date = None
 
+pyfalog.debug('Initializing saveddata')
 saveddata_connectionstring = config.saveddata_connectionstring
 if saveddata_connectionstring is not None:
     if callable(saveddata_connectionstring):
@@ -76,16 +79,19 @@ else:
 # Lock controlling any changes introduced to session
 sd_lock = threading.RLock()
 
+pyfalog.debug('Importing gamedata DB scheme')
 # Import all the definitions for all our database stuff
 # noinspection PyPep8
 from eos.db.gamedata import alphaClones, attribute, category, effect, group, item, marketGroup, metaData, metaGroup, queries, traits, unit, dynamicAttributes
+pyfalog.debug('Importing saveddata DB scheme')
 # noinspection PyPep8
 from eos.db.saveddata import booster, cargo, character, damagePattern, databaseRepair, drone, fighter, fit, implant, implantSet, loadDefaultDatabaseValues, \
-    miscData, mutator, module, override, price, queries, skill, targetResists, user
+    miscData, mutator, module, override, price, queries, skill, targetProfile, user
 
-# Import queries
+pyfalog.debug('Importing gamedata queries')
 # noinspection PyPep8
 from eos.db.gamedata.queries import *
+pyfalog.debug('Importing saveddata queries')
 # noinspection PyPep8
 from eos.db.saveddata.queries import *
 

eos/db/gamedata/item.py

@@ -25,7 +25,7 @@ from sqlalchemy.orm.collections import attribute_mapped_collection
 from eos.db import gamedata_meta
 from eos.db.gamedata.dynamicAttributes import dynamicApplicable_table
 from eos.db.gamedata.effect import typeeffects_table
-from eos.gamedata import Attribute, DynamicItem, Effect, Group, Item, MetaType, Traits
+from eos.gamedata import Attribute, DynamicItem, Effect, Group, Item, Traits, MetaGroup
 
 items_table = Table("invtypes", gamedata_meta,
                     Column("typeID", Integer, primary_key=True),
@@ -41,9 +41,11 @@ items_table = Table("invtypes", gamedata_meta,
                     Column("iconID", Integer),
                     Column("graphicID", Integer),
                     Column("groupID", Integer, ForeignKey("invgroups.groupID"), index=True),
+                    Column("metaLevel", Integer),
+                    Column("metaGroupID", Integer, ForeignKey("invmetagroups.metaGroupID"), index=True),
+                    Column("variationParentTypeID", Integer, ForeignKey("invtypes.typeID"), index=True),
                     Column("replacements", String))
 
-from .metaGroup import metatypes_table  # noqa
 from .traits import traits_table  # noqa
 
 mapper(Item, items_table,
@@ -51,9 +53,8 @@ mapper(Item, items_table,
            "group"            : relation(Group, backref=backref("items", cascade="all,delete")),
            "_Item__attributes": relation(Attribute, cascade='all, delete, delete-orphan', collection_class=attribute_mapped_collection('name')),
            "effects": relation(Effect, secondary=typeeffects_table, collection_class=attribute_mapped_collection('name')),
-           "metaGroup"        : relation(MetaType,
-                                         primaryjoin=metatypes_table.c.typeID == items_table.c.typeID,
-                                         uselist=False),
+           "metaGroup"        : relation(MetaGroup, backref=backref("items", cascade="all,delete")),
+           "varParent"        : relation(Item, backref=backref("varChildren", cascade="all,delete"), remote_side=items_table.c.typeID),
            "ID"               : synonym("typeID"),
            "name"             : synonym("typeName"),
            "description"      : deferred(items_table.c.description),
@@ -64,7 +65,6 @@ mapper(Item, items_table,
                    primaryjoin=dynamicApplicable_table.c.applicableTypeID == items_table.c.typeID,
                    secondaryjoin=dynamicApplicable_table.c.typeID == DynamicItem.typeID,
                    secondary=dynamicApplicable_table,
-                   backref="applicableItems")
-       })
+                   backref="applicableItems")})
 
 Item.category = association_proxy("group", "category")

eos/db/gamedata/metaGroup.py

@@ -17,35 +17,17 @@
 # along with eos.  If not, see <http://www.gnu.org/licenses/>.
 # ===============================================================================
 
-from sqlalchemy import Table, Column, Integer, ForeignKey, String
-from sqlalchemy.ext.associationproxy import association_proxy
-from sqlalchemy.orm import relation, mapper, synonym
+from sqlalchemy import Table, Column, Integer, String
+from sqlalchemy.orm import mapper, synonym
 
 from eos.db import gamedata_meta
-from eos.db.gamedata.item import items_table
-from eos.gamedata import Item, MetaGroup, MetaType
+from eos.gamedata import MetaGroup
 
 metagroups_table = Table("invmetagroups", gamedata_meta,
                          Column("metaGroupID", Integer, primary_key=True),
                          Column("metaGroupName", String))
 
-metatypes_table = Table("invmetatypes", gamedata_meta,
-                        Column("typeID", Integer, ForeignKey("invtypes.typeID"), primary_key=True),
-                        Column("parentTypeID", Integer, ForeignKey("invtypes.typeID")),
-                        Column("metaGroupID", Integer, ForeignKey("invmetagroups.metaGroupID")))
-
 mapper(MetaGroup, metagroups_table,
        properties={
            "ID"  : synonym("metaGroupID"),
-           "name": synonym("metaGroupName")
-        })
-
-mapper(MetaType, metatypes_table,
-       properties={
-           "ID"    : synonym("metaGroupID"),
-           "parent": relation(Item, primaryjoin=metatypes_table.c.parentTypeID == items_table.c.typeID),
-           "items" : relation(Item, primaryjoin=metatypes_table.c.typeID == items_table.c.typeID),
-           "info"  : relation(MetaGroup, lazy=False)
-        })
-
-MetaType.name = association_proxy("info", "name")
+           "name": synonym("metaGroupName")})

eos/db/gamedata/queries.py

@@ -23,8 +23,8 @@ from sqlalchemy.sql import and_, or_, select
 
 import eos.config
 from eos.db import gamedata_session
+from eos.db.gamedata.item import items_table
 from eos.db.gamedata.group import groups_table
-from eos.db.gamedata.metaGroup import items_table, metatypes_table
 from eos.db.util import processEager, processWhere
 from eos.gamedata import AlphaClone, Attribute, AttributeInfo, Category, DynamicItem, Group, Item, MarketGroup, MetaData, MetaGroup
 
@@ -92,7 +92,8 @@ def getItem(lookfor, eager=None):
         else:
             # Item names are unique, so we can use first() instead of one()
             item = gamedata_session.query(Item).options(*processEager(eager)).filter(Item.name == lookfor).first()
-            itemNameMap[lookfor] = item.ID
+            if item is not None:
+                itemNameMap[lookfor] = item.ID
     else:
         raise TypeError("Need integer or string as argument")
     return item
@@ -195,7 +196,8 @@ def getGroup(lookfor, eager=None):
         else:
             # Group names are unique, so we can use first() instead of one()
             group = gamedata_session.query(Group).options(*processEager(eager)).filter(Group.name == lookfor).first()
-            groupNameMap[lookfor] = group.ID
+            if group is not None:
+                groupNameMap[lookfor] = group.ID
     else:
         raise TypeError("Need integer or string as argument")
     return group
@@ -224,7 +226,8 @@ def getCategory(lookfor, eager=None):
             # Category names are unique, so we can use first() instead of one()
             category = gamedata_session.query(Category).options(*processEager(eager)).filter(
                     Category.name == lookfor).first()
-            categoryNameMap[lookfor] = category.ID
+            if category is not None:
+                categoryNameMap[lookfor] = category.ID
     else:
         raise TypeError("Need integer or string as argument")
     return category
@@ -253,12 +256,17 @@ def getMetaGroup(lookfor, eager=None):
             # MetaGroup names are unique, so we can use first() instead of one()
             metaGroup = gamedata_session.query(MetaGroup).options(*processEager(eager)).filter(
                     MetaGroup.name == lookfor).first()
-            metaGroupNameMap[lookfor] = metaGroup.ID
+            if metaGroup is not None:
+                metaGroupNameMap[lookfor] = metaGroup.ID
     else:
         raise TypeError("Need integer or string as argument")
     return metaGroup
 
 
+def getMetaGroups():
+    return gamedata_session.query(MetaGroup).all()
+
+
 @cachedQuery(1, "lookfor")
 def getMarketGroup(lookfor, eager=None):
     if isinstance(lookfor, int):
@@ -342,11 +350,9 @@ def getVariations(itemids, groupIDs=None, where=None, eager=None):
     if len(itemids) == 0:
         return []
 
-    itemfilter = or_(*(metatypes_table.c.parentTypeID == itemid for itemid in itemids))
+    itemfilter = or_(*(items_table.c.variationParentTypeID == itemid for itemid in itemids))
     filter = processWhere(itemfilter, where)
-    joinon = items_table.c.typeID == metatypes_table.c.typeID
-    vars = gamedata_session.query(Item).options(*processEager(eager)).join((metatypes_table, joinon)).filter(
-            filter).all()
+    vars = gamedata_session.query(Item).options(*processEager(eager)).filter(filter).all()
 
     if vars:
         return vars

eos/db/migrations/upgrade32.py

@@ -0,0 +1,16 @@
+"""
+Migration 32
+
+- added speed, sig and radius columns to targetResists table
+"""
+
+
+import sqlalchemy
+
+
+def upgrade(saveddata_engine):
+    for column in ('maxVelocity', 'signatureRadius', 'radius'):
+        try:
+            saveddata_engine.execute("SELECT {} FROM targetResists LIMIT 1;".format(column))
+        except sqlalchemy.exc.DatabaseError:
+            saveddata_engine.execute("ALTER TABLE targetResists ADD COLUMN {} FLOAT;".format(column))

eos/db/migrations/upgrade33.py

@@ -0,0 +1,30 @@
+"""
+Migration 33
+
+Allow use of floats in damage pattern values
+"""
+
+tmpTable = """
+CREATE TABLE "damagePatternsTemp" (
+	"ID" INTEGER NOT NULL, 
+	"name" VARCHAR, 
+	"emAmount" FLOAT, 
+	"thermalAmount" FLOAT, 
+	"kineticAmount" FLOAT, 
+	"explosiveAmount" FLOAT, 
+	"ownerID" INTEGER, 
+	"created" DATETIME, 
+	"modified" DATETIME, 
+	PRIMARY KEY ("ID"), 
+	FOREIGN KEY("ownerID") REFERENCES users ("ID")
+)
+"""
+
+
+def upgrade(saveddata_engine):
+    saveddata_engine.execute(tmpTable)
+    saveddata_engine.execute(
+            'INSERT INTO damagePatternsTemp (ID, name, emAmount, thermalAmount, kineticAmount, explosiveAmount, ownerID, created, modified) '
+            'SELECT ID, name, emAmount, thermalAmount, kineticAmount, explosiveAmount, ownerID, created, modified FROM damagePatterns')
+    saveddata_engine.execute('DROP TABLE damagePatterns')
+    saveddata_engine.execute('ALTER TABLE damagePatternsTemp RENAME TO damagePatterns')

eos/db/migrations/upgrade34.py

@@ -0,0 +1,25 @@
+"""
+Migration 34
+
+- Adds projection range columns to projectable entities
+"""
+import sqlalchemy
+
+
+def upgrade(saveddata_engine):
+    try:
+        saveddata_engine.execute("SELECT projectionRange FROM projectedFits LIMIT 1")
+    except sqlalchemy.exc.DatabaseError:
+        saveddata_engine.execute("ALTER TABLE projectedFits ADD COLUMN projectionRange FLOAT;")
+    try:
+        saveddata_engine.execute("SELECT projectionRange FROM modules LIMIT 1")
+    except sqlalchemy.exc.DatabaseError:
+        saveddata_engine.execute("ALTER TABLE modules ADD COLUMN projectionRange FLOAT;")
+    try:
+        saveddata_engine.execute("SELECT projectionRange FROM drones LIMIT 1")
+    except sqlalchemy.exc.DatabaseError:
+        saveddata_engine.execute("ALTER TABLE drones ADD COLUMN projectionRange FLOAT;")
+    try:
+        saveddata_engine.execute("SELECT projectionRange FROM fighters LIMIT 1")
+    except sqlalchemy.exc.DatabaseError:
+        saveddata_engine.execute("ALTER TABLE fighters ADD COLUMN projectionRange FLOAT;")

eos/db/saveddata/__init__.py

@@ -11,7 +11,7 @@ __all__ = [
     "implant",
     "damagePattern",
     "miscData",
-    "targetResists",
+    "targetProfile",
     "override",
     "implantSet",
     "loadDefaultDatabaseValues"

eos/db/saveddata/damagePattern.py

@@ -17,7 +17,7 @@
 # along with eos.  If not, see <http://www.gnu.org/licenses/>.
 # ===============================================================================
 
-from sqlalchemy import Table, Column, Integer, ForeignKey, String, DateTime
+from sqlalchemy import Table, Column, Integer, Float, ForeignKey, String, DateTime
 from sqlalchemy.orm import mapper
 import datetime
 
@@ -27,10 +27,10 @@ from eos.saveddata.damagePattern import DamagePattern
 damagePatterns_table = Table("damagePatterns", saveddata_meta,
                              Column("ID", Integer, primary_key=True),
                              Column("name", String),
-                             Column("emAmount", Integer),
-                             Column("thermalAmount", Integer),
-                             Column("kineticAmount", Integer),
-                             Column("explosiveAmount", Integer),
+                             Column("emAmount", Float),
+                             Column("thermalAmount", Float),
+                             Column("kineticAmount", Float),
+                             Column("explosiveAmount", Float),
                              Column("ownerID", ForeignKey("users.ID"), nullable=True),
                              Column("created", DateTime, nullable=True, default=datetime.datetime.now),
                              Column("modified", DateTime, nullable=True, onupdate=datetime.datetime.now)

eos/db/saveddata/databaseRepair.py

@@ -23,7 +23,7 @@ from logbook import Logger
 pyfalog = Logger(__name__)
 
 
-class DatabaseCleanup(object):
+class DatabaseCleanup:
     def __init__(self):
         pass
 

eos/db/saveddata/drone.py

@@ -17,7 +17,7 @@
 # along with eos.  If not, see <http://www.gnu.org/licenses/>.
 # ===============================================================================
 
-from sqlalchemy import Table, Column, Integer, ForeignKey, Boolean, DateTime
+from sqlalchemy import Table, Column, Integer, Float, ForeignKey, Boolean, DateTime
 from sqlalchemy.orm import mapper, relation
 import datetime
 
@@ -33,7 +33,8 @@ drones_table = Table("drones", saveddata_meta,
                      Column("amountActive", Integer, nullable=False),
                      Column("projected", Boolean, default=False),
                      Column("created", DateTime, nullable=True, default=datetime.datetime.now),
-                     Column("modified", DateTime, nullable=True, onupdate=datetime.datetime.now)
+                     Column("modified", DateTime, nullable=True, onupdate=datetime.datetime.now),
+                     Column("projectionRange", Float, nullable=True)
                      )
 
 mapper(Drone, drones_table,

eos/db/saveddata/fighter.py

@@ -17,7 +17,7 @@
 # along with eos.  If not, see <http://www.gnu.org/licenses/>.
 # ===============================================================================
 
-from sqlalchemy import Table, Column, Integer, ForeignKey, Boolean, DateTime
+from sqlalchemy import Table, Column, Integer, Float, ForeignKey, Boolean, DateTime
 from sqlalchemy.orm import mapper, relation
 import datetime
 
@@ -34,7 +34,8 @@ fighters_table = Table("fighters", saveddata_meta,
                        Column("amount", Integer, nullable=False),
                        Column("projected", Boolean, default=False),
                        Column("created", DateTime, nullable=True, default=datetime.datetime.now),
-                       Column("modified", DateTime, nullable=True, onupdate=datetime.datetime.now)
+                       Column("modified", DateTime, nullable=True, onupdate=datetime.datetime.now),
+                       Column("projectionRange", Float, nullable=True),
                        )
 
 fighter_abilities_table = Table("fightersAbilities", saveddata_meta,
@@ -46,6 +47,7 @@ fighter_abilities_table = Table("fightersAbilities", saveddata_meta,
 mapper(Fighter, fighters_table,
        properties={
            "owner"              : relation(Fit),
+           "_amount"            : fighters_table.c.amount,
            "_Fighter__abilities": relation(
                    FighterAbility,
                    backref="fighter",

eos/db/saveddata/fit.py

@@ -19,7 +19,7 @@
 
 import datetime
 
-from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, String, Table
+from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, Float, String, Table
 from sqlalchemy.ext.associationproxy import association_proxy
 from sqlalchemy.orm import mapper, reconstructor, relation, relationship
 from sqlalchemy.orm.collections import attribute_mapped_collection
@@ -41,7 +41,7 @@ from eos.saveddata.fighter import Fighter
 from eos.saveddata.fit import Fit as es_Fit
 from eos.saveddata.implant import Implant
 from eos.saveddata.module import Module
-from eos.saveddata.targetResists import TargetResists
+from eos.saveddata.targetProfile import TargetProfile
 from eos.saveddata.user import User
 
 
@@ -70,7 +70,8 @@ projectedFits_table = Table("projectedFits", saveddata_meta,
                             Column("amount", Integer, nullable=False, default=1),
                             Column("active", Boolean, nullable=False, default=1),
                             Column("created", DateTime, nullable=True, default=datetime.datetime.now),
-                            Column("modified", DateTime, nullable=True, onupdate=datetime.datetime.now)
+                            Column("modified", DateTime, nullable=True, onupdate=datetime.datetime.now),
+                            Column("projectionRange", Float, nullable=True),
                             )
 
 commandFits_table = Table("commandFits", saveddata_meta,
@@ -82,7 +83,8 @@ commandFits_table = Table("commandFits", saveddata_meta,
                           )
 
 
-class ProjectedFit(object):
+class ProjectedFit:
+
     def __init__(self, sourceID, source_fit, amount=1, active=True):
         self.sourceID = sourceID
         self.source_fit = source_fit
@@ -113,7 +115,7 @@ class ProjectedFit(object):
         )
 
 
-class CommandFit(object):
+class CommandFit:
     def __init__(self, boosterID, booster_fit, active=True):
         self.boosterID = boosterID
         self.booster_fit = booster_fit
@@ -232,7 +234,7 @@ mapper(es_Fit, fits_table,
                    Character,
                    backref="fits"),
            "_Fit__damagePattern": relation(DamagePattern),
-           "_Fit__targetResists": relation(TargetResists),
+           "_Fit__targetProfile": relation(TargetProfile),
            "projectedOnto": projectedFitSourceRel,
            "victimOf": relationship(
                    ProjectedFit,

eos/db/saveddata/loadDefaultDatabaseValues.py

@@ -17,16 +17,17 @@
 # along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
 # ===============================================================================
 
+
 import eos.db
 from eos.saveddata.damagePattern import DamagePattern as es_DamagePattern
-from eos.saveddata.targetResists import TargetResists as es_TargetResists
+from eos.saveddata.targetProfile import TargetProfile as es_TargetProfile
 
 
 class ImportError(Exception):
     pass
 
 
-class DefaultDatabaseValues(object):
+class DefaultDatabaseValues:
     def __init__(self):
         pass
 
@@ -34,95 +35,97 @@ class DefaultDatabaseValues(object):
 
     @classmethod
     def importDamageProfileDefaults(cls):
-        damageProfileList = [["Uniform", "25", "25", "25", "25"], ["[Generic]EM", "100", "0", "0", "0"],
-                             ["[Generic]Thermal", "0", "100", "0", "0"], ["[Generic]Kinetic", "0", "0", "100", "0"],
-                             ["[Generic]Explosive", "0", "0", "0", "100"],
-                             ["[NPC][Asteroid] Blood Raiders", "5067", "4214", "0", "0"],
-                             ["[Bombs]Electron Bomb", "6400", "0", "0", "0"],
-                             ["[Bombs]Scorch Bomb", "0", "6400", "0", "0"],
-                             ["[Bombs]Concussion Bomb", "0", "0", "6400", "0"],
-                             ["[Bombs]Shrapnel Bomb", "0", "0", "0", "6400"],
-                             ["[Frequency Crystals][T2] Conflagration", "61.6", "61.6", "0", "0"],
-                             ["[Frequency Crystals][T2] Scorch", "72", "16", "0", "0"],
-                             ["[Frequency Crystals][T2] Gleam", "56", "56", "0", "0"],
-                             ["[Frequency Crystals][T2] Aurora", "40", "24", "0", "0"],
-                             ["[Frequency Crystals]Multifrequency", "61.6", "44", "0", "0"],
-                             ["[Frequency Crystals]Gamma", "61.6", "35.2", "0", "0"],
-                             ["[Frequency Crystals]Xray", "52.8", "35.2", "0", "0"],
-                             ["[Frequency Crystals]Ultraviolet", "52.8", "26.4", "0", "0"],
-                             ["[Frequency Crystals]Standard", "44", "26.4", "0", "0"],
-                             ["[Frequency Crystals]Infrared", "44", "17.6", "0", "0"],
-                             ["[Frequency Crystals]Microwave", "35.2", "17.6", "0", "0"],
-                             ["[Frequency Crystals]Radio", "44", "0", "0", "0"],
-                             ["[Hybrid Charges][T2] Void", "0", "61.6", "61.6", "0"],
-                             ["[Hybrid Charges][T2] Null", "0", "48", "40", "0"],
-                             ["[Hybrid Charges][T2] Javelin", "0", "64", "48", "0"],
-                             ["[Hybrid Charges][T2] Spike", "0", "32", "32", "0"],
-                             ["[Hybrid Charges]Antimatter", "0", "48", "67.2", "0"],
-                             ["[Hybrid Charges]Plutonium", "0", "48", "57.6", "0"],
-                             ["[Hybrid Charges]Uranium", "0", "38.4", "57.6", "0"],
-                             ["[Hybrid Charges]Thorium", "0", "38.4", "48", "0"],
-                             ["[Hybrid Charges]Lead", "0", "28.8", "48", "0"],
-                             ["[Hybrid Charges]Iridium", "0", "28.8", "38.4", "0"],
-                             ["[Hybrid Charges]Tungsten", "0", "19.2", "38.4", "0"],
-                             ["[Hybrid Charges]Iron", "0", "19.2", "28.8", "0"],
-                             ["[Missiles]Mjolnir", "100", "0", "0", "0"],
-                             ["[Missiles]Inferno", "0", "100", "0", "0"],
-                             ["[Missiles]Scourge", "0", "0", "100", "0"],
-                             ["[Missiles]Nova", "0", "0", "0", "100"],
-                             ["[Missiles][Structure] Standup Missile", "100", "100", "100", "100"],
-                             ["[Projectile Ammo][T2] Hail", "0", "0", "26.4", "96.8"],
-                             ["[Projectile Ammo][T2] Barrage", "0", "0", "40", "48"],
-                             ["[Projectile Ammo][T2] Quake", "0", "0", "40", "72"],
-                             ["[Projectile Ammo][T2] Tremor", "0", "0", "24", "40"],
-                             ["[Projectile Ammo]EMP", "79.2", "0", "8.8", "17.6"],
-                             ["[Projectile Ammo]Phased Plasma", "0", "88", "17.6", "0"],
-                             ["[Projectile Ammo]Fusion", "0", "0", "17.6", "88"],
-                             ["[Projectile Ammo]Depleted Uranium", "0", "26.4", "17.6", "26.4"],
-                             ["[Projectile Ammo]Titanium Sabot", "0", "0", "52.8", "176"],
-                             ["[Projectile Ammo]Proton", "26.4", "0", "17.6", "0"],
-                             ["[Projectile Ammo]Carbonized Lead", "0", "0", "35.2", "8.8"],
-                             ["[Projectile Ammo]Nuclear", "0", "0", "8.8", "35.2"],
+        damageProfileList = [["Uniform", 25, 25, 25, 25],
+                             ["[Generic]EM", 1, 0, 0, 0],
+                             ["[Generic]Thermal", 0, 1, 0, 0],
+                             ["[Generic]Kinetic", 0, 0, 1, 0],
+                             ["[Generic]Explosive", 0, 0, 0, 1],
+                             ["[NPC][Asteroid] Blood Raiders", 5067, 4214, 0, 0],
+                             ["[Bombs]Electron Bomb", 6400, 0, 0, 0],
+                             ["[Bombs]Scorch Bomb", 0, 6400, 0, 0],
+                             ["[Bombs]Concussion Bomb", 0, 0, 6400, 0],
+                             ["[Bombs]Shrapnel Bomb", 0, 0, 0, 6400],
+                             ["[Frequency Crystals][T2] Conflagration", 7.7, 7.7, 0, 0],
+                             ["[Frequency Crystals][T2] Scorch", 9, 2, 0, 0],
+                             ["[Frequency Crystals][T2] Gleam", 7, 7, 0, 0],
+                             ["[Frequency Crystals][T2] Aurora", 5, 3, 0, 0],
+                             ["[Frequency Crystals]Multifrequency", 7, 5, 0, 0],
+                             ["[Frequency Crystals]Gamma", 7, 4, 0, 0],
+                             ["[Frequency Crystals]Xray", 6, 4, 0, 0],
+                             ["[Frequency Crystals]Ultraviolet", 6, 3, 0, 0],
+                             ["[Frequency Crystals]Standard", 5, 3, 0, 0],
+                             ["[Frequency Crystals]Infrared", 5, 2, 0, 0],
+                             ["[Frequency Crystals]Microwave", 4, 2, 0, 0],
+                             ["[Frequency Crystals]Radio", 5, 0, 0, 0],
+                             ["[Hybrid Charges][T2] Void", 0, 7.7, 7.7, 0],
+                             ["[Hybrid Charges][T2] Null", 0, 6, 5, 0],
+                             ["[Hybrid Charges][T2] Javelin", 0, 8, 6, 0],
+                             ["[Hybrid Charges][T2] Spike", 0, 4, 4, 0],
+                             ["[Hybrid Charges]Antimatter", 0, 5, 7, 0],
+                             ["[Hybrid Charges]Plutonium", 0, 5, 6, 0],
+                             ["[Hybrid Charges]Uranium", 0, 4, 6, 0],
+                             ["[Hybrid Charges]Thorium", 0, 4, 5, 0],
+                             ["[Hybrid Charges]Lead", 0, 3, 5, 0],
+                             ["[Hybrid Charges]Iridium", 0, 3, 4, 0],
+                             ["[Hybrid Charges]Tungsten", 0, 2, 4, 0],
+                             ["[Hybrid Charges]Iron", 0, 2, 3, 0],
+                             ["[Missiles]Mjolnir", 1, 0, 0, 0],
+                             ["[Missiles]Inferno", 0, 1, 0, 0],
+                             ["[Missiles]Scourge", 0, 0, 1, 0],
+                             ["[Missiles]Nova", 0, 0, 0, 1],
+                             ["[Missiles][Structure] Standup Missile", 1, 1, 1, 1],
+                             ["[Projectile Ammo][T2] Hail", 0, 0, 3.3, 12.1],
+                             ["[Projectile Ammo][T2] Barrage", 0, 0, 5, 6],
+                             ["[Projectile Ammo][T2] Quake", 0, 0, 5, 9],
+                             ["[Projectile Ammo][T2] Tremor", 0, 0, 3, 5],
+                             ["[Projectile Ammo]EMP", 9, 0, 1, 2],
+                             ["[Projectile Ammo]Phased Plasma", 0, 10, 2, 0],
+                             ["[Projectile Ammo]Fusion", 0, 0, 2, 10],
+                             ["[Projectile Ammo]Depleted Uranium", 0, 3, 2, 3],
+                             ["[Projectile Ammo]Titanium Sabot", 0, 0, 6, 2],
+                             ["[Projectile Ammo]Proton", 3, 0, 2, 0],
+                             ["[Projectile Ammo]Carbonized Lead", 0, 0, 4, 1],
+                             ["[Projectile Ammo]Nuclear", 0, 0, 1, 4],
                              # Different sizes of plasma do different damage, the values here are
                              # average of proportions across sizes
-                             ["[Exotic Plasma][T2] Occult", "0", "55863", "0", "44137"],
-                             ["[Exotic Plasma][T2] Mystic", "0", "66319", "0", "33681"],
-                             ["[Exotic Plasma]Tetryon", "0", "69208", "0", "30792"],
-                             ["[Exotic Plasma]Baryon", "0", "59737", "0", "40263"],
-                             ["[Exotic Plasma]Meson", "0", "60519", "0", "39481"],
-                             ["[NPC][Burner] Cruor (Blood Raiders)", "90", "90", "0", "0"],
-                             ["[NPC][Burner] Dramiel (Angel)", "55", "0", "20", "96"],
-                             ["[NPC][Burner] Daredevil (Serpentis)", "0", "110", "154", "0"],
-                             ["[NPC][Burner] Succubus (Sanshas Nation)", "135", "30", "0", "0"],
-                             ["[NPC][Burner] Worm (Guristas)", "0", "0", "228", "0"],
-                             ["[NPC][Burner] Enyo", "0", "147", "147", "0"],
-                             ["[NPC][Burner] Hawk", "0", "0", "247", "0"],
-                             ["[NPC][Burner] Jaguar", "36", "0", "50", "182"],
-                             ["[NPC][Burner] Vengeance", "232", "0", "0", "0"],
-                             ["[NPC][Burner] Ashimmu (Blood Raiders)", "260", "100", "0", "0"],
-                             ["[NPC][Burner] Talos", "0", "413", "413", "0"],
-                             ["[NPC][Burner] Sentinel", "0", "75", "0", "90"],
-                             ["[NPC][Asteroid] Angel Cartel", "1838", "562", "2215", "3838"],
-                             ["[NPC][Deadspace] Angel Cartel", "369", "533", "1395", "3302"],
-                             ["[NPC][Deadspace] Blood Raiders", "6040", "5052", "10", "15"],
-                             ["[NPC][Asteroid] Guristas", "0", "1828", "7413", "0"],
-                             ["[NPC][Deadspace] Guristas", "0", "1531", "9680", "0"],
-                             ["[NPC][Asteroid] Rogue Drone", "394", "666", "1090", "1687"],
-                             ["[NPC][Deadspace] Rogue Drone", "276", "1071", "1069", "871"],
-                             ["[NPC][Asteroid] Sanshas Nation", "5586", "4112", "0", "0"],
-                             ["[NPC][Deadspace] Sanshas Nation", "3009", "2237", "0", "0"],
-                             ["[NPC][Asteroid] Serpentis", "0", "5373", "4813", "0"],
-                             ["[NPC][Deadspace] Serpentis", "0", "3110", "1929", "0"],
-                             ["[NPC][Mission] Amarr Empire", "4464", "3546", "97", "0"],
-                             ["[NPC][Mission] Caldari State", "0", "2139", "4867", "0"],
-                             ["[NPC][Mission] CONCORD", "336", "134", "212", "412"],
-                             ["[NPC][Mission] Gallente Federation", "9", "3712", "2758", "0"],
-                             ["[NPC][Mission] Khanid", "612", "483", "43", "6"],
-                             ["[NPC][Mission] Minmatar Republic", "1024", "388", "1655", "4285"],
-                             ["[NPC][Mission] Mordus Legion", "25", "262", "625", "0"],
-                             ["[NPC][Mission] Thukker", "0", "52", "10", "79"],
-                             ["[NPC][Other] Sleepers", "1472", "1472", "1384", "1384"],
-                             ["[NPC][Other] Sansha Incursion", "1682", "1347", "3678", "3678"]]
+                             ["[Exotic Plasma][T2] Occult", 0, 55863, 0, 44137],
+                             ["[Exotic Plasma][T2] Mystic", 0, 66319, 0, 33681],
+                             ["[Exotic Plasma]Tetryon", 0, 69208, 0, 30792],
+                             ["[Exotic Plasma]Baryon", 0, 59737, 0, 40263],
+                             ["[Exotic Plasma]Meson", 0, 60519, 0, 39481],
+                             ["[NPC][Burner] Cruor (Blood Raiders)", 90, 90, 0, 0],
+                             ["[NPC][Burner] Dramiel (Angel)", 55, 0, 20, 96],
+                             ["[NPC][Burner] Daredevil (Serpentis)", 0, 110, 154, 0],
+                             ["[NPC][Burner] Succubus (Sanshas Nation)", 135, 30, 0, 0],
+                             ["[NPC][Burner] Worm (Guristas)", 0, 0, 228, 0],
+                             ["[NPC][Burner] Enyo", 0, 147, 147, 0],
+                             ["[NPC][Burner] Hawk", 0, 0, 247, 0],
+                             ["[NPC][Burner] Jaguar", 36, 0, 50, 182],
+                             ["[NPC][Burner] Vengeance", 232, 0, 0, 0],
+                             ["[NPC][Burner] Ashimmu (Blood Raiders)", 260, 100, 0, 0],
+                             ["[NPC][Burner] Talos", 0, 413, 413, 0],
+                             ["[NPC][Burner] Sentinel", 0, 75, 0, 90],
+                             ["[NPC][Asteroid] Angel Cartel", 1838, 562, 2215, 3838],
+                             ["[NPC][Deadspace] Angel Cartel", 369, 533, 1395, 3302],
+                             ["[NPC][Deadspace] Blood Raiders", 6040, 5052, 10, 15],
+                             ["[NPC][Asteroid] Guristas", 0, 1828, 7413, 0],
+                             ["[NPC][Deadspace] Guristas", 0, 1531, 9680, 0],
+                             ["[NPC][Asteroid] Rogue Drone", 394, 666, 1090, 1687],
+                             ["[NPC][Deadspace] Rogue Drone", 276, 1071, 1069, 871],
+                             ["[NPC][Asteroid] Sanshas Nation", 5586, 4112, 0, 0],
+                             ["[NPC][Deadspace] Sanshas Nation", 3009, 2237, 0, 0],
+                             ["[NPC][Asteroid] Serpentis", 0, 5373, 4813, 0],
+                             ["[NPC][Deadspace] Serpentis", 0, 3110, 1929, 0],
+                             ["[NPC][Mission] Amarr Empire", 4464, 3546, 97, 0],
+                             ["[NPC][Mission] Caldari State", 0, 2139, 4867, 0],
+                             ["[NPC][Mission] CONCORD", 336, 134, 212, 412],
+                             ["[NPC][Mission] Gallente Federation", 9, 3712, 2758, 0],
+                             ["[NPC][Mission] Khanid", 612, 483, 43, 6],
+                             ["[NPC][Mission] Minmatar Republic", 1024, 388, 1655, 4285],
+                             ["[NPC][Mission] Mordus Legion", 25, 262, 625, 0],
+                             ["[NPC][Mission] Thukker", 0, 52, 10, 79],
+                             ["[NPC][Other] Sleepers", 1472, 1472, 1384, 1384],
+                             ["[NPC][Other] Sansha Incursion", 1682, 1347, 3678, 3678]]
 
         for damageProfileRow in damageProfileList:
             name, em, therm, kin, exp = damageProfileRow
@@ -130,73 +133,105 @@ class DefaultDatabaseValues(object):
             if damageProfile is None:
                 damageProfile = es_DamagePattern(em, therm, kin, exp)
                 damageProfile.name = name
-                eos.db.save(damageProfile)
+                eos.db.add(damageProfile)
+            else:
+                damageProfile.emAmount = em
+                damageProfile.thermalAmount = therm
+                damageProfile.kineticAmount = kin
+                damageProfile.explosiveAmount = exp
+        eos.db.commit()
 
     @classmethod
-    def importResistProfileDefaults(cls):
-        targetResistProfileList = [["Uniform (25%)", "0.25", "0.25", "0.25", "0.25"],
-                                   ["Uniform (50%)", "0.50", "0.50", "0.50", "0.50"],
-                                   ["Uniform (75%)", "0.75", "0.75", "0.75", "0.75"],
-                                   ["Uniform (90%)", "0.90", "0.90", "0.90", "0.90"],
-                                   ["[T1 Resist]Shield", "0.0", "0.20", "0.40", "0.50"],
-                                   ["[T1 Resist]Armor", "0.50", "0.45", "0.25", "0.10"],
-                                   ["[T1 Resist]Hull", "0.33", "0.33", "0.33", "0.33"],
-                                   ["[T1 Resist]Shield (+T2 DCU)", "0.125", "0.30", "0.475", "0.562"],
-                                   ["[T1 Resist]Armor (+T2 DCU)", "0.575", "0.532", "0.363", "0.235"],
-                                   ["[T1 Resist]Hull (+T2 DCU)", "0.598", "0.598", "0.598", "0.598"],
-                                   ["[T2 Resist]Amarr (Shield)", "0.0", "0.20", "0.70", "0.875"],
-                                   ["[T2 Resist]Amarr (Armor)", "0.50", "0.35", "0.625", "0.80"],
-                                   ["[T2 Resist]Caldari (Shield)", "0.20", "0.84", "0.76", "0.60"],
-                                   ["[T2 Resist]Caldari (Armor)", "0.50", "0.8625", "0.625", "0.10"],
-                                   ["[T2 Resist]Gallente (Shield)", "0.0", "0.60", "0.85", "0.50"],
-                                   ["[T2 Resist]Gallente (Armor)", "0.50", "0.675", "0.8375", "0.10"],
-                                   ["[T2 Resist]Minmatar (Shield)", "0.75", "0.60", "0.40", "0.50"],
-                                   ["[T2 Resist]Minmatar (Armor)", "0.90", "0.675", "0.25", "0.10"],
-                                   ["[NPC][Asteroid] Angel Cartel", "0.54", "0.42", "0.37", "0.32"],
-                                   ["[NPC][Asteroid] Blood Raiders", "0.34", "0.39", "0.45", "0.52"],
-                                   ["[NPC][Asteroid] Guristas", "0.55", "0.35", "0.3", "0.48"],
-                                   ["[NPC][Asteroid] Rogue Drones", "0.35", "0.38", "0.44", "0.49"],
-                                   ["[NPC][Asteroid] Sanshas Nation", "0.35", "0.4", "0.47", "0.53"],
-                                   ["[NPC][Asteroid] Serpentis", "0.49", "0.38", "0.29", "0.51"],
-                                   ["[NPC][Deadspace] Angel Cartel", "0.59", "0.48", "0.4", "0.32"],
-                                   ["[NPC][Deadspace] Blood Raiders", "0.31", "0.39", "0.47", "0.56"],
-                                   ["[NPC][Deadspace] Guristas", "0.57", "0.39", "0.31", "0.5"],
-                                   ["[NPC][Deadspace] Rogue Drones", "0.42", "0.42", "0.47", "0.49"],
-                                   ["[NPC][Deadspace] Sanshas Nation", "0.31", "0.39", "0.47", "0.56"],
-                                   ["[NPC][Deadspace] Serpentis", "0.49", "0.38", "0.29", "0.56"],
-                                   ["[NPC][Mission] Amarr Empire", "0.34", "0.38", "0.42", "0.46"],
-                                   ["[NPC][Mission] Caldari State", "0.51", "0.38", "0.3", "0.51"],
-                                   ["[NPC][Mission] CONCORD", "0.47", "0.46", "0.47", "0.47"],
-                                   ["[NPC][Mission] Gallente Federation", "0.51", "0.38", "0.31", "0.52"],
-                                   ["[NPC][Mission] Khanid", "0.51", "0.42", "0.36", "0.4"],
-                                   ["[NPC][Mission] Minmatar Republic", "0.51", "0.46", "0.41", "0.35"],
-                                   ["[NPC][Mission] Mordus Legion", "0.32", "0.48", "0.4", "0.62"],
-                                   ["[NPC][Other] Sleeper", "0.61", "0.61", "0.61", "0.61"],
-                                   ["[NPC][Other] Sansha Incursion", "0.65", "0.63", "0.64", "0.65"],
-                                   ["[NPC][Burner] Cruor (Blood Raiders)", "0.8", "0.73", "0.69", "0.67"],
-                                   ["[NPC][Burner] Dramiel (Angel)", "0.35", "0.48", "0.61", "0.68"],
-                                   ["[NPC][Burner] Daredevil (Serpentis)", "0.69", "0.59", "0.59", "0.43"],
-                                   ["[NPC][Burner] Succubus (Sanshas Nation)", "0.35", "0.48", "0.61", "0.68"],
-                                   ["[NPC][Burner] Worm (Guristas)", "0.48", "0.58", "0.69", "0.74"],
-                                   ["[NPC][Burner] Enyo", "0.58", "0.72", "0.86", "0.24"],
-                                   ["[NPC][Burner] Hawk", "0.3", "0.86", "0.79", "0.65"],
-                                   ["[NPC][Burner] Jaguar", "0.78", "0.65", "0.48", "0.56"],
-                                   ["[NPC][Burner] Vengeance", "0.66", "0.56", "0.75", "0.86"],
-                                   ["[NPC][Burner] Ashimmu (Blood Raiders)", "0.8", "0.76", "0.68", "0.7"],
-                                   ["[NPC][Burner] Talos", "0.68", "0.59", "0.59", "0.43"],
-                                   ["[NPC][Burner] Sentinel", "0.58", "0.45", "0.52", "0.66"]]
+    def importTargetProfileDefaults(cls):
+        targetProfileList = [["Uniform (25%)", 0.25, 0.25, 0.25, 0.25],
+                             ["Uniform (50%)", 0.50, 0.50, 0.50, 0.50],
+                             ["Uniform (75%)", 0.75, 0.75, 0.75, 0.75],
+                             ["Uniform (90%)", 0.90, 0.90, 0.90, 0.90],
+                             ["[T1 Resist]Shield", 0.0, 0.20, 0.40, 0.50],
+                             ["[T1 Resist]Armor", 0.50, 0.45, 0.25, 0.10],
+                             ["[T1 Resist]Hull", 0.33, 0.33, 0.33, 0.33],
+                             ["[T1 Resist]Shield (+T2 DCU)", 0.125, 0.30, 0.475, 0.562],
+                             ["[T1 Resist]Armor (+T2 DCU)", 0.575, 0.532, 0.363, 0.235],
+                             ["[T1 Resist]Hull (+T2 DCU)", 0.598, 0.598, 0.598, 0.598],
+                             ["[T2 Resist]Amarr (Shield)", 0.0, 0.20, 0.70, 0.875],
+                             ["[T2 Resist]Amarr (Armor)", 0.50, 0.35, 0.625, 0.80],
+                             ["[T2 Resist]Caldari (Shield)", 0.20, 0.84, 0.76, 0.60],
+                             ["[T2 Resist]Caldari (Armor)", 0.50, 0.8625, 0.625, 0.10],
+                             ["[T2 Resist]Gallente (Shield)", 0.0, 0.60, 0.85, 0.50],
+                             ["[T2 Resist]Gallente (Armor)", 0.50, 0.675, 0.8375, 0.10],
+                             ["[T2 Resist]Minmatar (Shield)", 0.75, 0.60, 0.40, 0.50],
+                             ["[T2 Resist]Minmatar (Armor)", 0.90, 0.675, 0.25, 0.10],
+                             ["[NPC][Asteroid] Angel Cartel", 0.54, 0.42, 0.37, 0.32],
+                             ["[NPC][Asteroid] Blood Raiders", 0.34, 0.39, 0.45, 0.52],
+                             ["[NPC][Asteroid] Guristas", 0.55, 0.35, 0.3, 0.48],
+                             ["[NPC][Asteroid] Rogue Drones", 0.35, 0.38, 0.44, 0.49],
+                             ["[NPC][Asteroid] Sanshas Nation", 0.35, 0.4, 0.47, 0.53],
+                             ["[NPC][Asteroid] Serpentis", 0.49, 0.38, 0.29, 0.51],
+                             ["[NPC][Deadspace] Angel Cartel", 0.59, 0.48, 0.4, 0.32],
+                             ["[NPC][Deadspace] Blood Raiders", 0.31, 0.39, 0.47, 0.56],
+                             ["[NPC][Deadspace] Guristas", 0.57, 0.39, 0.31, 0.5],
+                             ["[NPC][Deadspace] Rogue Drones", 0.42, 0.42, 0.47, 0.49],
+                             ["[NPC][Deadspace] Sanshas Nation", 0.31, 0.39, 0.47, 0.56],
+                             ["[NPC][Deadspace] Serpentis", 0.49, 0.38, 0.29, 0.56],
+                             ["[NPC][Mission] Amarr Empire", 0.34, 0.38, 0.42, 0.46],
+                             ["[NPC][Mission] Caldari State", 0.51, 0.38, 0.3, 0.51],
+                             ["[NPC][Mission] CONCORD", 0.47, 0.46, 0.47, 0.47],
+                             ["[NPC][Mission] Gallente Federation", 0.51, 0.38, 0.31, 0.52],
+                             ["[NPC][Mission] Khanid", 0.51, 0.42, 0.36, 0.4],
+                             ["[NPC][Mission] Minmatar Republic", 0.51, 0.46, 0.41, 0.35],
+                             ["[NPC][Mission] Mordus Legion", 0.32, 0.48, 0.4, 0.62],
+                             ["[NPC][Other] Sleeper", 0.61, 0.61, 0.61, 0.61],
+                             ["[NPC][Other] Sansha Incursion", 0.65, 0.63, 0.64, 0.65],
+                             ["[NPC][Burner] Cruor (Blood Raiders)", 0.8, 0.73, 0.69, 0.67],
+                             ["[NPC][Burner] Dramiel (Angel)", 0.35, 0.48, 0.61, 0.68],
+                             ["[NPC][Burner] Daredevil (Serpentis)", 0.69, 0.59, 0.59, 0.43],
+                             ["[NPC][Burner] Succubus (Sanshas Nation)", 0.35, 0.48, 0.61, 0.68],
+                             ["[NPC][Burner] Worm (Guristas)", 0.48, 0.58, 0.69, 0.74],
+                             ["[NPC][Burner] Enyo", 0.58, 0.72, 0.86, 0.24],
+                             ["[NPC][Burner] Hawk", 0.3, 0.86, 0.79, 0.65],
+                             ["[NPC][Burner] Jaguar", 0.78, 0.65, 0.48, 0.56],
+                             ["[NPC][Burner] Vengeance", 0.66, 0.56, 0.75, 0.86],
+                             ["[NPC][Burner] Ashimmu (Blood Raiders)", 0.8, 0.76, 0.68, 0.7],
+                             ["[NPC][Burner] Talos", 0.68, 0.59, 0.59, 0.43],
+                             ["[NPC][Burner] Sentinel", 0.58, 0.45, 0.52, 0.66]]
+
+        for targetProfileRow in targetProfileList:
+            name = targetProfileRow[0]
+            em = targetProfileRow[1]
+            therm = targetProfileRow[2]
+            kin = targetProfileRow[3]
+            exp = targetProfileRow[4]
+            try:
+                maxVel = targetProfileRow[5]
+            except IndexError:
+                maxVel = None
+            try:
+                sigRad = targetProfileRow[6]
+            except IndexError:
+                sigRad = None
+            try:
+                radius = targetProfileRow[7]
+            except:
+                radius = None
+            targetProfile = eos.db.getTargetProfile(name)
+            if targetProfile is None:
+                targetProfile = es_TargetProfile(em, therm, kin, exp, maxVel, sigRad, radius)
+                targetProfile.name = name
+                eos.db.add(targetProfile)
+            else:
+                targetProfile.emAmount = em
+                targetProfile.thermalAmount = therm
+                targetProfile.kineticAmount = kin
+                targetProfile.explosiveAmount = exp
+                targetProfile.maxVelocity = maxVel
+                targetProfile.signatureRadius = sigRad
+                targetProfile.radius = radius
+        eos.db.commit()
 
-        for targetResistProfileRow in targetResistProfileList:
-            name, em, therm, kin, exp = targetResistProfileRow
-            resistsProfile = eos.db.eos.db.getTargetResists(name)
-            if resistsProfile is None:
-                resistsProfile = es_TargetResists(em, therm, kin, exp)
-                resistsProfile.name = name
-                eos.db.save(resistsProfile)
 
     @classmethod
     def importRequiredDefaults(cls):
-        damageProfileList = [["Uniform", "25", "25", "25", "25"]]
+        damageProfileList = [["Uniform", 25, 25, 25, 25]]
 
         for damageProfileRow in damageProfileList:
             name, em, therm, kin, exp = damageProfileRow
@@ -204,4 +239,10 @@ class DefaultDatabaseValues(object):
             if damageProfile is None:
                 damageProfile = es_DamagePattern(em, therm, kin, exp)
                 damageProfile.name = name
-                eos.db.save(damageProfile)
+                eos.db.add(damageProfile)
+            else:
+                damageProfile.emAmount = em
+                damageProfile.thermalAmount = therm
+                damageProfile.kineticAmount = kin
+                damageProfile.explosiveAmount = exp
+        eos.db.commit()

eos/db/saveddata/module.py

@@ -42,6 +42,7 @@ modules_table = Table("modules", saveddata_meta,
                       Column("modified", DateTime, nullable=True, onupdate=datetime.datetime.now),
                       Column("spoolType", Integer, nullable=True),
                       Column("spoolAmount", Float, nullable=True),
+                      Column("projectionRange", Float, nullable=True),
                       CheckConstraint('("dummySlot" = NULL OR "itemID" = NULL) AND "dummySlot" != "itemID"'))
 
 mapper(Module, modules_table,

eos/db/saveddata/queries.py

@@ -24,16 +24,16 @@ from sqlalchemy import desc, select
 from sqlalchemy import func
 
 from eos.db import saveddata_session, sd_lock
-from eos.db.saveddata.fit import projectedFits_table
+from eos.db.saveddata.fit import fits_table, projectedFits_table
 from eos.db.util import processEager, processWhere
 from eos.saveddata.price import Price
 from eos.saveddata.user import User
 from eos.saveddata.ssocharacter import SsoCharacter
 from eos.saveddata.damagePattern import DamagePattern
-from eos.saveddata.targetResists import TargetResists
+from eos.saveddata.targetProfile import TargetProfile
 from eos.saveddata.character import Character
 from eos.saveddata.implantSet import ImplantSet
-from eos.saveddata.fit import Fit
+from eos.saveddata.fit import Fit, FitLite
 from eos.saveddata.module import Module
 from eos.saveddata.miscData import MiscData
 from eos.saveddata.override import Override
@@ -326,6 +326,17 @@ def getFitList(eager=None):
     return fits
 
 
+def getFitListLite():
+    with sd_lock:
+        stmt = select([fits_table.c.ID, fits_table.c.name, fits_table.c.shipID])
+        data = eos.db.saveddata_session.execute(stmt).fetchall()
+    fits = []
+    for fitID, fitName, shipID in data:
+        fit = FitLite(id=fitID, name=fitName, shipID=shipID)
+        fits.append(fit)
+    return fits
+
+
 @cachedQuery(Price, 1, "typeID")
 def getPrice(typeID):
     if isinstance(typeID, int):
@@ -366,16 +377,16 @@ def clearDamagePatterns():
     return deleted_rows
 
 
-def getTargetResistsList(eager=None):
+def getTargetProfileList(eager=None):
     eager = processEager(eager)
     with sd_lock:
-        patterns = saveddata_session.query(TargetResists).options(*eager).all()
+        patterns = saveddata_session.query(TargetProfile).options(*eager).all()
     return patterns
 
 
-def clearTargetResists():
+def clearTargetProfiles():
     with sd_lock:
-        deleted_rows = saveddata_session.query(TargetResists).delete()
+        deleted_rows = saveddata_session.query(TargetProfile).delete()
     commit()
     return deleted_rows
 
@@ -408,22 +419,22 @@ def getDamagePattern(lookfor, eager=None):
     return pattern
 
 
-@cachedQuery(TargetResists, 1, "lookfor")
-def getTargetResists(lookfor, eager=None):
+@cachedQuery(TargetProfile, 1, "lookfor")
+def getTargetProfile(lookfor, eager=None):
     if isinstance(lookfor, int):
         if eager is None:
             with sd_lock:
-                pattern = saveddata_session.query(TargetResists).get(lookfor)
+                pattern = saveddata_session.query(TargetProfile).get(lookfor)
         else:
             eager = processEager(eager)
             with sd_lock:
-                pattern = saveddata_session.query(TargetResists).options(*eager).filter(
-                        TargetResists.ID == lookfor).first()
+                pattern = saveddata_session.query(TargetProfile).options(*eager).filter(
+                    TargetProfile.ID == lookfor).first()
     elif isinstance(lookfor, str):
         eager = processEager(eager)
         with sd_lock:
-            pattern = saveddata_session.query(TargetResists).options(*eager).filter(
-                    TargetResists.name == lookfor).first()
+            pattern = saveddata_session.query(TargetProfile).options(*eager).filter(
+                TargetProfile.name == lookfor).first()
     else:
         raise TypeError("Need integer or string as argument")
     return pattern
@@ -439,11 +450,11 @@ def getImplantSet(lookfor, eager=None):
             eager = processEager(eager)
             with sd_lock:
                 pattern = saveddata_session.query(ImplantSet).options(*eager).filter(
-                        TargetResists.ID == lookfor).first()
+                    TargetProfile.ID == lookfor).first()
     elif isinstance(lookfor, str):
         eager = processEager(eager)
         with sd_lock:
-            pattern = saveddata_session.query(ImplantSet).options(*eager).filter(TargetResists.name == lookfor).first()
+            pattern = saveddata_session.query(ImplantSet).options(*eager).filter(TargetProfile.name == lookfor).first()
     else:
         raise TypeError("Improper argument")
     return pattern

eos/db/saveddata/targetProfile.py

@@ -0,0 +1,46 @@
+# ===============================================================================
+# Copyright (C) 2014 Ryan Holmes
+#
+# This file is part of eos.
+#
+# eos is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#
+# eos is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with eos.  If not, see <http://www.gnu.org/licenses/>.
+# ===============================================================================
+
+from sqlalchemy import Table, Column, Integer, Float, ForeignKey, String, DateTime
+from sqlalchemy.orm import mapper
+import datetime
+
+from eos.db import saveddata_meta
+from eos.saveddata.targetProfile import TargetProfile
+
+targetProfiles_table = Table("targetResists", saveddata_meta,
+                             Column("ID", Integer, primary_key=True),
+                             Column("name", String),
+                             Column("emAmount", Float),
+                             Column("thermalAmount", Float),
+                             Column("kineticAmount", Float),
+                             Column("explosiveAmount", Float),
+                             Column("maxVelocity", Float, nullable=True),
+                             Column("signatureRadius", Float, nullable=True),
+                             Column("radius", Float, nullable=True),
+                             Column("ownerID", ForeignKey("users.ID"), nullable=True),
+                             Column("created", DateTime, nullable=True, default=datetime.datetime.now),
+                             Column("modified", DateTime, nullable=True, onupdate=datetime.datetime.now)
+                             )
+
+mapper(TargetProfile, targetProfiles_table,
+       properties={
+           "_maxVelocity": targetProfiles_table.c.maxVelocity,
+           "_signatureRadius": targetProfiles_table.c.signatureRadius,
+           "_radius": targetProfiles_table.c.radius})

eos/db/saveddata/targetResists.py

@@ -1,39 +0,0 @@
-# ===============================================================================
-# Copyright (C) 2014 Ryan Holmes
-#
-# This file is part of eos.
-#
-# eos is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 2 of the License, or
-# (at your option) any later version.
-#
-# eos is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with eos.  If not, see <http://www.gnu.org/licenses/>.
-# ===============================================================================
-
-from sqlalchemy import Table, Column, Integer, Float, ForeignKey, String, DateTime
-from sqlalchemy.orm import mapper
-import datetime
-
-from eos.db import saveddata_meta
-from eos.saveddata.targetResists import TargetResists
-
-targetResists_table = Table("targetResists", saveddata_meta,
-                            Column("ID", Integer, primary_key=True),
-                            Column("name", String),
-                            Column("emAmount", Float),
-                            Column("thermalAmount", Float),
-                            Column("kineticAmount", Float),
-                            Column("explosiveAmount", Float),
-                            Column("ownerID", ForeignKey("users.ID"), nullable=True),
-                            Column("created", DateTime, nullable=True, default=datetime.datetime.now),
-                            Column("modified", DateTime, nullable=True, onupdate=datetime.datetime.now)
-                            )
-
-mapper(TargetResists, targetResists_table)

eos/effectHandlerHelpers.py

@@ -17,10 +17,9 @@
 # along with eos.  If not, see <http://www.gnu.org/licenses/>.
 # ===============================================================================
 
-from logbook import Logger
 
-from eos.exception import HandledListActionError
-from utils.deprecated import deprecated
+from logbook import Logger
+from sqlalchemy.orm.collections import collection
 
 
 pyfalog = Logger(__name__)
@@ -137,27 +136,24 @@ class HandledModuleList(HandledList):
             self.__toModule(emptyPosition, mod)
             if mod.isInvalid:
                 self.__toDummy(mod.position)
-                raise HandledListActionError(mod)
-            return
-
-        self.appendIgnoreEmpty(mod)
+        else:
+            self.appendIgnoreEmpty(mod)
 
+    @collection.appender
     def appendIgnoreEmpty(self, mod):
         mod.position = len(self)
-        HandledList.append(self, mod)
+        super().append(mod)
         if mod.isInvalid:
             self.remove(mod)
-            raise HandledListActionError(mod)
 
     def replace(self, idx, mod):
         try:
             oldMod = self[idx]
         except IndexError:
-            raise HandledListActionError(mod)
+            return
         self.__toModule(idx, mod)
         if mod.isInvalid:
             self.__toModule(idx, oldMod)
-            raise HandledListActionError(mod)
 
     def replaceRackPosition(self, rackPosition, mod):
         listPositions = []
@@ -182,7 +178,6 @@ class HandledModuleList(HandledList):
                         self.__toDummy(modListPosition)
                     else:
                         self.__toModule(modListPosition, oldMod)
-                    raise HandledListActionError(mod)
 
     def insert(self, idx, mod):
         mod.position = idx
@@ -193,8 +188,6 @@ class HandledModuleList(HandledList):
         HandledList.insert(self, idx, mod)
         if mod.isInvalid:
             self.remove(mod)
-            raise HandledListActionError(mod)
-
 
     def remove(self, mod):
         HandledList.remove(self, mod)
@@ -236,13 +229,11 @@ class HandledDroneCargoList(HandledList):
         HandledList.append(self, thing)
         if thing.isInvalid:
             self.remove(thing)
-            raise HandledListActionError(thing)
 
     def insert(self, idx, thing):
         HandledList.insert(self, idx, thing)
         if thing.isInvalid:
             self.remove(thing)
-            raise HandledListActionError(thing)
 
 
 class HandledImplantList(HandledList):
@@ -251,22 +242,22 @@ class HandledImplantList(HandledList):
         if implant.isInvalid:
             HandledList.append(self, implant)
             self.remove(implant)
-            raise HandledListActionError(implant)
+            return
         if self.__slotCheck(implant):
             HandledList.append(self, implant)
             self.remove(implant)
-            raise HandledListActionError(implant)
+            return
         HandledList.append(self, implant)
 
     def insert(self, idx, implant):
         if implant.isInvalid:
             HandledList.insert(self, idx, implant)
             self.remove(implant)
-            raise HandledListActionError(implant)
+            return
         if self.__slotCheck(implant):
             HandledList.insert(self, idx, implant)
             self.remove(implant)
-            raise HandledListActionError(implant)
+            return
         HandledList.insert(self, idx, implant)
 
     def makeRoom(self, implant):
@@ -292,22 +283,22 @@ class HandledBoosterList(HandledList):
         if booster.isInvalid:
             HandledList.append(self, booster)
             self.remove(booster)
-            raise HandledListActionError(booster)
+            return
         if self.__slotCheck(booster):
             HandledList.append(self, booster)
             self.remove(booster)
-            raise HandledListActionError(booster)
+            return
         HandledList.append(self, booster)
 
     def insert(self, idx, booster):
         if booster.isInvalid:
             HandledList.insert(self, idx, booster)
             self.remove(booster)
-            raise HandledListActionError(booster)
+            return
         if self.__slotCheck(booster):
             HandledList.insert(self, idx, booster)
             self.remove(booster)
-            raise HandledListActionError(booster)
+            return
         HandledList.insert(self, idx, booster)
 
     def makeRoom(self, booster):
@@ -346,16 +337,12 @@ class HandledProjectedModList(HandledList):
             # rows and relationships in database are removed as well
             HandledList.append(self, proj)
             self.remove(proj)
-            raise HandledListActionError(proj)
-
+            return
         proj.projected = True
-
         HandledList.append(self, proj)
-
         # Remove non-projectable modules
         if not proj.item.isType("projected") and not proj.isExclusiveSystemEffect:
             self.remove(proj)
-            raise HandledListActionError(proj)
 
     def insert(self, idx, proj):
         if proj.isInvalid:
@@ -363,16 +350,12 @@ class HandledProjectedModList(HandledList):
             # rows and relationships in database are removed as well
             HandledList.insert(self, idx, proj)
             self.remove(proj)
-            raise HandledListActionError(proj)
-
+            return
         proj.projected = True
-
         HandledList.insert(self, idx, proj)
-
         # Remove non-projectable modules
         if not proj.item.isType("projected") and not proj.isExclusiveSystemEffect:
             self.remove(proj)
-            raise HandledListActionError(proj)
 
     @property
     def currentSystemEffect(self):
@@ -399,27 +382,21 @@ class HandledProjectedDroneList(HandledDroneCargoList):
     def append(self, proj):
         proj.projected = True
         HandledList.append(self, proj)
-
         # Remove invalid or non-projectable drones
         if proj.isInvalid or not proj.item.isType("projected"):
             self.remove(proj)
             proj.projected = False
-            raise HandledListActionError(proj)
-        return True
 
     def insert(self, idx, proj):
         proj.projected = True
         HandledList.insert(self, idx, proj)
-
         # Remove invalid or non-projectable drones
         if proj.isInvalid or not proj.item.isType("projected"):
             self.remove(proj)
             proj.projected = False
-            raise HandledListActionError(proj)
-        return True
 
 
-class HandledItem(object):
+class HandledItem:
     def preAssignItemAttr(self, *args, **kwargs):
         self.itemModifiedAttributes.preAssign(*args, **kwargs)
 
@@ -436,7 +413,7 @@ class HandledItem(object):
         self.itemModifiedAttributes.force(*args, **kwargs)
 
 
-class HandledCharge(object):
+class HandledCharge:
     def preAssignChargeAttr(self, *args, **kwargs):
         self.chargeModifiedAttributes.preAssign(*args, **kwargs)
 

eos/eqBase.py

@@ -18,7 +18,7 @@
 # ===============================================================================
 
 
-class EqBase(object):
+class EqBase:
     ID = None
 
     def __eq__(self, other):

eos/exception.py

@@ -1,2 +0,0 @@
-class HandledListActionError(Exception):
-    ...

eos/gamedata.py

@@ -243,6 +243,20 @@ class Item(EqBase):
         self.__overrides = None
         self.__priceObj = None
 
+    def getShortName(self, charLimit=12):
+        if len(self.name) <= charLimit:
+            return self.name
+        splitName = self.name.strip().split(' ')
+        if len(splitName) == 1:
+            return self.name
+        shortName = ''
+        for word in splitName:
+            try:
+                shortName += word[0].capitalize()
+            except IndexError:
+                pass
+        return shortName
+
     @property
     def attributes(self):
         if not self.__moved:
@@ -516,6 +530,14 @@ class Item(EqBase):
     def isBooster(self):
         return self.group.name == 'Booster' and self.category.name == 'Implant'
 
+    @property
+    def isStandup(self):
+        if self.category.name == "Structure Module":
+            return True
+        if self.isFighter and {'fighterSquadronIsStandupLight', 'fighterSquadronIsStandupHeavy', 'fighterSquadronIsStandupSupport'}.intersection(self.attributes):
+            return True
+        return False
+
     def __repr__(self):
         return "Item(ID={}, name={}) at {}".format(
                 self.ID, self.name, hex(id(self))
@@ -580,18 +602,13 @@ class DynamicItemItem(EqBase):
 class MarketGroup(EqBase):
     def __repr__(self):
         return "MarketGroup(ID={}, name={}, parent={}) at {}".format(
-                self.ID, self.name, getattr(self.parent, "name", None), self.name, hex(id(self))
-        )
+            self.ID, self.name, getattr(self.parent, "name", None), hex(id(self)))
 
 
 class MetaGroup(EqBase):
     pass
 
 
-class MetaType(EqBase):
-    pass
-
-
 class Unit(EqBase):
 
     def __init__(self):

eos/graph/__init__.py

@@ -1,120 +0,0 @@
-# ===============================================================================
-# Copyright (C) 2010 Diego Duclos
-#
-# This file is part of eos.
-#
-# eos is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 2 of the License, or
-# (at your option) any later version.
-#
-# eos is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with eos.  If not, see <http://www.gnu.org/licenses/>.
-# ===============================================================================
-
-import itertools
-
-
-class Graph(object):
-    def __init__(self, fit, function, data=None):
-        self.fit = fit
-        self.data = {}
-        if data is not None:
-            for name, d in data.items():
-                self.setData(Data(name, d))
-
-        self.function = function
-
-    def clearData(self):
-        self.data.clear()
-
-    def setData(self, data):
-        self.data[data.name] = data
-
-    def getIterator(self):
-        pointNames = []
-        pointIterators = []
-        for data in self.data.values():
-            pointNames.append(data.name)
-            pointIterators.append(data)
-
-        return self._iterator(pointNames, pointIterators)
-
-    def _iterator(self, pointNames, pointIterators):
-        for pointValues in itertools.product(*pointIterators):
-            point = {}
-            for i in range(len(pointValues)):
-                point[pointNames[i]] = pointValues[i]
-
-            yield point, self.function(point)
-
-
-class Data(object):
-    def __init__(self, name, dataString, step=None):
-        self.name = name
-        self.step = step
-        self.data = self.parseString(dataString)
-
-    def parseString(self, dataString):
-        if not isinstance(dataString, str):
-            return Constant(dataString),
-
-        dataList = []
-        for data in dataString.split(";"):
-            if isinstance(data, str) and "-" in data:
-                # Dealing with a range
-                dataList.append(Range(data, self.step))
-            else:
-                dataList.append(Constant(data))
-
-        return dataList
-
-    def __iter__(self):
-        for data in self.data:
-            for value in data:
-                yield value
-
-    def isConstant(self):
-        return len(self.data) == 1 and self.data[0].isConstant()
-
-
-class Constant(object):
-    def __init__(self, const):
-        if isinstance(const, str):
-            self.value = None if const == "" else float(const)
-        else:
-            self.value = const
-
-    def __iter__(self):
-        yield self.value
-
-    @staticmethod
-    def isConstant():
-        return True
-
-
-class Range(object):
-    def __init__(self, string, step):
-        start, end = string.split("-")
-        self.start = float(start)
-        self.end = float(end)
-        self.step = step
-
-    def __iter__(self):
-        current = start = self.start
-        end = self.end
-        step = self.step or (end - start) / 50.0
-        i = 1
-        while current < end:
-            current = start + i * step
-            i += 1
-            yield current
-
-    @staticmethod
-    def isConstant():
-        return False

eos/graph/fitDps.py

@@ -1,197 +0,0 @@
-# ===============================================================================
-# Copyright (C) 2010 Diego Duclos
-#
-# This file is part of eos.
-#
-# eos is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 2 of the License, or
-# (at your option) any later version.
-#
-# eos is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with eos.  If not, see <http://www.gnu.org/licenses/>.
-# ===============================================================================
-
-from math import log, sin, radians, exp
-
-from eos.graph import Graph
-from eos.const import FittingModuleState, FittingHardpoint
-from logbook import Logger
-
-pyfalog = Logger(__name__)
-
-
-class FitDpsGraph(Graph):
-    defaults = {
-        "angle"          : 0,
-        "distance"       : 0,
-        "signatureRadius": None,
-        "velocity"       : 0
-    }
-
-    def __init__(self, fit, data=None):
-        Graph.__init__(self, fit, self.calcDps, data if data is not None else self.defaults)
-        self.fit = fit
-
-    def calcDps(self, data):
-        ew = {'signatureRadius': [], 'velocity': []}
-        fit = self.fit
-        total = 0
-        distance = data["distance"] * 1000
-        abssort = lambda _val: -abs(_val - 1)
-
-        for mod in fit.modules:
-            if not mod.isEmpty and mod.state >= FittingModuleState.ACTIVE:
-                if "remoteTargetPaintFalloff" in mod.item.effects or "structureModuleEffectTargetPainter" in mod.item.effects:
-                    ew['signatureRadius'].append(
-                            1 + (mod.getModifiedItemAttr("signatureRadiusBonus") / 100) * self.calculateModuleMultiplier(
-                                    mod, data))
-                if "remoteWebifierFalloff" in mod.item.effects or "structureModuleEffectStasisWebifier" in mod.item.effects:
-                    if distance <= mod.getModifiedItemAttr("maxRange"):
-                        ew['velocity'].append(1 + (mod.getModifiedItemAttr("speedFactor") / 100))
-                    elif mod.getModifiedItemAttr("falloffEffectiveness") > 0:
-                        # I am affected by falloff
-                        ew['velocity'].append(
-                                1 + (mod.getModifiedItemAttr("speedFactor") / 100) * self.calculateModuleMultiplier(mod,
-                                                                                                                    data))
-
-        ew['signatureRadius'].sort(key=abssort)
-        ew['velocity'].sort(key=abssort)
-
-        for attr, values in ew.items():
-            val = data[attr]
-            try:
-                for i in range(len(values)):
-                    bonus = values[i]
-                    val *= 1 + (bonus - 1) * exp(- i ** 2 / 7.1289)
-                data[attr] = val
-            except Exception as e:
-                pyfalog.critical("Caught exception in calcDPS.")
-                pyfalog.critical(e)
-
-        for mod in fit.modules:
-            dps = mod.getDps(targetResists=fit.targetResists).total
-            if mod.hardpoint == FittingHardpoint.TURRET:
-                if mod.state >= FittingModuleState.ACTIVE:
-                    total += dps * self.calculateTurretMultiplier(mod, data)
-
-            elif mod.hardpoint == FittingHardpoint.MISSILE:
-                if mod.state >= FittingModuleState.ACTIVE and mod.maxRange is not None and mod.maxRange >= distance:
-                    total += dps * self.calculateMissileMultiplier(mod, data)
-
-        if distance <= fit.extraAttributes["droneControlRange"]:
-            for drone in fit.drones:
-                multiplier = 1 if drone.getModifiedItemAttr("maxVelocity") > 1 else self.calculateTurretMultiplier(
-                        drone, data)
-                dps = drone.getDps(targetResists=fit.targetResists).total
-                total += dps * multiplier
-
-        # this is janky as fuck
-        for fighter in fit.fighters:
-            if not fighter.active:
-                continue
-            fighterDpsMap = fighter.getDpsPerEffect(targetResists=fit.targetResists)
-            for ability in fighter.abilities:
-                if ability.dealsDamage and ability.active:
-                    if ability.effectID not in fighterDpsMap:
-                        continue
-                    multiplier = self.calculateFighterMissileMultiplier(ability, data)
-                    dps = fighterDpsMap[ability.effectID].total
-                    total += dps * multiplier
-
-        return total
-
-    @staticmethod
-    def calculateMissileMultiplier(mod, data):
-        targetSigRad = data["signatureRadius"]
-        targetVelocity = data["velocity"]
-        explosionRadius = mod.getModifiedChargeAttr("aoeCloudSize")
-        targetSigRad = explosionRadius if targetSigRad is None else targetSigRad
-        explosionVelocity = mod.getModifiedChargeAttr("aoeVelocity")
-        damageReductionFactor = mod.getModifiedChargeAttr("aoeDamageReductionFactor")
-
-        sigRadiusFactor = targetSigRad / explosionRadius
-        if targetVelocity:
-            velocityFactor = (explosionVelocity / explosionRadius * targetSigRad / targetVelocity) ** damageReductionFactor
-        else:
-            velocityFactor = 1
-
-        return min(sigRadiusFactor, velocityFactor, 1)
-
-    def calculateTurretMultiplier(self, mod, data):
-        # Source for most of turret calculation info: http://wiki.eveonline.com/en/wiki/Falloff
-        chanceToHit = self.calculateTurretChanceToHit(mod, data)
-        if chanceToHit > 0.01:
-            # AvgDPS = Base Damage * [ ( ChanceToHit^2 + ChanceToHit + 0.0499 ) / 2 ]
-            multiplier = (chanceToHit ** 2 + chanceToHit + 0.0499) / 2
-        else:
-            # All hits are wreckings
-            multiplier = chanceToHit * 3
-        dmgScaling = mod.getModifiedItemAttr("turretDamageScalingRadius")
-        if dmgScaling:
-            targetSigRad = data["signatureRadius"]
-            multiplier = min(1, (float(targetSigRad) / dmgScaling) ** 2)
-        return multiplier
-
-    @staticmethod
-    def calculateFighterMissileMultiplier(ability, data):
-        prefix = ability.attrPrefix
-
-        targetSigRad = data["signatureRadius"]
-        targetVelocity = data["velocity"]
-        explosionRadius = ability.fighter.getModifiedItemAttr("{}ExplosionRadius".format(prefix))
-        explosionVelocity = ability.fighter.getModifiedItemAttr("{}ExplosionVelocity".format(prefix))
-        damageReductionFactor = ability.fighter.getModifiedItemAttr("{}ReductionFactor".format(prefix), None)
-
-        # the following conditionals are because CCP can't keep a decent naming convention, as if fighter implementation
-        # wasn't already fucked.
-        if damageReductionFactor is None:
-            damageReductionFactor = ability.fighter.getModifiedItemAttr("{}DamageReductionFactor".format(prefix))
-
-        damageReductionSensitivity = ability.fighter.getModifiedItemAttr("{}ReductionSensitivity".format(prefix), None)
-        if damageReductionSensitivity is None:
-            damageReductionSensitivity = ability.fighter.getModifiedItemAttr(
-                    "{}DamageReductionSensitivity".format(prefix))
-
-        targetSigRad = explosionRadius if targetSigRad is None else targetSigRad
-        sigRadiusFactor = targetSigRad / explosionRadius
-
-        if targetVelocity:
-            velocityFactor = (explosionVelocity / explosionRadius * targetSigRad / targetVelocity) ** (
-                log(damageReductionFactor) / log(damageReductionSensitivity))
-        else:
-            velocityFactor = 1
-
-        return min(sigRadiusFactor, velocityFactor, 1)
-
-    @staticmethod
-    def calculateTurretChanceToHit(mod, data):
-        distance = data["distance"] * 1000
-        tracking = mod.getModifiedItemAttr("trackingSpeed")
-        turretOptimal = mod.maxRange
-        turretFalloff = mod.falloff
-        turretSigRes = mod.getModifiedItemAttr("optimalSigRadius")
-        targetSigRad = data["signatureRadius"]
-        targetSigRad = turretSigRes if targetSigRad is None else targetSigRad
-        transversal = sin(radians(data["angle"])) * data["velocity"]
-        trackingEq = (((transversal / (distance * tracking)) *
-                       (turretSigRes / targetSigRad)) ** 2)
-        rangeEq = ((max(0, distance - turretOptimal)) / turretFalloff) ** 2
-
-        return 0.5 ** (trackingEq + rangeEq)
-
-    @staticmethod
-    def calculateModuleMultiplier(mod, data):
-        # Simplified formula, we make some assumptions about the module
-        # This is basically the calculateTurretChanceToHit without tracking values
-        distance = data["distance"] * 1000
-        turretOptimal = mod.maxRange
-        turretFalloff = mod.falloff
-        rangeEq = ((max(0, distance - turretOptimal)) / turretFalloff) ** 2
-
-        return 0.5 ** rangeEq

eos/modifiedAttributeDict.py

@@ -17,50 +17,90 @@
 # along with eos.  If not, see <http://www.gnu.org/licenses/>.
 # ===============================================================================
 
-import collections
+
+from collections.abc import MutableMapping
+from copy import copy
 from math import exp
+
+from eos.const import Operator
 # TODO: This needs to be moved out, we shouldn't have *ANY* dependencies back to other modules/methods inside eos.
 # This also breaks writing any tests. :(
 from eos.db.gamedata.queries import getAttributeInfo
 
+
 defaultValuesCache = {}
 cappingAttrKeyCache = {}
+resistanceCache = {}
 
 
-class ItemAttrShortcut(object):
+def getAttrDefault(key, fallback=None):
+    try:
+        default = defaultValuesCache[key]
+    except KeyError:
+        attrInfo = getAttributeInfo(key)
+        if attrInfo is None:
+            default = defaultValuesCache[key] = None
+        else:
+            default = defaultValuesCache[key] = attrInfo.defaultValue
+    if default is None:
+        default = fallback
+    return default
+
+
+def getResistanceAttrID(modifyingItem, effect):
+    # If it doesn't exist on the effect, check the modifying module's attributes.
+    # If it's there, cache it and return
+    if effect.resistanceID:
+        return effect.resistanceID
+    cacheKey = (modifyingItem.item.ID, effect.ID)
+    try:
+        return resistanceCache[cacheKey]
+    except KeyError:
+        attrPrefix = effect.getattr('prefix')
+        if attrPrefix:
+            resistanceID = int(modifyingItem.getModifiedItemAttr('{}ResistanceID'.format(attrPrefix))) or None
+            if not resistanceID:
+                resistanceID = int(modifyingItem.getModifiedItemAttr('{}RemoteResistanceID'.format(attrPrefix))) or None
+        else:
+            resistanceID = int(modifyingItem.getModifiedItemAttr("remoteResistanceID")) or None
+        resistanceCache[cacheKey] = resistanceID
+        return resistanceID
+
+
+class ItemAttrShortcut:
+
     def getModifiedItemAttr(self, key, default=0):
         return_value = self.itemModifiedAttributes.get(key)
+        return return_value or default
 
+    def getModifiedItemAttrExtended(self, key, extraMultipliers=None, ignoreAfflictors=(), default=0):
+        return_value = self.itemModifiedAttributes.getExtended(key, extraMultipliers=extraMultipliers, ignoreAfflictors=ignoreAfflictors)
         return return_value or default
 
     def getItemBaseAttrValue(self, key, default=0):
-        """
-        Gets base value in this order:
-        Mutated value > override value > attribute value
-        """
         return_value = self.itemModifiedAttributes.getOriginal(key)
         return return_value or default
 
+
+class ChargeAttrShortcut:
+
+    def getModifiedChargeAttr(self, key, default=0):
+        return_value = self.chargeModifiedAttributes.get(key)
+        return return_value or default
+
+    def getModifiedChargeAttrExtended(self, key, extraMultipliers=None, ignoreAfflictors=(), default=0):
+        return_value = self.chargeModifiedAttributes.getExtended(key, extraMultipliers=extraMultipliers, ignoreAfflictors=ignoreAfflictors)
+        return return_value or default
+
     def getChargeBaseAttrValue(self, key, default=0):
-        """
-        Gets base value in this order:
-        Mutated value > override value > attribute value
-        """
         return_value = self.chargeModifiedAttributes.getOriginal(key)
         return return_value or default
 
 
-class ChargeAttrShortcut(object):
-    def getModifiedChargeAttr(self, key, default=0):
-        return_value = self.chargeModifiedAttributes.get(key)
-
-        return return_value or default
-
-
-class ModifiedAttributeDict(collections.MutableMapping):
+class ModifiedAttributeDict(MutableMapping):
     overrides_enabled = False
 
-    class CalculationPlaceholder(object):
+    class CalculationPlaceholder:
         def __init__(self):
             pass
 
@@ -74,6 +114,10 @@ class ModifiedAttributeDict(collections.MutableMapping):
         # Final modified values
         self.__modified = {}
         # Affected by entities
+        # Format:
+        # {attr name: {modifying fit: (
+        #   modifying item, operation, stacking group, pre-resist amount,
+        #   post-resist amount, affects result or not)}}
         self.__affectedBy = {}
         # Overrides (per item)
         self.__overrides = {}
@@ -144,24 +188,74 @@ class ModifiedAttributeDict(collections.MutableMapping):
 
     def __getitem__(self, key):
         # Check if we have final calculated value
-        key_value = self.__modified.get(key)
-        if key_value is self.CalculationPlaceholder:
-            key_value = self.__modified[key] = self.__calculateValue(key)
-
-        if key_value is not None:
-            return key_value
+        val = self.__modified.get(key)
+        if val is self.CalculationPlaceholder:
+            val = self.__modified[key] = self.__calculateValue(key)
+        if val is not None:
+            return val
 
         # Then in values which are not yet calculated
         if self.__intermediary:
             val = self.__intermediary.get(key)
         else:
             val = None
-
         if val is not None:
             return val
+
+        # Original value is the least priority
+        return self.getOriginal(key)
+
+    def getExtended(self, key, extraMultipliers=None, ignoreAfflictors=None, default=0):
+        """
+        Here we consider couple of parameters. If they affect final result, we do
+        not store result, and if they are - we do.
+        """
+        # Here we do not have support for preAssigns/forceds, as doing them would
+        # mean that we have to store all of them in a list which increases memory use,
+        # and we do not actually need those operators atm
+        preIncreaseAdjustment = 0
+        multiplierAdjustment = 1
+        ignorePenalizedMultipliers = {}
+        postIncreaseAdjustment = 0
+        for fit, afflictors in self.getAfflictions(key).items():
+            for afflictor, operator, stackingGroup, preResAmount, postResAmount, used in afflictors:
+                if afflictor in ignoreAfflictors:
+                    if operator == Operator.MULTIPLY:
+                        if stackingGroup is None:
+                            multiplierAdjustment /= postResAmount
+                        else:
+                            ignorePenalizedMultipliers.setdefault(stackingGroup, []).append(postResAmount)
+                    elif operator == Operator.PREINCREASE:
+                        preIncreaseAdjustment -= postResAmount
+                    elif operator == Operator.POSTINCREASE:
+                        postIncreaseAdjustment -= postResAmount
+
+        # If we apply no customizations - use regular getter
+        if (
+            not extraMultipliers and
+            preIncreaseAdjustment == 0 and multiplierAdjustment == 1 and
+            postIncreaseAdjustment == 0 and len(ignorePenalizedMultipliers) == 0
+        ):
+            return self.get(key, default=default)
+
+        # Try to calculate custom values
+        val = self.__calculateValue(
+            key, extraMultipliers=extraMultipliers, preIncAdj=preIncreaseAdjustment, multAdj=multiplierAdjustment,
+            postIncAdj=postIncreaseAdjustment, ignorePenMult=ignorePenalizedMultipliers)
+        if val is not None:
+            return val
+
+        # Then the same fallbacks as in regular getter
+        if self.__intermediary:
+            val = self.__intermediary.get(key)
         else:
-            # Original value is the least priority
-            return self.getOriginal(key)
+            val = None
+        if val is not None:
+            return val
+        val = self.getOriginal(key)
+        if val is not None:
+            return val
+        return default
 
     def __delitem__(self, key):
         if key in self.__modified:
@@ -181,6 +275,9 @@ class ModifiedAttributeDict(collections.MutableMapping):
             if self.original:
                 val = self.original.get(key, val)
 
+        if val is None:
+            val = getAttrDefault(key, fallback=None)
+
         if val is None and val != default:
             val = default
 
@@ -208,7 +305,7 @@ class ModifiedAttributeDict(collections.MutableMapping):
         keys.update(iter(self.__intermediary.keys()))
         return len(keys)
 
-    def __calculateValue(self, key):
+    def __calculateValue(self, key, extraMultipliers=None, preIncAdj=None, multAdj=None, postIncAdj=None, ignorePenMult=None):
         # It's possible that various attributes are capped by other attributes,
         # it's defined by reference maxAttributeID
         try:
@@ -245,29 +342,52 @@ class ModifiedAttributeDict(collections.MutableMapping):
         preIncrease = self.__preIncreases.get(key, 0)
         multiplier = self.__multipliers.get(key, 1)
         penalizedMultiplierGroups = self.__penalizedMultipliers.get(key, {})
+        # Add extra multipliers to the group, not modifying initial data source
+        if extraMultipliers is not None:
+            penalizedMultiplierGroups = copy(penalizedMultiplierGroups)
+            for stackGroup, operationsData in extraMultipliers.items():
+                multipliers = []
+                for mult, resAttrID in operationsData:
+                    if not resAttrID:
+                        multipliers.append(mult)
+                        continue
+                    resAttrInfo = getAttributeInfo(resAttrID)
+                    if not resAttrInfo:
+                        multipliers.append(mult)
+                        continue
+                    resMult = self.fit.ship.itemModifiedAttributes[resAttrInfo.attributeName]
+                    if resMult is None or resMult == 1:
+                        multipliers.append(mult)
+                        continue
+                    mult = (mult - 1) * resMult + 1
+                    multipliers.append(mult)
+                penalizedMultiplierGroups[stackGroup] = penalizedMultiplierGroups.get(stackGroup, []) + multipliers
         postIncrease = self.__postIncreases.get(key, 0)
 
         # Grab initial value, priorities are:
         # Results of ongoing calculation > preAssign > original > 0
-        try:
-            default = defaultValuesCache[key]
-        except KeyError:
-            attrInfo = getAttributeInfo(key)
-            if attrInfo is None:
-                default = defaultValuesCache[key] = 0.0
-            else:
-                dv = attrInfo.defaultValue
-                default = defaultValuesCache[key] = dv if dv is not None else 0.0
-
+        default = getAttrDefault(key, fallback=0.0)
         val = self.__intermediary.get(key, self.__preAssigns.get(key, self.getOriginal(key, default)))
 
         # We'll do stuff in the following order:
         # preIncrease > multiplier > stacking penalized multipliers > postIncrease
         val += preIncrease
+        if preIncAdj is not None:
+            val += preIncAdj
         val *= multiplier
+        if multAdj is not None:
+            val *= multAdj
         # Each group is penalized independently
         # Things in different groups will not be stack penalized between each other
-        for penalizedMultipliers in penalizedMultiplierGroups.values():
+        for penaltyGroup, penalizedMultipliers in penalizedMultiplierGroups.items():
+            if ignorePenMult is not None and penaltyGroup in ignorePenMult:
+                # Avoid modifying source and remove multipliers we were asked to remove for this calc
+                penalizedMultipliers = penalizedMultipliers[:]
+                for ignoreMult in ignorePenMult[penaltyGroup]:
+                    try:
+                        penalizedMultipliers.remove(ignoreMult)
+                    except ValueError:
+                        pass
             # A quick explanation of how this works:
             # 1: Bonuses and penalties are calculated seperately, so we'll have to filter each of them
             l1 = [_val for _val in penalizedMultipliers if _val > 1]
@@ -285,6 +405,8 @@ class ModifiedAttributeDict(collections.MutableMapping):
                     bonus = l[i]
                     val *= 1 + (bonus - 1) * exp(- i ** 2 / 7.1289)
         val += postIncrease
+        if postIncAdj is not None:
+            val += postIncAdj
 
         # Cap value if we have cap defined
         if cappingValue is not None:
@@ -311,7 +433,7 @@ class ModifiedAttributeDict(collections.MutableMapping):
     def iterAfflictions(self):
         return self.__affectedBy.__iter__()
 
-    def __afflict(self, attributeName, operation, bonus, used=True):
+    def __afflict(self, attributeName, operator, stackingGroup, preResAmount, postResAmount, used=True):
         """Add modifier to list of things affecting current item"""
         # Do nothing if no fit is assigned
         fit = self.fit
@@ -337,13 +459,13 @@ class ModifiedAttributeDict(collections.MutableMapping):
             modifier = fit.getModifier()
 
         # Add current affliction to list
-        affs.append((modifier, operation, bonus, used))
+        affs.append((modifier, operator, stackingGroup, preResAmount, postResAmount, used))
 
-    def preAssign(self, attributeName, value):
+    def preAssign(self, attributeName, value, **kwargs):
         """Overwrites original value of the entity with given one, allowing further modification"""
         self.__preAssigns[attributeName] = value
         self.__placehold(attributeName)
-        self.__afflict(attributeName, "=", value, value != self.getOriginal(attributeName))
+        self.__afflict(attributeName, Operator.PREASSIGN, None, value, value, value != self.getOriginal(attributeName))
 
     def increase(self, attributeName, increase, position="pre", skill=None, **kwargs):
         """Increase value of given attribute by given number"""
@@ -356,8 +478,10 @@ class ModifiedAttributeDict(collections.MutableMapping):
         # Increases applied before multiplications and after them are
         # written in separate maps
         if position == "pre":
+            operator = Operator.PREINCREASE
             tbl = self.__preIncreases
         elif position == "post":
+            operator = Operator.POSTINCREASE
             tbl = self.__postIncreases
         else:
             raise ValueError("position should be either pre or post")
@@ -365,9 +489,9 @@ class ModifiedAttributeDict(collections.MutableMapping):
             tbl[attributeName] = 0
         tbl[attributeName] += increase
         self.__placehold(attributeName)
-        self.__afflict(attributeName, "+", increase, increase != 0)
+        self.__afflict(attributeName, operator, None, increase, increase, increase != 0)
 
-    def multiply(self, attributeName, multiplier, stackingPenalties=False, penaltyGroup="default", skill=None, resist=True, *args, **kwargs):
+    def multiply(self, attributeName, multiplier, stackingPenalties=False, penaltyGroup="default", skill=None, **kwargs):
         """Multiply value of given attribute by given factor"""
         if multiplier is None:  # See GH issue 397
             return
@@ -375,6 +499,15 @@ class ModifiedAttributeDict(collections.MutableMapping):
         if skill:
             multiplier *= self.__handleSkill(skill)
 
+        preResMultiplier = multiplier
+        resisted = False
+        # Goddammit CCP, make up your mind where you want this information >.< See #1139
+        if 'effect' in kwargs:
+            resistFactor = ModifiedAttributeDict.getResistance(self.fit, kwargs['effect']) or 1
+            if resistFactor != 1:
+                resisted = True
+                multiplier = (multiplier - 1) * resistFactor + 1
+
         # If we're asked to do stacking penalized multiplication, append values
         # to per penalty group lists
         if stackingPenalties:
@@ -395,53 +528,46 @@ class ModifiedAttributeDict(collections.MutableMapping):
         afflictPenal = ""
         if stackingPenalties:
             afflictPenal += "s"
-        if resist:
+        if resisted:
             afflictPenal += "r"
 
-        self.__afflict(attributeName, "%s*" % afflictPenal, multiplier, multiplier != 1)
+        self.__afflict(
+            attributeName, Operator.MULTIPLY, penaltyGroup if stackingPenalties else None,
+            preResMultiplier, multiplier, multiplier != 1)
 
-    def boost(self, attributeName, boostFactor, skill=None, *args, **kwargs):
+    def boost(self, attributeName, boostFactor, skill=None, **kwargs):
         """Boost value by some percentage"""
         if skill:
             boostFactor *= self.__handleSkill(skill)
 
-        resist = None
-
-        # Goddammit CCP, make up your mind where you want this information >.< See #1139
-        if 'effect' in kwargs:
-            resist = ModifiedAttributeDict.getResistance(self.fit, kwargs['effect']) or 1
-            boostFactor *= resist
-
         # We just transform percentage boost into multiplication factor
-        self.multiply(attributeName, 1 + boostFactor / 100.0, resist=(True if resist else False), *args, **kwargs)
+        self.multiply(attributeName, 1 + boostFactor / 100.0, **kwargs)
 
-    def force(self, attributeName, value):
+    def force(self, attributeName, value, **kwargs):
         """Force value to attribute and prohibit any changes to it"""
         self.__forced[attributeName] = value
         self.__placehold(attributeName)
-        self.__afflict(attributeName, "\u2263", value)
+        self.__afflict(attributeName, Operator.FORCE, None, value, value)
 
     @staticmethod
     def getResistance(fit, effect):
-        remoteResistID = effect.resistanceID
-
-        # If it doesn't exist on the effect, check the modifying modules attributes. If it's there, set it on the
-        # effect for this session so that we don't have to look here again (won't always work when it's None, but
-        # will catch most)
+        # Resistances are applicable only to projected effects
+        if isinstance(effect.type, (tuple, list)):
+            effectType = effect.type
+        else:
+            effectType = (effect.type,)
+        if 'projected' not in effectType:
+            return 1
+        remoteResistID = getResistanceAttrID(modifyingItem=fit.getModifier(), effect=effect)
         if not remoteResistID:
-            mod = fit.getModifier()
-            effect.resistanceID = int(mod.getModifiedItemAttr("remoteResistanceID")) or None
-            remoteResistID = effect.resistanceID
-
+            return 1
         attrInfo = getAttributeInfo(remoteResistID)
-
         # Get the attribute of the resist
         resist = fit.ship.itemModifiedAttributes[attrInfo.attributeName] or None
-
-        return resist or 1.0
+        return resist or 1
 
 
-class Affliction(object):
+class Affliction:
     def __init__(self, affliction_type, amount):
         self.type = affliction_type
         self.amount = amount

eos/saveddata/booster.py

@@ -122,7 +122,7 @@ class Booster(HandledItem, ItemAttrShortcut):
                     (effect.isType("passive") or effect.isType("boosterSideEffect")):
                 if effect.isType("boosterSideEffect") and effect not in self.activeSideEffectEffects:
                     continue
-                effect.handler(fit, self, ("booster",))
+                effect.handler(fit, self, ("booster",), None, effect=effect)
 
     @validates("ID", "itemID", "ammoID", "active")
     def validator(self, key, val):

eos/saveddata/boosterSideEffect.py

@@ -24,7 +24,7 @@ from sqlalchemy.orm import reconstructor
 pyfalog = Logger(__name__)
 
 
-class BoosterSideEffect(object):
+class BoosterSideEffect:
 
     def __init__(self, effect):
         """Initialize from the program"""

eos/saveddata/character.py

@@ -32,7 +32,7 @@ from eos.effectHandlerHelpers import HandledItem, HandledImplantList
 pyfalog = Logger(__name__)
 
 
-class Character(object):
+class Character:
     __itemList = None
     __itemIDMap = None
     __itemNameMap = None
@@ -422,7 +422,7 @@ class Skill(HandledItem):
                     (not fit.isStructure or effect.isType("structure")) and \
                     effect.activeByDefault:
                 try:
-                    effect.handler(fit, self, ("skill",))
+                    effect.handler(fit, self, ("skill",), None, effect=effect)
                 except AttributeError:
                     continue
 

eos/saveddata/damagePattern.py

@@ -21,7 +21,7 @@ import re
 import eos.db
 
 
-class DamagePattern(object):
+class DamagePattern:
     DAMAGE_TYPES = ("em", "thermal", "kinetic", "explosive")
 
     def __init__(self, *args, **kwargs):
@@ -78,6 +78,15 @@ class DamagePattern(object):
         "exp"  : "explosive"
     }
 
+    @classmethod
+    def oneType(cls, damageType, amount=100):
+        pattern = DamagePattern()
+        pattern.update(amount if damageType == "em" else 0,
+                       amount if damageType == "thermal" else 0,
+                       amount if damageType == "kinetic" else 0,
+                       amount if damageType == "explosive" else 0)
+        return pattern
+
     @classmethod
     def importPatterns(cls, text):
         lines = re.split('[\n\r]+', text)

eos/saveddata/drone.py

@@ -17,14 +17,17 @@
 # along with eos.  If not, see <http://www.gnu.org/licenses/>.
 # ===============================================================================
 
-from logbook import Logger
+import math
 
-from sqlalchemy.orm import validates, reconstructor
+from logbook import Logger
+from sqlalchemy.orm import reconstructor, validates
 
 import eos.db
-from eos.effectHandlerHelpers import HandledItem, HandledCharge
-from eos.modifiedAttributeDict import ModifiedAttributeDict, ItemAttrShortcut, ChargeAttrShortcut
-from eos.utils.stats import DmgTypes
+from eos.effectHandlerHelpers import HandledCharge, HandledItem
+from eos.modifiedAttributeDict import ChargeAttrShortcut, ItemAttrShortcut, ModifiedAttributeDict
+from eos.utils.cycles import CycleInfo
+from eos.utils.default import DEFAULT
+from eos.utils.stats import DmgTypes, RRTypes
 
 
 pyfalog = Logger(__name__)
@@ -44,6 +47,7 @@ class Drone(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
         self.amount = 0
         self.amountActive = 0
         self.projected = False
+        self.projectionRange = None
         self.build()
 
     @reconstructor
@@ -67,7 +71,7 @@ class Drone(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
         """ Build object. Assumes proper and valid item already set """
         self.__charge = None
         self.__baseVolley = None
-        self.__baseRemoteReps = None
+        self.__baseRRAmount = None
         self.__miningyield = None
         self.__itemModifiedAttributes = ModifiedAttributeDict()
         self.__itemModifiedAttributes.original = self.__item.attributes
@@ -104,7 +108,16 @@ class Drone(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
 
     @property
     def cycleTime(self):
-        return max(self.getModifiedItemAttr("duration", 0), 0)
+        if self.hasAmmo:
+            cycleTime = self.getModifiedItemAttr("missileLaunchDuration", 0)
+        else:
+            for attr in ("speed", "duration"):
+                cycleTime = self.getModifiedItemAttr(attr, None)
+                if cycleTime is not None:
+                    break
+        if cycleTime is None:
+            return 0
+        return max(cycleTime, 0)
 
     @property
     def dealsDamage(self):
@@ -121,9 +134,16 @@ class Drone(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
     def hasAmmo(self):
         return self.charge is not None
 
-    def getVolley(self, targetResists=None):
+    def isDealingDamage(self):
+        volleyParams = self.getVolleyParameters()
+        for volley in volleyParams.values():
+            if volley.total > 0:
+                return True
+        return False
+
+    def getVolleyParameters(self, targetProfile=None):
         if not self.dealsDamage or self.amountActive <= 0:
-            return DmgTypes(0, 0, 0, 0)
+            return {0: DmgTypes(0, 0, 0, 0)}
         if self.__baseVolley is None:
             dmgGetter = self.getModifiedChargeAttr if self.hasAmmo else self.getModifiedItemAttr
             dmgMult = self.amountActive * (self.getModifiedItemAttr("damageMultiplier", 1))
@@ -133,19 +153,23 @@ class Drone(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
                 kinetic=(dmgGetter("kineticDamage", 0)) * dmgMult,
                 explosive=(dmgGetter("explosiveDamage", 0)) * dmgMult)
         volley = DmgTypes(
-            em=self.__baseVolley.em * (1 - getattr(targetResists, "emAmount", 0)),
-            thermal=self.__baseVolley.thermal * (1 - getattr(targetResists, "thermalAmount", 0)),
-            kinetic=self.__baseVolley.kinetic * (1 - getattr(targetResists, "kineticAmount", 0)),
-            explosive=self.__baseVolley.explosive * (1 - getattr(targetResists, "explosiveAmount", 0)))
-        return volley
+            em=self.__baseVolley.em * (1 - getattr(targetProfile, "emAmount", 0)),
+            thermal=self.__baseVolley.thermal * (1 - getattr(targetProfile, "thermalAmount", 0)),
+            kinetic=self.__baseVolley.kinetic * (1 - getattr(targetProfile, "kineticAmount", 0)),
+            explosive=self.__baseVolley.explosive * (1 - getattr(targetProfile, "explosiveAmount", 0)))
+        return {0: volley}
 
-    def getDps(self, targetResists=None):
-        volley = self.getVolley(targetResists=targetResists)
+    def getVolley(self, targetProfile=None):
+        return self.getVolleyParameters(targetProfile=targetProfile)[0]
+
+    def getDps(self, targetProfile=None):
+        volley = self.getVolley(targetProfile=targetProfile)
         if not volley:
             return DmgTypes(0, 0, 0, 0)
-        cycleAttr = "missileLaunchDuration" if self.hasAmmo else "speed"
-        cycleTime = self.getModifiedItemAttr(cycleAttr)
-        dpsFactor = 1 / (cycleTime / 1000)
+        cycleParams = self.getCycleParameters()
+        if cycleParams is None:
+            return DmgTypes(0, 0, 0, 0)
+        dpsFactor = 1 / (cycleParams.averageTime / 1000)
         dps = DmgTypes(
             em=volley.em * dpsFactor,
             thermal=volley.thermal * dpsFactor,
@@ -153,41 +177,65 @@ class Drone(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
             explosive=volley.explosive * dpsFactor)
         return dps
 
+    def isRemoteRepping(self, ignoreState=False):
+        repParams = self.getRepAmountParameters(ignoreState=ignoreState)
+        for rrData in repParams.values():
+            if rrData:
+                return True
+        return False
+
+    def getRepAmountParameters(self, ignoreState=False):
+        amount = self.amount if ignoreState else self.amountActive
+        if amount <= 0:
+            return {}
+        if self.__baseRRAmount is None:
+            self.__baseRRAmount = {}
+            hullAmount = self.getModifiedItemAttr("structureDamageAmount", 0)
+            armorAmount = self.getModifiedItemAttr("armorDamageAmount", 0)
+            shieldAmount = self.getModifiedItemAttr("shieldBonus", 0)
+            if shieldAmount:
+                self.__baseRRAmount[0] = RRTypes(
+                    shield=shieldAmount * amount,
+                    armor=0, hull=0, capacitor=0)
+            if armorAmount or hullAmount:
+                self.__baseRRAmount[self.cycleTime] = RRTypes(
+                    shield=0, armor=armorAmount * amount,
+                    hull=hullAmount * amount, capacitor=0)
+        return self.__baseRRAmount
+
     def getRemoteReps(self, ignoreState=False):
-        if self.amountActive <= 0 and not ignoreState:
-            return (None, 0)
-        if self.__baseRemoteReps is None:
-            rrShield = self.getModifiedItemAttr("shieldBonus", 0)
-            rrArmor = self.getModifiedItemAttr("armorDamageAmount", 0)
-            rrHull = self.getModifiedItemAttr("structureDamageAmount", 0)
-            if rrShield:
-                rrType = "Shield"
-                rrAmount = rrShield
-            elif rrArmor:
-                rrType = "Armor"
-                rrAmount = rrArmor
-            elif rrHull:
-                rrType = "Hull"
-                rrAmount = rrHull
-            else:
-                rrType = None
-                rrAmount = 0
-            if rrAmount:
-                droneAmount = self.amount if ignoreState else self.amountActive
-                rrAmount *= droneAmount / (self.cycleTime / 1000)
-            self.__baseRemoteReps = (rrType, rrAmount)
-        return self.__baseRemoteReps
+        rrDuringCycle = RRTypes(0, 0, 0, 0)
+        cycleParams = self.getCycleParameters()
+        if cycleParams is None:
+            return rrDuringCycle
+        repAmountParams = self.getRepAmountParameters(ignoreState=ignoreState)
+        avgCycleTime = cycleParams.averageTime
+        if len(repAmountParams) == 0 or avgCycleTime == 0:
+            return rrDuringCycle
+        for rrAmount in repAmountParams.values():
+            rrDuringCycle += rrAmount
+        rrFactor = 1 / (avgCycleTime / 1000)
+        rrDuringCycle *= rrFactor
+        return rrDuringCycle
+
+    def getCycleParameters(self, reloadOverride=None):
+        cycleTime = self.cycleTime
+        if cycleTime == 0:
+            return None
+        return CycleInfo(self.cycleTime, 0, math.inf, False)
 
     @property
     def miningStats(self):
         if self.__miningyield is None:
             if self.mines is True and self.amountActive > 0:
-                attr = "duration"
                 getter = self.getModifiedItemAttr
-
-                cycleTime = self.getModifiedItemAttr(attr)
-                volley = sum([getter(d) for d in self.MINING_ATTRIBUTES]) * self.amountActive
-                self.__miningyield = volley / (cycleTime / 1000.0)
+                cycleParams = self.getCycleParameters()
+                if cycleParams is None:
+                    self.__miningyield = 0
+                else:
+                    cycleTime = cycleParams.averageTime
+                    volley = sum([getter(d) for d in self.MINING_ATTRIBUTES]) * self.amountActive
+                    self.__miningyield = volley / (cycleTime / 1000.0)
             else:
                 self.__miningyield = 0
 
@@ -236,7 +284,7 @@ class Drone(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
 
     def clear(self):
         self.__baseVolley = None
-        self.__baseRemoteReps = None
+        self.__baseRRAmount = None
         self.__miningyield = None
         self.itemModifiedAttributes.clear()
         self.chargeModifiedAttributes.clear()
@@ -259,7 +307,7 @@ class Drone(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
         else:
             return True
 
-    def calculateModifiedAttributes(self, fit, runTime, forceProjected=False):
+    def calculateModifiedAttributes(self, fit, runTime, forceProjected=False, forcedProjRange=DEFAULT):
         if self.projected or forceProjected:
             context = "projected", "drone"
             projected = True
@@ -267,6 +315,8 @@ class Drone(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
             context = ("drone",)
             projected = False
 
+        projectionRange = self.projectionRange if forcedProjRange is DEFAULT else forcedProjRange
+
         for effect in self.item.effects.values():
             if effect.runTime == runTime and \
                     effect.activeByDefault and \
@@ -274,30 +324,34 @@ class Drone(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
                                  projected is False and effect.isType("passive")):
                 # See GH issue #765
                 if effect.getattr('grouped'):
-                    effect.handler(fit, self, context)
+                    effect.handler(fit, self, context, projectionRange, effect=effect)
                 else:
                     i = 0
                     while i != self.amountActive:
-                        effect.handler(fit, self, context)
+                        effect.handler(fit, self, context, projectionRange, effect=effect)
                         i += 1
 
         if self.charge:
             for effect in self.charge.effects.values():
                 if effect.runTime == runTime and effect.activeByDefault:
-                    effect.handler(fit, self, ("droneCharge",))
+                    effect.handler(fit, self, ("droneCharge",), projectionRange, effect=effect)
 
     def __deepcopy__(self, memo):
         copy = Drone(self.item)
         copy.amount = self.amount
         copy.amountActive = self.amountActive
+        copy.projectionRange = self.projectionRange
         return copy
 
     def rebase(self, item):
         amount = self.amount
         amountActive = self.amountActive
+        projectionRange = self.projectionRange
+
         Drone.__init__(self, item)
         self.amount = amount
         self.amountActive = amountActive
+        self.projectionRange = projectionRange
 
     def fits(self, fit):
         fitDroneGroupLimits = set()

eos/saveddata/fighter.py

@@ -17,16 +17,21 @@
 # along with eos.  If not, see <http://www.gnu.org/licenses/>.
 # ===============================================================================
 
-from logbook import Logger
+import math
 
-from sqlalchemy.orm import validates, reconstructor
+from logbook import Logger
+from sqlalchemy.orm import reconstructor, validates
 
 import eos.db
-from eos.effectHandlerHelpers import HandledItem, HandledCharge
-from eos.modifiedAttributeDict import ModifiedAttributeDict, ItemAttrShortcut, ChargeAttrShortcut
-from eos.saveddata.fighterAbility import FighterAbility
-from eos.utils.stats import DmgTypes
 from eos.const import FittingSlot
+from eos.effectHandlerHelpers import HandledCharge, HandledItem
+from eos.modifiedAttributeDict import ChargeAttrShortcut, ItemAttrShortcut, ModifiedAttributeDict
+from eos.saveddata.fighterAbility import FighterAbility
+from eos.utils.cycles import CycleInfo, CycleSequence
+from eos.utils.default import DEFAULT
+from eos.utils.float import floatUnerr
+from eos.utils.stats import DmgTypes
+
 
 pyfalog = Logger(__name__)
 
@@ -44,11 +49,12 @@ class Fighter(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
 
         self.itemID = item.ID if item is not None else None
         self.projected = False
+        self.projectionRange = None
         self.active = True
 
         # -1 is a placeholder that represents max squadron size, which we may not know yet as ships may modify this with
         # their effects. If user changes this, it is then overridden with user value.
-        self.amount = -1
+        self._amount = -1
 
         self.__abilities = self.__getAbilities()
 
@@ -133,12 +139,15 @@ class Fighter(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
         return self.__slot
 
     @property
-    def amountActive(self):
-        return int(self.getModifiedItemAttr("fighterSquadronMaxSize")) if self.amount == -1 else self.amount
+    def amount(self):
+        return int(self.getModifiedItemAttr("fighterSquadronMaxSize")) if self._amount == -1 else self._amount
 
-    @amountActive.setter
-    def amountActive(self, i):
-        self.amount = int(max(min(i, self.getModifiedItemAttr("fighterSquadronMaxSize")), 0))
+    @amount.setter
+    def amount(self, amount):
+        amount = max(0, int(amount))
+        if amount >= self.getModifiedItemAttr("fighterSquadronMaxSize"):
+            amount = -1
+        self._amount = amount
 
     @property
     def fighterSquadronMaxSize(self):
@@ -172,79 +181,143 @@ class Fighter(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
     def hasAmmo(self):
         return self.charge is not None
 
-    def getVolley(self, targetResists=None):
-        if not self.active or self.amountActive <= 0:
-            return DmgTypes(0, 0, 0, 0)
+    def isDealingDamage(self):
+        volleyParams = self.getVolleyParametersPerEffect()
+        for effectData in volleyParams.values():
+            for volley in effectData.values():
+                if volley.total > 0:
+                    return True
+        return False
+
+    def getVolleyParametersPerEffect(self, targetProfile=None):
+        if not self.active or self.amount <= 0:
+            return {}
         if self.__baseVolley is None:
-            em = 0
-            therm = 0
-            kin = 0
-            exp = 0
+            self.__baseVolley = {}
             for ability in self.abilities:
                 # Not passing resists here as we want to calculate and store base volley
-                abilityVolley = ability.getVolley()
-                em += abilityVolley.em
-                therm += abilityVolley.thermal
-                kin += abilityVolley.kinetic
-                exp += abilityVolley.explosive
-            self.__baseVolley = DmgTypes(em, therm, kin, exp)
-        volley = DmgTypes(
-            em=self.__baseVolley.em * (1 - getattr(targetResists, "emAmount", 0)),
-            thermal=self.__baseVolley.thermal * (1 - getattr(targetResists, "thermalAmount", 0)),
-            kinetic=self.__baseVolley.kinetic * (1 - getattr(targetResists, "kineticAmount", 0)),
-            explosive=self.__baseVolley.explosive * (1 - getattr(targetResists, "explosiveAmount", 0)))
-        return volley
+                self.__baseVolley[ability.effectID] = {0: ability.getVolley()}
+        adjustedVolley = {}
+        for effectID, effectData in self.__baseVolley.items():
+            adjustedVolley[effectID] = {}
+            for volleyTime, volleyValue in effectData.items():
+                adjustedVolley[effectID][volleyTime] = DmgTypes(
+                    em=volleyValue.em * (1 - getattr(targetProfile, "emAmount", 0)),
+                    thermal=volleyValue.thermal * (1 - getattr(targetProfile, "thermalAmount", 0)),
+                    kinetic=volleyValue.kinetic * (1 - getattr(targetProfile, "kineticAmount", 0)),
+                    explosive=volleyValue.explosive * (1 - getattr(targetProfile, "explosiveAmount", 0)))
+        return adjustedVolley
 
-    def getDps(self, targetResists=None):
+    def getVolleyPerEffect(self, targetProfile=None):
+        volleyParams = self.getVolleyParametersPerEffect(targetProfile=targetProfile)
+        volleyMap = {}
+        for effectID, volleyData in volleyParams.items():
+            volleyMap[effectID] = volleyData[0]
+        return volleyMap
+
+    def getVolley(self, targetProfile=None):
+        volleyParams = self.getVolleyParametersPerEffect(targetProfile=targetProfile)
+        em = 0
+        therm = 0
+        kin = 0
+        exp = 0
+        for volleyData in volleyParams.values():
+            em += volleyData[0].em
+            therm += volleyData[0].thermal
+            kin += volleyData[0].kinetic
+            exp += volleyData[0].explosive
+        return DmgTypes(em, therm, kin, exp)
+
+    def getDps(self, targetProfile=None):
         em = 0
         thermal = 0
         kinetic = 0
         explosive = 0
-        for dps in self.getDpsPerEffect(targetResists=targetResists).values():
+        for dps in self.getDpsPerEffect(targetProfile=targetProfile).values():
             em += dps.em
             thermal += dps.thermal
             kinetic += dps.kinetic
             explosive += dps.explosive
         return DmgTypes(em=em, thermal=thermal, kinetic=kinetic, explosive=explosive)
 
-    def getUptime(self):
-        if not self.owner.factorReload:
-            return 1
-        activeTimes = []
-        reloadTimes = []
-        for ability in self.abilities:
-            if ability.numShots > 0:
-                activeTimes.append(ability.numShots * ability.cycleTime)
-                reloadTimes.append(ability.reloadTime)
-        if not activeTimes:
-            return 1
-        shortestActive = sorted(activeTimes)[0]
-        longestReload = sorted(reloadTimes, reverse=True)[0]
-        uptime = shortestActive / (shortestActive + longestReload)
-        return uptime
-
-    def getDpsPerEffect(self, targetResists=None):
-        if not self.active or self.amountActive <= 0:
+    def getDpsPerEffect(self, targetProfile=None):
+        if not self.active or self.amount <= 0:
             return {}
-        uptime = self.getUptime()
-        if uptime == 1:
-            return {a.effectID: a.getDps(targetResists=targetResists) for a in self.abilities}
-        # Decide if it's better to keep steady dps up and never reload or reload from time to time
-        dpsMapSteady = {}
-        dpsMapPeakAdjusted = {}
+        cycleParams = self.getCycleParametersPerEffectOptimizedDps(targetProfile=targetProfile)
+        dpsMap = {}
         for ability in self.abilities:
-            abilityDps = ability.getDps(targetResists=targetResists)
-            dpsMapPeakAdjusted[ability.effectID] = DmgTypes(
-                em=abilityDps.em * uptime,
-                thermal=abilityDps.thermal * uptime,
-                kinetic=abilityDps.kinetic * uptime,
-                explosive=abilityDps.explosive * uptime)
-            # Infinite use - add to steady dps
-            if ability.numShots == 0:
-                dpsMapSteady[ability.effectID] = abilityDps
-        totalSteady = sum(i.total for i in dpsMapSteady.values())
-        totalPeakAdjusted = sum(i.total for i in dpsMapPeakAdjusted.values())
-        return dpsMapSteady if totalSteady >= totalPeakAdjusted else dpsMapPeakAdjusted
+            if ability.effectID in cycleParams:
+                cycleTime = cycleParams[ability.effectID].averageTime
+                dpsMap[ability.effectID] = ability.getDps(targetProfile=targetProfile, cycleTimeOverride=cycleTime)
+        return dpsMap
+
+    def getCycleParametersPerEffectOptimizedDps(self, targetProfile=None, reloadOverride=None):
+        cycleParamsInfinite = self.getCycleParametersPerEffectInfinite()
+        cycleParamsReload = self.getCycleParametersPerEffect(reloadOverride=reloadOverride)
+        dpsMapOnlyInfinite = {}
+        dpsMapAllWithReloads = {}
+        # Decide if it's better to keep steady dps up and never reload or reload from time to time
+        for ability in self.abilities:
+            if ability.effectID in cycleParamsInfinite:
+                cycleTime = cycleParamsInfinite[ability.effectID].averageTime
+                dpsMapOnlyInfinite[ability.effectID] = ability.getDps(targetProfile=targetProfile, cycleTimeOverride=cycleTime)
+            if ability.effectID in cycleParamsReload:
+                cycleTime = cycleParamsReload[ability.effectID].averageTime
+                dpsMapAllWithReloads[ability.effectID] = ability.getDps(targetProfile=targetProfile, cycleTimeOverride=cycleTime)
+        totalOnlyInfinite = sum(i.total for i in dpsMapOnlyInfinite.values())
+        totalAllWithReloads = sum(i.total for i in dpsMapAllWithReloads.values())
+        return cycleParamsInfinite if totalOnlyInfinite >= totalAllWithReloads else cycleParamsReload
+
+    def getCycleParametersPerEffectInfinite(self):
+        return {
+            a.effectID: CycleInfo(a.cycleTime, 0, math.inf, False)
+            for a in self.abilities
+            if a.numShots == 0 and a.cycleTime > 0}
+
+    def getCycleParametersPerEffect(self, reloadOverride=None):
+        factorReload = reloadOverride if reloadOverride is not None else self.owner.factorReload
+        # Assume it can cycle infinitely
+        if not factorReload:
+            return {a.effectID: CycleInfo(a.cycleTime, 0, math.inf, False) for a in self.abilities if a.cycleTime > 0}
+        limitedAbilities = [a for a in self.abilities if a.numShots > 0 and a.cycleTime > 0]
+        if len(limitedAbilities) == 0:
+            return {a.effectID: CycleInfo(a.cycleTime, 0, math.inf, False) for a in self.abilities if a.cycleTime > 0}
+        validAbilities = [a for a in self.abilities if a.cycleTime > 0]
+        if len(validAbilities) == 0:
+            return {}
+        mostLimitedAbility = min(limitedAbilities, key=lambda a: a.cycleTime * a.numShots)
+        durationToRefuel = mostLimitedAbility.cycleTime * mostLimitedAbility.numShots
+        # find out how many shots various abilities will do until reload, and how much time
+        # "extra" cycle will last (None for no extra cycle)
+        cyclesUntilRefuel = {mostLimitedAbility.effectID: (mostLimitedAbility.numShots, None)}
+        for ability in (a for a in validAbilities if a is not mostLimitedAbility):
+            fullCycles = int(floatUnerr(durationToRefuel / ability.cycleTime))
+            extraShotTime = floatUnerr(durationToRefuel - (fullCycles * ability.cycleTime))
+            if extraShotTime == 0:
+                extraShotTime = None
+            cyclesUntilRefuel[ability.effectID] = (fullCycles, extraShotTime)
+        refuelTimes = {}
+        for ability in validAbilities:
+            spentShots, extraShotTime = cyclesUntilRefuel[ability.effectID]
+            if extraShotTime is not None:
+                spentShots += 1
+            refuelTimes[ability.effectID] = ability.getReloadTime(spentShots)
+        refuelTime = max(refuelTimes.values())
+        cycleParams = {}
+        for ability in validAbilities:
+            regularShots, extraShotTime = cyclesUntilRefuel[ability.effectID]
+            sequence = []
+            if extraShotTime is not None:
+                if regularShots > 0:
+                    sequence.append(CycleInfo(ability.cycleTime, 0, regularShots, False))
+                sequence.append(CycleInfo(extraShotTime, refuelTime, 1, True))
+            else:
+                regularShotsNonReload = regularShots - 1
+                if regularShotsNonReload > 0:
+                    sequence.append(CycleInfo(ability.cycleTime, 0, regularShotsNonReload, False))
+                sequence.append(CycleInfo(ability.cycleTime, refuelTime, 1, True))
+            cycleParams[ability.effectID] = CycleSequence(sequence, math.inf)
+        return cycleParams
 
     @property
     def maxRange(self):
@@ -272,7 +345,7 @@ class Fighter(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
             if falloff is not None:
                 return falloff
 
-    @validates("ID", "itemID", "chargeID", "amount", "amountActive")
+    @validates("ID", "itemID", "chargeID", "amount")
     def validator(self, key, val):
         map = {
             "ID"      : lambda _val: isinstance(_val, int),
@@ -280,7 +353,6 @@ class Fighter(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
             "chargeID": lambda _val: isinstance(_val, int),
             "amount"  : lambda _val: isinstance(_val, int) and _val >= -1,
         }
-
         if not map[key](val):
             raise ValueError(str(val) + " is not a valid value for " + key)
         else:
@@ -311,7 +383,7 @@ class Fighter(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
         else:
             return True
 
-    def calculateModifiedAttributes(self, fit, runTime, forceProjected=False):
+    def calculateModifiedAttributes(self, fit, runTime, forceProjected=False, forcedProjRange=DEFAULT):
         if not self.active:
             return
 
@@ -322,6 +394,8 @@ class Fighter(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
             context = ("fighter",)
             projected = False
 
+        projectionRange = self.projectionRange if forcedProjRange is DEFAULT else forcedProjRange
+
         for ability in self.abilities:
             if not ability.active:
                 continue
@@ -330,32 +404,36 @@ class Fighter(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
             if effect.runTime == runTime and effect.activeByDefault and \
                     ((projected and effect.isType("projected")) or not projected):
                 if ability.grouped:
-                    effect.handler(fit, self, context)
+                    effect.handler(fit, self, context, projectionRange, effect=effect)
                 else:
                     i = 0
-                    while i != self.amountActive:
-                        effect.handler(fit, self, context)
+                    while i != self.amount:
+                        effect.handler(fit, self, context, projectionRange, effect=effect)
                         i += 1
 
     def __deepcopy__(self, memo):
         copy = Fighter(self.item)
-        copy.amount = self.amount
+        copy._amount = self._amount
         copy.active = self.active
         for ability in self.abilities:
             copyAbility = next(filter(lambda a: a.effectID == ability.effectID, copy.abilities))
             copyAbility.active = ability.active
+        copy.projectionRange = self.projectionRange
         return copy
 
     def rebase(self, item):
-        amount = self.amount
+        amount = self._amount
         active = self.active
         abilityEffectStates = {a.effectID: a.active for a in self.abilities}
+        projectionRange = self.projectionRange
+
         Fighter.__init__(self, item)
-        self.amount = amount
+        self._amount = amount
         self.active = active
         for ability in self.abilities:
             if ability.effectID in abilityEffectStates:
                 ability.active = abilityEffectStates[ability.effectID]
+        self.projectionRange = projectionRange
 
     def fits(self, fit):
         # If ships doesn't support this type of fighter, don't add it

eos/saveddata/fighterAbility.py

@@ -26,7 +26,7 @@ from eos.utils.stats import DmgTypes
 pyfalog = Logger(__name__)
 
 
-class FighterAbility(object):
+class FighterAbility:
 
     # We aren't able to get data on the charges that can be stored with fighters. So we hardcode that data here, keyed
     # with the fighter squadron role
@@ -95,8 +95,15 @@ class FighterAbility(object):
 
     @property
     def reloadTime(self):
+        return self.getReloadTime()
+
+    def getReloadTime(self, spentShots=None):
+        if spentShots is not None:
+            spentShots = max(self.numShots, spentShots)
+        else:
+            spentShots = self.numShots
         rearm_time = (self.REARM_TIME_MAPPING[self.fighter.getModifiedItemAttr("fighterSquadronRole")] or 0 if self.hasCharges else 0)
-        return self.fighter.getModifiedItemAttr("fighterRefuelingTime") + rearm_time * self.numShots
+        return self.fighter.getModifiedItemAttr("fighterRefuelingTime") + rearm_time * spentShots
 
     @property
     def numShots(self):
@@ -107,7 +114,7 @@ class FighterAbility(object):
         speed = self.fighter.getModifiedItemAttr("{}Duration".format(self.attrPrefix))
         return speed
 
-    def getVolley(self, targetResists=None):
+    def getVolley(self, targetProfile=None):
         if not self.dealsDamage or not self.active:
             return DmgTypes(0, 0, 0, 0)
         if self.attrPrefix == "fighterAbilityLaunchBomb":
@@ -120,19 +127,20 @@ class FighterAbility(object):
             therm = self.fighter.getModifiedItemAttr("{}DamageTherm".format(self.attrPrefix), 0)
             kin = self.fighter.getModifiedItemAttr("{}DamageKin".format(self.attrPrefix), 0)
             exp = self.fighter.getModifiedItemAttr("{}DamageExp".format(self.attrPrefix), 0)
-        dmgMult = self.fighter.amountActive * self.fighter.getModifiedItemAttr("{}DamageMultiplier".format(self.attrPrefix), 1)
+        dmgMult = self.fighter.amount * self.fighter.getModifiedItemAttr("{}DamageMultiplier".format(self.attrPrefix), 1)
         volley = DmgTypes(
-            em=em * dmgMult * (1 - getattr(targetResists, "emAmount", 0)),
-            thermal=therm * dmgMult * (1 - getattr(targetResists, "thermalAmount", 0)),
-            kinetic=kin * dmgMult * (1 - getattr(targetResists, "kineticAmount", 0)),
-            explosive=exp * dmgMult * (1 - getattr(targetResists, "explosiveAmount", 0)))
+            em=em * dmgMult * (1 - getattr(targetProfile, "emAmount", 0)),
+            thermal=therm * dmgMult * (1 - getattr(targetProfile, "thermalAmount", 0)),
+            kinetic=kin * dmgMult * (1 - getattr(targetProfile, "kineticAmount", 0)),
+            explosive=exp * dmgMult * (1 - getattr(targetProfile, "explosiveAmount", 0)))
         return volley
 
-    def getDps(self, targetResists=None):
-        volley = self.getVolley(targetResists=targetResists)
+    def getDps(self, targetProfile=None, cycleTimeOverride=None):
+        volley = self.getVolley(targetProfile=targetProfile)
         if not volley:
             return DmgTypes(0, 0, 0, 0)
-        dpsFactor = 1 / (self.cycleTime / 1000)
+        cycleTime = cycleTimeOverride if cycleTimeOverride is not None else self.cycleTime
+        dpsFactor = 1 / (cycleTime / 1000)
         dps = DmgTypes(
             em=volley.em * dpsFactor,
             thermal=volley.thermal * dpsFactor,
@@ -141,5 +149,4 @@ class FighterAbility(object):
         return dps
 
     def clear(self):
-        self.__dps = None
-        self.__volley = None
+        pass

eos/saveddata/fit.py

@@ -21,13 +21,14 @@ import datetime
 import time
 from copy import deepcopy
 from itertools import chain
+from math import log, sqrt
 
 from logbook import Logger
-from math import asinh, log, sqrt
 from sqlalchemy.orm import reconstructor, validates
 
 import eos.db
 from eos import capSim
+from eos.calc import calculateMultiplier, calculateLockTime
 from eos.const import CalcType, FitSystemSecurity, FittingHardpoint, FittingModuleState, FittingSlot, ImplantLocation
 from eos.effectHandlerHelpers import (
     HandledBoosterList, HandledDroneCargoList, HandledImplantList,
@@ -36,13 +37,26 @@ from eos.saveddata.character import Character
 from eos.saveddata.citadel import Citadel
 from eos.saveddata.module import Module
 from eos.saveddata.ship import Ship
-from eos.utils.stats import DmgTypes
+from eos.utils.stats import DmgTypes, RRTypes
 
 
 pyfalog = Logger(__name__)
 
 
-class Fit(object):
+class FitLite:
+
+    def __init__(self, id=None, name=None, shipID=None, shipName=None, shipNameShort=None):
+        self.ID = id
+        self.name = name
+        self.shipID = shipID
+        self.shipName = shipName
+        self.shipNameShort = shipNameShort
+
+    def __repr__(self):
+        return 'FitLite(ID={})'.format(self.ID)
+
+
+class Fit:
     """Represents a fitting, with modules, ship, implants, etc."""
 
     PEAK_RECHARGE = 0.25
@@ -130,6 +144,7 @@ class Fit(object):
         self.__capState = None
         self.__capUsed = None
         self.__capRecharge = None
+        self.__savedCapSimData = {}
         self.__calculatedTargets = []
         self.factorReload = False
         self.boostsFits = set()
@@ -137,13 +152,25 @@ class Fit(object):
         self.ecmProjectedStr = 1
         self.commandBonuses = {}
 
-    @property
-    def targetResists(self):
-        return self.__targetResists
+    def clearFactorReloadDependentData(self):
+        # Here we clear all data known to rely on cycle parameters
+        # (which, in turn, relies on factor reload flag)
+        self.__weaponDpsMap.clear()
+        self.__droneDps = None
+        self.__remoteRepMap.clear()
+        self.__capStable = None
+        self.__capState = None
+        self.__capUsed = None
+        self.__capRecharge = None
+        self.__savedCapSimData.clear()
 
-    @targetResists.setter
-    def targetResists(self, targetResists):
-        self.__targetResists = targetResists
+    @property
+    def targetProfile(self):
+        return self.__targetProfile
+
+    @targetProfile.setter
+    def targetProfile(self, targetProfile):
+        self.__targetProfile = targetProfile
         self.__weaponDpsMap = {}
         self.__weaponVolleyMap = {}
         self.__droneDps = None
@@ -414,10 +441,8 @@ class Fit(object):
             return False
 
         # Citadel modules are now under a new category, so we can check this to ensure only structure modules can fit on a citadel
-        if isinstance(self.ship, Citadel) and item.category.name != "Structure Module" or \
-                not isinstance(self.ship, Citadel) and item.category.name == "Structure Module":
+        if isinstance(self.ship, Citadel) is not item.isStandup:
             return False
-
         return True
 
     def clear(self, projected=False, command=False):
@@ -437,6 +462,7 @@ class Fit(object):
         self.__capState = None
         self.__capUsed = None
         self.__capRecharge = None
+        self.__savedCapSimData.clear()
         self.ecmProjectedStr = 1
         # self.commandBonuses = {}
 
@@ -907,13 +933,20 @@ class Fit(object):
         To support a simpler way of doing self projections (so that we don't have to make a copy of the fit and
         recalculate), this function was developed to be a common source of projected effect application.
         """
-        c = chain(self.drones, self.fighters, self.modules)
-        for item in c:
+        for item in chain(self.drones, self.fighters):
             if item is not None:
                 # apply effects onto target fit x amount of times
                 for _ in range(projectionInfo.amount):
                     targetFit.register(item, origin=self)
-                    item.calculateModifiedAttributes(targetFit, runTime, True)
+                    item.calculateModifiedAttributes(
+                        targetFit, runTime, forceProjected=True,
+                        forcedProjRange=0)
+        for mod in self.modules:
+            for _ in range(projectionInfo.amount):
+                targetFit.register(mod, origin=self)
+                mod.calculateModifiedAttributes(
+                    targetFit, runTime, forceProjected=True,
+                    forcedProjRange=projectionInfo.projectionRange)
 
     def fill(self):
         """
@@ -1071,7 +1104,7 @@ class Fit(object):
     def fighterBayUsed(self):
         amount = 0
         for f in self.fighters:
-            amount += f.item.volume * f.amountActive
+            amount += f.item.volume * f.amount
 
         return amount
 
@@ -1167,9 +1200,15 @@ class Fit(object):
 
         return self.__capRecharge
 
-    def calculateCapRecharge(self, percent=PEAK_RECHARGE):
-        capacity = self.ship.getModifiedItemAttr("capacitorCapacity")
-        rechargeRate = self.ship.getModifiedItemAttr("rechargeRate") / 1000.0
+    @property
+    def capDelta(self):
+        return (self.__capRecharge or 0) - (self.__capUsed or 0)
+
+    def calculateCapRecharge(self, percent=PEAK_RECHARGE, capacity=None, rechargeRate=None):
+        if capacity is None:
+            capacity = self.ship.getModifiedItemAttr("capacitorCapacity")
+        if rechargeRate is None:
+            rechargeRate = self.ship.getModifiedItemAttr("rechargeRate") / 1000.0
         return 10 / rechargeRate * sqrt(percent) * (1 - sqrt(percent)) * capacity
 
     def calculateShieldRecharge(self, percent=PEAK_RECHARGE):
@@ -1186,8 +1225,8 @@ class Fit(object):
         # Signature reduction, uses the bomb formula as per CCP Larrikin
         if energyNeutralizerSignatureResolution:
             capNeed = capNeed * min(1, signatureRadius / energyNeutralizerSignatureResolution)
-
-        self.__extraDrains.append((cycleTime, capNeed, clipSize, reloadTime))
+        if capNeed:
+            self.__extraDrains.append((cycleTime, capNeed, clipSize, reloadTime))
 
     def removeDrain(self, i):
         del self.__extraDrains[i]
@@ -1199,29 +1238,39 @@ class Fit(object):
         drains = []
         capUsed = 0
         capAdded = 0
-        for mod in self.modules:
-            if mod.state >= FittingModuleState.ACTIVE:
-                if (mod.getModifiedItemAttr("capacitorNeed") or 0) != 0:
-                    cycleTime = mod.rawCycleTime or 0
-                    reactivationTime = mod.getModifiedItemAttr("moduleReactivationDelay") or 0
-                    fullCycleTime = cycleTime + reactivationTime
-                    reloadTime = mod.reloadTime
-                    if fullCycleTime > 0:
-                        capNeed = mod.capUse
-                        if capNeed > 0:
-                            capUsed += capNeed
-                        else:
-                            capAdded -= capNeed
+        for mod in self.activeModulesIter():
+            if (mod.getModifiedItemAttr("capacitorNeed") or 0) != 0:
+                cycleTime = mod.rawCycleTime or 0
+                reactivationTime = mod.getModifiedItemAttr("moduleReactivationDelay") or 0
+                fullCycleTime = cycleTime + reactivationTime
+                reloadTime = mod.reloadTime
+                if fullCycleTime > 0:
+                    capNeed = mod.capUse
+                    if capNeed > 0:
+                        capUsed += capNeed
+                    else:
+                        capAdded -= capNeed
 
-                        # If this is a turret, don't stagger activations
-                        disableStagger = mod.hardpoint == FittingHardpoint.TURRET
+                    # If this is a turret, don't stagger activations
+                    disableStagger = mod.hardpoint == FittingHardpoint.TURRET
 
-                        drains.append((int(fullCycleTime), mod.getModifiedItemAttr("capacitorNeed") or 0,
-                                       mod.numShots or 0, disableStagger, reloadTime))
+                    drains.append((
+                        int(fullCycleTime),
+                        mod.getModifiedItemAttr("capacitorNeed") or 0,
+                        mod.numShots or 0,
+                        disableStagger,
+                        reloadTime,
+                        mod.item.group.name == 'Capacitor Booster'))
 
         for fullCycleTime, capNeed, clipSize, reloadTime in self.iterDrains():
-            # Stagger incoming effects for cap simulation
-            drains.append((int(fullCycleTime), capNeed, clipSize, False, reloadTime))
+            drains.append((
+                int(fullCycleTime),
+                capNeed,
+                clipSize,
+                # Stagger incoming effects for cap simulation
+                False,
+                reloadTime,
+                False))
             if capNeed > 0:
                 capUsed += capNeed / (fullCycleTime / 1000.0)
             else:
@@ -1232,17 +1281,8 @@ class Fit(object):
     def simulateCap(self):
         drains, self.__capUsed, self.__capRecharge = self.__generateDrain()
         self.__capRecharge += self.calculateCapRecharge()
-        if len(drains) > 0:
-            sim = capSim.CapSimulator()
-            sim.init(drains)
-            sim.capacitorCapacity = self.ship.getModifiedItemAttr("capacitorCapacity")
-            sim.capacitorRecharge = self.ship.getModifiedItemAttr("rechargeRate")
-            sim.stagger = True
-            sim.scale = False
-            sim.t_max = 6 * 60 * 60 * 1000
-            sim.reload = self.factorReload
-            sim.run()
-
+        sim = self.__runCapSim(drains=drains)
+        if sim is not None:
             capState = (sim.cap_stable_low + sim.cap_stable_high) / (2 * sim.capacitorCapacity)
             self.__capStable = capState > 0
             self.__capState = min(100, capState * 100) if self.__capStable else sim.t / 1000.0
@@ -1250,23 +1290,55 @@ class Fit(object):
             self.__capStable = True
             self.__capState = 100
 
+    def getCapSimData(self, startingCap):
+        if startingCap not in self.__savedCapSimData:
+            self.__runCapSim(startingCap=startingCap, tMax=3600, optimizeRepeats=False)
+        return self.__savedCapSimData[startingCap]
+
+    def __runCapSim(self, drains=None, startingCap=None, tMax=None, optimizeRepeats=True):
+        if drains is None:
+            drains, nil, nil = self.__generateDrain()
+        if tMax is None:
+            tMax = 6 * 60 * 60 * 1000
+        else:
+            tMax *= 1000
+        if len(drains) > 0:
+            sim = capSim.CapSimulator()
+            sim.init(drains)
+            sim.capacitorCapacity = self.ship.getModifiedItemAttr("capacitorCapacity")
+            sim.capacitorRecharge = self.ship.getModifiedItemAttr("rechargeRate")
+            sim.startingCapacity = startingCap = self.ship.getModifiedItemAttr("capacitorCapacity") if startingCap is None else startingCap
+            sim.stagger = True
+            sim.scale = False
+            sim.t_max = tMax
+            sim.reload = self.factorReload
+            sim.optimize_repeats = optimizeRepeats
+            sim.run()
+            # We do not want to store partial results
+            if not sim.result_optimized_repeats:
+                self.__savedCapSimData[startingCap] = sim.saved_changes
+            return sim
+        else:
+            self.__savedCapSimData[startingCap] = []
+            return None
+
+    def getCapRegenGainFromMod(self, mod):
+        """Return how much cap regen do we gain from having this module"""
+        currentRegen = self.calculateCapRecharge()
+        nomodRegen = self.calculateCapRecharge(
+            capacity=self.ship.getModifiedItemAttrExtended("capacitorCapacity", ignoreAfflictors=[mod]),
+            rechargeRate=self.ship.getModifiedItemAttrExtended("rechargeRate", ignoreAfflictors=[mod]) / 1000.0)
+        return currentRegen - nomodRegen
+
     def getRemoteReps(self, spoolOptions=None):
         if spoolOptions not in self.__remoteRepMap:
-            remoteReps = {}
+            remoteReps = RRTypes(0, 0, 0, 0)
 
             for module in self.modules:
-                rrType, rrAmount = module.getRemoteReps(spoolOptions=spoolOptions)
-                if rrType:
-                    if rrType not in remoteReps:
-                        remoteReps[rrType] = 0
-                    remoteReps[rrType] += rrAmount
+                remoteReps += module.getRemoteReps(spoolOptions=spoolOptions)
 
             for drone in self.drones:
-                rrType, rrAmount = drone.getRemoteReps()
-                if rrType:
-                    if rrType not in remoteReps:
-                        remoteReps[rrType] = 0
-                    remoteReps[rrType] += rrAmount
+                remoteReps += drone.getRemoteReps()
 
             self.__remoteRepMap[spoolOptions] = remoteReps
 
@@ -1361,47 +1433,47 @@ class Fit(object):
                 for tankType in localAdjustment:
                     dict = self.extraAttributes.getAfflictions(tankType)
                     if self in dict:
-                        for mod, _, amount, used in dict[self]:
+                        for afflictor, operator, stackingGroup, preResAmount, postResAmount, used in dict[self]:
                             if not used:
                                 continue
-                            if mod.projected:
+                            if afflictor.projected:
                                 continue
-                            if mod.item.group.name not in groupAttrMap:
+                            if afflictor.item.group.name not in groupAttrMap:
                                 continue
                             usesCap = True
                             try:
-                                if mod.capUse:
-                                    capUsed -= mod.capUse
+                                if afflictor.capUse:
+                                    capUsed -= afflictor.capUse
                                 else:
                                     usesCap = False
                             except AttributeError:
                                 usesCap = False
 
                             # Normal Repairers
-                            if usesCap and not mod.charge:
-                                cycleTime = mod.rawCycleTime
-                                amount = mod.getModifiedItemAttr(groupAttrMap[mod.item.group.name])
+                            if usesCap and not afflictor.charge:
+                                cycleTime = afflictor.rawCycleTime
+                                amount = afflictor.getModifiedItemAttr(groupAttrMap[afflictor.item.group.name])
                                 localAdjustment[tankType] -= amount / (cycleTime / 1000.0)
-                                repairers.append(mod)
+                                repairers.append(afflictor)
                             # Ancillary Armor reps etc
-                            elif usesCap and mod.charge:
-                                cycleTime = mod.rawCycleTime
-                                amount = mod.getModifiedItemAttr(groupAttrMap[mod.item.group.name])
-                                if mod.charge.name == "Nanite Repair Paste":
-                                    multiplier = mod.getModifiedItemAttr("chargedArmorDamageMultiplier") or 1
+                            elif usesCap and afflictor.charge:
+                                cycleTime = afflictor.rawCycleTime
+                                amount = afflictor.getModifiedItemAttr(groupAttrMap[afflictor.item.group.name])
+                                if afflictor.charge.name == "Nanite Repair Paste":
+                                    multiplier = afflictor.getModifiedItemAttr("chargedArmorDamageMultiplier") or 1
                                 else:
                                     multiplier = 1
                                 localAdjustment[tankType] -= amount * multiplier / (cycleTime / 1000.0)
-                                repairers.append(mod)
+                                repairers.append(afflictor)
                             # Ancillary Shield boosters etc
-                            elif not usesCap and mod.item.group.name in ("Ancillary Shield Booster", "Ancillary Remote Shield Booster"):
-                                cycleTime = mod.rawCycleTime
-                                amount = mod.getModifiedItemAttr(groupAttrMap[mod.item.group.name])
-                                if self.factorReload and mod.charge:
-                                    reloadtime = mod.reloadTime
+                            elif not usesCap and afflictor.item.group.name in ("Ancillary Shield Booster", "Ancillary Remote Shield Booster"):
+                                cycleTime = afflictor.rawCycleTime
+                                amount = afflictor.getModifiedItemAttr(groupAttrMap[afflictor.item.group.name])
+                                if self.factorReload and afflictor.charge:
+                                    reloadtime = afflictor.reloadTime
                                 else:
                                     reloadtime = 0.0
-                                offdutycycle = reloadtime / ((max(mod.numShots, 1) * cycleTime) + reloadtime)
+                                offdutycycle = reloadtime / ((max(afflictor.numShots, 1) * cycleTime) + reloadtime)
                                 localAdjustment[tankType] -= amount * offdutycycle / (cycleTime / 1000.0)
 
                 # Sort repairers by efficiency. We want to use the most efficient repairers first
@@ -1413,35 +1485,35 @@ class Fit(object):
                 # Most efficient first, as we sorted earlier.
                 # calculate how much the repper can rep stability & add to total
                 totalPeakRecharge = self.capRecharge
-                for mod in repairers:
+                for afflictor in repairers:
                     if capUsed > totalPeakRecharge:
                         break
 
-                    if self.factorReload and mod.charge:
-                        reloadtime = mod.reloadTime
+                    if self.factorReload and afflictor.charge:
+                        reloadtime = afflictor.reloadTime
                     else:
                         reloadtime = 0.0
 
-                    cycleTime = mod.rawCycleTime
-                    capPerSec = mod.capUse
+                    cycleTime = afflictor.rawCycleTime
+                    capPerSec = afflictor.capUse
 
                     if capPerSec is not None and cycleTime is not None:
                         # Check how much this repper can work
                         sustainability = min(1, (totalPeakRecharge - capUsed) / capPerSec)
-                        amount = mod.getModifiedItemAttr(groupAttrMap[mod.item.group.name])
+                        amount = afflictor.getModifiedItemAttr(groupAttrMap[afflictor.item.group.name])
                         # Add the sustainable amount
-                        if not mod.charge:
-                            localAdjustment[groupStoreMap[mod.item.group.name]] += sustainability * amount / (
+                        if not afflictor.charge:
+                            localAdjustment[groupStoreMap[afflictor.item.group.name]] += sustainability * amount / (
                                     cycleTime / 1000.0)
                         else:
-                            if mod.charge.name == "Nanite Repair Paste":
-                                multiplier = mod.getModifiedItemAttr("chargedArmorDamageMultiplier") or 1
+                            if afflictor.charge.name == "Nanite Repair Paste":
+                                multiplier = afflictor.getModifiedItemAttr("chargedArmorDamageMultiplier") or 1
                             else:
                                 multiplier = 1
-                            ondutycycle = (max(mod.numShots, 1) * cycleTime) / (
-                                    (max(mod.numShots, 1) * cycleTime) + reloadtime)
+                            ondutycycle = (max(afflictor.numShots, 1) * cycleTime) / (
+                                    (max(afflictor.numShots, 1) * cycleTime) + reloadtime)
                             localAdjustment[groupStoreMap[
-                                mod.item.group.name]] += sustainability * amount * ondutycycle * multiplier / (
+                                afflictor.item.group.name]] += sustainability * amount * ondutycycle * multiplier / (
                                     cycleTime / 1000.0)
 
                         capUsed += capPerSec
@@ -1458,9 +1530,7 @@ class Fit(object):
     def calculateLockTime(self, radius):
         scanRes = self.ship.getModifiedItemAttr("scanResolution")
         if scanRes is not None and scanRes > 0:
-            # Yes, this function returns time in seconds, not miliseconds.
-            # 40,000 is indeed the correct constant here.
-            return min(40000 / scanRes / asinh(radius) ** 2, 30 * 60)
+            return calculateLockTime(srcScanRes=scanRes, tgtSigRadius=radius)
         else:
             return self.ship.getModifiedItemAttr("scanSpeed") / 1000.0
 
@@ -1482,8 +1552,8 @@ class Fit(object):
         weaponDps = DmgTypes(0, 0, 0, 0)
 
         for mod in self.modules:
-            weaponVolley += mod.getVolley(spoolOptions=spoolOptions, targetResists=self.targetResists)
-            weaponDps += mod.getDps(spoolOptions=spoolOptions, targetResists=self.targetResists)
+            weaponVolley += mod.getVolley(spoolOptions=spoolOptions, targetProfile=self.targetProfile)
+            weaponDps += mod.getDps(spoolOptions=spoolOptions, targetProfile=self.targetProfile)
 
         self.__weaponVolleyMap[spoolOptions] = weaponVolley
         self.__weaponDpsMap[spoolOptions] = weaponDps
@@ -1493,12 +1563,12 @@ class Fit(object):
         droneDps = DmgTypes(0, 0, 0, 0)
 
         for drone in self.drones:
-            droneVolley += drone.getVolley(targetResists=self.targetResists)
-            droneDps += drone.getDps(targetResists=self.targetResists)
+            droneVolley += drone.getVolley(targetProfile=self.targetProfile)
+            droneDps += drone.getDps(targetProfile=self.targetProfile)
 
         for fighter in self.fighters:
-            droneVolley += fighter.getVolley(targetResists=self.targetResists)
-            droneDps += fighter.getDps(targetResists=self.targetResists)
+            droneVolley += fighter.getVolley(targetProfile=self.targetProfile)
+            droneDps += fighter.getDps(targetProfile=self.targetProfile)
 
         self.__droneDps = droneDps
         self.__droneVolley = droneVolley
@@ -1533,6 +1603,44 @@ class Fit(object):
             secstatus = FitSystemSecurity.NULLSEC
         return secstatus
 
+
+    def activeModulesIter(self):
+        for mod in self.modules:
+            if mod.state >= FittingModuleState.ACTIVE:
+                yield mod
+
+    def activeDronesIter(self):
+        for drone in self.drones:
+            if drone.amountActive > 0:
+                yield drone
+
+    def activeFightersIter(self):
+        for fighter in self.fighters:
+            if fighter.active:
+                yield fighter
+
+    def activeFighterAbilityIter(self):
+        for fighter in self.activeFightersIter():
+            for ability in fighter.abilities:
+                if ability.active:
+                    yield fighter, ability
+
+    def getDampMultScanRes(self):
+        damps = []
+        for mod in self.activeModulesIter():
+            for effectName in ('remoteSensorDampFalloff', 'structureModuleEffectRemoteSensorDampener'):
+                if effectName in mod.item.effects:
+                    damps.append((mod.getModifiedItemAttr('scanResolutionBonus'), 'default'))
+            if 'doomsdayAOEDamp' in mod.item.effects:
+                damps.append((mod.getModifiedItemAttr('scanResolutionBonus'), 'default'))
+        for drone in self.activeDronesIter():
+            if 'remoteSensorDampEntity' in drone.item.effects:
+                damps.extend(drone.amountActive * ((drone.getModifiedItemAttr('scanResolutionBonus'), 'default'),))
+        mults = {}
+        for strength, stackingGroup in damps:
+            mults.setdefault(stackingGroup, []).append((1 + strength / 100, None))
+        return calculateMultiplier(mults)
+
     def __deepcopy__(self, memo=None):
         fitCopy = Fit()
         # Character and owner are not copied
@@ -1542,13 +1650,14 @@ class Fit(object):
         fitCopy.mode = deepcopy(self.mode)
         fitCopy.name = "%s copy" % self.name
         fitCopy.damagePattern = self.damagePattern
-        fitCopy.targetResists = self.targetResists
+        fitCopy.targetProfile = self.targetProfile
         fitCopy.implantLocation = self.implantLocation
         fitCopy.systemSecurity = self.systemSecurity
         fitCopy.notes = self.notes
 
+        for i in self.modules:
+            fitCopy.modules.appendIgnoreEmpty(deepcopy(i))
         toCopy = (
-            "modules",
             "drones",
             "fighters",
             "cargo",
@@ -1582,6 +1691,8 @@ class Fit(object):
             copyProjectionInfo = fit.getProjectionInfo(fitCopy.ID)
             originalProjectionInfo = fit.getProjectionInfo(self.ID)
             copyProjectionInfo.active = originalProjectionInfo.active
+            copyProjectionInfo.amount = originalProjectionInfo.amount
+            copyProjectionInfo.projectionRange = originalProjectionInfo.projectionRange
             forceUpdateSavedata(fit)
 
         return fitCopy

eos/saveddata/implant.py

@@ -95,7 +95,7 @@ class Implant(HandledItem, ItemAttrShortcut):
             return
         for effect in self.item.effects.values():
             if effect.runTime == runTime and effect.isType("passive") and effect.activeByDefault:
-                effect.handler(fit, self, ("implant",))
+                effect.handler(fit, self, ("implant",), None, effect=effect)
 
     @validates("fitID", "itemID", "active")
     def validator(self, key, val):

eos/saveddata/implantSet.py

@@ -22,7 +22,7 @@ from copy import deepcopy
 from eos.effectHandlerHelpers import HandledImplantList
 
 
-class ImplantSet(object):
+class ImplantSet:
     def __init__(self, name=None):
         self.name = name
         self.__implants = HandledImplantList()

eos/saveddata/mode.py

@@ -54,7 +54,7 @@ class Mode(ItemAttrShortcut, HandledItem):
         if self.item:
             for effect in self.item.effects.values():
                 if effect.runTime == runTime and effect.activeByDefault:
-                    effect.handler(fit, self, context=("module",))
+                    effect.handler(fit, self, ("module",), None, effect=effect)
 
     def __deepcopy__(self, memo):
         copy = Mode(self.item)

eos/saveddata/module.py

@@ -17,20 +17,23 @@
 # along with eos.  If not, see <http://www.gnu.org/licenses/>.
 # ===============================================================================
 
-from math import floor
+import math
 
 from logbook import Logger
 from sqlalchemy.orm import reconstructor, validates
 
 import eos.db
-from eos.const import FittingModuleState, FittingHardpoint, FittingSlot
+from eos.const import FittingHardpoint, FittingModuleState, FittingSlot
 from eos.effectHandlerHelpers import HandledCharge, HandledItem
 from eos.modifiedAttributeDict import ChargeAttrShortcut, ItemAttrShortcut, ModifiedAttributeDict
 from eos.saveddata.citadel import Citadel
 from eos.saveddata.mutator import Mutator
+from eos.utils.cycles import CycleInfo, CycleSequence
+from eos.utils.default import DEFAULT
 from eos.utils.float import floatUnerr
 from eos.utils.spoolSupport import calculateSpoolup, resolveSpoolOptions
-from eos.utils.stats import DmgTypes
+from eos.utils.stats import DmgTypes, RRTypes
+
 
 pyfalog = Logger(__name__)
 
@@ -89,6 +92,7 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
         self.__charge = None
 
         self.projected = False
+        self.projectionRange = None
         self.state = FittingModuleState.ONLINE
         self.build()
 
@@ -133,7 +137,7 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
             self.__charge = None
 
         self.__baseVolley = None
-        self.__baseRemoteReps = None
+        self.__baseRRAmount = None
         self.__miningyield = None
         self.__reloadTime = None
         self.__reloadForce = None
@@ -287,7 +291,7 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
             # numcycles = math.floor(module_capacity / (module_volume * module_chargerate))
             chargeRate = self.getModifiedItemAttr("chargeRate")
             numCharges = self.numCharges
-            numShots = floor(numCharges / chargeRate)
+            numShots = math.floor(numCharges / chargeRate)
         else:
             numShots = None
         return numShots
@@ -300,7 +304,7 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
                 chance = self.getModifiedChargeAttr("crystalVolatilityChance")
                 damage = self.getModifiedChargeAttr("crystalVolatilityDamage")
                 crystals = self.numCharges
-                numShots = floor((crystals * hp) / (damage * chance))
+                numShots = math.floor((crystals * hp) / (damage * chance))
             else:
                 # Set 0 (infinite) for permanent crystals like t1 laser crystals
                 numShots = 0
@@ -314,31 +318,68 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
                  "energyDestabilizationRange", "empFieldRange",
                  "ecmBurstRange", "warpScrambleRange", "cargoScanRange",
                  "shipScanRange", "surveyScanRange")
+        maxRange = None
         for attr in attrs:
             maxRange = self.getModifiedItemAttr(attr, None)
             if maxRange is not None:
-                return maxRange
-        if self.charge is not None:
-            try:
-                chargeName = self.charge.group.name
-            except AttributeError:
-                pass
-            else:
-                if chargeName in ("Scanner Probe", "Survey Probe"):
-                    return None
+                break
+        if maxRange is not None:
+            if 'burst projector' in self.item.name.lower():
+                maxRange -= self.owner.ship.getModifiedItemAttr("radius")
+            return maxRange
+        missileMaxRangeData = self.missileMaxRangeData
+        if missileMaxRangeData is None:
+            return None
+        lowerRange, higherRange, higherChance = missileMaxRangeData
+        maxRange = lowerRange * (1 - higherChance) + higherRange * higherChance
+        return maxRange
+
+    @property
+    def missileMaxRangeData(self):
+        if self.charge is None:
+            return None
+        try:
+            chargeName = self.charge.group.name
+        except AttributeError:
+            pass
+        else:
+            if chargeName in ("Scanner Probe", "Survey Probe"):
+                return None
+
+        def calculateRange(maxVelocity, mass, agility, flightTime):
             # Source: http://www.eveonline.com/ingameboard.asp?a=topic&threadID=1307419&page=1#15
             # D_m = V_m * (T_m + T_0*[exp(- T_m/T_0)-1])
-            maxVelocity = self.getModifiedChargeAttr("maxVelocity")
-            flightTime = self.getModifiedChargeAttr("explosionDelay") / 1000.0
-            mass = self.getModifiedChargeAttr("mass")
-            agility = self.getModifiedChargeAttr("agility")
-            if maxVelocity and (flightTime or mass or agility):
-                accelTime = min(flightTime, mass * agility / 1000000)
-                # Average distance done during acceleration
-                duringAcceleration = maxVelocity / 2 * accelTime
-                # Distance done after being at full speed
-                fullSpeed = maxVelocity * (flightTime - accelTime)
-                return duringAcceleration + fullSpeed
+            accelTime = min(flightTime, mass * agility / 1000000)
+            # Average distance done during acceleration
+            duringAcceleration = maxVelocity / 2 * accelTime
+            # Distance done after being at full speed
+            fullSpeed = maxVelocity * (flightTime - accelTime)
+            maxRange = duringAcceleration + fullSpeed
+            return maxRange
+
+        maxVelocity = self.getModifiedChargeAttr("maxVelocity")
+        if not maxVelocity:
+            return None
+        shipRadius = self.owner.ship.getModifiedItemAttr("radius")
+        # Flight time has bonus based on ship radius, see https://github.com/pyfa-org/Pyfa/issues/2083
+        flightTime = floatUnerr(self.getModifiedChargeAttr("explosionDelay") / 1000 + shipRadius / maxVelocity)
+        mass = self.getModifiedChargeAttr("mass")
+        agility = self.getModifiedChargeAttr("agility")
+        lowerTime = math.floor(flightTime)
+        higherTime = math.ceil(flightTime)
+        lowerRange = calculateRange(maxVelocity, mass, agility, lowerTime)
+        higherRange = calculateRange(maxVelocity, mass, agility, higherTime)
+        # Fof range limit is supposedly calculated based on overview (surface-to-surface) range
+        if 'fofMissileLaunching' in self.charge.effects:
+            rangeLimit = self.getModifiedChargeAttr("maxFOFTargetRange")
+            if rangeLimit:
+                lowerRange = min(lowerRange, rangeLimit)
+                higherRange = min(higherRange, rangeLimit)
+        # Make range center-to-surface, as missiles spawn in the center of the ship
+        lowerRange = max(0, lowerRange - shipRadius)
+        higherRange = max(0, higherRange - shipRadius)
+        higherChance = flightTime - lowerTime
+        return lowerRange, higherRange, higherChance
 
     @property
     def falloff(self):
@@ -400,8 +441,12 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
                     volley = self.getModifiedItemAttr("specialtyMiningAmount") or self.getModifiedItemAttr(
                             "miningAmount") or 0
                     if volley:
-                        cycleTime = self.cycleTime
-                        self.__miningyield = volley / (cycleTime / 1000.0)
+                        cycleParams = self.getCycleParameters()
+                        if cycleParams is None:
+                            self.__miningyield = 0
+                        else:
+                            cycleTime = cycleParams.averageTime
+                            self.__miningyield = volley / (cycleTime / 1000.0)
                     else:
                         self.__miningyield = 0
                 else:
@@ -409,91 +454,149 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
 
         return self.__miningyield
 
-    def getVolley(self, spoolOptions=None, targetResists=None, ignoreState=False):
+    def isDealingDamage(self, ignoreState=False):
+        volleyParams = self.getVolleyParameters(ignoreState=ignoreState)
+        for volley in volleyParams.values():
+            if volley.total > 0:
+                return True
+        return False
+
+    def getVolleyParameters(self, spoolOptions=None, targetProfile=None, ignoreState=False):
         if self.isEmpty or (self.state < FittingModuleState.ACTIVE and not ignoreState):
-            return DmgTypes(0, 0, 0, 0)
+            return {0: DmgTypes(0, 0, 0, 0)}
         if self.__baseVolley is None:
+            self.__baseVolley = {}
             dmgGetter = self.getModifiedChargeAttr if self.charge else self.getModifiedItemAttr
             dmgMult = self.getModifiedItemAttr("damageMultiplier", 1)
-            self.__baseVolley = DmgTypes(
-                em=(dmgGetter("emDamage", 0)) * dmgMult,
-                thermal=(dmgGetter("thermalDamage", 0)) * dmgMult,
-                kinetic=(dmgGetter("kineticDamage", 0)) * dmgMult,
-                explosive=(dmgGetter("explosiveDamage", 0)) * dmgMult)
+            # Some delay attributes have non-0 default value, so we have to pick according to effects
+            if {'superWeaponAmarr', 'superWeaponCaldari', 'superWeaponGallente', 'superWeaponMinmatar', 'lightningWeapon'}.intersection(self.item.effects):
+                dmgDelay = self.getModifiedItemAttr("damageDelayDuration", 0)
+            elif {'doomsdayBeamDOT', 'doomsdaySlash', 'doomsdayConeDOT'}.intersection(self.item.effects):
+                dmgDelay = self.getModifiedItemAttr("doomsdayWarningDuration", 0)
+            else:
+                dmgDelay = 0
+            dmgDuration = self.getModifiedItemAttr("doomsdayDamageDuration", 0)
+            dmgSubcycle = self.getModifiedItemAttr("doomsdayDamageCycleTime", 0)
+            # Reaper DD can damage each target only once
+            if dmgDuration != 0 and dmgSubcycle != 0 and 'doomsdaySlash' not in self.item.effects:
+                subcycles = math.floor(floatUnerr(dmgDuration / dmgSubcycle))
+            else:
+                subcycles = 1
+            for i in range(subcycles):
+                self.__baseVolley[dmgDelay + dmgSubcycle * i] = DmgTypes(
+                    em=(dmgGetter("emDamage", 0)) * dmgMult,
+                    thermal=(dmgGetter("thermalDamage", 0)) * dmgMult,
+                    kinetic=(dmgGetter("kineticDamage", 0)) * dmgMult,
+                    explosive=(dmgGetter("explosiveDamage", 0)) * dmgMult)
         spoolType, spoolAmount = resolveSpoolOptions(spoolOptions, self)
         spoolBoost = calculateSpoolup(
             self.getModifiedItemAttr("damageMultiplierBonusMax", 0),
             self.getModifiedItemAttr("damageMultiplierBonusPerCycle", 0),
             self.rawCycleTime / 1000, spoolType, spoolAmount)[0]
         spoolMultiplier = 1 + spoolBoost
-        volley = DmgTypes(
-            em=self.__baseVolley.em * spoolMultiplier * (1 - getattr(targetResists, "emAmount", 0)),
-            thermal=self.__baseVolley.thermal * spoolMultiplier * (1 - getattr(targetResists, "thermalAmount", 0)),
-            kinetic=self.__baseVolley.kinetic * spoolMultiplier * (1 - getattr(targetResists, "kineticAmount", 0)),
-            explosive=self.__baseVolley.explosive * spoolMultiplier * (1 - getattr(targetResists, "explosiveAmount", 0)))
-        return volley
+        adjustedVolley = {}
+        for volleyTime, volleyValue in self.__baseVolley.items():
+            adjustedVolley[volleyTime] = DmgTypes(
+                em=volleyValue.em * spoolMultiplier * (1 - getattr(targetProfile, "emAmount", 0)),
+                thermal=volleyValue.thermal * spoolMultiplier * (1 - getattr(targetProfile, "thermalAmount", 0)),
+                kinetic=volleyValue.kinetic * spoolMultiplier * (1 - getattr(targetProfile, "kineticAmount", 0)),
+                explosive=volleyValue.explosive * spoolMultiplier * (1 - getattr(targetProfile, "explosiveAmount", 0)))
+        return adjustedVolley
 
-    def getDps(self, spoolOptions=None, targetResists=None, ignoreState=False):
-        volley = self.getVolley(spoolOptions=spoolOptions, targetResists=targetResists, ignoreState=ignoreState)
-        if not volley:
+    def getVolley(self, spoolOptions=None, targetProfile=None, ignoreState=False):
+        volleyParams = self.getVolleyParameters(spoolOptions=spoolOptions, targetProfile=targetProfile, ignoreState=ignoreState)
+        if len(volleyParams) == 0:
             return DmgTypes(0, 0, 0, 0)
-        # Some weapons repeat multiple times in one cycle (bosonic doomsdays). Get the number of times it fires off
-        volleysPerCycle = max(self.getModifiedItemAttr("doomsdayDamageDuration", 1) / self.getModifiedItemAttr("doomsdayDamageCycleTime", 1), 1)
-        dpsFactor = volleysPerCycle / (self.cycleTime / 1000)
+        return volleyParams[min(volleyParams)]
+
+    def getDps(self, spoolOptions=None, targetProfile=None, ignoreState=False):
+        dmgDuringCycle = DmgTypes(0, 0, 0, 0)
+        cycleParams = self.getCycleParameters()
+        if cycleParams is None:
+            return dmgDuringCycle
+        volleyParams = self.getVolleyParameters(spoolOptions=spoolOptions, targetProfile=targetProfile, ignoreState=ignoreState)
+        avgCycleTime = cycleParams.averageTime
+        if len(volleyParams) == 0 or avgCycleTime == 0:
+            return dmgDuringCycle
+        for volleyValue in volleyParams.values():
+            dmgDuringCycle += volleyValue
+        dpsFactor = 1 / (avgCycleTime / 1000)
         dps = DmgTypes(
-            em=volley.em * dpsFactor,
-            thermal=volley.thermal * dpsFactor,
-            kinetic=volley.kinetic * dpsFactor,
-            explosive=volley.explosive * dpsFactor)
+            em=dmgDuringCycle.em * dpsFactor,
+            thermal=dmgDuringCycle.thermal * dpsFactor,
+            kinetic=dmgDuringCycle.kinetic * dpsFactor,
+            explosive=dmgDuringCycle.explosive * dpsFactor)
         return dps
 
-    def getRemoteReps(self, spoolOptions=None, ignoreState=False):
+    def isRemoteRepping(self, ignoreState=False):
+        repParams = self.getRepAmountParameters(ignoreState=ignoreState)
+        for rrData in repParams.values():
+            if rrData:
+                return True
+        return False
+
+    def getRepAmountParameters(self, spoolOptions=None, ignoreState=False):
         if self.isEmpty or (self.state < FittingModuleState.ACTIVE and not ignoreState):
-            return None, 0
-
-        def getBaseRemoteReps(module):
-            remoteModuleGroups = {
-                "Remote Armor Repairer": "Armor",
-                "Ancillary Remote Armor Repairer": "Armor",
-                "Mutadaptive Remote Armor Repairer": "Armor",
-                "Remote Hull Repairer": "Hull",
-                "Remote Shield Booster": "Shield",
-                "Ancillary Remote Shield Booster": "Shield",
-                "Remote Capacitor Transmitter": "Capacitor"}
-            rrType = remoteModuleGroups.get(module.item.group.name, None)
-            if not rrType:
-                return None, 0
+            return {}
+        remoteModuleGroups = {
+            "Remote Armor Repairer": "Armor",
+            "Ancillary Remote Armor Repairer": "Armor",
+            "Mutadaptive Remote Armor Repairer": "Armor",
+            "Remote Hull Repairer": "Hull",
+            "Remote Shield Booster": "Shield",
+            "Ancillary Remote Shield Booster": "Shield",
+            "Remote Capacitor Transmitter": "Capacitor"}
+        rrType = remoteModuleGroups.get(self.item.group.name)
+        if rrType is None:
+            return {}
+        if self.__baseRRAmount is None:
+            self.__baseRRAmount = {}
+            shieldAmount = 0
+            armorAmount = 0
+            hullAmount = 0
+            capacitorAmount = 0
             if rrType == "Hull":
-                rrAmount = module.getModifiedItemAttr("structureDamageAmount", 0)
+                hullAmount += self.getModifiedItemAttr("structureDamageAmount", 0)
             elif rrType == "Armor":
-                rrAmount = module.getModifiedItemAttr("armorDamageAmount", 0)
+                if self.item.group.name == "Ancillary Remote Armor Repairer" and self.charge:
+                    mult = self.getModifiedItemAttr("chargedArmorDamageMultiplier", 1)
+                else:
+                    mult = 1
+                armorAmount += self.getModifiedItemAttr("armorDamageAmount", 0) * mult
             elif rrType == "Shield":
-                rrAmount = module.getModifiedItemAttr("shieldBonus", 0)
+                shieldAmount += self.getModifiedItemAttr("shieldBonus", 0)
             elif rrType == "Capacitor":
-                rrAmount = module.getModifiedItemAttr("powerTransferAmount", 0)
+                capacitorAmount += self.getModifiedItemAttr("powerTransferAmount", 0)
+            rrDelay = 0 if rrType == "Shield" else self.rawCycleTime
+            self.__baseRRAmount[rrDelay] = RRTypes(shield=shieldAmount, armor=armorAmount, hull=hullAmount, capacitor=capacitorAmount)
+        spoolType, spoolAmount = resolveSpoolOptions(spoolOptions, self)
+        spoolBoost = calculateSpoolup(
+            self.getModifiedItemAttr("repairMultiplierBonusMax", 0),
+            self.getModifiedItemAttr("repairMultiplierBonusPerCycle", 0),
+            self.rawCycleTime / 1000, spoolType, spoolAmount)[0]
+        spoolMultiplier = 1 + spoolBoost
+        adjustedRRAmount = {}
+        for rrTime, rrAmount in self.__baseRRAmount.items():
+            if spoolMultiplier == 1:
+                adjustedRRAmount[rrTime] = rrAmount
             else:
-                return None, 0
-            if rrAmount:
-                rrAmount *= 1 / (self.cycleTime / 1000)
-                if module.item.group.name == "Ancillary Remote Armor Repairer" and module.charge:
-                    rrAmount *= module.getModifiedItemAttr("chargedArmorDamageMultiplier", 1)
+                adjustedRRAmount[rrTime] = rrAmount * spoolMultiplier
+        return adjustedRRAmount
 
-            return rrType, rrAmount
-
-        if self.__baseRemoteReps is None:
-            self.__baseRemoteReps = getBaseRemoteReps(self)
-
-        rrType, rrAmount = self.__baseRemoteReps
-
-        if rrType and rrAmount and self.item.group.name == "Mutadaptive Remote Armor Repairer":
-            spoolType, spoolAmount = resolveSpoolOptions(spoolOptions, self)
-            spoolBoost = calculateSpoolup(
-                self.getModifiedItemAttr("repairMultiplierBonusMax", 0),
-                self.getModifiedItemAttr("repairMultiplierBonusPerCycle", 0),
-                self.rawCycleTime / 1000, spoolType, spoolAmount)[0]
-            rrAmount *= (1 + spoolBoost)
-
-        return rrType, rrAmount
+    def getRemoteReps(self, spoolOptions=None, ignoreState=False, reloadOverride=None):
+        rrDuringCycle = RRTypes(0, 0, 0, 0)
+        cycleParams = self.getCycleParameters(reloadOverride=reloadOverride)
+        if cycleParams is None:
+            return rrDuringCycle
+        repAmountParams = self.getRepAmountParameters(spoolOptions=spoolOptions, ignoreState=ignoreState)
+        avgCycleTime = cycleParams.averageTime
+        if len(repAmountParams) == 0 or avgCycleTime == 0:
+            return rrDuringCycle
+        for rrAmount in repAmountParams.values():
+            rrDuringCycle += rrAmount
+        rrFactor = 1 / (avgCycleTime / 1000)
+        rps = rrDuringCycle * rrFactor
+        return rps
 
     def getSpoolData(self, spoolOptions=None):
         weaponMultMax = self.getModifiedItemAttr("damageMultiplierBonusMax", 0)
@@ -620,30 +723,41 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
 
     def canHaveState(self, state=None, projectedOnto=None):
         """
-        Check with other modules if there are restrictions that might not allow this module to be activated
+        Check with other modules if there are restrictions that might not allow this module to be activated.
+        Returns True if state is allowed, or max state module can have if current state is invalid.
         """
-        # If we're going to set module to offline or online for local modules or offline for projected,
-        # it should be fine for all cases
+        # If we're going to set module to offline, it should be fine for all cases
         item = self.item
-        if (state <= FittingModuleState.ONLINE and projectedOnto is None) or (state <= FittingModuleState.OFFLINE):
+        if state <= FittingModuleState.OFFLINE:
             return True
 
         # Check if the local module is over it's max limit; if it's not, we're fine
+        maxGroupOnline = self.getModifiedItemAttr("maxGroupOnline", None)
         maxGroupActive = self.getModifiedItemAttr("maxGroupActive", None)
-        if maxGroupActive is None and projectedOnto is None:
+        if maxGroupOnline is None and maxGroupActive is None and projectedOnto is None:
             return True
 
         # Following is applicable only to local modules, we do not want to limit projected
         if projectedOnto is None:
+            currOnline = 0
             currActive = 0
             group = item.group.name
+            maxState = None
             for mod in self.owner.modules:
                 currItem = getattr(mod, "item", None)
-                if mod.state >= FittingModuleState.ACTIVE and currItem is not None and currItem.group.name == group:
-                    currActive += 1
-                if currActive > maxGroupActive:
-                    break
-            return currActive <= maxGroupActive
+                if currItem is not None and currItem.group.name == group:
+                    if mod.state >= FittingModuleState.ONLINE:
+                        currOnline += 1
+                    if mod.state >= FittingModuleState.ACTIVE:
+                        currActive += 1
+                    if maxGroupOnline is not None and currOnline > maxGroupOnline:
+                        if maxState is None or maxState > FittingModuleState.OFFLINE:
+                            maxState = FittingModuleState.OFFLINE
+                            break
+                    if maxGroupActive is not None and currActive > maxGroupActive:
+                        if maxState is None or maxState > FittingModuleState.ONLINE:
+                            maxState = FittingModuleState.ONLINE
+            return True if maxState is None else maxState
         # For projected, we're checking if ship is vulnerable to given item
         else:
             # Do not allow to apply offensive modules on ship with offensive module immunite, with few exceptions
@@ -654,10 +768,10 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
                                          "energyNosferatuFalloff",
                                          "energyNeutralizerFalloff"}
                 if not offensiveNonModifiers.intersection(set(item.effects)):
-                    return False
+                    return FittingModuleState.OFFLINE
             # If assistive modules are not allowed, do not let to apply these altogether
             if item.assistive and projectedOnto.ship.getModifiedItemAttr("disallowAssistance") == 1:
-                return False
+                return FittingModuleState.OFFLINE
             return True
 
     def isValidCharge(self, charge):
@@ -750,7 +864,7 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
 
     def clear(self):
         self.__baseVolley = None
-        self.__baseRemoteReps = None
+        self.__baseRRAmount = None
         self.__miningyield = None
         self.__reloadTime = None
         self.__reloadForce = None
@@ -758,7 +872,7 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
         self.itemModifiedAttributes.clear()
         self.chargeModifiedAttributes.clear()
 
-    def calculateModifiedAttributes(self, fit, runTime, forceProjected=False, gang=False):
+    def calculateModifiedAttributes(self, fit, runTime, forceProjected=False, gang=False, forcedProjRange=DEFAULT):
         # We will run the effect when two conditions are met:
         # 1: It makes sense to run the effect
         #    The effect is either offline
@@ -775,6 +889,8 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
             context = ("module",)
             projected = False
 
+        projectionRange = self.projectionRange if forcedProjRange is DEFAULT else forcedProjRange
+
         if self.charge is not None:
             # fix for #82 and it's regression #106
             if not projected or (self.projected and not forceProjected) or gang:
@@ -788,13 +904,7 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
                         (not gang or (gang and effect.isType("gang")))
                     ):
                         contexts = ("moduleCharge",)
-                        # For gang effects, we pass in the effect itself as an argument. However, to avoid going through all
-                        # the effect definitions and defining this argument, do a simple try/catch here and be done with it.
-                        # @todo: possibly fix this
-                        try:
-                            effect.handler(fit, self, contexts, effect=effect)
-                        except:
-                            effect.handler(fit, self, contexts)
+                        effect.handler(fit, self, contexts, projectionRange, effect=effect)
 
         if self.item:
             if self.state >= FittingModuleState.OVERHEATED:
@@ -804,7 +914,7 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
                             and not forceProjected \
                             and effect.activeByDefault \
                             and ((gang and effect.isType("gang")) or not gang):
-                        effect.handler(fit, self, context)
+                        effect.handler(fit, self, context, projectionRange, effect=effect)
 
             for effect in self.item.effects.values():
                 if effect.runTime == runTime and \
@@ -814,54 +924,64 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
                          (effect.isType("active") and self.state >= FittingModuleState.ACTIVE)) \
                         and ((projected and effect.isType("projected")) or not projected) \
                         and ((gang and effect.isType("gang")) or not gang):
-                    try:
-                        effect.handler(fit, self, context, effect=effect)
-                    except:
-                        effect.handler(fit, self, context)
+                    effect.handler(fit, self, context, projectionRange, effect=effect)
 
-    @property
-    def cycleTime(self):
+    def getCycleParameters(self, reloadOverride=None):
+        """Copied from new eos as well"""
         # Determine if we'll take into account reload time or not
-        factorReload = self.owner.factorReload if self.forceReload is None else self.forceReload
-
-        numShots = self.numShots
-        speed = self.rawCycleTime
-
-        if factorReload and self.charge:
-            raw_reload_time = self.reloadTime
+        if reloadOverride is not None:
+            factorReload = reloadOverride
         else:
-            raw_reload_time = 0.0
+            factorReload = self.owner.factorReload if self.forceReload is None else self.forceReload
 
-        # Module can only fire one shot at a time, think bomb launchers or defender launchers
-        if self.disallowRepeatingAction:
-            if numShots > 0:
-                """
-                The actual mechanics behind this is complex.  Behavior will be (for 3 ammo):
-                    fire, reactivation delay, fire, reactivation delay, fire, max(reactivation delay, reload)
-                so your effective reload time depends on where you are at in the cycle.
+        cycles_until_reload = self.numShots
+        if cycles_until_reload == 0:
+            cycles_until_reload = math.inf
 
-                We can't do that, so instead we'll average it out.
-
-                Currently would apply to bomb launchers and defender missiles
-                """
-                effective_reload_time = ((self.reactivationDelay * (numShots - 1)) + max(raw_reload_time, self.reactivationDelay, 0))
-            else:
-                """
-                Applies to MJD/MJFG
-                """
-                effective_reload_time = max(raw_reload_time, self.reactivationDelay, 0)
-                speed = speed + effective_reload_time
+        active_time = self.rawCycleTime
+        if active_time == 0:
+            return None
+        forced_inactive_time = self.reactivationDelay
+        reload_time = self.reloadTime
+        # Effects which cannot be reloaded have the same processing whether
+        # caller wants to take reload time into account or not
+        if reload_time is None and cycles_until_reload < math.inf:
+            final_cycles = 1
+            early_cycles = cycles_until_reload - final_cycles
+            # Single cycle until effect cannot run anymore
+            if early_cycles == 0:
+                return CycleInfo(active_time, 0, 1, False)
+            # Multiple cycles with the same parameters
+            if forced_inactive_time == 0:
+                return CycleInfo(active_time, 0, cycles_until_reload, False)
+            # Multiple cycles with different parameters
+            return CycleSequence((
+                CycleInfo(active_time, forced_inactive_time, early_cycles, False),
+                CycleInfo(active_time, 0, final_cycles, False)
+            ), 1)
+        # Module cycles the same way all the time in 3 cases:
+        # 1) caller doesn't want to take into account reload time
+        # 2) effect does not have to reload anything to keep running
+        # 3) effect has enough time to reload during inactivity periods
+        if (
+            not factorReload or
+            cycles_until_reload == math.inf or
+            forced_inactive_time >= reload_time
+        ):
+            isInactivityReload = factorReload and forced_inactive_time >= reload_time
+            return CycleInfo(active_time, forced_inactive_time, math.inf, isInactivityReload)
+        # We've got to take reload into consideration
         else:
-            """
-            Currently no other modules would have a reactivation delay, so for sanities sake don't try and account for it.
-            Okay, technically cloaks do, but they also have 0 cycle time and cap usage so why do you care?
-            """
-            effective_reload_time = raw_reload_time
-
-        if numShots > 0 and self.charge:
-            speed = (speed * numShots + effective_reload_time) / numShots
-
-        return speed
+            final_cycles = 1
+            early_cycles = cycles_until_reload - final_cycles
+            # If effect has to reload after each its cycle, then its parameters
+            # are the same all the time
+            if early_cycles == 0:
+                return CycleInfo(active_time, reload_time, math.inf, True)
+            return CycleSequence((
+                CycleInfo(active_time, forced_inactive_time, early_cycles, False),
+                CycleInfo(active_time, reload_time, final_cycles, True)
+            ), math.inf)
 
     @property
     def rawCycleTime(self):
@@ -887,7 +1007,10 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
     def capUse(self):
         capNeed = self.getModifiedItemAttr("capacitorNeed")
         if capNeed and self.state >= FittingModuleState.ACTIVE:
-            cycleTime = self.cycleTime
+            cycleParams = self.getCycleParameters()
+            if cycleParams is None:
+                return 0
+            cycleTime = cycleParams.averageTime
             if cycleTime > 0:
                 capUsed = capNeed / (cycleTime / 1000.0)
                 return capUsed
@@ -932,6 +1055,7 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
         copy.state = self.state
         copy.spoolType = self.spoolType
         copy.spoolAmount = self.spoolAmount
+        copy.projectionRange = self.projectionRange
 
         for x in self.mutators.values():
             Mutator(copy, x.attribute, x.value)
@@ -941,10 +1065,17 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
     def rebase(self, item):
         state = self.state
         charge = self.charge
+        spoolType = self.spoolType
+        spoolAmount = self.spoolAmount
+        projectionRange = self.projectionRange
+
         Module.__init__(self, item, self.baseItem, self.mutaplasmid)
         self.state = state
         if self.isValidCharge(charge):
             self.charge = charge
+        self.spoolType = spoolType
+        self.spoolAmount = spoolAmount
+        self.projectionRange = projectionRange
         for x in self.mutators.values():
             Mutator(self, x.attribute, x.value)
 

eos/saveddata/price.py

@@ -42,7 +42,7 @@ class PriceStatus(IntEnum):
     fetchTimeout = 4
 
 
-class Price(object):
+class Price:
     def __init__(self, typeID):
         self.typeID = typeID
         self.time = 0

eos/saveddata/ship.py

@@ -98,7 +98,7 @@ class Ship(ItemAttrShortcut, HandledItem):
                 # skillbook modifiers will use the stale modifier value
                 # GH issue #351
                 fit.register(self)
-                effect.handler(fit, self, ("ship",))
+                effect.handler(fit, self, ("ship",), None, effect=effect)
 
     def validateModeItem(self, item, owner=None):
         """ Checks if provided item is a valid mode """

eos/saveddata/ssocharacter.py

@@ -24,7 +24,7 @@ import time
 # from tomorrow import threads
 
 
-class SsoCharacter(object):
+class SsoCharacter:
     def __init__(self, charID, name, client, accessToken=None, refreshToken=None):
         self.characterID = charID
         self.characterName = name

eos/saveddata/targetProfile.py

@@ -17,25 +17,77 @@
 # along with eos.  If not, see <http://www.gnu.org/licenses/>.
 # ===============================================================================
 
+import math
 import re
+
 from logbook import Logger
+
 import eos.db
 
+
 pyfalog = Logger(__name__)
 
 
-class TargetResists(object):
+class TargetProfile:
     # also determined import/export order - VERY IMPORTANT
     DAMAGE_TYPES = ("em", "thermal", "kinetic", "explosive")
 
     def __init__(self, *args, **kwargs):
         self.update(*args, **kwargs)
 
-    def update(self, emAmount=0, thermalAmount=0, kineticAmount=0, explosiveAmount=0):
+    def update(self, emAmount=0, thermalAmount=0, kineticAmount=0, explosiveAmount=0, maxVelocity=None, signatureRadius=None, radius=None):
         self.emAmount = emAmount
         self.thermalAmount = thermalAmount
         self.kineticAmount = kineticAmount
         self.explosiveAmount = explosiveAmount
+        self._maxVelocity = maxVelocity
+        self._signatureRadius = signatureRadius
+        self._radius = radius
+
+    _idealTarget = None
+
+    @classmethod
+    def getIdeal(cls):
+        if cls._idealTarget is None:
+            cls._idealTarget = cls(
+                emAmount=0,
+                thermalAmount=0,
+                kineticAmount=0,
+                explosiveAmount=0,
+                maxVelocity=0,
+                signatureRadius=None,
+                radius=0)
+            cls._idealTarget.name = 'Ideal Target'
+            cls._idealTarget.ID = -1
+        return cls._idealTarget
+
+    @property
+    def maxVelocity(self):
+        return self._maxVelocity or 0
+
+    @maxVelocity.setter
+    def maxVelocity(self, val):
+        self._maxVelocity = val
+
+    @property
+    def signatureRadius(self):
+        if self._signatureRadius is None or self._signatureRadius == -1:
+            return math.inf
+        return self._signatureRadius
+
+    @signatureRadius.setter
+    def signatureRadius(self, val):
+        if val is not None and math.isinf(val):
+            val = None
+        self._signatureRadius = val
+
+    @property
+    def radius(self):
+        return self._radius or 0
+
+    @radius.setter
+    def radius(self, val):
+        self._radius = val
 
     @classmethod
     def importPatterns(cls, text):
@@ -46,7 +98,7 @@ class TargetResists(object):
         # When we import damage profiles, we create new ones and update old ones. To do this, get a list of current
         # patterns to allow lookup
         lookup = {}
-        current = eos.db.getTargetResistsList()
+        current = eos.db.getTargetProfileList()
         for pattern in current:
             lookup[pattern.name] = pattern
 
@@ -56,20 +108,22 @@ class TargetResists(object):
                     continue
                 line = line.split('#', 1)[0]  # allows for comments
                 type, data = line.rsplit('=', 1)
-                type, data = type.strip(), data.split(',')
+                type, data = type.strip(), [d.strip() for d in data.split(',')]
             except:
                 pyfalog.warning("Data isn't in correct format, continue to next line.")
                 continue
 
-            if type != "TargetResists":
+            if type not in ("TargetProfile", "TargetResists"):
                 continue
 
             numPatterns += 1
-            name, data = data[0], data[1:5]
+            name, dataRes, dataMisc = data[0], data[1:5], data[5:8]
             fields = {}
 
-            for index, val in enumerate(data):
-                val = float(val)
+            for index, val in enumerate(dataRes):
+                val = float(val) if val else 0
+                if math.isinf(val):
+                    val = 0
                 try:
                     assert 0 <= val <= 100
                     fields["%sAmount" % cls.DAMAGE_TYPES[index]] = val / 100
@@ -77,13 +131,24 @@ class TargetResists(object):
                     pyfalog.warning("Caught unhandled exception in import patterns.")
                     continue
 
-            if len(fields) == 4:  # Avoid possible blank lines
+            if len(dataMisc) == 3:
+                for index, val in enumerate(dataMisc):
+                    try:
+                        fieldName = ("maxVelocity", "signatureRadius", "radius")[index]
+                    except IndexError:
+                        break
+                    val = float(val) if val else 0
+                    if fieldName != "signatureRadius" and math.isinf(val):
+                        val = 0
+                    fields[fieldName] = val
+
+            if len(fields) in (4, 7):  # Avoid possible blank lines
                 if name.strip() in lookup:
                     pattern = lookup[name.strip()]
                     pattern.update(**fields)
                     eos.db.save(pattern)
                 else:
-                    pattern = TargetResists(**fields)
+                    pattern = TargetProfile(**fields)
                     pattern.name = name.strip()
                     eos.db.save(pattern)
                 patterns.append(pattern)
@@ -92,25 +157,30 @@ class TargetResists(object):
 
         return patterns, numPatterns
 
-    EXPORT_FORMAT = "TargetResists = %s,%.1f,%.1f,%.1f,%.1f\n"
+    EXPORT_FORMAT = "TargetProfile = %s,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f\n"
 
     @classmethod
     def exportPatterns(cls, *patterns):
         out = "# Exported from pyfa\n#\n"
         out += "# Values are in following format:\n"
-        out += "# TargetResists = [name],[EM %],[Thermal %],[Kinetic %],[Explosive %]\n\n"
+        out += "# TargetProfile = [name],[EM %],[Thermal %],[Kinetic %],[Explosive %],[Max velocity m/s],[Signature radius m],[Radius m]\n\n"
         for dp in patterns:
             out += cls.EXPORT_FORMAT % (
                 dp.name,
                 dp.emAmount * 100,
                 dp.thermalAmount * 100,
                 dp.kineticAmount * 100,
-                dp.explosiveAmount * 100
+                dp.explosiveAmount * 100,
+                dp.maxVelocity,
+                dp.signatureRadius,
+                dp.radius
             )
 
         return out.strip()
 
     def __deepcopy__(self, memo):
-        p = TargetResists(self.emAmount, self.thermalAmount, self.kineticAmount, self.explosiveAmount)
+        p = TargetProfile(
+            self.emAmount, self.thermalAmount, self.kineticAmount, self.explosiveAmount,
+            self._maxVelocity, self._signatureRadius, self._radius)
         p.name = "%s copy" % self.name
         return p

eos/saveddata/user.py

@@ -24,7 +24,7 @@ import string
 from sqlalchemy.orm import validates
 
 
-class User(object):
+class User:
     def __init__(self, username, password=None, admin=False):
         self.username = username
         if password is not None:

eos/utils/cycles.py

@@ -0,0 +1,69 @@
+# Borrowed from new eos
+
+
+from utils.repr import makeReprStr
+
+
+class CycleInfo:
+
+    def __init__(self, activeTime, inactiveTime, quantity, isInactivityReload):
+        self.activeTime = activeTime
+        self.inactiveTime = inactiveTime
+        self.quantity = quantity
+        self.isInactivityReload = isInactivityReload
+
+    @property
+    def averageTime(self):
+        return self.activeTime + self.inactiveTime
+
+    def iterCycles(self):
+        i = 0
+        while i < self.quantity:
+            yield self.activeTime, self.inactiveTime, self.isInactivityReload
+            i += 1
+
+    def _getCycleQuantity(self):
+        return self.quantity
+
+    def _getTime(self):
+        return (self.activeTime + self.inactiveTime) * self.quantity
+
+    def __repr__(self):
+        spec = ['activeTime', 'inactiveTime', 'quantity', 'isInactivityReload']
+        return makeReprStr(self, spec)
+
+
+class CycleSequence:
+
+    def __init__(self, sequence, quantity):
+        self.sequence = sequence
+        self.quantity = quantity
+
+    @property
+    def averageTime(self):
+        """Get average time between cycles."""
+        return self._getTime() / self._getCycleQuantity()
+
+    def iterCycles(self):
+        i = 0
+        while i < self.quantity:
+            for cycleInfo in self.sequence:
+                for cycleTime, inactiveTime, isInactivityReload in cycleInfo.iterCycles():
+                    yield cycleTime, inactiveTime, isInactivityReload
+            i += 1
+
+    def _getCycleQuantity(self):
+        quantity = 0
+        for item in self.sequence:
+            quantity += item._getCycleQuantity()
+        return quantity
+
+    def _getTime(self):
+        time = 0
+        for item in self.sequence:
+            time += item._getTime()
+        return time
+
+    def __repr__(self):
+        spec = ['sequence', 'quantity']
+        return makeReprStr(self, spec)

eos/utils/default.py

@@ -0,0 +1,3 @@
+class DEFAULT:
+    """Singleton class to signify default argument value."""
+    pass

eos/utils/float.py

@@ -18,7 +18,7 @@ keepDigits = int(sys.float_info.dig / 2)
 
 def floatUnerr(value):
     """Round possible float number error, killing some precision in process."""
-    if value == 0:
+    if value in (0, math.inf):
         return value
     # Find round factor, taking into consideration that we want to keep at least
     # predefined amount of significant digits

eos/utils/spoolSupport.py

@@ -18,6 +18,7 @@
 # ===============================================================================
 
 
+import math
 from collections import namedtuple
 
 from eos.const import SpoolType
@@ -36,15 +37,33 @@ def calculateSpoolup(modMaxValue, modStepValue, modCycleTime, spoolType, spoolAm
     """
     if not modMaxValue or not modStepValue:
         return 0, 0, 0
-    if spoolType == SpoolType.SCALE:
-        cycles = int(floatUnerr(spoolAmount * modMaxValue / modStepValue))
-        return cycles * modStepValue, cycles, cycles * modCycleTime
+    if spoolType == SpoolType.SPOOL_SCALE:
+        # Find out at which point of spoolup scale we're on, find out how many cycles
+        # is enough to reach it and recalculate spoolup value for that amount of cycles
+        cycles = math.ceil(floatUnerr(modMaxValue * spoolAmount / modStepValue))
+        spoolValue = min(modMaxValue, cycles * modStepValue)
+        return spoolValue, cycles, cycles * modCycleTime
+    elif spoolType == SpoolType.CYCLE_SCALE:
+        # For cycle scale, find out max amount of cycles and scale against it
+        cycles = round(spoolAmount * math.ceil(floatUnerr(modMaxValue / modStepValue)))
+        spoolValue = min(modMaxValue, cycles * modStepValue)
+        return spoolValue, cycles, cycles * modCycleTime
     elif spoolType == SpoolType.TIME:
-        cycles = min(int(floatUnerr(spoolAmount / modCycleTime)), int(floatUnerr(modMaxValue / modStepValue)))
-        return cycles * modStepValue, cycles, cycles * modCycleTime
+        cycles = min(
+            # How many full cycles mod had by passed time
+            math.floor(floatUnerr(spoolAmount / modCycleTime)),
+            # Max amount of cycles
+            math.ceil(floatUnerr(modMaxValue / modStepValue)))
+        spoolValue = min(modMaxValue, cycles * modStepValue)
+        return spoolValue, cycles, cycles * modCycleTime
     elif spoolType == SpoolType.CYCLES:
-        cycles = min(int(spoolAmount), int(floatUnerr(modMaxValue / modStepValue)))
-        return cycles * modStepValue, cycles, cycles * modCycleTime
+        cycles = min(
+            # Consider full cycles only
+            math.floor(spoolAmount),
+            # Max amount of cycles
+            math.ceil(floatUnerr(modMaxValue / modStepValue)))
+        spoolValue = min(modMaxValue, cycles * modStepValue)
+        return spoolValue, cycles, cycles * modCycleTime
     else:
         return 0, 0, 0
 

eos/utils/stats.py

@@ -18,6 +18,10 @@
 # ===============================================================================
 
 
+from eos.utils.float import floatUnerr
+from utils.repr import makeReprStr
+
+
 class DmgTypes:
     """Container for damage data stats."""
 
@@ -39,12 +43,14 @@ class DmgTypes:
     def __eq__(self, other):
         if not isinstance(other, DmgTypes):
             return NotImplemented
-        return all((
-            self.em == other.em,
-            self.thermal == other.thermal,
-            self.kinetic == other.kinetic,
-            self.explosive == other.explosive,
-            self.total == other.total))
+        # Round for comparison's sake because often damage profiles are
+        # generated from data which includes float errors
+        return (
+                floatUnerr(self.em) == floatUnerr(other.em) and
+                floatUnerr(self.thermal) == floatUnerr(other.thermal) and
+                floatUnerr(self.kinetic) == floatUnerr(other.kinetic) and
+                floatUnerr(self.explosive) == floatUnerr(other.explosive) and
+                floatUnerr(self.total) == floatUnerr(other.total))
 
     def __bool__(self):
         return any((
@@ -68,3 +74,144 @@ class DmgTypes:
         self.explosive += other.explosive
         self._calcTotal()
         return self
+
+    def __mul__(self, mul):
+        return type(self)(
+            em=self.em * mul,
+            thermal=self.thermal * mul,
+            kinetic=self.kinetic * mul,
+            explosive=self.explosive * mul)
+
+    def __imul__(self, mul):
+        if mul == 1:
+            return
+        self.em *= mul
+        self.thermal *= mul
+        self.kinetic *= mul
+        self.explosive *= mul
+        self._calcTotal()
+        return self
+
+    def __truediv__(self, div):
+        return type(self)(
+            em=self.em / div,
+            thermal=self.thermal / div,
+            kinetic=self.kinetic / div,
+            explosive=self.explosive / div)
+
+    def __itruediv__(self, div):
+        if div == 1:
+            return
+        self.em /= div
+        self.thermal /= div
+        self.kinetic /= div
+        self.explosive /= div
+        self._calcTotal()
+        return self
+
+    def __repr__(self):
+        spec = DmgTypes.names()
+        spec.append('total')
+        return makeReprStr(self, spec)
+
+    @staticmethod
+    def names(short=None, postProcessor=None):
+        value = ['em', 'th', 'kin', 'exp'] if short else ['em', 'thermal', 'kinetic', 'explosive']
+
+        if postProcessor:
+            value = [postProcessor(x) for x in value]
+
+        return value
+
+
+class RRTypes:
+    """Container for tank data stats."""
+
+    def __init__(self, shield, armor, hull, capacitor):
+        self.shield = shield
+        self.armor = armor
+        self.hull = hull
+        self.capacitor = capacitor
+
+    # Iterator is needed to support tuple-style unpacking
+    def __iter__(self):
+        yield self.shield
+        yield self.armor
+        yield self.hull
+        yield self.capacitor
+
+    def __eq__(self, other):
+        if not isinstance(other, RRTypes):
+            return NotImplemented
+        # Round for comparison's sake because often tanking numbers are
+        # generated from data which includes float errors
+        return (
+                floatUnerr(self.shield) == floatUnerr(other.shield) and
+                floatUnerr(self.armor) == floatUnerr(other.armor) and
+                floatUnerr(self.hull) == floatUnerr(other.hull) and
+                floatUnerr(self.capacitor) == floatUnerr(other.capacitor))
+
+    def __bool__(self):
+        return any((self.shield, self.armor, self.hull, self.capacitor))
+
+    def __add__(self, other):
+        return type(self)(
+            shield=self.shield + other.shield,
+            armor=self.armor + other.armor,
+            hull=self.hull + other.hull,
+            capacitor=self.capacitor + other.capacitor)
+
+    def __iadd__(self, other):
+        self.shield += other.shield
+        self.armor += other.armor
+        self.hull += other.hull
+        self.capacitor += other.capacitor
+        return self
+
+    def __mul__(self, mul):
+        return type(self)(
+            shield=self.shield * mul,
+            armor=self.armor * mul,
+            hull=self.hull * mul,
+            capacitor=self.capacitor * mul)
+
+    def __imul__(self, mul):
+        if mul == 1:
+            return
+        self.shield *= mul
+        self.armor *= mul
+        self.hull *= mul
+        self.capacitor *= mul
+        return self
+
+    def __truediv__(self, div):
+        return type(self)(
+            shield=self.shield / div,
+            armor=self.armor / div,
+            hull=self.hull / div,
+            capacitor=self.capacitor / div)
+
+    def __itruediv__(self, div):
+        if div == 1:
+            return self
+        self.shield /= div
+        self.armor /= div
+        self.hull /= div
+        self.capacitor /= div
+        return self
+
+    def __repr__(self):
+        spec = RRTypes.names(False)
+        return makeReprStr(self, spec)
+
+    @staticmethod
+    def names(ehpOnly=True, postProcessor=None):
+        value = ['shield', 'armor', 'hull']
+
+        if not ehpOnly:
+            value.append('capacitor')
+
+        if postProcessor:
+            value = [postProcessor(x) for x in value]
+
+        return value

graphs/__init__.py

@@ -0,0 +1,22 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from .gui.canvasPanel import graphFrame_enabled
+from .gui.frame import GraphFrame

graphs/calc.py

@@ -0,0 +1,37 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from service.settings import GraphSettings
+
+
+def checkLockRange(src, distance):
+    if distance is None:
+        return True
+    if GraphSettings.getInstance().get('ignoreLockRange'):
+        return True
+    return distance <= src.item.maxTargetRange
+
+
+def checkDroneControlRange(src, distance):
+    if distance is None:
+        return True
+    if GraphSettings.getInstance().get('ignoreDCR'):
+        return True
+    return distance <= src.item.extraAttributes['droneControlRange']

graphs/data/__init__.py

@@ -0,0 +1,30 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from . import fitDamageStats
+from . import fitEwarStats
+from . import fitRemoteReps
+from . import fitShieldRegen
+from . import fitCapacitor
+from . import fitMobility
+from . import fitWarpTime
+from . import fitLockTime
+# Hidden graphs, available via ctrl-alt-g
+from . import fitEcmBurstScanresDamps

graphs/data/base/__init__.py

@@ -0,0 +1,23 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+from .cache import FitDataCache
+from .defs import XDef, YDef, VectorDef, Input, InputCheckbox
+from .getter import PointGetter, SmoothPointGetter
+from .graph import FitGraph

graphs/data/base/cache.py

@@ -18,22 +18,14 @@
 # =============================================================================
 
 
-class Graph(object):
-    views = []
-
-    @classmethod
-    def register(cls):
-        Graph.views.append(cls)
+class FitDataCache:
 
     def __init__(self):
-        self.name = ""
+        self._data = {}
 
-    def getFields(self, fit, fields):
-        raise NotImplementedError()
+    def clearForFit(self, fitID):
+        if fitID in self._data:
+            del self._data[fitID]
 
-    def getIcons(self):
-        return None
-
-
-# noinspection PyUnresolvedReferences
-from gui.builtinGraphs import fitDps  # noqa: E402, F401
+    def clearAll(self):
+        self._data.clear()

graphs/data/base/defs.py

@@ -0,0 +1,134 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from collections import namedtuple
+
+
+VectorDef = namedtuple('VectorDef', ('lengthHandle', 'lengthUnit', 'angleHandle', 'angleUnit', 'label'))
+
+
+class YDef:
+
+    def __init__(self, handle, unit, label, selectorLabel=None):
+        self.handle = handle
+        self.unit = unit
+        self.label = label
+        self._selectorLabel = selectorLabel
+
+    @property
+    def selectorLabel(self):
+        if self._selectorLabel is not None:
+            return self._selectorLabel
+        return self.label
+
+    def __hash__(self):
+        return hash((self.handle, self.unit, self.label, self._selectorLabel))
+
+    def __eq__(self, other):
+        if not isinstance(other, YDef):
+            return False
+        return all((
+            self.handle == other.handle,
+            self.unit == other.unit,
+            self.label == other.label,
+            self._selectorLabel == other._selectorLabel))
+
+
+class XDef:
+
+    def __init__(self, handle, unit, label, mainInput, selectorLabel=None):
+        self.handle = handle
+        self.unit = unit
+        self.label = label
+        self.mainInput = mainInput
+        self._selectorLabel = selectorLabel
+
+    @property
+    def selectorLabel(self):
+        if self._selectorLabel is not None:
+            return self._selectorLabel
+        return self.label
+
+    def __hash__(self):
+        return hash((self.handle, self.unit, self.label, self.mainInput, self._selectorLabel))
+
+    def __eq__(self, other):
+        if not isinstance(other, XDef):
+            return False
+        return all((
+            self.handle == other.handle,
+            self.unit == other.unit,
+            self.label == other.label,
+            self.mainInput == other.mainInput,
+            self._selectorLabel == other._selectorLabel))
+
+
+class Input:
+
+    def __init__(self, handle, unit, label, iconID, defaultValue, defaultRange, mainTooltip=None, secondaryTooltip=None, conditions=()):
+        self.handle = handle
+        self.unit = unit
+        self.label = label
+        self.iconID = iconID
+        self.defaultValue = defaultValue
+        self.defaultRange = defaultRange
+        self.mainTooltip = mainTooltip
+        self.secondaryTooltip = secondaryTooltip
+        # Format: ((x condition, y condition), (x condition, y condition), ...)
+        self.conditions = tuple(conditions)
+
+    def __hash__(self):
+        return hash((self.handle, self.unit, self.label, self.iconID, self.defaultValue, self.defaultRange, self.mainTooltip, self.secondaryTooltip, self.conditions))
+
+    def __eq__(self, other):
+        if not isinstance(other, Input):
+            return False
+        return all((
+            self.handle == other.handle,
+            self.unit == other.unit,
+            self.label == other.label,
+            self.iconID == other.iconID,
+            self.defaultValue == other.defaultValue,
+            self.defaultRange == other.defaultRange,
+            self.mainTooltip == other.mainTooltip,
+            self.secondaryTooltip == other.secondaryTooltip,
+            self.conditions == other.conditions))
+
+
+class InputCheckbox:
+
+    def __init__(self, handle, label, defaultValue, conditions=()):
+        self.handle = handle
+        self.label = label
+        self.defaultValue = defaultValue
+        # Format: ((x condition, y condition), (x condition, y condition), ...)
+        self.conditions = tuple(conditions)
+
+    def __hash__(self):
+        return hash((self.handle, self.label, self.defaultValue, self.conditions))
+
+    def __eq__(self, other):
+        if not isinstance(other, Input):
+            return False
+        return all((
+            self.handle == other.handle,
+            self.label == other.label,
+            self.defaultValue == other.defaultValue,
+            self.conditions == other.conditions))

graphs/data/base/getter.py

@@ -0,0 +1,95 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+import math
+from abc import ABCMeta, abstractmethod
+
+
+class PointGetter(metaclass=ABCMeta):
+
+    def __init__(self, graph):
+        self.graph = graph
+
+    @abstractmethod
+    def getRange(self, xRange, miscParams, src, tgt):
+        raise NotImplementedError
+
+    @abstractmethod
+    def getPoint(self, x, miscParams, src, tgt):
+        raise NotImplementedError
+
+
+class SmoothPointGetter(PointGetter, metaclass=ABCMeta):
+
+    _baseResolution = 200
+    _extraDepth = 0
+
+    def getRange(self, xRange, miscParams, src, tgt):
+        xs = []
+        ys = []
+        commonData = self._getCommonData(miscParams=miscParams, src=src, tgt=tgt)
+
+        def addExtraPoints(x1, y1, x2, y2, depth):
+            if depth <= 0 or y1 == y2:
+                return
+            newX = (x1 + x2) / 2
+            newY = self._calculatePoint(x=newX, miscParams=miscParams, src=src, tgt=tgt, commonData=commonData)
+            addExtraPoints(x1=prevX, y1=prevY, x2=newX, y2=newY, depth=depth - 1)
+            xs.append(newX)
+            ys.append(newY)
+            addExtraPoints(x1=newX, y1=newY, x2=x2, y2=y2, depth=depth - 1)
+
+        prevX = None
+        prevY = None
+        # Go through X points defined by our resolution setting
+        for x in self._xIterLinear(xRange):
+            y = self._calculatePoint(x=x, miscParams=miscParams, src=src, tgt=tgt, commonData=commonData)
+            if prevX is not None and prevY is not None:
+                # And if Y values of adjacent data points are not equal, add extra points
+                # depending on extra depth setting
+                addExtraPoints(x1=prevX, y1=prevY, x2=x, y2=y, depth=self._extraDepth)
+            prevX = x
+            prevY = y
+            xs.append(x)
+            ys.append(y)
+        return xs, ys
+
+    def getPoint(self, x, miscParams, src, tgt):
+        commonData = self._getCommonData(miscParams=miscParams, src=src, tgt=tgt)
+        return self._calculatePoint(x=x, miscParams=miscParams, src=src, tgt=tgt, commonData=commonData)
+
+    def _xIterLinear(self, xRange):
+        xLow = min(xRange)
+        xHigh = max(xRange)
+        # Resolution defines amount of ranges between points here,
+        # not amount of points
+        step = (xHigh - xLow) / self._baseResolution
+        if step == 0 or math.isnan(step):
+            yield xLow
+        else:
+            for i in range(self._baseResolution + 1):
+                yield xLow + step * i
+
+    def _getCommonData(self, miscParams, src, tgt):
+        return {}
+
+    @abstractmethod
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        raise NotImplementedError

graphs/data/base/graph.py

@@ -0,0 +1,299 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+import math
+from abc import ABCMeta, abstractmethod
+from collections import OrderedDict
+
+from eos.utils.float import floatUnerr
+from service.const import GraphCacheCleanupReason
+
+
+class FitGraph(metaclass=ABCMeta):
+
+    # UI stuff
+    hidden = False
+    views = []
+    viewMap = {}
+
+    @classmethod
+    def register(cls):
+        FitGraph.views.append(cls)
+        FitGraph.viewMap[cls.internalName] = cls
+
+    def __init__(self):
+        # Format: {(fit ID, target type, target ID): {(xSpec, ySpec): (xs, ys)}}
+        self._plotCache = {}
+        # Format: {(fit ID, target type, target ID): {(xSpec, ySpec): {x: y}}}
+        self._pointCache = {}
+
+    @property
+    @abstractmethod
+    def name(self):
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def internalName(self):
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def yDefs(self):
+        raise NotImplementedError
+
+    @property
+    def yDefMap(self):
+        return OrderedDict(((y.handle, y.unit), y) for y in self.yDefs)
+
+    @property
+    @abstractmethod
+    def xDefs(self):
+        raise NotImplementedError
+
+    @property
+    def xDefMap(self):
+        return OrderedDict(((x.handle, x.unit), x) for x in self.xDefs)
+
+    @property
+    def inputs(self):
+        raise NotImplementedError
+
+    @property
+    def inputMap(self):
+        return OrderedDict(((i.handle, i.unit), i) for i in self.inputs)
+
+    checkboxes = ()
+
+    @property
+    def checkboxesMap(self):
+        return OrderedDict((ec.handle, ec) for ec in self.checkboxes)
+
+    hasTargets = False
+    srcVectorDef = None
+    tgtVectorDef = None
+    srcExtraCols = ()
+    tgtExtraCols = ()
+    usesHpEffectivity = False
+
+    def getPlotPoints(self, mainInput, miscInputs, xSpec, ySpec, src, tgt=None):
+        cacheKey = self._makeCacheKey(src=src, tgt=tgt)
+        try:
+            plotData = self._plotCache[cacheKey][(ySpec, xSpec)]
+        except KeyError:
+            plotData = self._calcPlotPoints(
+                mainInput=mainInput, miscInputs=miscInputs,
+                xSpec=xSpec, ySpec=ySpec, src=src, tgt=tgt)
+            self._plotCache.setdefault(cacheKey, {})[(ySpec, xSpec)] = plotData
+        return plotData
+
+    def getPoint(self, x, miscInputs, xSpec, ySpec, src, tgt=None):
+        cacheKey = self._makeCacheKey(src=src, tgt=tgt)
+        try:
+            y = self._pointCache[cacheKey][(ySpec, xSpec)][x]
+        except KeyError:
+            y = self._calcPoint(x=x, miscInputs=miscInputs, xSpec=xSpec, ySpec=ySpec, src=src, tgt=tgt)
+            self._pointCache.setdefault(cacheKey, {}).setdefault((ySpec, xSpec), {})[x] = y
+        return y
+
+    def clearCache(self, reason, extraData=None):
+        caches = (self._plotCache, self._pointCache)
+        plotKeysToClear = set()
+        # If fit changed - clear plots which concern this fit
+        if reason in (GraphCacheCleanupReason.fitChanged, GraphCacheCleanupReason.fitRemoved):
+            for cache in caches:
+                for cacheKey in cache:
+                    cacheFitID, cacheTgtType, cacheTgtID = cacheKey
+                    if extraData == cacheFitID:
+                        plotKeysToClear.add(cacheKey)
+                    elif cacheTgtType == 'fit' and extraData == cacheTgtID:
+                        plotKeysToClear.add(cacheKey)
+        # Same for profile
+        elif reason in (GraphCacheCleanupReason.profileChanged, GraphCacheCleanupReason.profileRemoved):
+            for cache in caches:
+                for cacheKey in cache:
+                    cacheFitID, cacheTgtType, cacheTgtID = cacheKey
+                    if cacheTgtType == 'profile' and extraData == cacheTgtID:
+                        plotKeysToClear.add(cacheKey)
+        # Target fit resist mode changed
+        elif reason == GraphCacheCleanupReason.resistModeChanged:
+            for cache in caches:
+                for cacheKey in cache:
+                    cacheFitID, cacheTgtType, cacheTgtID = cacheKey
+                    if cacheTgtType == 'fit' and extraData == cacheTgtID:
+                        plotKeysToClear.add(cacheKey)
+        # Wipe out whole plot cache otherwise
+        else:
+            for cache in caches:
+                for cacheKey in cache:
+                    plotKeysToClear.add(cacheKey)
+        # Do actual cleanup
+        for cache in caches:
+            for cacheKey in plotKeysToClear:
+                try:
+                    del cache[cacheKey]
+                except KeyError:
+                    pass
+        # Process any internal caches graphs might have
+        self._clearInternalCache(reason, extraData)
+
+    def _makeCacheKey(self, src, tgt):
+        if tgt is not None and tgt.isFit:
+            tgtType = 'fit'
+            tgtItemID = tgt.item.ID
+        elif tgt is not None and tgt.isProfile:
+            tgtType = 'profile'
+            tgtItemID = tgt.item.ID
+        else:
+            tgtType = None
+            tgtItemID = None
+        cacheKey = (src.item.ID, tgtType, tgtItemID)
+        return cacheKey
+
+    def _clearInternalCache(self, reason, extraData):
+        return
+
+    # Calculation stuff
+    def _calcPlotPoints(self, mainInput, miscInputs, xSpec, ySpec, src, tgt):
+        mainParamRange = self._normalizeMain(mainInput=mainInput, src=src, tgt=tgt)
+        miscParams = self._normalizeMisc(miscInputs=miscInputs, src=src, tgt=tgt)
+        mainParamRange = self._limitMain(mainParamRange=mainParamRange, src=src, tgt=tgt)
+        miscParams = self._limitMisc(miscParams=miscParams, src=src, tgt=tgt)
+        xs, ys = self._getPlotPoints(
+            xRange=mainParamRange[1], miscParams=miscParams,
+            xSpec=xSpec, ySpec=ySpec, src=src, tgt=tgt)
+        ys = self._denormalizeValues(values=ys, axisSpec=ySpec, src=src, tgt=tgt)
+        # Sometimes x denormalizer may fail (e.g. during conversion of 0 ship speed to %).
+        # If both inputs and outputs are in %, do some extra processing to at least have
+        # proper graph which shows the same value over whole specified relative parameter
+        # range
+        try:
+            xs = self._denormalizeValues(values=xs, axisSpec=xSpec, src=src, tgt=tgt)
+        except ZeroDivisionError:
+            if mainInput.unit == xSpec.unit == '%' and len(set(floatUnerr(y) for y in ys)) == 1:
+                xs = [min(mainInput.value), max(mainInput.value)]
+                ys = [ys[0], ys[0]]
+            else:
+                raise
+        else:
+            # Same for NaN which means we tried to denormalize infinity values, which might be the
+            # case for the ideal target profile with infinite signature radius
+            if mainInput.unit == xSpec.unit == '%' and all(math.isnan(x) for x in xs):
+                xs = [min(mainInput.value), max(mainInput.value)]
+                ys = [ys[0], ys[0]]
+        return xs, ys
+
+    def _calcPoint(self, x, miscInputs, xSpec, ySpec, src, tgt):
+        x = self._normalizeValue(value=x, axisSpec=xSpec, src=src, tgt=tgt)
+        miscParams = self._normalizeMisc(miscInputs=miscInputs, src=src, tgt=tgt)
+        miscParams = self._limitMisc(miscParams=miscParams, src=src, tgt=tgt)
+        y = self._getPoint(x=x, miscParams=miscParams, xSpec=xSpec, ySpec=ySpec, src=src, tgt=tgt)
+        y = self._denormalizeValue(value=y, axisSpec=ySpec, src=src, tgt=tgt)
+        return y
+
+    _normalizers = {}
+
+    def _normalizeMain(self, mainInput, src, tgt):
+        key = (mainInput.handle, mainInput.unit)
+        if key in self._normalizers:
+            normalizer = self._normalizers[key]
+            mainParamRange = (mainInput.handle, tuple(normalizer(v, src, tgt) for v in mainInput.value))
+        else:
+            mainParamRange = (mainInput.handle, mainInput.value)
+        return mainParamRange
+
+    def _normalizeMisc(self, miscInputs, src, tgt):
+        miscParams = {}
+        for miscInput in miscInputs:
+            key = (miscInput.handle, miscInput.unit)
+            if key in self._normalizers:
+                normalizer = self._normalizers[key]
+                miscParams[miscInput.handle] = normalizer(miscInput.value, src, tgt)
+            else:
+                miscParams[miscInput.handle] = miscInput.value
+        return miscParams
+
+    def _normalizeValue(self, value, axisSpec, src, tgt):
+        key = (axisSpec.handle, axisSpec.unit)
+        if key in self._normalizers:
+            normalizer = self._normalizers[key]
+            value = normalizer(value, src, tgt)
+        return value
+
+    _limiters = {}
+
+    def _limitMain(self, mainParamRange, src, tgt):
+        mainHandle, mainValue = mainParamRange
+        if mainHandle in self._limiters:
+            limiter = self._limiters[mainHandle]
+            mainParamRange = (mainHandle, tuple(self.__limitToRange(v, limiter(src, tgt)) for v in mainValue))
+        return mainParamRange
+
+    def _limitMisc(self, miscParams, src, tgt):
+        for miscHandle in miscParams:
+            if miscHandle in self._limiters:
+                limiter = self._limiters[miscHandle]
+                miscValue = miscParams[miscHandle]
+                miscParams[miscHandle] = self.__limitToRange(miscValue, limiter(src, tgt))
+        return miscParams
+
+    @staticmethod
+    def __limitToRange(val, limitRange):
+        if val is None:
+            return None
+        val = max(val, min(limitRange))
+        val = min(val, max(limitRange))
+        return val
+
+    _getters = {}
+
+    def _getPlotPoints(self, xRange, miscParams, xSpec, ySpec, src, tgt):
+        try:
+            getterClass = self._getters[(xSpec.handle, ySpec.handle)]
+        except KeyError:
+            return [], []
+        else:
+            getter = getterClass(graph=self)
+            return getter.getRange(xRange=xRange, miscParams=miscParams, src=src, tgt=tgt)
+
+    def _getPoint(self, x, miscParams, xSpec, ySpec, src, tgt):
+        try:
+            getterClass = self._getters[(xSpec.handle, ySpec.handle)]
+        except KeyError:
+            return [], []
+        else:
+            getter = getterClass(graph=self)
+            return getter.getPoint(x=x, miscParams=miscParams, src=src, tgt=tgt)
+
+    _denormalizers = {}
+
+    def _denormalizeValues(self, values, axisSpec, src, tgt):
+        key = (axisSpec.handle, axisSpec.unit)
+        if key in self._denormalizers:
+            denormalizer = self._denormalizers[key]
+            values = [denormalizer(v, src, tgt) for v in values]
+        return values
+
+    def _denormalizeValue(self, value, axisSpec, src, tgt):
+        key = (axisSpec.handle, axisSpec.unit)
+        if key in self._denormalizers:
+            denormalizer = self._denormalizers[key]
+            value = denormalizer(value, src, tgt)
+        return value

graphs/data/fitCapacitor/__init__.py

@@ -0,0 +1,24 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from .graph import FitCapacitorGraph
+
+
+FitCapacitorGraph.register()

graphs/data/fitCapacitor/getter.py

@@ -0,0 +1,197 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+import math
+
+from graphs.data.base import SmoothPointGetter
+
+
+class Time2CapAmountGetter(SmoothPointGetter):
+
+    def getRange(self, xRange, miscParams, src, tgt):
+        # Use smooth getter when we're not using cap sim
+        if not miscParams['useCapsim']:
+            return super().getRange(xRange=xRange, miscParams=miscParams, src=src, tgt=tgt)
+        capAmountT0 = miscParams['capAmountT0'] or 0
+        capSimDataRaw = src.item.getCapSimData(startingCap=capAmountT0)
+        # Same here, no cap sim data - use smooth getter which considers only regen
+        if not capSimDataRaw:
+            return super().getRange(xRange=xRange, miscParams=miscParams, src=src, tgt=tgt)
+        capSimDataMaxTime = capSimDataRaw[-1][0]
+        minTime, maxTime = xRange
+        maxTime = min(maxTime, capSimDataMaxTime)
+        maxPointXDistance = (maxTime - minTime) / self._baseResolution
+        capSimDataInRange = {k: v for k, v in capSimDataRaw if minTime <= k <= maxTime}
+        prevTime = minTime
+        xs = []
+        ys = []
+        capSimDataBefore = {k: v for k, v in capSimDataRaw if k < minTime}
+        # When time range lies to the right of last cap sim data point, return nothing
+        if len(capSimDataBefore) > 0 and max(capSimDataBefore) == capSimDataMaxTime:
+            return xs, ys
+        maxCapAmount = src.item.ship.getModifiedItemAttr('capacitorCapacity')
+        capRegenTime = src.item.ship.getModifiedItemAttr('rechargeRate') / 1000
+
+        def plotCapRegen(prevTime, prevCap, currentTime):
+            subrangeAmount = math.ceil((currentTime - prevTime) / maxPointXDistance)
+            subrangeLength = (currentTime - prevTime) / subrangeAmount
+            for i in range(1, subrangeAmount + 1):
+                subrangeTime = prevTime + subrangeLength * i
+                subrangeCap = calculateCapAmount(
+                    maxCapAmount=maxCapAmount,
+                    capRegenTime=capRegenTime,
+                    capAmountT0=prevCap,
+                    time=subrangeTime - prevTime)
+                xs.append(subrangeTime)
+                ys.append(subrangeCap)
+
+        # Calculate starting cap for first value seen in our range
+        if capSimDataBefore:
+            timeBefore = max(capSimDataBefore)
+            capBefore = capSimDataBefore[timeBefore]
+            prevCap = calculateCapAmount(
+                    maxCapAmount=maxCapAmount,
+                    capRegenTime=capRegenTime,
+                    capAmountT0=capBefore,
+                    time=prevTime - timeBefore)
+        else:
+            prevCap = calculateCapAmount(
+                maxCapAmount=maxCapAmount,
+                capRegenTime=capRegenTime,
+                capAmountT0=capAmountT0,
+                time=prevTime)
+        xs.append(prevTime)
+        ys.append(prevCap)
+        for currentTime in sorted(capSimDataInRange):
+            if currentTime > prevTime:
+                plotCapRegen(prevTime=prevTime, prevCap=prevCap, currentTime=currentTime)
+            currentCap = capSimDataInRange[currentTime]
+            xs.append(currentTime)
+            ys.append(currentCap)
+            prevTime = currentTime
+            prevCap = currentCap
+        if maxTime > prevTime:
+            plotCapRegen(prevTime=prevTime, prevCap=prevCap, currentTime=maxTime)
+        return xs, ys
+
+    def getPoint(self, x, miscParams, src, tgt):
+        # Use smooth getter when we're not using cap sim
+        if not miscParams['useCapsim']:
+            return super().getPoint(x=x, miscParams=miscParams, src=src, tgt=tgt)
+        capAmountT0 = miscParams['capAmountT0'] or 0
+        capSimDataRaw = src.item.getCapSimData(startingCap=capAmountT0)
+        # Same here, no cap sim data - use smooth getter which considers only regen
+        if not capSimDataRaw:
+            return super().getPoint(x=x, miscParams=miscParams, src=src, tgt=tgt)
+        currentTime = x
+        capSimDataBefore = {k: v for k, v in capSimDataRaw if k <= currentTime}
+        capSimDataMaxTime = capSimDataRaw[-1][0]
+        # When time range lies to the right of last cap sim data point, return nothing
+        if len(capSimDataBefore) > 0 and max(capSimDataBefore) == capSimDataMaxTime:
+            return None
+        maxCapAmount = src.item.ship.getModifiedItemAttr('capacitorCapacity')
+        capRegenTime = src.item.ship.getModifiedItemAttr('rechargeRate') / 1000
+        if capSimDataBefore:
+            timeBefore = max(capSimDataBefore)
+            capBefore = capSimDataBefore[timeBefore]
+            if timeBefore == currentTime:
+                currentCap = capBefore
+            else:
+                currentCap = calculateCapAmount(
+                        maxCapAmount=maxCapAmount,
+                        capRegenTime=capRegenTime,
+                        capAmountT0=capBefore,
+                        time=currentTime - timeBefore)
+        else:
+            currentCap = calculateCapAmount(
+                maxCapAmount=maxCapAmount,
+                capRegenTime=capRegenTime,
+                capAmountT0=capAmountT0,
+                time=currentTime)
+        return currentCap
+
+    def _getCommonData(self, miscParams, src, tgt):
+        return {
+            'maxCapAmount': src.item.ship.getModifiedItemAttr('capacitorCapacity'),
+            'capRegenTime': src.item.ship.getModifiedItemAttr('rechargeRate') / 1000}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        time = x
+        capAmount = calculateCapAmount(
+            maxCapAmount=commonData['maxCapAmount'],
+            capRegenTime=commonData['capRegenTime'],
+            capAmountT0=miscParams['capAmountT0'] or 0,
+            time=time)
+        return capAmount
+
+
+class Time2CapRegenGetter(SmoothPointGetter):
+
+    def _getCommonData(self, miscParams, src, tgt):
+        return {
+            'maxCapAmount': src.item.ship.getModifiedItemAttr('capacitorCapacity'),
+            'capRegenTime': src.item.ship.getModifiedItemAttr('rechargeRate') / 1000}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        time = x
+        capAmount = calculateCapAmount(
+            maxCapAmount=commonData['maxCapAmount'],
+            capRegenTime=commonData['capRegenTime'],
+            capAmountT0=miscParams['capAmountT0'] or 0,
+            time=time)
+        capRegen = calculateCapRegen(
+            maxCapAmount=commonData['maxCapAmount'],
+            capRegenTime=commonData['capRegenTime'],
+            currentCapAmount=capAmount)
+        return capRegen
+
+
+# Useless, but valid combination of x and y
+class CapAmount2CapAmountGetter(SmoothPointGetter):
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        capAmount = x
+        return capAmount
+
+
+class CapAmount2CapRegenGetter(SmoothPointGetter):
+
+    def _getCommonData(self, miscParams, src, tgt):
+        return {
+            'maxCapAmount': src.item.ship.getModifiedItemAttr('capacitorCapacity'),
+            'capRegenTime': src.item.ship.getModifiedItemAttr('rechargeRate') / 1000}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        capAmount = x
+        capRegen = calculateCapRegen(
+            maxCapAmount=commonData['maxCapAmount'],
+            capRegenTime=commonData['capRegenTime'],
+            currentCapAmount=capAmount)
+        return capRegen
+
+
+def calculateCapAmount(maxCapAmount, capRegenTime, capAmountT0, time):
+    # https://wiki.eveuniversity.org/Capacitor#Capacitor_recharge_rate
+    return maxCapAmount * (1 + math.exp(5 * -time / capRegenTime) * (math.sqrt(capAmountT0 / maxCapAmount) - 1)) ** 2
+
+
+def calculateCapRegen(maxCapAmount, capRegenTime, currentCapAmount):
+    # https://wiki.eveuniversity.org/Capacitor#Capacitor_recharge_rate
+    return 10 * maxCapAmount / capRegenTime * (math.sqrt(currentCapAmount / maxCapAmount) - currentCapAmount / maxCapAmount)

graphs/data/fitCapacitor/graph.py

@@ -0,0 +1,62 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from graphs.data.base import FitGraph, XDef, YDef, Input, InputCheckbox
+from .getter import CapAmount2CapAmountGetter, CapAmount2CapRegenGetter, Time2CapAmountGetter, Time2CapRegenGetter
+
+
+class FitCapacitorGraph(FitGraph):
+
+    # UI stuff
+    internalName = 'capacitorGraph'
+    name = 'Capacitor'
+    xDefs = [
+        XDef(handle='time', unit='s', label='Time', mainInput=('time', 's')),
+        XDef(handle='capAmount', unit='GJ', label='Cap amount', mainInput=('capAmount', '%')),
+        XDef(handle='capAmount', unit='%', label='Cap amount', mainInput=('capAmount', '%'))]
+    yDefs = [
+        YDef(handle='capAmount', unit='GJ', label='Cap amount'),
+        YDef(handle='capRegen', unit='GJ/s', label='Cap regen')]
+    inputs = [
+        Input(handle='time', unit='s', label='Time', iconID=1392, defaultValue=120, defaultRange=(0, 300), conditions=[
+            (('time', 's'), None)]),
+        Input(handle='capAmount', unit='%', label='Cap amount', iconID=1668, defaultValue=25, defaultRange=(0, 100), conditions=[
+            (('capAmount', 'GJ'), None),
+            (('capAmount', '%'), None)]),
+        Input(handle='capAmountT0', unit='%', label='Starting cap amount', iconID=1668, defaultValue=100, defaultRange=(0, 100), conditions=[
+            (('time', 's'), None)])]
+    checkboxes = [InputCheckbox(handle='useCapsim', label='Use capacitor simulator', defaultValue=True, conditions=[
+        (('time', 's'), ('capAmount', 'GJ'))])]
+    srcExtraCols = ('CapAmount', 'CapTime')
+
+    # Calculation stuff
+    _normalizers = {
+        ('capAmount', '%'): lambda v, src, tgt: v / 100 * src.item.ship.getModifiedItemAttr('capacitorCapacity'),
+        ('capAmountT0', '%'): lambda v, src, tgt: None if v is None else v / 100 * src.item.ship.getModifiedItemAttr('capacitorCapacity')}
+    _limiters = {
+        'time': lambda src, tgt: (0, 3600),
+        'capAmount': lambda src, tgt: (0, src.item.ship.getModifiedItemAttr('capacitorCapacity')),
+        'capAmountT0': lambda src, tgt: (0, src.item.ship.getModifiedItemAttr('capacitorCapacity'))}
+    _getters = {
+        ('time', 'capAmount'): Time2CapAmountGetter,
+        ('time', 'capRegen'): Time2CapRegenGetter,
+        ('capAmount', 'capAmount'): CapAmount2CapAmountGetter,
+        ('capAmount', 'capRegen'): CapAmount2CapRegenGetter}
+    _denormalizers = {('capAmount', '%'): lambda v, src, tgt: v * 100 / src.item.ship.getModifiedItemAttr('capacitorCapacity')}

graphs/data/fitDamageStats/__init__.py

@@ -0,0 +1,24 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from .graph import FitDamageStatsGraph
+
+
+FitDamageStatsGraph.register()

graphs/data/fitDamageStats/cache/__init__.py

@@ -0,0 +1,22 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from .projected import ProjectedDataCache
+from .time import TimeCache

graphs/data/fitDamageStats/cache/projected.py

@@ -0,0 +1,121 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from collections import namedtuple
+
+from eos.modifiedAttributeDict import getResistanceAttrID
+from graphs.data.base import FitDataCache
+
+
+ModProjData = namedtuple('ModProjData', ('boost', 'optimal', 'falloff', 'stackingGroup', 'resAttrID'))
+MobileProjData = namedtuple('MobileProjData', ('boost', 'optimal', 'falloff', 'stackingGroup', 'resAttrID', 'speed', 'radius'))
+
+
+class ProjectedDataCache(FitDataCache):
+
+    def getProjModData(self, src):
+        try:
+            projectedData = self._data[src.item.ID]['modules']
+        except KeyError:
+            # Format of items for both: (boost strength, optimal, falloff, stacking group, resistance attr ID)
+            webMods = []
+            tpMods = []
+            projectedData = self._data.setdefault(src.item.ID, {})['modules'] = (webMods, tpMods)
+            for mod in src.item.activeModulesIter():
+                for webEffectName in ('remoteWebifierFalloff', 'structureModuleEffectStasisWebifier'):
+                    if webEffectName in mod.item.effects:
+                        webMods.append(ModProjData(
+                            mod.getModifiedItemAttr('speedFactor'),
+                            mod.maxRange or 0,
+                            mod.falloff or 0,
+                            'default',
+                            getResistanceAttrID(modifyingItem=mod, effect=mod.item.effects[webEffectName])))
+                if 'doomsdayAOEWeb' in mod.item.effects:
+                    webMods.append(ModProjData(
+                        mod.getModifiedItemAttr('speedFactor'),
+                        max(0, (mod.maxRange or 0) + mod.getModifiedItemAttr('doomsdayAOERange') - src.getRadius()),
+                        mod.falloff or 0,
+                        'default',
+                        getResistanceAttrID(modifyingItem=mod, effect=mod.item.effects['doomsdayAOEWeb'])))
+                for tpEffectName in ('remoteTargetPaintFalloff', 'structureModuleEffectTargetPainter'):
+                    if tpEffectName in mod.item.effects:
+                        tpMods.append(ModProjData(
+                            mod.getModifiedItemAttr('signatureRadiusBonus'),
+                            mod.maxRange or 0,
+                            mod.falloff or 0,
+                            'default',
+                            getResistanceAttrID(modifyingItem=mod, effect=mod.item.effects[tpEffectName])))
+                if 'doomsdayAOEPaint' in mod.item.effects:
+                    tpMods.append(ModProjData(
+                        mod.getModifiedItemAttr('signatureRadiusBonus'),
+                        max(0, (mod.maxRange or 0) + mod.getModifiedItemAttr('doomsdayAOERange') - src.getRadius()),
+                        mod.falloff or 0,
+                        'default',
+                        getResistanceAttrID(modifyingItem=mod, effect=mod.item.effects['doomsdayAOEPaint'])))
+        return projectedData
+
+    def getProjDroneData(self, src):
+        try:
+            projectedData = self._data[src.item.ID]['drones']
+        except KeyError:
+            # Format of items for both: (boost strength, optimal, falloff, stacking group, resistance attr ID, drone speed, drone radius)
+            webDrones = []
+            tpDrones = []
+            projectedData = self._data.setdefault(src.item.ID, {})['drones'] = (webDrones, tpDrones)
+            for drone in src.item.activeDronesIter():
+                if 'remoteWebifierEntity' in drone.item.effects:
+                    webDrones.extend(drone.amountActive * (MobileProjData(
+                        drone.getModifiedItemAttr('speedFactor'),
+                        drone.maxRange or 0,
+                        drone.falloff or 0,
+                        'default',
+                        getResistanceAttrID(modifyingItem=drone, effect=drone.item.effects['remoteWebifierEntity']),
+                        drone.getModifiedItemAttr('maxVelocity'),
+                        drone.getModifiedItemAttr('radius')),))
+                if 'remoteTargetPaintEntity' in drone.item.effects:
+                    tpDrones.extend(drone.amountActive * (MobileProjData(
+                        drone.getModifiedItemAttr('signatureRadiusBonus'),
+                        drone.maxRange or 0,
+                        drone.falloff or 0,
+                        'default',
+                        getResistanceAttrID(modifyingItem=drone, effect=drone.item.effects['remoteTargetPaintEntity']),
+                        drone.getModifiedItemAttr('maxVelocity'),
+                        drone.getModifiedItemAttr('radius')),))
+        return projectedData
+
+    def getProjFighterData(self, src):
+        try:
+            projectedData = self._data[src.item.ID]['fighters']
+        except KeyError:
+            # Format of items for both: (boost strength, optimal, falloff, stacking group, resistance attr ID, fighter speed, fighter radius)
+            webFighters = []
+            tpFighters = []
+            projectedData = self._data.setdefault(src.item.ID, {})['fighters'] = (webFighters, tpFighters)
+            for fighter, ability in src.item.activeFighterAbilityIter():
+                if ability.effect.name == 'fighterAbilityStasisWebifier':
+                    webFighters.append(MobileProjData(
+                        fighter.getModifiedItemAttr('fighterAbilityStasisWebifierSpeedPenalty') * fighter.amount,
+                        fighter.getModifiedItemAttr('fighterAbilityStasisWebifierOptimalRange'),
+                        fighter.getModifiedItemAttr('fighterAbilityStasisWebifierFalloffRange'),
+                        'default',
+                        getResistanceAttrID(modifyingItem=fighter, effect=fighter.item.effects['fighterAbilityStasisWebifier']),
+                        fighter.getModifiedItemAttr('maxVelocity'),
+                        fighter.getModifiedItemAttr('radius')))
+        return projectedData

graphs/data/fitDamageStats/cache/time.py

@@ -0,0 +1,254 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from copy import copy
+
+from eos.utils.float import floatUnerr
+from eos.utils.spoolSupport import SpoolOptions, SpoolType
+from eos.utils.stats import DmgTypes
+from graphs.data.base import FitDataCache
+
+
+class TimeCache(FitDataCache):
+
+    # Whole data getters
+    def getDpsData(self, src):
+        """Return DPS data in {time: {key: dps}} format."""
+        return self._data[src.item.ID]['finalDps']
+
+    def getVolleyData(self, src):
+        """Return volley data in {time: {key: volley}} format."""
+        return self._data[src.item.ID]['finalVolley']
+
+    def getDmgData(self, src):
+        """Return inflicted damage data in {time: {key: damage}} format."""
+        return self._data[src.item.ID]['finalDmg']
+
+    # Specific data point getters
+    def getDpsDataPoint(self, src, time):
+        """Get DPS data by specified time in {key: dps} format."""
+        return self._getDataPoint(src=src, time=time, dataFunc=self.getDpsData)
+
+    def getVolleyDataPoint(self, src, time):
+        """Get volley data by specified time in {key: volley} format."""
+        return self._getDataPoint(src=src, time=time, dataFunc=self.getVolleyData)
+
+    def getDmgDataPoint(self, src, time):
+        """Get inflicted damage data by specified time in {key: dmg} format."""
+        return self._getDataPoint(src=src, time=time, dataFunc=self.getDmgData)
+
+    # Preparation functions
+    def prepareDpsData(self, src, maxTime):
+        self._prepareDpsVolleyData(src=src, maxTime=maxTime)
+
+    def prepareVolleyData(self, src, maxTime):
+        self._prepareDpsVolleyData(src=src, maxTime=maxTime)
+
+    def prepareDmgData(self, src, maxTime):
+        # Time is none means that time parameter has to be ignored,
+        # we do not need cache for that
+        if maxTime is None:
+            return
+        self._generateInternalForm(src=src, maxTime=maxTime)
+        fitCache = self._data[src.item.ID]
+        # Final cache has been generated already, don't do anything
+        if 'finalDmg' in fitCache:
+            return
+        intCache = fitCache['internalDmg']
+        changesByTime = {}
+        for key, dmgMap in intCache.items():
+            for time in dmgMap:
+                changesByTime.setdefault(time, []).append(key)
+        # Here we convert cache to following format:
+        # {time: {key: damage done by key at this time}}
+        finalCache = fitCache['finalDmg'] = {}
+        timeDmgData = {}
+        for time in sorted(changesByTime):
+            timeDmgData = copy(timeDmgData)
+            for key in changesByTime[time]:
+                keyDmg = intCache[key][time]
+                if key in timeDmgData:
+                    timeDmgData[key] = timeDmgData[key] + keyDmg
+                else:
+                    timeDmgData[key] = keyDmg
+            finalCache[time] = timeDmgData
+        # We do not need internal cache once we have final
+        del fitCache['internalDmg']
+
+    # Private stuff
+    def _prepareDpsVolleyData(self, src, maxTime):
+        # Time is none means that time parameter has to be ignored,
+        # we do not need cache for that
+        if maxTime is None:
+            return True
+        self._generateInternalForm(src=src, maxTime=maxTime)
+        fitCache = self._data[src.item.ID]
+        # Final cache has been generated already, don't do anything
+        if 'finalDps' in fitCache and 'finalVolley' in fitCache:
+            return
+        # Convert cache from segments with assigned values into points
+        # which are located at times when dps/volley values change
+        pointCache = {}
+        for key, dmgList in fitCache['internalDpsVolley'].items():
+            pointData = pointCache[key] = {}
+            prevDps = None
+            prevVolley = None
+            prevTimeEnd = None
+            for timeStart, timeEnd, dps, volley in dmgList:
+                # First item
+                if not pointData:
+                    pointData[timeStart] = (dps, volley)
+                # Gap between items
+                elif floatUnerr(prevTimeEnd) < floatUnerr(timeStart):
+                    pointData[prevTimeEnd] = (DmgTypes(0, 0, 0, 0), DmgTypes(0, 0, 0, 0))
+                    pointData[timeStart] = (dps, volley)
+                # Changed value
+                elif dps != prevDps or volley != prevVolley:
+                    pointData[timeStart] = (dps, volley)
+                prevDps = dps
+                prevVolley = volley
+                prevTimeEnd = timeEnd
+        # We have data in another form, do not need old one any longer
+        del fitCache['internalDpsVolley']
+        changesByTime = {}
+        for key, dmgMap in pointCache.items():
+            for time in dmgMap:
+                changesByTime.setdefault(time, []).append(key)
+        # Here we convert cache to following format:
+        # {time: {key: (dps, volley}}
+        finalDpsCache = fitCache['finalDps'] = {}
+        finalVolleyCache = fitCache['finalVolley'] = {}
+        timeDpsData = {}
+        timeVolleyData = {}
+        for time in sorted(changesByTime):
+            timeDpsData = copy(timeDpsData)
+            timeVolleyData = copy(timeVolleyData)
+            for key in changesByTime[time]:
+                dps, volley = pointCache[key][time]
+                timeDpsData[key] = dps
+                timeVolleyData[key] = volley
+            finalDpsCache[time] = timeDpsData
+            finalVolleyCache[time] = timeVolleyData
+
+    def _generateInternalForm(self, src, maxTime):
+        if self._isTimeCacheValid(src=src, maxTime=maxTime):
+            return
+        fitCache = self._data[src.item.ID] = {'maxTime': maxTime}
+        intCacheDpsVolley = fitCache['internalDpsVolley'] = {}
+        intCacheDmg = fitCache['internalDmg'] = {}
+
+        def addDpsVolley(ddKey, addedTimeStart, addedTimeFinish, addedVolleys):
+            if not addedVolleys:
+                return
+            volleySum = sum(addedVolleys, DmgTypes(0, 0, 0, 0))
+            if volleySum.total > 0:
+                addedDps = volleySum / (addedTimeFinish - addedTimeStart)
+                # We can take "just best" volley, no matter target resistances, because all
+                # known items have the same damage type ratio throughout their cycle - and
+                # applying resistances doesn't change final outcome
+                bestVolley = max(addedVolleys, key=lambda v: v.total)
+                ddCacheDps = intCacheDpsVolley.setdefault(ddKey, [])
+                ddCacheDps.append((addedTimeStart, addedTimeFinish, addedDps, bestVolley))
+
+        def addDmg(ddKey, addedTime, addedDmg):
+            if addedDmg.total == 0:
+                return
+            intCacheDmg.setdefault(ddKey, {})[addedTime] = addedDmg
+
+        # Modules
+        for mod in src.item.activeModulesIter():
+            if not mod.isDealingDamage():
+                continue
+            cycleParams = mod.getCycleParameters(reloadOverride=True)
+            if cycleParams is None:
+                continue
+            currentTime = 0
+            nonstopCycles = 0
+            for cycleTimeMs, inactiveTimeMs, isInactivityReload in cycleParams.iterCycles():
+                cycleVolleys = []
+                volleyParams = mod.getVolleyParameters(spoolOptions=SpoolOptions(SpoolType.CYCLES, nonstopCycles, True))
+                for volleyTimeMs, volley in volleyParams.items():
+                    cycleVolleys.append(volley)
+                    addDmg(mod, currentTime + volleyTimeMs / 1000, volley)
+                addDpsVolley(mod, currentTime, currentTime + cycleTimeMs / 1000, cycleVolleys)
+                if inactiveTimeMs > 0:
+                    nonstopCycles = 0
+                else:
+                    nonstopCycles += 1
+                if currentTime > maxTime:
+                    break
+                currentTime += cycleTimeMs / 1000 + inactiveTimeMs / 1000
+        # Drones
+        for drone in src.item.activeDronesIter():
+            if not drone.isDealingDamage():
+                continue
+            cycleParams = drone.getCycleParameters(reloadOverride=True)
+            if cycleParams is None:
+                continue
+            currentTime = 0
+            volleyParams = drone.getVolleyParameters()
+            for cycleTimeMs, inactiveTimeMs, isInactivityReload in cycleParams.iterCycles():
+                cycleVolleys = []
+                for volleyTimeMs, volley in volleyParams.items():
+                    cycleVolleys.append(volley)
+                    addDmg(drone, currentTime + volleyTimeMs / 1000, volley)
+                addDpsVolley(drone, currentTime, currentTime + cycleTimeMs / 1000, cycleVolleys)
+                if currentTime > maxTime:
+                    break
+                currentTime += cycleTimeMs / 1000 + inactiveTimeMs / 1000
+        # Fighters
+        for fighter in src.item.activeFightersIter():
+            if not fighter.isDealingDamage():
+                continue
+            cycleParams = fighter.getCycleParametersPerEffectOptimizedDps(reloadOverride=True)
+            if cycleParams is None:
+                continue
+            volleyParams = fighter.getVolleyParametersPerEffect()
+            for effectID, abilityCycleParams in cycleParams.items():
+                if effectID not in volleyParams:
+                    continue
+                currentTime = 0
+                abilityVolleyParams = volleyParams[effectID]
+                for cycleTimeMs, inactiveTimeMs, isInactivityReload in abilityCycleParams.iterCycles():
+                    cycleVolleys = []
+                    for volleyTimeMs, volley in abilityVolleyParams.items():
+                        cycleVolleys.append(volley)
+                        addDmg((fighter, effectID), currentTime + volleyTimeMs / 1000, volley)
+                    addDpsVolley((fighter, effectID), currentTime, currentTime + cycleTimeMs / 1000, cycleVolleys)
+                    if currentTime > maxTime:
+                        break
+                    currentTime += cycleTimeMs / 1000 + inactiveTimeMs / 1000
+
+    def _isTimeCacheValid(self, src, maxTime):
+        try:
+            cacheMaxTime = self._data[src.item.ID]['maxTime']
+        except KeyError:
+            return False
+        return maxTime <= cacheMaxTime
+
+    def _getDataPoint(self, src, time, dataFunc):
+        data = dataFunc(src)
+        timesBefore = [t for t in data if floatUnerr(t) <= floatUnerr(time)]
+        try:
+            time = max(timesBefore)
+        except ValueError:
+            return {}
+        else:
+            return data[time]

graphs/data/fitDamageStats/calc/__init__.py

@@ -0,0 +1,18 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================

graphs/data/fitDamageStats/calc/application.py

@@ -0,0 +1,403 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+import math
+from functools import lru_cache
+
+from eos.calc import calculateRangeFactor
+from eos.const import FittingHardpoint
+from eos.utils.float import floatUnerr
+from graphs.calc import checkLockRange, checkDroneControlRange
+from service.attribute import Attribute
+from service.const import GraphDpsDroneMode
+from service.settings import GraphSettings
+
+
+def getApplicationPerKey(src, tgt, atkSpeed, atkAngle, distance, tgtSpeed, tgtAngle, tgtSigRadius):
+    inLockRange = checkLockRange(src=src, distance=distance)
+    inDroneRange = checkDroneControlRange(src=src, distance=distance)
+    applicationMap = {}
+    for mod in src.item.activeModulesIter():
+        if not mod.isDealingDamage():
+            continue
+        if mod.hardpoint == FittingHardpoint.TURRET:
+            if inLockRange:
+                applicationMap[mod] = getTurretMult(
+                    mod=mod,
+                    src=src,
+                    tgt=tgt,
+                    atkSpeed=atkSpeed,
+                    atkAngle=atkAngle,
+                    distance=distance,
+                    tgtSpeed=tgtSpeed,
+                    tgtAngle=tgtAngle,
+                    tgtSigRadius=tgtSigRadius)
+            else:
+                applicationMap[mod] = 0
+        elif mod.hardpoint == FittingHardpoint.MISSILE:
+            # FoF missiles can shoot beyond lock range
+            if inLockRange or (mod.charge is not None and 'fofMissileLaunching' in mod.charge.effects):
+                applicationMap[mod] = getLauncherMult(
+                    mod=mod,
+                    src=src,
+                    distance=distance,
+                    tgtSpeed=tgtSpeed,
+                    tgtSigRadius=tgtSigRadius)
+            else:
+                applicationMap[mod] = 0
+        elif mod.item.group.name in ('Smart Bomb', 'Structure Area Denial Module'):
+            applicationMap[mod] = getSmartbombMult(
+                mod=mod,
+                distance=distance)
+        elif mod.item.group.name == 'Missile Launcher Bomb':
+            applicationMap[mod] = getBombMult(
+                mod=mod,
+                src=src,
+                tgt=tgt,
+                distance=distance,
+                tgtSigRadius=tgtSigRadius)
+        elif mod.item.group.name == 'Structure Guided Bomb Launcher':
+            if inLockRange:
+                applicationMap[mod] = getGuidedBombMult(
+                    mod=mod,
+                    src=src,
+                    distance=distance,
+                    tgtSigRadius=tgtSigRadius)
+            else:
+                applicationMap[mod] = 0
+        elif mod.item.group.name in ('Super Weapon', 'Structure Doomsday Weapon'):
+            # Only single-target DDs need locks
+            if not inLockRange and {'superWeaponAmarr', 'superWeaponCaldari', 'superWeaponGallente', 'superWeaponMinmatar', 'lightningWeapon'}.intersection(mod.item.effects):
+                applicationMap[mod] = 0
+            else:
+                applicationMap[mod] = getDoomsdayMult(
+                    mod=mod,
+                    tgt=tgt,
+                    distance=distance,
+                    tgtSigRadius=tgtSigRadius)
+    for drone in src.item.activeDronesIter():
+        if not drone.isDealingDamage():
+            continue
+        if inLockRange and inDroneRange:
+            applicationMap[drone] = getDroneMult(
+                drone=drone,
+                src=src,
+                tgt=tgt,
+                atkSpeed=atkSpeed,
+                atkAngle=atkAngle,
+                distance=distance,
+                tgtSpeed=tgtSpeed,
+                tgtAngle=tgtAngle,
+                tgtSigRadius=tgtSigRadius)
+        else:
+            applicationMap[drone] = 0
+    for fighter in src.item.activeFightersIter():
+        if not fighter.isDealingDamage():
+            continue
+        for ability in fighter.abilities:
+            if not ability.dealsDamage or not ability.active:
+                continue
+            # Bomb launching doesn't need locks
+            if inLockRange or ability.effect.name == 'fighterAbilityLaunchBomb':
+                applicationMap[(fighter, ability.effectID)] = getFighterAbilityMult(
+                    fighter=fighter,
+                    ability=ability,
+                    src=src,
+                    tgt=tgt,
+                    distance=distance,
+                    tgtSpeed=tgtSpeed,
+                    tgtSigRadius=tgtSigRadius)
+            else:
+                applicationMap[(fighter, ability.effectID)] = 0
+    # Ensure consistent results - round off a little to avoid float errors
+    for k, v in applicationMap.items():
+        applicationMap[k] = floatUnerr(v)
+    return applicationMap
+
+
+# Item application multiplier calculation
+def getTurretMult(mod, src, tgt, atkSpeed, atkAngle, distance, tgtSpeed, tgtAngle, tgtSigRadius):
+    cth = _calcTurretChanceToHit(
+        atkSpeed=atkSpeed,
+        atkAngle=atkAngle,
+        atkRadius=src.getRadius(),
+        atkOptimalRange=mod.maxRange or 0,
+        atkFalloffRange=mod.falloff or 0,
+        atkTracking=mod.getModifiedItemAttr('trackingSpeed'),
+        atkOptimalSigRadius=mod.getModifiedItemAttr('optimalSigRadius'),
+        distance=distance,
+        tgtSpeed=tgtSpeed,
+        tgtAngle=tgtAngle,
+        tgtRadius=tgt.getRadius(),
+        tgtSigRadius=tgtSigRadius)
+    mult = _calcTurretMult(cth)
+    return mult
+
+
+def getLauncherMult(mod, src, distance, tgtSpeed, tgtSigRadius):
+    missileMaxRangeData = mod.missileMaxRangeData
+    if missileMaxRangeData is None:
+        return 0
+    # The ranges already consider ship radius
+    lowerRange, higherRange, higherChance = missileMaxRangeData
+    if distance is None or distance <= lowerRange:
+        distanceFactor = 1
+    elif lowerRange < distance <= higherRange:
+        distanceFactor = higherChance
+    else:
+        distanceFactor = 0
+    applicationFactor = _calcMissileFactor(
+        atkEr=mod.getModifiedChargeAttr('aoeCloudSize'),
+        atkEv=mod.getModifiedChargeAttr('aoeVelocity'),
+        atkDrf=mod.getModifiedChargeAttr('aoeDamageReductionFactor'),
+        tgtSpeed=tgtSpeed,
+        tgtSigRadius=tgtSigRadius)
+    return distanceFactor * applicationFactor
+
+
+def getSmartbombMult(mod, distance):
+    modRange = mod.maxRange
+    if modRange is None:
+        return 0
+    if distance is not None and distance > modRange:
+        return 0
+    return 1
+
+
+def getDoomsdayMult(mod, tgt, distance, tgtSigRadius):
+    modRange = mod.maxRange
+    # Single-target DDs have no range limit
+    if distance is not None and modRange and distance > modRange:
+        return 0
+    # Single-target titan DDs are vs capitals only
+    if {'superWeaponAmarr', 'superWeaponCaldari', 'superWeaponGallente', 'superWeaponMinmatar'}.intersection(mod.item.effects):
+        # Disallow only against subcaps, allow against caps and tgt profiles
+        if tgt.isFit and not tgt.item.ship.item.requiresSkill('Capital Ships'):
+            return 0
+    damageSig = mod.getModifiedItemAttr('doomsdayDamageRadius') or mod.getModifiedItemAttr('signatureRadius')
+    if not damageSig:
+        return 1
+    return min(1, tgtSigRadius / damageSig)
+
+
+def getBombMult(mod, src, tgt, distance, tgtSigRadius):
+    modRange = mod.maxRange
+    if modRange is None:
+        return 0
+    blastRadius = mod.getModifiedChargeAttr('explosionRange')
+    atkRadius = src.getRadius()
+    tgtRadius = tgt.getRadius()
+    # Bomb starts in the center of the ship
+    # Also here we assume that it affects target as long as blast
+    # touches its surface, not center - I did not check this
+    if distance is not None and distance < max(0, modRange - atkRadius - tgtRadius - blastRadius):
+        return 0
+    if distance is not None and distance > max(0, modRange - atkRadius + tgtRadius + blastRadius):
+        return 0
+    return _calcBombFactor(
+        atkEr=mod.getModifiedChargeAttr('aoeCloudSize'),
+        tgtSigRadius=tgtSigRadius)
+
+
+def getGuidedBombMult(mod, src, distance, tgtSigRadius):
+    modRange = mod.maxRange
+    if modRange is None:
+        return 0
+    if distance is not None and distance > modRange - src.getRadius():
+        return 0
+    eR = mod.getModifiedChargeAttr('aoeCloudSize')
+    if eR == 0:
+        return 1
+    else:
+        return min(1, tgtSigRadius / eR)
+
+
+def getDroneMult(drone, src, tgt, atkSpeed, atkAngle, distance, tgtSpeed, tgtAngle, tgtSigRadius):
+    if (
+        distance is not None and (
+            (not GraphSettings.getInstance().get('ignoreDCR') and distance > src.item.extraAttributes['droneControlRange']) or
+            (not GraphSettings.getInstance().get('ignoreLockRange') and distance > src.item.maxTargetRange))
+    ):
+        return 0
+    droneSpeed = drone.getModifiedItemAttr('maxVelocity')
+    # Hard to simulate drone behavior, so assume chance to hit is 1 for mobile drones
+    # which catch up with target
+    droneOpt = GraphSettings.getInstance().get('mobileDroneMode')
+    if (
+        droneSpeed > 1 and (
+            (droneOpt == GraphDpsDroneMode.auto and droneSpeed >= tgtSpeed) or
+            droneOpt == GraphDpsDroneMode.followTarget)
+    ):
+        cth = 1
+    # Otherwise put the drone into center of the ship, move it at its max speed or ship's speed
+    # (whichever is lower) towards direction of attacking ship and see how well it projects
+    else:
+        droneRadius = drone.getModifiedItemAttr('radius')
+        if distance is None:
+            cthDistance = None
+        else:
+            # As distance is ship surface to ship surface, we adjust it according
+            # to attacker ship's radiuses to have drone surface to ship surface distance
+            cthDistance = distance + src.getRadius() - droneRadius
+        cth = _calcTurretChanceToHit(
+            atkSpeed=min(atkSpeed, droneSpeed),
+            atkAngle=atkAngle,
+            atkRadius=droneRadius,
+            atkOptimalRange=drone.maxRange or 0,
+            atkFalloffRange=drone.falloff or 0,
+            atkTracking=drone.getModifiedItemAttr('trackingSpeed'),
+            atkOptimalSigRadius=drone.getModifiedItemAttr('optimalSigRadius'),
+            distance=cthDistance,
+            tgtSpeed=tgtSpeed,
+            tgtAngle=tgtAngle,
+            tgtRadius=tgt.getRadius(),
+            tgtSigRadius=tgtSigRadius)
+    mult = _calcTurretMult(cth)
+    return mult
+
+
+def getFighterAbilityMult(fighter, ability, src, tgt, distance, tgtSpeed, tgtSigRadius):
+    fighterSpeed = fighter.getModifiedItemAttr('maxVelocity')
+    attrPrefix = ability.attrPrefix
+    # It's bomb attack
+    if attrPrefix == 'fighterAbilityLaunchBomb':
+        # Just assume we can land bomb anywhere
+        return _calcBombFactor(
+            atkEr=fighter.getModifiedChargeAttr('aoeCloudSize'),
+            tgtSigRadius=tgtSigRadius)
+    droneOpt = GraphSettings.getInstance().get('mobileDroneMode')
+    # It's regular missile-based attack
+    if (droneOpt == GraphDpsDroneMode.auto and fighterSpeed >= tgtSpeed) or droneOpt == GraphDpsDroneMode.followTarget:
+        rangeFactor = 1
+    # Same as with drones, if fighters are slower - put them to center of
+    # the ship and see how they apply
+    else:
+        if distance is None:
+            rangeFactorDistance = None
+        else:
+            rangeFactorDistance = distance + src.getRadius() - fighter.getModifiedItemAttr('radius')
+        rangeFactor = calculateRangeFactor(
+            srcOptimalRange=fighter.getModifiedItemAttr('{}RangeOptimal'.format(attrPrefix)) or fighter.getModifiedItemAttr('{}Range'.format(attrPrefix)),
+            srcFalloffRange=fighter.getModifiedItemAttr('{}RangeFalloff'.format(attrPrefix)),
+            distance=rangeFactorDistance)
+    drf = fighter.getModifiedItemAttr('{}ReductionFactor'.format(attrPrefix), None)
+    if drf is None:
+        drf = fighter.getModifiedItemAttr('{}DamageReductionFactor'.format(attrPrefix))
+    drs = fighter.getModifiedItemAttr('{}ReductionSensitivity'.format(attrPrefix), None)
+    if drs is None:
+        drs = fighter.getModifiedItemAttr('{}DamageReductionSensitivity'.format(attrPrefix))
+    missileFactor = _calcMissileFactor(
+        atkEr=fighter.getModifiedItemAttr('{}ExplosionRadius'.format(attrPrefix)),
+        atkEv=fighter.getModifiedItemAttr('{}ExplosionVelocity'.format(attrPrefix)),
+        atkDrf=_calcAggregatedDrf(reductionFactor=drf, reductionSensitivity=drs),
+        tgtSpeed=tgtSpeed,
+        tgtSigRadius=tgtSigRadius)
+    resistMult = 1
+    if tgt.isFit:
+        resistAttrID = fighter.getModifiedItemAttr('{}ResistanceID'.format(attrPrefix))
+        if resistAttrID:
+            resistAttrInfo = Attribute.getInstance().getAttributeInfo(resistAttrID)
+            if resistAttrInfo is not None:
+                resistMult = tgt.item.ship.getModifiedItemAttr(resistAttrInfo.name, 1)
+    mult = rangeFactor * missileFactor * resistMult
+    return mult
+
+
+# Turret-specific math
+@lru_cache(maxsize=50)
+def _calcTurretMult(chanceToHit):
+    """Calculate damage multiplier for turret-based weapons."""
+    # https://wiki.eveuniversity.org/Turret_mechanics#Damage
+    wreckingChance = min(chanceToHit, 0.01)
+    wreckingPart = wreckingChance * 3
+    normalChance = chanceToHit - wreckingChance
+    if normalChance > 0:
+        avgDamageMult = (0.01 + chanceToHit) / 2 + 0.49
+        normalPart = normalChance * avgDamageMult
+    else:
+        normalPart = 0
+    totalMult = normalPart + wreckingPart
+    return totalMult
+
+
+@lru_cache(maxsize=1000)
+def _calcTurretChanceToHit(
+    atkSpeed, atkAngle, atkRadius, atkOptimalRange, atkFalloffRange, atkTracking, atkOptimalSigRadius,
+    distance, tgtSpeed, tgtAngle, tgtRadius, tgtSigRadius
+):
+    """Calculate chance to hit for turret-based weapons."""
+    # https://wiki.eveuniversity.org/Turret_mechanics#Hit_Math
+    angularSpeed = _calcAngularSpeed(atkSpeed, atkAngle, atkRadius, distance, tgtSpeed, tgtAngle, tgtRadius)
+    # Turrets can be activated regardless of range to target
+    rangeFactor = calculateRangeFactor(atkOptimalRange, atkFalloffRange, distance, restrictedRange=False)
+    trackingFactor = _calcTrackingFactor(atkTracking, atkOptimalSigRadius, angularSpeed, tgtSigRadius)
+    cth = rangeFactor * trackingFactor
+    return cth
+
+
+def _calcAngularSpeed(atkSpeed, atkAngle, atkRadius, distance, tgtSpeed, tgtAngle, tgtRadius):
+    """Calculate angular speed based on mobility parameters of two ships."""
+    if distance is None:
+        return 0
+    atkAngle = atkAngle * math.pi / 180
+    tgtAngle = tgtAngle * math.pi / 180
+    ctcDistance = atkRadius + distance + tgtRadius
+    # Target is to the right of the attacker, so transversal is projection onto Y axis
+    transSpeed = abs(atkSpeed * math.sin(atkAngle) - tgtSpeed * math.sin(tgtAngle))
+    if ctcDistance == 0:
+        return 0 if transSpeed == 0 else math.inf
+    else:
+        return transSpeed / ctcDistance
+
+
+def _calcTrackingFactor(atkTracking, atkOptimalSigRadius, angularSpeed, tgtSigRadius):
+    """Calculate tracking chance to hit component."""
+    return 0.5 ** (((angularSpeed * atkOptimalSigRadius) / (atkTracking * tgtSigRadius)) ** 2)
+
+
+# Missile-specific math
+@lru_cache(maxsize=200)
+def _calcMissileFactor(atkEr, atkEv, atkDrf, tgtSpeed, tgtSigRadius):
+    """Missile application."""
+    factors = [1]
+    # "Slow" part
+    if atkEr > 0:
+        factors.append(tgtSigRadius / atkEr)
+    # "Fast" part
+    if tgtSpeed > 0:
+        factors.append(((atkEv * tgtSigRadius) / (atkEr * tgtSpeed)) ** atkDrf)
+    totalMult = min(factors)
+    return totalMult
+
+
+def _calcAggregatedDrf(reductionFactor, reductionSensitivity):
+    """
+    Sometimes DRF is specified as 2 separate numbers,
+    here we combine them into generic form.
+    """
+    return math.log(reductionFactor) / math.log(reductionSensitivity)
+
+
+# Misc math
+def _calcBombFactor(atkEr, tgtSigRadius):
+    if atkEr == 0:
+        return 1
+    else:
+        return min(1, tgtSigRadius / atkEr)

graphs/data/fitDamageStats/calc/projected.py

@@ -0,0 +1,189 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+import math
+
+from eos.calc import calculateRangeFactor
+from eos.utils.float import floatUnerr
+from graphs.calc import checkLockRange, checkDroneControlRange
+from service.const import GraphDpsDroneMode
+from service.settings import GraphSettings
+
+
+def _isRegularScram(mod):
+    if not mod.item:
+        return False
+    if not {'warpScrambleBlockMWDWithNPCEffect', 'structureWarpScrambleBlockMWDWithNPCEffect'}.intersection(mod.item.effects):
+        return False
+    if not mod.getModifiedItemAttr('activationBlockedStrenght', 0):
+        return False
+    return True
+
+
+def _isHicScram(mod):
+    if not mod.item:
+        return False
+    if 'warpDisruptSphere' not in mod.item.effects:
+        return False
+    if not mod.charge:
+        return False
+    if 'shipModuleFocusedWarpScramblingScript' not in mod.charge.effects:
+        return False
+    return True
+
+
+def getScramRange(src):
+    scramRange = None
+    for mod in src.item.activeModulesIter():
+        if _isRegularScram(mod) or _isHicScram(mod):
+            scramRange = max(scramRange or 0, mod.maxRange or 0)
+    return scramRange
+
+
+def getScrammables(tgt):
+    scrammables = []
+    if tgt.isFit:
+        for mod in tgt.item.activeModulesIter():
+            if not mod.item:
+                continue
+            if {'moduleBonusMicrowarpdrive', 'microJumpDrive', 'microJumpPortalDrive'}.intersection(mod.item.effects):
+                scrammables.append(mod)
+    return scrammables
+
+
+def getTackledSpeed(src, tgt, currentUntackledSpeed, srcScramRange, tgtScrammables, webMods, webDrones, webFighters, distance):
+    # Can slow down non-immune ships and target profiles
+    if tgt.isFit and tgt.item.ship.getModifiedItemAttr('disallowOffensiveModifiers'):
+        return currentUntackledSpeed
+    maxUntackledSpeed = tgt.getMaxVelocity()
+    # What's immobile cannot be slowed
+    if maxUntackledSpeed == 0:
+        return maxUntackledSpeed
+    inLockRange = checkLockRange(src=src, distance=distance)
+    inDroneRange = checkDroneControlRange(src=src, distance=distance)
+    speedRatio = currentUntackledSpeed / maxUntackledSpeed
+    # No scrams or distance is longer than longest scram - nullify scrammables list
+    if not inLockRange or srcScramRange is None or (distance is not None and distance > srcScramRange):
+        tgtScrammables = ()
+    appliedMultipliers = {}
+    # Modules first, they are always applied the same way
+    if inLockRange:
+        for wData in webMods:
+            appliedBoost = wData.boost * calculateRangeFactor(
+                srcOptimalRange=wData.optimal,
+                srcFalloffRange=wData.falloff,
+                distance=distance)
+            if appliedBoost:
+                appliedMultipliers.setdefault(wData.stackingGroup, []).append((1 + appliedBoost / 100, wData.resAttrID))
+    maxTackledSpeed = tgt.getMaxVelocity(extraMultipliers=appliedMultipliers, ignoreAfflictors=tgtScrammables)
+    currentTackledSpeed = maxTackledSpeed * speedRatio
+    # Drones and fighters
+    mobileWebs = []
+    if inLockRange:
+        mobileWebs.extend(webFighters)
+    if inLockRange and inDroneRange:
+        mobileWebs.extend(webDrones)
+    atkRadius = src.getRadius()
+    # As mobile webs either follow the target or stick to the attacking ship,
+    # if target is within mobile web optimal - it can be applied unconditionally
+    longEnoughMws = [mw for mw in mobileWebs if distance is None or distance <= mw.optimal - atkRadius + mw.radius]
+    if longEnoughMws:
+        for mwData in longEnoughMws:
+            appliedMultipliers.setdefault(mwData.stackingGroup, []).append((1 + mwData.boost / 100, mwData.resAttrID))
+            mobileWebs.remove(mwData)
+        maxTackledSpeed = tgt.getMaxVelocity(extraMultipliers=appliedMultipliers, ignoreAfflictors=tgtScrammables)
+        currentTackledSpeed = maxTackledSpeed * speedRatio
+    # Apply remaining webs, from fastest to slowest
+    droneOpt = GraphSettings.getInstance().get('mobileDroneMode')
+    while mobileWebs:
+        # Process in batches unified by speed to save up resources
+        fastestMwSpeed = max(mobileWebs, key=lambda mw: mw.speed).speed
+        fastestMws = [mw for mw in mobileWebs if mw.speed == fastestMwSpeed]
+        for mwData in fastestMws:
+            # Faster than target or set to follow it - apply full slowdown
+            if (droneOpt == GraphDpsDroneMode.auto and mwData.speed >= currentTackledSpeed) or droneOpt == GraphDpsDroneMode.followTarget:
+                appliedMwBoost = mwData.boost
+            # Otherwise project from the center of the ship
+            else:
+                if distance is None:
+                    rangeFactorDistance = None
+                else:
+                    rangeFactorDistance = distance + atkRadius - mwData.radius
+                appliedMwBoost = mwData.boost * calculateRangeFactor(
+                    srcOptimalRange=mwData.optimal,
+                    srcFalloffRange=mwData.falloff,
+                    distance=rangeFactorDistance)
+            appliedMultipliers.setdefault(mwData.stackingGroup, []).append((1 + appliedMwBoost / 100, mwData.resAttrID))
+            mobileWebs.remove(mwData)
+        maxTackledSpeed = tgt.getMaxVelocity(extraMultipliers=appliedMultipliers, ignoreAfflictors=tgtScrammables)
+        currentTackledSpeed = maxTackledSpeed * speedRatio
+    # Ensure consistent results - round off a little to avoid float errors
+    return floatUnerr(currentTackledSpeed)
+
+
+def getSigRadiusMult(src, tgt, tgtSpeed, srcScramRange, tgtScrammables, tpMods, tpDrones, tpFighters, distance):
+    # Can blow non-immune ships and target profiles
+    if tgt.isFit and tgt.item.ship.getModifiedItemAttr('disallowOffensiveModifiers'):
+        return 1
+    inLockRange = checkLockRange(src=src, distance=distance)
+    inDroneRange = checkDroneControlRange(src=src, distance=distance)
+    initSig = tgt.getSigRadius()
+    # No scrams or distance is longer than longest scram - nullify scrammables list
+    if not inLockRange or srcScramRange is None or (distance is not None and distance > srcScramRange):
+        tgtScrammables = ()
+    # TPing modules
+    appliedMultipliers = {}
+    if inLockRange:
+        for tpData in tpMods:
+            appliedBoost = tpData.boost * calculateRangeFactor(
+                srcOptimalRange=tpData.optimal,
+                srcFalloffRange=tpData.falloff,
+                distance=distance)
+            if appliedBoost:
+                appliedMultipliers.setdefault(tpData.stackingGroup, []).append((1 + appliedBoost / 100, tpData.resAttrID))
+    # TPing drones
+    mobileTps = []
+    if inLockRange:
+        mobileTps.extend(tpFighters)
+    if inLockRange and inDroneRange:
+        mobileTps.extend(tpDrones)
+    droneOpt = GraphSettings.getInstance().get('mobileDroneMode')
+    atkRadius = src.getRadius()
+    for mtpData in mobileTps:
+        # Faster than target or set to follow it - apply full TP
+        if (droneOpt == GraphDpsDroneMode.auto and mtpData.speed >= tgtSpeed) or droneOpt == GraphDpsDroneMode.followTarget:
+            appliedMtpBoost = mtpData.boost
+        # Otherwise project from the center of the ship
+        else:
+            if distance is None:
+                rangeFactorDistance = None
+            else:
+                rangeFactorDistance = distance + atkRadius - mtpData.radius
+            appliedMtpBoost = mtpData.boost * calculateRangeFactor(
+                srcOptimalRange=mtpData.optimal,
+                srcFalloffRange=mtpData.falloff,
+                distance=rangeFactorDistance)
+        appliedMultipliers.setdefault(mtpData.stackingGroup, []).append((1 + appliedMtpBoost / 100, mtpData.resAttrID))
+    modifiedSig = tgt.getSigRadius(extraMultipliers=appliedMultipliers, ignoreAfflictors=tgtScrammables)
+    if modifiedSig == math.inf and initSig == math.inf:
+        return 1
+    mult = modifiedSig / initSig
+    # Ensure consistent results - round off a little to avoid float errors
+    return floatUnerr(mult)

graphs/data/fitDamageStats/getter.py

@@ -0,0 +1,467 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+import eos.config
+from eos.utils.spoolSupport import SpoolOptions, SpoolType
+from eos.utils.stats import DmgTypes
+from graphs.data.base import PointGetter, SmoothPointGetter
+from service.settings import GraphSettings
+from .calc.application import getApplicationPerKey
+from .calc.projected import getScramRange, getScrammables, getTackledSpeed, getSigRadiusMult
+
+
+def applyDamage(dmgMap, applicationMap, tgtResists):
+    total = DmgTypes(em=0, thermal=0, kinetic=0, explosive=0)
+    for key, dmg in dmgMap.items():
+        total += dmg * applicationMap.get(key, 0)
+    if not GraphSettings.getInstance().get('ignoreResists'):
+        emRes, thermRes, kinRes, exploRes = tgtResists
+        total = DmgTypes(
+            em=total.em * (1 - emRes),
+            thermal=total.thermal * (1 - thermRes),
+            kinetic=total.kinetic * (1 - kinRes),
+            explosive=total.explosive * (1 - exploRes))
+    return total
+
+
+# Y mixins
+class YDpsMixin:
+
+    def _getDamagePerKey(self, src, time):
+        # Use data from time cache if time was not specified
+        if time is not None:
+            return self._getTimeCacheDataPoint(src=src, time=time)
+        # Compose map ourselves using current fit settings if time is not specified
+        dpsMap = {}
+        defaultSpoolValue = eos.config.settings['globalDefaultSpoolupPercentage']
+        for mod in src.item.activeModulesIter():
+            if not mod.isDealingDamage():
+                continue
+            dpsMap[mod] = mod.getDps(spoolOptions=SpoolOptions(SpoolType.SPOOL_SCALE, defaultSpoolValue, False))
+        for drone in src.item.activeDronesIter():
+            if not drone.isDealingDamage():
+                continue
+            dpsMap[drone] = drone.getDps()
+        for fighter in src.item.activeFightersIter():
+            if not fighter.isDealingDamage():
+                continue
+            for effectID, effectDps in fighter.getDpsPerEffect().items():
+                dpsMap[(fighter, effectID)] = effectDps
+        return dpsMap
+
+    def _prepareTimeCache(self, src, maxTime):
+        self.graph._timeCache.prepareDpsData(src=src, maxTime=maxTime)
+
+    def _getTimeCacheData(self, src):
+        return self.graph._timeCache.getDpsData(src=src)
+
+    def _getTimeCacheDataPoint(self, src, time):
+        return self.graph._timeCache.getDpsDataPoint(src=src, time=time)
+
+
+class YVolleyMixin:
+
+    def _getDamagePerKey(self, src, time):
+        # Use data from time cache if time was not specified
+        if time is not None:
+            return self._getTimeCacheDataPoint(src=src, time=time)
+        # Compose map ourselves using current fit settings if time is not specified
+        volleyMap = {}
+        defaultSpoolValue = eos.config.settings['globalDefaultSpoolupPercentage']
+        for mod in src.item.activeModulesIter():
+            if not mod.isDealingDamage():
+                continue
+            volleyMap[mod] = mod.getVolley(spoolOptions=SpoolOptions(SpoolType.SPOOL_SCALE, defaultSpoolValue, False))
+        for drone in src.item.activeDronesIter():
+            if not drone.isDealingDamage():
+                continue
+            volleyMap[drone] = drone.getVolley()
+        for fighter in src.item.activeFightersIter():
+            if not fighter.isDealingDamage():
+                continue
+            for effectID, effectVolley in fighter.getVolleyPerEffect().items():
+                volleyMap[(fighter, effectID)] = effectVolley
+        return volleyMap
+
+    def _prepareTimeCache(self, src, maxTime):
+        self.graph._timeCache.prepareVolleyData(src=src, maxTime=maxTime)
+
+    def _getTimeCacheData(self, src):
+        return self.graph._timeCache.getVolleyData(src=src)
+
+    def _getTimeCacheDataPoint(self, src, time):
+        return self.graph._timeCache.getVolleyDataPoint(src=src, time=time)
+
+
+class YInflictedDamageMixin:
+
+    def _getDamagePerKey(self, src, time):
+        # Damage inflicted makes no sense without time specified
+        if time is None:
+            raise ValueError
+        return self._getTimeCacheDataPoint(src=src, time=time)
+
+    def _prepareTimeCache(self, src, maxTime):
+        self.graph._timeCache.prepareDmgData(src=src, maxTime=maxTime)
+
+    def _getTimeCacheData(self, src):
+        return self.graph._timeCache.getDmgData(src=src)
+
+    def _getTimeCacheDataPoint(self, src, time):
+        return self.graph._timeCache.getDmgDataPoint(src=src, time=time)
+
+
+# X mixins
+class XDistanceMixin(SmoothPointGetter):
+
+    _baseResolution = 50
+    _extraDepth = 2
+
+    def _getCommonData(self, miscParams, src, tgt):
+        # Prepare time cache here because we need to do it only once,
+        # and this function is called once per point info fetch
+        self._prepareTimeCache(src=src, maxTime=miscParams['time'])
+        applyProjected = GraphSettings.getInstance().get('applyProjected')
+        return {
+            'applyProjected': applyProjected,
+            'srcScramRange': getScramRange(src=src) if applyProjected else None,
+            'tgtScrammables': getScrammables(tgt=tgt) if applyProjected else (),
+            'dmgMap': self._getDamagePerKey(src=src, time=miscParams['time']),
+            'tgtResists': tgt.getResists()}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        distance = x
+        tgtSpeed = miscParams['tgtSpeed']
+        tgtSigRadius = tgt.getSigRadius()
+        if commonData['applyProjected']:
+            webMods, tpMods = self.graph._projectedCache.getProjModData(src)
+            webDrones, tpDrones = self.graph._projectedCache.getProjDroneData(src)
+            webFighters, tpFighters = self.graph._projectedCache.getProjFighterData(src)
+            tgtSpeed = getTackledSpeed(
+                src=src,
+                tgt=tgt,
+                currentUntackledSpeed=tgtSpeed,
+                srcScramRange=commonData['srcScramRange'],
+                tgtScrammables=commonData['tgtScrammables'],
+                webMods=webMods,
+                webDrones=webDrones,
+                webFighters=webFighters,
+                distance=distance)
+            tgtSigRadius = tgtSigRadius * getSigRadiusMult(
+                src=src,
+                tgt=tgt,
+                tgtSpeed=tgtSpeed,
+                srcScramRange=commonData['srcScramRange'],
+                tgtScrammables=commonData['tgtScrammables'],
+                tpMods=tpMods,
+                tpDrones=tpDrones,
+                tpFighters=tpFighters,
+                distance=distance)
+        applicationMap = getApplicationPerKey(
+            src=src,
+            tgt=tgt,
+            atkSpeed=miscParams['atkSpeed'],
+            atkAngle=miscParams['atkAngle'],
+            distance=distance,
+            tgtSpeed=tgtSpeed,
+            tgtAngle=miscParams['tgtAngle'],
+            tgtSigRadius=tgtSigRadius)
+        y = applyDamage(
+            dmgMap=commonData['dmgMap'],
+            applicationMap=applicationMap,
+            tgtResists=commonData['tgtResists']).total
+        return y
+
+
+class XTimeMixin(PointGetter):
+
+    def _prepareApplicationMap(self, miscParams, src, tgt):
+        tgtSpeed = miscParams['tgtSpeed']
+        tgtSigRadius = tgt.getSigRadius()
+        if GraphSettings.getInstance().get('applyProjected'):
+            srcScramRange = getScramRange(src=src)
+            tgtScrammables = getScrammables(tgt=tgt)
+            webMods, tpMods = self.graph._projectedCache.getProjModData(src)
+            webDrones, tpDrones = self.graph._projectedCache.getProjDroneData(src)
+            webFighters, tpFighters = self.graph._projectedCache.getProjFighterData(src)
+            tgtSpeed = getTackledSpeed(
+                src=src,
+                tgt=tgt,
+                currentUntackledSpeed=tgtSpeed,
+                srcScramRange=srcScramRange,
+                tgtScrammables=tgtScrammables,
+                webMods=webMods,
+                webDrones=webDrones,
+                webFighters=webFighters,
+                distance=miscParams['distance'])
+            tgtSigRadius = tgtSigRadius * getSigRadiusMult(
+                src=src,
+                tgt=tgt,
+                tgtSpeed=tgtSpeed,
+                srcScramRange=srcScramRange,
+                tgtScrammables=tgtScrammables,
+                tpMods=tpMods,
+                tpDrones=tpDrones,
+                tpFighters=tpFighters,
+                distance=miscParams['distance'])
+        # Get all data we need for all times into maps/caches
+        applicationMap = getApplicationPerKey(
+            src=src,
+            tgt=tgt,
+            atkSpeed=miscParams['atkSpeed'],
+            atkAngle=miscParams['atkAngle'],
+            distance=miscParams['distance'],
+            tgtSpeed=tgtSpeed,
+            tgtAngle=miscParams['tgtAngle'],
+            tgtSigRadius=tgtSigRadius)
+        return applicationMap
+
+    def getRange(self, xRange, miscParams, src, tgt):
+        xs = []
+        ys = []
+        minTime, maxTime = xRange
+        # Prepare time cache and various shared data
+        self._prepareTimeCache(src=src, maxTime=maxTime)
+        timeCache = self._getTimeCacheData(src=src)
+        applicationMap = self._prepareApplicationMap(miscParams=miscParams, src=src, tgt=tgt)
+        tgtResists = tgt.getResists()
+        # Custom iteration for time graph to show all data points
+        currentDmg = None
+        currentTime = None
+        for currentTime in sorted(timeCache):
+            prevDmg = currentDmg
+            currentDmgData = timeCache[currentTime]
+            currentDmg = applyDamage(dmgMap=currentDmgData, applicationMap=applicationMap, tgtResists=tgtResists).total
+            if currentTime < minTime:
+                continue
+            # First set of data points
+            if not xs:
+                # Start at exactly requested time, at last known value
+                initialDmg = prevDmg or 0
+                xs.append(minTime)
+                ys.append(initialDmg)
+                # If current time is bigger then starting, extend plot to that time with old value
+                if currentTime > minTime:
+                    xs.append(currentTime)
+                    ys.append(initialDmg)
+                # If new value is different, extend it with new point to the new value
+                if currentDmg != prevDmg:
+                    xs.append(currentTime)
+                    ys.append(currentDmg)
+                continue
+            # Last data point
+            if currentTime >= maxTime:
+                xs.append(maxTime)
+                ys.append(prevDmg)
+                break
+            # Anything in-between
+            if currentDmg != prevDmg:
+                if prevDmg is not None:
+                    xs.append(currentTime)
+                    ys.append(prevDmg)
+                xs.append(currentTime)
+                ys.append(currentDmg)
+        # Special case - there are no damage dealers
+        if currentDmg is None and currentTime is None:
+            xs.append(minTime)
+            ys.append(0)
+        # Make sure that last data point is always at max time
+        if maxTime > (currentTime or 0):
+            xs.append(maxTime)
+            ys.append(currentDmg or 0)
+        return xs, ys
+
+    def getPoint(self, x, miscParams, src, tgt):
+        time = x
+        # Prepare time cache and various data
+        self._prepareTimeCache(src=src, maxTime=time)
+        dmgData = self._getTimeCacheDataPoint(src=src, time=time)
+        applicationMap = self._prepareApplicationMap(miscParams=miscParams, src=src, tgt=tgt)
+        y = applyDamage(dmgMap=dmgData, applicationMap=applicationMap, tgtResists=tgt.getResists()).total
+        return y
+
+
+class XTgtSpeedMixin(SmoothPointGetter):
+
+    _baseResolution = 50
+    _extraDepth = 2
+
+    def _getCommonData(self, miscParams, src, tgt):
+        # Prepare time cache here because we need to do it only once,
+        # and this function is called once per point info fetch
+        self._prepareTimeCache(src=src, maxTime=miscParams['time'])
+        return {
+            'applyProjected': GraphSettings.getInstance().get('applyProjected'),
+            'dmgMap': self._getDamagePerKey(src=src, time=miscParams['time']),
+            'tgtResists': tgt.getResists()}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        tgtSpeed = x
+        tgtSigRadius = tgt.getSigRadius()
+        if commonData['applyProjected']:
+            srcScramRange = getScramRange(src=src)
+            tgtScrammables = getScrammables(tgt=tgt)
+            webMods, tpMods = self.graph._projectedCache.getProjModData(src)
+            webDrones, tpDrones = self.graph._projectedCache.getProjDroneData(src)
+            webFighters, tpFighters = self.graph._projectedCache.getProjFighterData(src)
+            tgtSpeed = getTackledSpeed(
+                src=src,
+                tgt=tgt,
+                currentUntackledSpeed=tgtSpeed,
+                srcScramRange=srcScramRange,
+                tgtScrammables=tgtScrammables,
+                webMods=webMods,
+                webDrones=webDrones,
+                webFighters=webFighters,
+                distance=miscParams['distance'])
+            tgtSigRadius = tgtSigRadius * getSigRadiusMult(
+                src=src,
+                tgt=tgt,
+                tgtSpeed=tgtSpeed,
+                srcScramRange=srcScramRange,
+                tgtScrammables=tgtScrammables,
+                tpMods=tpMods,
+                tpDrones=tpDrones,
+                tpFighters=tpFighters,
+                distance=miscParams['distance'])
+        applicationMap = getApplicationPerKey(
+            src=src,
+            tgt=tgt,
+            atkSpeed=miscParams['atkSpeed'],
+            atkAngle=miscParams['atkAngle'],
+            distance=miscParams['distance'],
+            tgtSpeed=tgtSpeed,
+            tgtAngle=miscParams['tgtAngle'],
+            tgtSigRadius=tgtSigRadius)
+        y = applyDamage(
+            dmgMap=commonData['dmgMap'],
+            applicationMap=applicationMap,
+            tgtResists=commonData['tgtResists']).total
+        return y
+
+
+class XTgtSigRadiusMixin(SmoothPointGetter):
+
+    _baseResolution = 50
+    _extraDepth = 2
+
+    def _getCommonData(self, miscParams, src, tgt):
+        tgtSpeed = miscParams['tgtSpeed']
+        tgtSigMult = 1
+        if GraphSettings.getInstance().get('applyProjected'):
+            srcScramRange = getScramRange(src=src)
+            tgtScrammables = getScrammables(tgt=tgt)
+            webMods, tpMods = self.graph._projectedCache.getProjModData(src)
+            webDrones, tpDrones = self.graph._projectedCache.getProjDroneData(src)
+            webFighters, tpFighters = self.graph._projectedCache.getProjFighterData(src)
+            tgtSpeed = getTackledSpeed(
+                src=src,
+                tgt=tgt,
+                currentUntackledSpeed=tgtSpeed,
+                srcScramRange=srcScramRange,
+                tgtScrammables=tgtScrammables,
+                webMods=webMods,
+                webDrones=webDrones,
+                webFighters=webFighters,
+                distance=miscParams['distance'])
+            tgtSigMult = getSigRadiusMult(
+                src=src,
+                tgt=tgt,
+                tgtSpeed=tgtSpeed,
+                srcScramRange=srcScramRange,
+                tgtScrammables=tgtScrammables,
+                tpMods=tpMods,
+                tpDrones=tpDrones,
+                tpFighters=tpFighters,
+                distance=miscParams['distance'])
+        # Prepare time cache here because we need to do it only once,
+        # and this function is called once per point info fetch
+        self._prepareTimeCache(src=src, maxTime=miscParams['time'])
+        return {
+            'tgtSpeed': tgtSpeed,
+            'tgtSigMult': tgtSigMult,
+            'dmgMap': self._getDamagePerKey(src=src, time=miscParams['time']),
+            'tgtResists': tgt.getResists()}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        tgtSigRadius = x
+        applicationMap = getApplicationPerKey(
+            src=src,
+            tgt=tgt,
+            atkSpeed=miscParams['atkSpeed'],
+            atkAngle=miscParams['atkAngle'],
+            distance=miscParams['distance'],
+            tgtSpeed=commonData['tgtSpeed'],
+            tgtAngle=miscParams['tgtAngle'],
+            tgtSigRadius=tgtSigRadius * commonData['tgtSigMult'])
+        y = applyDamage(
+            dmgMap=commonData['dmgMap'],
+            applicationMap=applicationMap,
+            tgtResists=commonData['tgtResists']).total
+        return y
+
+
+# Final getters
+class Distance2DpsGetter(XDistanceMixin, YDpsMixin):
+    pass
+
+
+class Distance2VolleyGetter(XDistanceMixin, YVolleyMixin):
+    pass
+
+
+class Distance2InflictedDamageGetter(XDistanceMixin, YInflictedDamageMixin):
+    pass
+
+
+class Time2DpsGetter(XTimeMixin, YDpsMixin):
+    pass
+
+
+class Time2VolleyGetter(XTimeMixin, YVolleyMixin):
+    pass
+
+
+class Time2InflictedDamageGetter(XTimeMixin, YInflictedDamageMixin):
+    pass
+
+
+class TgtSpeed2DpsGetter(XTgtSpeedMixin, YDpsMixin):
+    pass
+
+
+class TgtSpeed2VolleyGetter(XTgtSpeedMixin, YVolleyMixin):
+    pass
+
+
+class TgtSpeed2InflictedDamageGetter(XTgtSpeedMixin, YInflictedDamageMixin):
+    pass
+
+
+class TgtSigRadius2DpsGetter(XTgtSigRadiusMixin, YDpsMixin):
+    pass
+
+
+class TgtSigRadius2VolleyGetter(XTgtSigRadiusMixin, YVolleyMixin):
+    pass
+
+
+class TgtSigRadius2InflictedDamageGetter(XTgtSigRadiusMixin, YInflictedDamageMixin):
+    pass

graphs/data/fitDamageStats/graph.py

@@ -0,0 +1,113 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from graphs.data.base import FitGraph, XDef, YDef, Input, VectorDef
+from service.const import GraphCacheCleanupReason
+from service.settings import GraphSettings
+from .cache import ProjectedDataCache, TimeCache
+from .getter import (
+    Distance2DpsGetter, Distance2VolleyGetter, Distance2InflictedDamageGetter,
+    Time2DpsGetter, Time2VolleyGetter, Time2InflictedDamageGetter,
+    TgtSpeed2DpsGetter, TgtSpeed2VolleyGetter, TgtSpeed2InflictedDamageGetter,
+    TgtSigRadius2DpsGetter, TgtSigRadius2VolleyGetter, TgtSigRadius2InflictedDamageGetter)
+
+
+class FitDamageStatsGraph(FitGraph):
+
+    def __init__(self):
+        super().__init__()
+        self._timeCache = TimeCache()
+        self._projectedCache = ProjectedDataCache()
+
+    def _clearInternalCache(self, reason, extraData):
+        # Here, we care only about fit changes and graph changes.
+        # - Input changes are irrelevant as time cache cares only about
+        # time input, and it regenerates once time goes beyond cached value
+        # - Option changes are irrelevant as cache contains "raw" damage
+        # values which do not rely on any graph options
+        if reason in (GraphCacheCleanupReason.fitChanged, GraphCacheCleanupReason.fitRemoved):
+            self._timeCache.clearForFit(extraData)
+            self._projectedCache.clearForFit(extraData)
+        elif reason == GraphCacheCleanupReason.graphSwitched:
+            self._timeCache.clearAll()
+            self._projectedCache.clearAll()
+
+    # UI stuff
+    internalName = 'dmgStatsGraph'
+    name = 'Damage Stats'
+    xDefs = [
+        XDef(handle='distance', unit='km', label='Distance', mainInput=('distance', 'km')),
+        XDef(handle='time', unit='s', label='Time', mainInput=('time', 's')),
+        XDef(handle='tgtSpeed', unit='m/s', label='Target speed', mainInput=('tgtSpeed', '%')),
+        XDef(handle='tgtSpeed', unit='%', label='Target speed', mainInput=('tgtSpeed', '%')),
+        XDef(handle='tgtSigRad', unit='m', label='Target signature radius', mainInput=('tgtSigRad', '%')),
+        XDef(handle='tgtSigRad', unit='%', label='Target signature radius', mainInput=('tgtSigRad', '%'))]
+    inputs = [
+        Input(handle='distance', unit='km', label='Distance', iconID=1391, defaultValue=None, defaultRange=(0, 100), mainTooltip='Distance between the attacker and the target, as seen in overview (surface-to-surface)', secondaryTooltip='Distance between the attacker and the target, as seen in overview (surface-to-surface)\nWhen set, places the target that far away from the attacker\nWhen not set, attacker\'s weapons always hit the target'),
+        Input(handle='time', unit='s', label='Time', iconID=1392, defaultValue=None, defaultRange=(0, 80), secondaryTooltip='When set, uses attacker\'s exact damage stats at a given time\nWhen not set, uses attacker\'s damage stats as shown in stats panel of main window'),
+        Input(handle='tgtSpeed', unit='%', label='Target speed', iconID=1389, defaultValue=100, defaultRange=(0, 100)),
+        Input(handle='tgtSigRad', unit='%', label='Target signature', iconID=1390, defaultValue=100, defaultRange=(100, 200), conditions=[
+            (('tgtSigRad', 'm'), None),
+            (('tgtSigRad', '%'), None)])]
+    srcVectorDef = VectorDef(lengthHandle='atkSpeed', lengthUnit='%', angleHandle='atkAngle', angleUnit='degrees', label='Attacker')
+    tgtVectorDef = VectorDef(lengthHandle='tgtSpeed', lengthUnit='%', angleHandle='tgtAngle', angleUnit='degrees', label='Target')
+    hasTargets = True
+    srcExtraCols = ('Dps', 'Volley', 'Speed', 'Radius')
+
+    @property
+    def yDefs(self):
+        ignoreResists = GraphSettings.getInstance().get('ignoreResists')
+        return [
+            YDef(handle='dps', unit=None, label='DPS' if ignoreResists else 'Effective DPS'),
+            YDef(handle='volley', unit=None, label='Volley' if ignoreResists else 'Effective volley'),
+            YDef(handle='damage', unit=None, label='Damage inflicted' if ignoreResists else 'Effective damage inflicted')]
+
+    @property
+    def tgtExtraCols(self):
+        cols = []
+        if not GraphSettings.getInstance().get('ignoreResists'):
+            cols.append('Target Resists')
+        cols.extend(('Speed', 'SigRadius', 'Radius'))
+        return cols
+
+    # Calculation stuff
+    _normalizers = {
+        ('distance', 'km'): lambda v, src, tgt: None if v is None else v * 1000,
+        ('atkSpeed', '%'): lambda v, src, tgt: v / 100 * src.getMaxVelocity(),
+        ('tgtSpeed', '%'): lambda v, src, tgt: v / 100 * tgt.getMaxVelocity(),
+        ('tgtSigRad', '%'): lambda v, src, tgt: v / 100 * tgt.getSigRadius()}
+    _limiters = {'time': lambda src, tgt: (0, 2500)}
+    _getters = {
+        ('distance', 'dps'): Distance2DpsGetter,
+        ('distance', 'volley'): Distance2VolleyGetter,
+        ('distance', 'damage'): Distance2InflictedDamageGetter,
+        ('time', 'dps'): Time2DpsGetter,
+        ('time', 'volley'): Time2VolleyGetter,
+        ('time', 'damage'): Time2InflictedDamageGetter,
+        ('tgtSpeed', 'dps'): TgtSpeed2DpsGetter,
+        ('tgtSpeed', 'volley'): TgtSpeed2VolleyGetter,
+        ('tgtSpeed', 'damage'): TgtSpeed2InflictedDamageGetter,
+        ('tgtSigRad', 'dps'): TgtSigRadius2DpsGetter,
+        ('tgtSigRad', 'volley'): TgtSigRadius2VolleyGetter,
+        ('tgtSigRad', 'damage'): TgtSigRadius2InflictedDamageGetter}
+    _denormalizers = {
+        ('distance', 'km'): lambda v, src, tgt: None if v is None else v / 1000,
+        ('tgtSpeed', '%'): lambda v, src, tgt: v * 100 / tgt.getMaxVelocity(),
+        ('tgtSigRad', '%'): lambda v, src, tgt: v * 100 / tgt.getSigRadius()}

graphs/data/fitEcmBurstScanresDamps/__init__.py

@@ -0,0 +1,24 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from .graph import FitEcmBurstScanresDampsGraph
+
+
+FitEcmBurstScanresDampsGraph.register()

graphs/data/fitEcmBurstScanresDamps/getter.py

@@ -0,0 +1,117 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from eos.calc import calculateLockTime
+from graphs.data.base import SmoothPointGetter
+
+
+ECM_BURST_DURATION = 30
+DRONE_LOCK_TIME = 2
+
+
+class TgtScanRes2TgtLockTimeGetter(SmoothPointGetter):
+
+    def _getCommonData(self, miscParams, src, tgt):
+        if miscParams['applyDamps']:
+            tgtScanResMult = src.item.getDampMultScanRes()
+        else:
+            tgtScanResMult = 1
+        return {
+            'tgtScanResMult': tgtScanResMult,
+            'sigRadius': src.item.ship.getModifiedItemAttr('signatureRadius')}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        scanRes = x
+        time = calculateLockTime(
+            srcScanRes=scanRes * commonData['tgtScanResMult'],
+            tgtSigRadius=commonData['sigRadius'])
+        return time
+
+
+class TgtScanRes2TgtLockUptimeGetter(TgtScanRes2TgtLockTimeGetter):
+
+    def _calculatePoint(self, *args, **kwargs):
+        # Assuming you ECM burst every 30 seconds, find out how long you
+        # will be locked before you burst another time
+        lockTime = super()._calculatePoint(*args, **kwargs)
+        lockedTime = max(0, ECM_BURST_DURATION - lockTime)
+        return lockedTime
+
+
+class SrcDmgBaseGetter(SmoothPointGetter):
+
+    def _getCommonData(self, miscParams, src, tgt):
+        if miscParams['applyDamps']:
+            tgtScanResMult = src.item.getDampMultScanRes()
+        else:
+            tgtScanResMult = 1
+        return {
+            'tgtScanResMult': tgtScanResMult,
+            'srcSigRadius': src.item.ship.getModifiedItemAttr('signatureRadius'),
+            'srcEhp': sum(src.item.ehp.values()),
+            'srcDpsWeapon': src.item.getWeaponDps().total,
+            'srcDpsDrone': src.item.getDroneDps().total if miscParams['applyDrones'] else 0}
+
+    @staticmethod
+    def _calculateInflictedDamage(srcSigRadius, srcWeaponDps, srcDroneDps, srcEhp, tgtScanRes, tgtDps, uptimeAdjustment, uptimeAmountLimit):
+        lockTime = calculateLockTime(srcScanRes=tgtScanRes, tgtSigRadius=srcSigRadius)
+        lockUptime = max(0, ECM_BURST_DURATION - lockTime - uptimeAdjustment)
+        lockDowntime = ECM_BURST_DURATION - lockUptime
+        inflictedDmg = 0
+        remainingEhp = srcEhp
+        for i in range(int(uptimeAmountLimit)):
+            timeAliveUnderFire = min(lockUptime, remainingEhp / tgtDps)
+            timeAlive = lockDowntime + timeAliveUnderFire
+            remainingEhp -= lockUptime * tgtDps
+            inflictedDmg += timeAlive * srcWeaponDps
+            inflictedDmg += max(0, timeAlive - DRONE_LOCK_TIME - 1) * srcDroneDps
+            if remainingEhp <= 0:
+                break
+        return inflictedDmg
+
+
+class TgtScanRes2SrcDmgGetter(SrcDmgBaseGetter):
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        damage = self._calculateInflictedDamage(
+            srcSigRadius=commonData['srcSigRadius'],
+            srcWeaponDps=commonData['srcDpsWeapon'],
+            srcDroneDps=commonData['srcDpsDrone'],
+            srcEhp=commonData['srcEhp'],
+            tgtScanRes=x * commonData['tgtScanResMult'],
+            tgtDps=miscParams['tgtDps'],
+            uptimeAdjustment=miscParams['uptimeAdj'],
+            uptimeAmountLimit=miscParams['uptimeAmtLimit'])
+        return damage
+
+
+class TgtDps2SrcDmgGetter(SrcDmgBaseGetter):
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        damage = self._calculateInflictedDamage(
+            srcSigRadius=commonData['srcSigRadius'],
+            srcWeaponDps=commonData['srcDpsWeapon'],
+            srcDroneDps=commonData['srcDpsDrone'],
+            srcEhp=commonData['srcEhp'],
+            tgtScanRes=miscParams['tgtScanRes'] * commonData['tgtScanResMult'],
+            tgtDps=x,
+            uptimeAdjustment=miscParams['uptimeAdj'],
+            uptimeAmountLimit=miscParams['uptimeAmtLimit'])
+        return damage

graphs/data/fitEcmBurstScanresDamps/graph.py

@@ -0,0 +1,65 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+"""
+Disclaimer by kadesh: this graph was made to analyze my ECM burst + damp frig
+concept. I do not think it is useful for regular player, so it is disabled.
+Enable by setting config.experimentalFeatures = True.
+"""
+
+
+import math
+
+from graphs.data.base import FitGraph, XDef, YDef, Input, InputCheckbox
+from .getter import (
+    TgtScanRes2TgtLockTimeGetter, TgtScanRes2TgtLockUptimeGetter,
+    TgtScanRes2SrcDmgGetter, TgtDps2SrcDmgGetter)
+
+
+class FitEcmBurstScanresDampsGraph(FitGraph):
+
+    # UI stuff
+    hidden = True
+    internalName = 'ecmBurstScanresDamps'
+    name = 'ECM Burst + Scanres Damps'
+    xDefs = [
+        XDef(handle='tgtDps', unit=None, label='Enemy DPS', mainInput=('tgtDps', None)),
+        XDef(handle='tgtScanRes', unit='mm', label='Enemy scanres', mainInput=('tgtScanRes', 'mm'))]
+    yDefs = [
+        YDef(handle='srcDmg', unit=None, label='Damage inflicted'),
+        YDef(handle='tgtLockTime', unit='s', label='Lock time'),
+        YDef(handle='tgtLockUptime', unit='s', label='Lock uptime')]
+    inputs = [
+        Input(handle='tgtScanRes', unit='mm', label='Enemy scanres', iconID=74, defaultValue=700, defaultRange=(100, 1000)),
+        Input(handle='tgtDps', unit=None, label='Enemy DPS', iconID=1432, defaultValue=200, defaultRange=(100, 600)),
+        Input(handle='uptimeAdj', unit='s', label='Uptime adjustment', iconID=1392, defaultValue=1, defaultRange=(None, None), conditions=[(None, ('srcDmg', None))]),
+        Input(handle='uptimeAmtLimit', unit=None, label='Max amount of uptimes', iconID=1397, defaultValue=3, defaultRange=(None, None), conditions=[(None, ('srcDmg', None))])]
+    checkboxes = [
+        InputCheckbox(handle='applyDamps', label='Apply sensor dampeners', defaultValue=True),
+        InputCheckbox(handle='applyDrones', label='Use drones', defaultValue=True, conditions=[(None, ('srcDmg', None))])]
+    srcExtraCols = ('SigRadius', 'Damp ScanRes')
+
+    # Calculation stuff
+    _limiters = {'tgtScanRes': lambda src, tgt: (1, math.inf)}
+    _getters = {
+        ('tgtScanRes', 'tgtLockTime'): TgtScanRes2TgtLockTimeGetter,
+        ('tgtScanRes', 'tgtLockUptime'): TgtScanRes2TgtLockUptimeGetter,
+        ('tgtScanRes', 'srcDmg'): TgtScanRes2SrcDmgGetter,
+        ('tgtDps', 'srcDmg'): TgtDps2SrcDmgGetter}

graphs/data/fitEwarStats/__init__.py

@@ -0,0 +1,24 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from .graph import FitEwarStatsGraph
+
+
+FitEwarStatsGraph.register()

graphs/data/fitEwarStats/getter.py

@@ -0,0 +1,334 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+import math
+
+from eos.calc import calculateMultiplier, calculateRangeFactor
+from graphs.calc import checkLockRange, checkDroneControlRange
+from graphs.data.base import SmoothPointGetter
+
+
+class Distance2NeutingStrGetter(SmoothPointGetter):
+
+    _baseResolution = 50
+    _extraDepth = 2
+
+    def _getCommonData(self, miscParams, src, tgt):
+        resonance = 1 - (miscParams['resist'] or 0)
+        neuts = []
+        for mod in src.item.activeModulesIter():
+            for effectName in ('energyNeutralizerFalloff', 'structureEnergyNeutralizerFalloff'):
+                if effectName in mod.item.effects:
+                    neuts.append((
+                        mod.getModifiedItemAttr('energyNeutralizerAmount') / self.__getDuration(mod) * resonance,
+                        mod.maxRange or 0, mod.falloff or 0, True, False))
+            if 'energyNosferatuFalloff' in mod.item.effects and mod.getModifiedItemAttr('nosOverride'):
+                neuts.append((
+                    mod.getModifiedItemAttr('powerTransferAmount') / self.__getDuration(mod) * resonance,
+                    mod.maxRange or 0, mod.falloff or 0, True, False))
+            if 'doomsdayAOENeut' in mod.item.effects:
+                neuts.append((
+                    mod.getModifiedItemAttr('energyNeutralizerAmount') / self.__getDuration(mod) * resonance,
+                    max(0, (mod.maxRange or 0) + mod.getModifiedItemAttr('doomsdayAOERange') - src.getRadius()),
+                    mod.falloff or 0, False, False))
+        for drone in src.item.activeDronesIter():
+            if 'entityEnergyNeutralizerFalloff' in drone.item.effects:
+                neuts.extend(drone.amountActive * ((
+                    drone.getModifiedItemAttr('energyNeutralizerAmount') / (drone.getModifiedItemAttr('energyNeutralizerDuration') / 1000) * resonance,
+                    math.inf, 0, True, True),))
+        for fighter, ability in src.item.activeFighterAbilityIter():
+            if ability.effect.name == 'fighterAbilityEnergyNeutralizer':
+                nps = fighter.getModifiedItemAttr('fighterAbilityEnergyNeutralizerAmount') / (ability.cycleTime / 1000)
+                neuts.append((
+                    nps * fighter.amount * resonance,
+                    math.inf, 0, True, False))
+        return {'neuts': neuts}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        distance = x
+        inLockRange = checkLockRange(src=src, distance=distance)
+        inDroneRange = checkDroneControlRange(src=src, distance=distance)
+        combinedStr = 0
+        for strength, optimal, falloff, needsLock, needsDcr in commonData['neuts']:
+            if (needsLock and not inLockRange) or (needsDcr and not inDroneRange):
+                continue
+            combinedStr += strength * calculateRangeFactor(srcOptimalRange=optimal, srcFalloffRange=falloff, distance=distance)
+        return combinedStr
+
+    def __getDuration(self, mod):
+        return getattr(mod.getCycleParameters(), 'averageTime', math.inf) / 1000
+
+
+class Distance2WebbingStrGetter(SmoothPointGetter):
+
+    _baseResolution = 50
+    _extraDepth = 2
+
+    def _getCommonData(self, miscParams, src, tgt):
+        resonance = 1 - (miscParams['resist'] or 0)
+        webs = []
+        for mod in src.item.activeModulesIter():
+            for effectName in ('remoteWebifierFalloff', 'structureModuleEffectStasisWebifier'):
+                if effectName in mod.item.effects:
+                    webs.append((
+                        mod.getModifiedItemAttr('speedFactor') * resonance,
+                        mod.maxRange or 0, mod.falloff or 0, 'default', True, False))
+            if 'doomsdayAOEWeb' in mod.item.effects:
+                webs.append((
+                    mod.getModifiedItemAttr('speedFactor') * resonance,
+                    max(0, (mod.maxRange or 0) + mod.getModifiedItemAttr('doomsdayAOERange') - src.getRadius()),
+                    mod.falloff or 0, 'default', False, False))
+        for drone in src.item.activeDronesIter():
+            if 'remoteWebifierEntity' in drone.item.effects:
+                webs.extend(drone.amountActive * ((
+                    drone.getModifiedItemAttr('speedFactor') * resonance,
+                    math.inf, 0, 'default', True, True),))
+        for fighter, ability in src.item.activeFighterAbilityIter():
+            if ability.effect.name == 'fighterAbilityStasisWebifier':
+                webs.append((
+                    fighter.getModifiedItemAttr('fighterAbilityStasisWebifierSpeedPenalty') * fighter.amount * resonance,
+                    math.inf, 0, 'default', True, False))
+        return {'webs': webs}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        distance = x
+        inLockRange = checkLockRange(src=src, distance=distance)
+        inDroneRange = checkDroneControlRange(src=src, distance=distance)
+        strMults = {}
+        for strength, optimal, falloff, stackingGroup, needsLock, needsDcr in commonData['webs']:
+            if (needsLock and not inLockRange) or (needsDcr and not inDroneRange):
+                continue
+            strength *= calculateRangeFactor(srcOptimalRange=optimal, srcFalloffRange=falloff, distance=distance)
+            strMults.setdefault(stackingGroup, []).append((1 + strength / 100, None))
+        strMult = calculateMultiplier(strMults)
+        strength = (1 - strMult) * 100
+        return strength
+
+
+class Distance2EcmStrMaxGetter(SmoothPointGetter):
+
+    _baseResolution = 50
+    _extraDepth = 2
+
+    ECM_ATTRS_GENERAL = ('scanGravimetricStrengthBonus', 'scanLadarStrengthBonus', 'scanMagnetometricStrengthBonus', 'scanRadarStrengthBonus')
+    ECM_ATTRS_FIGHTERS = ('fighterAbilityECMStrengthGravimetric', 'fighterAbilityECMStrengthLadar', 'fighterAbilityECMStrengthMagnetometric', 'fighterAbilityECMStrengthRadar')
+
+    def _getCommonData(self, miscParams, src, tgt):
+        resonance = 1 - (miscParams['resist'] or 0)
+        ecms = []
+        for mod in src.item.activeModulesIter():
+            for effectName in ('remoteECMFalloff', 'structureModuleEffectECM'):
+                if effectName in mod.item.effects:
+                    ecms.append((
+                        max(mod.getModifiedItemAttr(a) for a in self.ECM_ATTRS_GENERAL) * resonance,
+                        mod.maxRange or 0, mod.falloff or 0, True, False))
+            if 'doomsdayAOEECM' in mod.item.effects:
+                ecms.append((
+                    max(mod.getModifiedItemAttr(a) for a in self.ECM_ATTRS_GENERAL) * resonance,
+                    max(0, (mod.maxRange or 0) + mod.getModifiedItemAttr('doomsdayAOERange') - src.getRadius()),
+                    mod.falloff or 0, False, False))
+        for drone in src.item.activeDronesIter():
+            if 'entityECMFalloff' in drone.item.effects:
+                ecms.extend(drone.amountActive * ((
+                    max(drone.getModifiedItemAttr(a) for a in self.ECM_ATTRS_GENERAL) * resonance,
+                    math.inf, 0, True, True),))
+        for fighter, ability in src.item.activeFighterAbilityIter():
+            if ability.effect.name == 'fighterAbilityECM':
+                ecms.append((
+                    max(fighter.getModifiedItemAttr(a) for a in self.ECM_ATTRS_FIGHTERS) * fighter.amount * resonance,
+                    math.inf, 0, True, False))
+        return {'ecms': ecms}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        distance = x
+        inLockRange = checkLockRange(src=src, distance=distance)
+        inDroneRange = checkDroneControlRange(src=src, distance=distance)
+        combinedStr = 0
+        for strength, optimal, falloff, needsLock, needsDcr in commonData['ecms']:
+            if (needsLock and not inLockRange) or (needsDcr and not inDroneRange):
+                continue
+            combinedStr += strength * calculateRangeFactor(srcOptimalRange=optimal, srcFalloffRange=falloff, distance=distance)
+        return combinedStr
+
+
+class Distance2DampStrLockRangeGetter(SmoothPointGetter):
+
+    _baseResolution = 50
+    _extraDepth = 2
+
+    def _getCommonData(self, miscParams, src, tgt):
+        resonance = 1 - (miscParams['resist'] or 0)
+        damps = []
+        for mod in src.item.activeModulesIter():
+            for effectName in ('remoteSensorDampFalloff', 'structureModuleEffectRemoteSensorDampener'):
+                if effectName in mod.item.effects:
+                    damps.append((
+                        mod.getModifiedItemAttr('maxTargetRangeBonus') * resonance,
+                        mod.maxRange or 0, mod.falloff or 0, 'default', True, False))
+            if 'doomsdayAOEDamp' in mod.item.effects:
+                damps.append((
+                    mod.getModifiedItemAttr('maxTargetRangeBonus') * resonance,
+                    max(0, (mod.maxRange or 0) + mod.getModifiedItemAttr('doomsdayAOERange') - src.getRadius()),
+                    mod.falloff or 0, 'default', False, False))
+        for drone in src.item.activeDronesIter():
+            if 'remoteSensorDampEntity' in drone.item.effects:
+                damps.extend(drone.amountActive * ((
+                    drone.getModifiedItemAttr('maxTargetRangeBonus') * resonance,
+                    math.inf, 0, 'default', True, True),))
+        return {'damps': damps}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        distance = x
+        inLockRange = checkLockRange(src=src, distance=distance)
+        inDroneRange = checkDroneControlRange(src=src, distance=distance)
+        strMults = {}
+        for strength, optimal, falloff, stackingGroup, needsLock, needsDcr in commonData['damps']:
+            if (needsLock and not inLockRange) or (needsDcr and not inDroneRange):
+                continue
+            strength *= calculateRangeFactor(srcOptimalRange=optimal, srcFalloffRange=falloff, distance=distance)
+            strMults.setdefault(stackingGroup, []).append((1 + strength / 100, None))
+        strMult = calculateMultiplier(strMults)
+        strength = (1 - strMult) * 100
+        return strength
+
+
+class Distance2TdStrOptimalGetter(SmoothPointGetter):
+
+    _baseResolution = 50
+    _extraDepth = 2
+
+    def _getCommonData(self, miscParams, src, tgt):
+        resonance = 1 - (miscParams['resist'] or 0)
+        tds = []
+        for mod in src.item.activeModulesIter():
+            for effectName in ('shipModuleTrackingDisruptor', 'structureModuleEffectWeaponDisruption'):
+                if effectName in mod.item.effects:
+                    tds.append((
+                        mod.getModifiedItemAttr('maxRangeBonus') * resonance,
+                        mod.maxRange or 0, mod.falloff or 0, 'default', True, False))
+            if 'doomsdayAOETrack' in mod.item.effects:
+                tds.append((
+                    mod.getModifiedItemAttr('maxRangeBonus') * resonance,
+                    max(0, (mod.maxRange or 0) + mod.getModifiedItemAttr('doomsdayAOERange') - src.getRadius()),
+                    mod.falloff or 0, 'default', False, False))
+        for drone in src.item.activeDronesIter():
+            if 'npcEntityWeaponDisruptor' in drone.item.effects:
+                tds.extend(drone.amountActive * ((
+                    drone.getModifiedItemAttr('maxRangeBonus') * resonance,
+                    math.inf, 0, 'default', True, True),))
+        return {'tds': tds}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        distance = x
+        inLockRange = checkLockRange(src=src, distance=distance)
+        inDroneRange = checkDroneControlRange(src=src, distance=distance)
+        strMults = {}
+        for strength, optimal, falloff, stackingGroup, needsLock, needsDcr in commonData['tds']:
+            if (needsLock and not inLockRange) or (needsDcr and not inDroneRange):
+                continue
+            strength *= calculateRangeFactor(srcOptimalRange=optimal, srcFalloffRange=falloff, distance=distance)
+            strMults.setdefault(stackingGroup, []).append((1 + strength / 100, None))
+        strMult = calculateMultiplier(strMults)
+        strength = (1 - strMult) * 100
+        return strength
+
+
+class Distance2GdStrRangeGetter(SmoothPointGetter):
+
+    _baseResolution = 50
+    _extraDepth = 2
+
+    def _getCommonData(self, miscParams, src, tgt):
+        resonance = 1 - (miscParams['resist'] or 0)
+        gds = []
+        for mod in src.item.activeModulesIter():
+            for effectName in ('shipModuleGuidanceDisruptor', 'structureModuleEffectWeaponDisruption'):
+                if effectName in mod.item.effects:
+                    gds.append((
+                        mod.getModifiedItemAttr('missileVelocityBonus') * resonance,
+                        mod.getModifiedItemAttr('explosionDelayBonus') * resonance,
+                        mod.maxRange or 0, mod.falloff or 0, 'default', True, False))
+            if 'doomsdayAOETrack' in mod.item.effects:
+                gds.append((
+                    mod.getModifiedItemAttr('missileVelocityBonus') * resonance,
+                    mod.getModifiedItemAttr('explosionDelayBonus') * resonance,
+                    max(0, (mod.maxRange or 0) + mod.getModifiedItemAttr('doomsdayAOERange') - src.getRadius()),
+                    mod.falloff or 0, 'default', False, False))
+        return {'gds': gds}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        distance = x
+        inLockRange = checkLockRange(src=src, distance=distance)
+        inDroneRange = checkDroneControlRange(src=src, distance=distance)
+        velocityStrMults = {}
+        timeStrMults = {}
+        for velocityStr, timeStr, optimal, falloff, stackingGroup, needsLock, needsDcr in commonData['gds']:
+            if (needsLock and not inLockRange) or (needsDcr and not inDroneRange):
+                continue
+            rangeFactor = calculateRangeFactor(srcOptimalRange=optimal, srcFalloffRange=falloff, distance=distance)
+            velocityStr *= rangeFactor
+            timeStr *= rangeFactor
+            velocityStrMults.setdefault(stackingGroup, []).append((1 + velocityStr / 100, None))
+            timeStrMults.setdefault(stackingGroup, []).append((1 + timeStr / 100, None))
+        velocityStrMult = calculateMultiplier(velocityStrMults)
+        timeStrMult = calculateMultiplier(timeStrMults)
+        strength = (1 - velocityStrMult * timeStrMult) * 100
+        return strength
+
+
+class Distance2TpStrGetter(SmoothPointGetter):
+
+    _baseResolution = 50
+    _extraDepth = 2
+
+    def _getCommonData(self, miscParams, src, tgt):
+        resonance = 1 - (miscParams['resist'] or 0)
+        tps = []
+        for mod in src.item.activeModulesIter():
+            for effectName in ('remoteTargetPaintFalloff', 'structureModuleEffectTargetPainter'):
+                if effectName in mod.item.effects:
+                    tps.append((
+                        mod.getModifiedItemAttr('signatureRadiusBonus') * resonance,
+                        mod.maxRange or 0, mod.falloff or 0, 'default', True, False))
+            if 'doomsdayAOEPaint' in mod.item.effects:
+                tps.append((
+                    mod.getModifiedItemAttr('signatureRadiusBonus') * resonance,
+                    max(0, (mod.maxRange or 0) + mod.getModifiedItemAttr('doomsdayAOERange') - src.getRadius()),
+                    mod.falloff or 0, 'default', False, False))
+        for drone in src.item.activeDronesIter():
+            if 'remoteTargetPaintEntity' in drone.item.effects:
+                tps.extend(drone.amountActive * ((
+                    drone.getModifiedItemAttr('signatureRadiusBonus') * resonance,
+                    math.inf, 0, 'default', True, True),))
+        return {'tps': tps}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        distance = x
+        inLockRange = checkLockRange(src=src, distance=distance)
+        inDroneRange = checkDroneControlRange(src=src, distance=distance)
+        strMults = {}
+        for strength, optimal, falloff, stackingGroup, needsLock, needsDcr in commonData['tps']:
+            if (needsLock and not inLockRange) or (needsDcr and not inDroneRange):
+                continue
+            strength *= calculateRangeFactor(srcOptimalRange=optimal, srcFalloffRange=falloff, distance=distance)
+            strMults.setdefault(stackingGroup, []).append((1 + strength / 100, None))
+        strMult = calculateMultiplier(strMults)
+        strength = (strMult - 1) * 100
+        return strength

graphs/data/fitEwarStats/graph.py

@@ -0,0 +1,59 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from graphs.data.base import FitGraph, Input, XDef, YDef
+from .getter import (
+    Distance2NeutingStrGetter, Distance2WebbingStrGetter, Distance2EcmStrMaxGetter,
+    Distance2DampStrLockRangeGetter, Distance2TdStrOptimalGetter, Distance2GdStrRangeGetter,
+    Distance2TpStrGetter)
+
+
+class FitEwarStatsGraph(FitGraph):
+
+    # UI stuff
+    internalName = 'ewarStatsGraph'
+    name = 'Electronic Warfare Stats'
+    xDefs = [XDef(handle='distance', unit='km', label='Distance', mainInput=('distance', 'km'))]
+    yDefs = [
+        YDef(handle='neutStr', unit=None, label='Cap neutralized per second', selectorLabel='Neuts: cap per second'),
+        YDef(handle='webStr', unit='%', label='Speed reduction', selectorLabel='Webs: speed reduction'),
+        YDef(handle='ecmStrMax', unit=None, label='Combined ECM strength', selectorLabel='ECM: combined strength'),
+        YDef(handle='dampStrLockRange', unit='%', label='Lock range reduction', selectorLabel='Damps: lock range reduction'),
+        YDef(handle='tdStrOptimal', unit='%', label='Turret optimal range reduction', selectorLabel='TDs: turret optimal range reduction'),
+        YDef(handle='gdStrRange', unit='%', label='Missile flight range reduction', selectorLabel='GDs: missile flight range reduction'),
+        YDef(handle='tpStr', unit='%', label='Signature radius increase', selectorLabel='TPs: signature radius increase')]
+    inputs = [
+        Input(handle='distance', unit='km', label='Distance', iconID=1391, defaultValue=None, defaultRange=(0, 100)),
+        Input(handle='resist', unit='%', label='Target resistance', iconID=1393, defaultValue=0, defaultRange=(0, 100))]
+
+    # Calculation stuff
+    _normalizers = {
+        ('distance', 'km'): lambda v, src, tgt: None if v is None else v * 1000,
+        ('resist', '%'): lambda v, src, tgt: None if v is None else v / 100}
+    _limiters = {'resist': lambda src, tgt: (0, 1)}
+    _getters = {
+        ('distance', 'neutStr'): Distance2NeutingStrGetter,
+        ('distance', 'webStr'): Distance2WebbingStrGetter,
+        ('distance', 'ecmStrMax'): Distance2EcmStrMaxGetter,
+        ('distance', 'dampStrLockRange'): Distance2DampStrLockRangeGetter,
+        ('distance', 'tdStrOptimal'): Distance2TdStrOptimalGetter,
+        ('distance', 'gdStrRange'): Distance2GdStrRangeGetter,
+        ('distance', 'tpStr'): Distance2TpStrGetter}
+    _denormalizers = {('distance', 'km'): lambda v, src, tgt: None if v is None else v / 1000}

graphs/data/fitLockTime/__init__.py

@@ -0,0 +1,24 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from .graph import FitLockTimeGraph
+
+
+FitLockTimeGraph.register()

graphs/data/fitLockTime/getter.py

@@ -0,0 +1,29 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from graphs.data.base import SmoothPointGetter
+
+
+class TgtSigRadius2LockTimeGetter(SmoothPointGetter):
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        tgtSigRadius = x
+        time = src.item.calculateLockTime(radius=tgtSigRadius)
+        return time

graphs/data/fitLockTime/graph.py

@@ -0,0 +1,39 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+import math
+
+from graphs.data.base import FitGraph, XDef, YDef, Input
+from .getter import TgtSigRadius2LockTimeGetter
+
+
+class FitLockTimeGraph(FitGraph):
+
+    # UI stuff
+    internalName = 'lockTimeGraph'
+    name = 'Lock Time'
+    xDefs = [XDef(handle='tgtSigRad', unit='m', label='Target signature radius', mainInput=('tgtSigRad', 'm'))]
+    yDefs = [YDef(handle='time', unit='s', label='Lock time')]
+    inputs = [Input(handle='tgtSigRad', unit='m', label='Target signature', iconID=1390, defaultValue=None, defaultRange=(25, 500))]
+    srcExtraCols = ('ScanResolution',)
+
+    # Calculation stuff
+    _limiters = {'tgtSigRad': lambda src, tgt: (1, math.inf)}
+    _getters = {('tgtSigRad', 'time'): TgtSigRadius2LockTimeGetter}

graphs/data/fitMobility/__init__.py

@@ -0,0 +1,24 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from .graph import FitMobilityGraph
+
+
+FitMobilityGraph.register()

graphs/data/fitMobility/getter.py

@@ -0,0 +1,62 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+import math
+
+from graphs.data.base import SmoothPointGetter
+
+
+class Time2SpeedGetter(SmoothPointGetter):
+
+    def _getCommonData(self, miscParams, src, tgt):
+        return {
+            'maxSpeed': src.getMaxVelocity(),
+            'mass': src.item.ship.getModifiedItemAttr('mass'),
+            'agility': src.item.ship.getModifiedItemAttr('agility')}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        time = x
+        maxSpeed = commonData['maxSpeed']
+        mass = commonData['mass']
+        agility = commonData['agility']
+        # https://wiki.eveuniversity.org/Acceleration#Mathematics_and_formulae
+        speed = maxSpeed * (1 - math.exp((-time * 1000000) / (agility * mass)))
+        return speed
+
+
+class Time2DistanceGetter(SmoothPointGetter):
+
+    def _getCommonData(self, miscParams, src, tgt):
+        return {
+            'maxSpeed': src.getMaxVelocity(),
+            'mass': src.item.ship.getModifiedItemAttr('mass'),
+            'agility': src.item.ship.getModifiedItemAttr('agility')}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        time = x
+        maxSpeed = commonData['maxSpeed']
+        mass = commonData['mass']
+        agility = commonData['agility']
+        # Definite integral of:
+        # https://wiki.eveuniversity.org/Acceleration#Mathematics_and_formulae
+        distance_t = maxSpeed * time + (maxSpeed * agility * mass * math.exp((-time * 1000000) / (agility * mass)) / 1000000)
+        distance_0 = maxSpeed * 0 + (maxSpeed * agility * mass * math.exp((-0 * 1000000) / (agility * mass)) / 1000000)
+        distance = distance_t - distance_0
+        return distance

graphs/data/fitMobility/graph.py

@@ -0,0 +1,41 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from graphs.data.base import FitGraph, XDef, YDef, Input
+from .getter import Time2SpeedGetter, Time2DistanceGetter
+
+
+class FitMobilityGraph(FitGraph):
+
+    # UI stuff
+    internalName = 'mobilityGraph'
+    name = 'Mobility'
+    xDefs = [XDef(handle='time', unit='s', label='Time', mainInput=('time', 's'))]
+    yDefs = [
+        YDef(handle='speed', unit='m/s', label='Speed'),
+        YDef(handle='distance', unit='km', label='Distance')]
+    inputs = [Input(handle='time', unit='s', label='Time', iconID=1392, defaultValue=10, defaultRange=(0, 30))]
+    srcExtraCols = ('Speed', 'Agility')
+
+    # Calculation stuff
+    _getters = {
+        ('time', 'speed'): Time2SpeedGetter,
+        ('time', 'distance'): Time2DistanceGetter}
+    _denormalizers = {('distance', 'km'): lambda v, src, tgt: v / 1000}

graphs/data/fitRemoteReps/__init__.py

@@ -0,0 +1,24 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from .graph import FitRemoteRepsGraph
+
+
+FitRemoteRepsGraph.register()

graphs/data/fitRemoteReps/cache.py

@@ -0,0 +1,218 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from copy import copy
+
+from eos.utils.float import floatUnerr
+from eos.utils.spoolSupport import SpoolOptions, SpoolType
+from eos.utils.stats import RRTypes
+from graphs.data.base import FitDataCache
+
+
+class TimeCache(FitDataCache):
+
+    # Whole data getters
+    def getRpsData(self, src, ancReload):
+        """Return RPS data in {time: {key: rps}} format."""
+        return self._data[src.item.ID][ancReload]['finalRps']
+
+    def getRepAmountData(self, src, ancReload):
+        """Return rep amount data in {time: {key: amount}} format."""
+        return self._data[src.item.ID][ancReload]['finalRepAmount']
+
+    # Specific data point getters
+    def getRpsDataPoint(self, src, ancReload, time):
+        """Get RPS data by specified time in {key: rps} format."""
+        return self._getDataPoint(src=src, ancReload=ancReload, time=time, dataFunc=self.getRpsData)
+
+    def getRepAmountDataPoint(self, src, ancReload, time):
+        """Get rep amount data by specified time in {key: amount} format."""
+        return self._getDataPoint(src=src, ancReload=ancReload, time=time, dataFunc=self.getRepAmountData)
+
+    # Preparation functions
+    def prepareRpsData(self, src, ancReload, maxTime):
+        # Time is none means that time parameter has to be ignored,
+        # we do not need cache for that
+        if maxTime is None:
+            return True
+        self._generateInternalForm(src=src, ancReload=ancReload, maxTime=maxTime)
+        fitCache = self._data[src.item.ID][ancReload]
+        # Final cache has been generated already, don't do anything
+        if 'finalRps' in fitCache:
+            return
+        # Convert cache from segments with assigned values into points
+        # which are located at times when rps value changes
+        pointCache = {}
+        for key, rpsList in fitCache['internalRps'].items():
+            pointData = pointCache[key] = {}
+            prevRps = None
+            prevTimeEnd = None
+            for timeStart, timeEnd, rps in rpsList:
+                # First item
+                if not pointData:
+                    pointData[timeStart] = rps
+                # Gap between items
+                elif floatUnerr(prevTimeEnd) < floatUnerr(timeStart):
+                    pointData[prevTimeEnd] = RRTypes(0, 0, 0, 0)
+                    pointData[timeStart] = rps
+                # Changed value
+                elif rps != prevRps:
+                    pointData[timeStart] = rps
+                prevRps = rps
+                prevTimeEnd = timeEnd
+        # We have data in another form, do not need old one any longer
+        del fitCache['internalRps']
+        changesByTime = {}
+        for key, rpsMap in pointCache.items():
+            for time in rpsMap:
+                changesByTime.setdefault(time, []).append(key)
+        # Here we convert cache to following format:
+        # {time: {key: rps}
+        finalRpsCache = fitCache['finalRps'] = {}
+        timeRpsData = {}
+        for time in sorted(changesByTime):
+            timeRpsData = copy(timeRpsData)
+            for key in changesByTime[time]:
+                timeRpsData[key] = pointCache[key][time]
+            finalRpsCache[time] = timeRpsData
+
+    def prepareRepAmountData(self, src, ancReload, maxTime):
+        # Time is none means that time parameter has to be ignored,
+        # we do not need cache for that
+        if maxTime is None:
+            return
+        self._generateInternalForm(src=src, ancReload=ancReload, maxTime=maxTime)
+        fitCache = self._data[src.item.ID][ancReload]
+        # Final cache has been generated already, don't do anything
+        if 'finalRepAmount' in fitCache:
+            return
+        intCache = fitCache['internalRepAmount']
+        changesByTime = {}
+        for key, remAmountMap in intCache.items():
+            for time in remAmountMap:
+                changesByTime.setdefault(time, []).append(key)
+        # Here we convert cache to following format:
+        # {time: {key: hp repaired by key at this time}}
+        finalCache = fitCache['finalRepAmount'] = {}
+        timeRepAmountData = {}
+        for time in sorted(changesByTime):
+            timeRepAmountData = copy(timeRepAmountData)
+            for key in changesByTime[time]:
+                keyRepAmount = intCache[key][time]
+                if key in timeRepAmountData:
+                    timeRepAmountData[key] = timeRepAmountData[key] + keyRepAmount
+                else:
+                    timeRepAmountData[key] = keyRepAmount
+            finalCache[time] = timeRepAmountData
+        # We do not need internal cache once we have final
+        del fitCache['internalRepAmount']
+
+    # Private stuff
+    def _generateInternalForm(self, src, ancReload, maxTime):
+        if self._isTimeCacheValid(src=src, ancReload=ancReload, maxTime=maxTime):
+            return
+        fitCache = self._data.setdefault(src.item.ID, {})[ancReload] = {'maxTime': maxTime}
+        intCacheRps = fitCache['internalRps'] = {}
+        intCacheRepAmount = fitCache['internalRepAmount'] = {}
+
+        def addRps(rrKey, addedTimeStart, addedTimeFinish, addedRepAmounts):
+            if not addedRepAmounts:
+                return
+            repAmountSum = sum(addedRepAmounts, RRTypes(0, 0, 0, 0))
+            if repAmountSum.shield > 0 or repAmountSum.armor > 0 or repAmountSum.hull > 0:
+                addedRps = repAmountSum / (addedTimeFinish - addedTimeStart)
+                rrCacheRps = intCacheRps.setdefault(rrKey, [])
+                rrCacheRps.append((addedTimeStart, addedTimeFinish, addedRps))
+
+        def addRepAmount(rrKey, addedTime, addedRepAmount):
+            if addedRepAmount.shield > 0 or addedRepAmount.armor > 0 or addedRepAmount.hull > 0:
+                intCacheRepAmount.setdefault(rrKey, {})[addedTime] = addedRepAmount
+
+        # Modules
+        for mod in src.item.activeModulesIter():
+            if not mod.isRemoteRepping():
+                continue
+            isAncShield = 'shipModuleAncillaryRemoteShieldBooster' in mod.item.effects
+            isAncArmor = 'shipModuleAncillaryRemoteArmorRepairer' in mod.item.effects
+            if isAncShield or isAncArmor:
+                cycleParams = mod.getCycleParameters(reloadOverride=ancReload)
+            else:
+                cycleParams = mod.getCycleParameters(reloadOverride=True)
+            if cycleParams is None:
+                continue
+            currentTime = 0
+            nonstopCycles = 0
+            cyclesWithoutReload = 0
+            cyclesUntilReload = mod.numShots
+            for cycleTimeMs, inactiveTimeMs, isInactivityReload in cycleParams.iterCycles():
+                cyclesWithoutReload += 1
+                cycleRepAmounts = []
+                repAmountParams = mod.getRepAmountParameters(spoolOptions=SpoolOptions(SpoolType.CYCLES, nonstopCycles, True))
+                for repTimeMs, repAmount in repAmountParams.items():
+                    # Loaded ancillary armor rep can keep running at less efficiency if we decide to not reload
+                    if isAncArmor and mod.charge and not ancReload and cyclesWithoutReload > cyclesUntilReload:
+                        repAmount = repAmount / mod.getModifiedItemAttr('chargedArmorDamageMultiplier', 1)
+                    cycleRepAmounts.append(repAmount)
+                    addRepAmount(mod, currentTime + repTimeMs / 1000, repAmount)
+                addRps(mod, currentTime, currentTime + cycleTimeMs / 1000, cycleRepAmounts)
+                if inactiveTimeMs > 0:
+                    nonstopCycles = 0
+                else:
+                    nonstopCycles += 1
+                if isInactivityReload:
+                    cyclesWithoutReload = 0
+                if currentTime > maxTime:
+                    break
+                currentTime += cycleTimeMs / 1000 + inactiveTimeMs / 1000
+        # Drones
+        for drone in src.item.activeDronesIter():
+            if not drone.isRemoteRepping():
+                continue
+            cycleParams = drone.getCycleParameters(reloadOverride=True)
+            if cycleParams is None:
+                continue
+            currentTime = 0
+            repAmountParams = drone.getRepAmountParameters()
+            for cycleTimeMs, inactiveTimeMs, isInactivityReload in cycleParams.iterCycles():
+                cycleRepAmounts = []
+                for repTimeMs, repAmount in repAmountParams.items():
+                    cycleRepAmounts.append(repAmount)
+                    addRepAmount(drone, currentTime + repTimeMs / 1000, repAmount)
+                addRps(drone, currentTime, currentTime + cycleTimeMs / 1000, cycleRepAmounts)
+                if currentTime > maxTime:
+                    break
+                currentTime += cycleTimeMs / 1000 + inactiveTimeMs / 1000
+
+    def _isTimeCacheValid(self, src, ancReload, maxTime):
+        try:
+            cacheMaxTime = self._data[src.item.ID][ancReload]['maxTime']
+        except KeyError:
+            return False
+        return maxTime <= cacheMaxTime
+
+    def _getDataPoint(self, src, ancReload, time, dataFunc):
+        data = dataFunc(src=src, ancReload=ancReload)
+        timesBefore = [t for t in data if floatUnerr(t) <= floatUnerr(time)]
+        try:
+            time = max(timesBefore)
+        except ValueError:
+            return {}
+        else:
+            return data[time]

graphs/data/fitRemoteReps/calc.py

@@ -0,0 +1,50 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from eos.calc import calculateRangeFactor
+from eos.utils.float import floatUnerr
+from graphs.calc import checkLockRange, checkDroneControlRange
+
+
+def getApplicationPerKey(src, distance):
+    inLockRange = checkLockRange(src=src, distance=distance)
+    inDroneRange = checkDroneControlRange(src=src, distance=distance)
+    applicationMap = {}
+    for mod in src.item.activeModulesIter():
+        if not mod.isRemoteRepping():
+            continue
+        if not inLockRange:
+            applicationMap[mod] = 0
+        else:
+            applicationMap[mod] = calculateRangeFactor(
+                srcOptimalRange=mod.maxRange or 0,
+                srcFalloffRange=mod.falloff or 0,
+                distance=distance)
+    for drone in src.item.activeDronesIter():
+        if not drone.isRemoteRepping():
+            continue
+        if not inLockRange or not inDroneRange:
+            applicationMap[drone] = 0
+        else:
+            applicationMap[drone] = 1
+    # Ensure consistent results - round off a little to avoid float errors
+    for k, v in applicationMap.items():
+        applicationMap[k] = floatUnerr(v)
+    return applicationMap

graphs/data/fitRemoteReps/getter.py

@@ -0,0 +1,190 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+import eos.config
+from eos.utils.spoolSupport import SpoolOptions, SpoolType
+from eos.utils.stats import RRTypes
+from graphs.data.base import PointGetter, SmoothPointGetter
+from .calc import getApplicationPerKey
+
+
+def applyReps(rrMap, applicationMap):
+    totalAmount = RRTypes(shield=0, armor=0, hull=0, capacitor=0)
+    for key, repAmount in rrMap.items():
+        totalAmount += repAmount * applicationMap.get(key, 0)
+    # We do not want to include energy transfers into final value
+    totalReps = totalAmount.shield + totalAmount.armor + totalAmount.hull
+    return totalReps
+
+
+# Y mixins
+class YRpsMixin:
+
+    def _getRepsPerKey(self, src, ancReload, time):
+        # Use data from time cache if time was not specified
+        if time is not None:
+            return self._getTimeCacheDataPoint(src=src, ancReload=ancReload, time=time)
+        # Compose map ourselves using current fit settings if time is not specified
+        rpsMap = {}
+        defaultSpoolValue = eos.config.settings['globalDefaultSpoolupPercentage']
+        for mod in src.item.activeModulesIter():
+            if not mod.isRemoteRepping():
+                continue
+            isAncShield = 'shipModuleAncillaryRemoteShieldBooster' in mod.item.effects
+            isAncArmor = 'shipModuleAncillaryRemoteArmorRepairer' in mod.item.effects
+            rpsMap[mod] = mod.getRemoteReps(
+                spoolOptions=SpoolOptions(SpoolType.SPOOL_SCALE, defaultSpoolValue, False),
+                reloadOverride=ancReload if (isAncShield or isAncArmor) else None)
+        for drone in src.item.activeDronesIter():
+            if not drone.isRemoteRepping():
+                continue
+            rpsMap[drone] = drone.getRemoteReps()
+        return rpsMap
+
+    def _prepareTimeCache(self, src, ancReload, maxTime):
+        self.graph._timeCache.prepareRpsData(src=src, ancReload=ancReload, maxTime=maxTime)
+
+    def _getTimeCacheData(self, src, ancReload):
+        return self.graph._timeCache.getRpsData(src=src, ancReload=ancReload)
+
+    def _getTimeCacheDataPoint(self, src, ancReload, time):
+        return self.graph._timeCache.getRpsDataPoint(src=src, ancReload=ancReload, time=time)
+
+
+class YRepAmountMixin:
+
+    def _getRepsPerKey(self, src, ancReload, time):
+        # Total reps given makes no sense without time specified
+        if time is None:
+            raise ValueError
+        return self._getTimeCacheDataPoint(src=src, ancReload=ancReload, time=time)
+
+    def _prepareTimeCache(self, src, ancReload, maxTime):
+        self.graph._timeCache.prepareRepAmountData(src=src, ancReload=ancReload, maxTime=maxTime)
+
+    def _getTimeCacheData(self, src, ancReload):
+        return self.graph._timeCache.getRepAmountData(src=src, ancReload=ancReload)
+
+    def _getTimeCacheDataPoint(self, src, ancReload, time):
+        return self.graph._timeCache.getRepAmountDataPoint(src=src, ancReload=ancReload, time=time)
+
+
+# X mixins
+class XDistanceMixin(SmoothPointGetter):
+
+    _baseResolution = 50
+    _extraDepth = 2
+
+    def _getCommonData(self, miscParams, src, tgt):
+        # Prepare time cache here because we need to do it only once,
+        # and this function is called once per point info fetch
+        self._prepareTimeCache(src=src, ancReload=miscParams['ancReload'], maxTime=miscParams['time'])
+        return {'rrMap': self._getRepsPerKey(src=src, ancReload=miscParams['ancReload'], time=miscParams['time'])}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        distance = x
+        applicationMap = getApplicationPerKey(src=src, distance=distance)
+        y = applyReps(
+            rrMap=commonData['rrMap'],
+            applicationMap=applicationMap)
+        return y
+
+
+class XTimeMixin(PointGetter):
+
+    def getRange(self, xRange, miscParams, src, tgt):
+        xs = []
+        ys = []
+        minTime, maxTime = xRange
+        # Prepare time cache and various shared data
+        self._prepareTimeCache(src=src, ancReload=miscParams['ancReload'], maxTime=maxTime)
+        timeCache = self._getTimeCacheData(src=src, ancReload=miscParams['ancReload'])
+        applicationMap = getApplicationPerKey(src=src, distance=miscParams['distance'])
+        # Custom iteration for time graph to show all data points
+        currentRepAmount = None
+        currentTime = None
+        for currentTime in sorted(timeCache):
+            prevRepAmount = currentRepAmount
+            currentRepAmountData = timeCache[currentTime]
+            currentRepAmount = applyReps(rrMap=currentRepAmountData, applicationMap=applicationMap)
+            if currentTime < minTime:
+                continue
+            # First set of data points
+            if not xs:
+                # Start at exactly requested time, at last known value
+                initialRepAmount = prevRepAmount or 0
+                xs.append(minTime)
+                ys.append(initialRepAmount)
+                # If current time is bigger then starting, extend plot to that time with old value
+                if currentTime > minTime:
+                    xs.append(currentTime)
+                    ys.append(initialRepAmount)
+                # If new value is different, extend it with new point to the new value
+                if currentRepAmount != prevRepAmount:
+                    xs.append(currentTime)
+                    ys.append(currentRepAmount)
+                continue
+            # Last data point
+            if currentTime >= maxTime:
+                xs.append(maxTime)
+                ys.append(prevRepAmount)
+                break
+            # Anything in-between
+            if currentRepAmount != prevRepAmount:
+                if prevRepAmount is not None:
+                    xs.append(currentTime)
+                    ys.append(prevRepAmount)
+                xs.append(currentTime)
+                ys.append(currentRepAmount)
+        # Special case - there are no remote reppers
+        if currentRepAmount is None and currentTime is None:
+            xs.append(minTime)
+            ys.append(0)
+        # Make sure that last data point is always at max time
+        if maxTime > (currentTime or 0):
+            xs.append(maxTime)
+            ys.append(currentRepAmount or 0)
+        return xs, ys
+
+    def getPoint(self, x, miscParams, src, tgt):
+        time = x
+        # Prepare time cache and various data
+        self._prepareTimeCache(src=src, ancReload=miscParams['ancReload'], maxTime=time)
+        repAmountData = self._getTimeCacheDataPoint(src=src, ancReload=miscParams['ancReload'], time=time)
+        applicationMap = getApplicationPerKey(src=src, distance=miscParams['distance'])
+        y = applyReps(rrMap=repAmountData, applicationMap=applicationMap)
+        return y
+
+
+# Final getters
+class Distance2RpsGetter(XDistanceMixin, YRpsMixin):
+    pass
+
+
+class Distance2RepAmountGetter(XDistanceMixin, YRepAmountMixin):
+    pass
+
+
+class Time2RpsGetter(XTimeMixin, YRpsMixin):
+    pass
+
+
+class Time2RepAmountGetter(XTimeMixin, YRepAmountMixin):
+    pass

graphs/data/fitRemoteReps/graph.py

@@ -0,0 +1,65 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from graphs.data.base import FitGraph, XDef, YDef, Input, InputCheckbox
+from service.const import GraphCacheCleanupReason
+from .cache import TimeCache
+from .getter import Distance2RpsGetter, Distance2RepAmountGetter, Time2RpsGetter, Time2RepAmountGetter
+
+
+class FitRemoteRepsGraph(FitGraph):
+
+    def __init__(self):
+        super().__init__()
+        self._timeCache = TimeCache()
+
+    def _clearInternalCache(self, reason, extraData):
+        # Here, we care only about fit changes, graph changes and option switches
+        # - Input changes are irrelevant as time cache cares only about
+        # time input, and it regenerates once time goes beyond cached value
+        if reason in (GraphCacheCleanupReason.fitChanged, GraphCacheCleanupReason.fitRemoved):
+            self._timeCache.clearForFit(extraData)
+        elif reason == GraphCacheCleanupReason.graphSwitched:
+            self._timeCache.clearAll()
+
+    # UI stuff
+    internalName = 'remoteRepsGraph'
+    name = 'Remote Repairs'
+    xDefs = [
+        XDef(handle='distance', unit='km', label='Distance', mainInput=('distance', 'km')),
+        XDef(handle='time', unit='s', label='Time', mainInput=('time', 's'))]
+    yDefs = [
+        YDef(handle='rps', unit='HP/s', label='Repair speed'),
+        YDef(handle='total', unit='HP', label='Total repaired')]
+    inputs = [
+        Input(handle='time', unit='s', label='Time', iconID=1392, defaultValue=None, defaultRange=(0, 80), secondaryTooltip='When set, uses repairing ship\'s exact RR stats at a given time\nWhen not set, uses repairing ship\'s RR stats as shown in stats panel of main window'),
+        Input(handle='distance', unit='km', label='Distance', iconID=1391, defaultValue=None, defaultRange=(0, 100), mainTooltip='Distance between the repairing ship and the target, as seen in overview (surface-to-surface)', secondaryTooltip='Distance between the repairing ship and the target, as seen in overview (surface-to-surface)')]
+    srcExtraCols = ('ShieldRR', 'ArmorRR', 'HullRR')
+    checkboxes = [InputCheckbox(handle='ancReload', label='Reload ancillary RRs', defaultValue=True)]
+
+    # Calculation stuff
+    _normalizers = {('distance', 'km'): lambda v, src, tgt: None if v is None else v * 1000}
+    _limiters = {'time': lambda src, tgt: (0, 2500)}
+    _getters = {
+        ('distance', 'rps'): Distance2RpsGetter,
+        ('distance', 'total'): Distance2RepAmountGetter,
+        ('time', 'rps'): Time2RpsGetter,
+        ('time', 'total'): Time2RepAmountGetter}
+    _denormalizers = {('distance', 'km'): lambda v, src, tgt: None if v is None else v / 1000}

graphs/data/fitShieldRegen/__init__.py

@@ -0,0 +1,24 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+from .graph import FitShieldRegenGraph
+
+
+FitShieldRegenGraph.register()

graphs/data/fitShieldRegen/getter.py

@@ -0,0 +1,97 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+import math
+
+from graphs.data.base import SmoothPointGetter
+
+
+class Time2ShieldAmountGetter(SmoothPointGetter):
+
+    def _getCommonData(self, miscParams, src, tgt):
+        return {
+            'maxShieldAmount': src.item.ship.getModifiedItemAttr('shieldCapacity'),
+            'shieldRegenTime': src.item.ship.getModifiedItemAttr('shieldRechargeRate') / 1000}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        time = x
+        shieldAmount = calculateShieldAmount(
+            maxShieldAmount=commonData['maxShieldAmount'],
+            shieldRegenTime=commonData['shieldRegenTime'],
+            shieldAmountT0=miscParams['shieldAmountT0'] or 0,
+            time=time)
+        return shieldAmount
+
+
+class Time2ShieldRegenGetter(SmoothPointGetter):
+
+    def _getCommonData(self, miscParams, src, tgt):
+        return {
+            'maxShieldAmount': src.item.ship.getModifiedItemAttr('shieldCapacity'),
+            'shieldRegenTime': src.item.ship.getModifiedItemAttr('shieldRechargeRate') / 1000}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        time = x
+        shieldAmount = calculateShieldAmount(
+            maxShieldAmount=commonData['maxShieldAmount'],
+            shieldRegenTime=commonData['shieldRegenTime'],
+            shieldAmountT0=miscParams['shieldAmountT0'] or 0,
+            time=time)
+        shieldRegen = calculateShieldRegen(
+            maxShieldAmount=commonData['maxShieldAmount'],
+            shieldRegenTime=commonData['shieldRegenTime'],
+            currentShieldAmount=shieldAmount)
+        return shieldRegen
+
+
+# Useless, but valid combination of x and y
+class ShieldAmount2ShieldAmountGetter(SmoothPointGetter):
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        shieldAmount = x
+        return shieldAmount
+
+
+class ShieldAmount2ShieldRegenGetter(SmoothPointGetter):
+
+    def _getCommonData(self, miscParams, src, tgt):
+        return {
+            'maxShieldAmount': src.item.ship.getModifiedItemAttr('shieldCapacity'),
+            'shieldRegenTime': src.item.ship.getModifiedItemAttr('shieldRechargeRate') / 1000}
+
+    def _calculatePoint(self, x, miscParams, src, tgt, commonData):
+        shieldAmount = x
+        shieldRegen = calculateShieldRegen(
+            maxShieldAmount=commonData['maxShieldAmount'],
+            shieldRegenTime=commonData['shieldRegenTime'],
+            currentShieldAmount=shieldAmount)
+        return shieldRegen
+
+
+def calculateShieldAmount(maxShieldAmount, shieldRegenTime, shieldAmountT0, time):
+    # The same formula as for cap
+    # https://wiki.eveuniversity.org/Capacitor#Capacitor_recharge_rate
+    return maxShieldAmount * (1 + math.exp(5 * -time / shieldRegenTime) * (math.sqrt(shieldAmountT0 / maxShieldAmount) - 1)) ** 2
+
+
+def calculateShieldRegen(maxShieldAmount, shieldRegenTime, currentShieldAmount):
+    # The same formula as for cap
+    # https://wiki.eveuniversity.org/Capacitor#Capacitor_recharge_rate
+    return 10 * maxShieldAmount / shieldRegenTime * (math.sqrt(currentShieldAmount / maxShieldAmount) - currentShieldAmount / maxShieldAmount)

graphs/data/fitShieldRegen/graph.py

@@ -0,0 +1,79 @@
+# =============================================================================
+# Copyright (C) 2010 Diego Duclos
+#
+# This file is part of pyfa.
+#
+# pyfa is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pyfa is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
+# =============================================================================
+
+
+import gui.mainFrame
+from graphs.data.base import FitGraph, XDef, YDef, Input
+from .getter import (
+    Time2ShieldAmountGetter, Time2ShieldRegenGetter,
+    ShieldAmount2ShieldAmountGetter, ShieldAmount2ShieldRegenGetter)
+
+
+class FitShieldRegenGraph(FitGraph):
+
+    # UI stuff
+    internalName = 'shieldRegenGraph'
+    name = 'Shield Regeneration'
+    inputs = [
+        Input(handle='time', unit='s', label='Time', iconID=1392, defaultValue=120, defaultRange=(0, 300), conditions=[
+            (('time', 's'), None)]),
+        Input(handle='shieldAmount', unit='%', label='Shield amount', iconID=1384, defaultValue=25, defaultRange=(0, 100), conditions=[
+            (('shieldAmount', 'EHP'), None),
+            (('shieldAmount', 'HP'), None),
+            (('shieldAmount', '%'), None)]),
+        Input(handle='shieldAmountT0', unit='%', label='Starting shield amount', iconID=1384, defaultValue=0, defaultRange=(0, 100), conditions=[
+            (('time', 's'), None)])]
+    srcExtraCols = ('ShieldAmount', 'ShieldTime')
+    usesHpEffectivity = True
+
+    @property
+    def xDefs(self):
+        return [
+            XDef(handle='time', unit='s', label='Time', mainInput=('time', 's')),
+            XDef(handle='shieldAmount', unit='EHP' if self.isEffective else 'HP', label='Shield amount', mainInput=('shieldAmount', '%')),
+            XDef(handle='shieldAmount', unit='%', label='Shield amount', mainInput=('shieldAmount', '%'))]
+
+    @property
+    def yDefs(self):
+        return [
+            YDef(handle='shieldAmount', unit='EHP' if self.isEffective else 'HP', label='Shield amount'),
+            YDef(handle='shieldRegen', unit='EHP/s' if self.isEffective else 'HP/s', label='Shield regen')]
+
+    # Calculation stuff
+    _normalizers = {
+        ('shieldAmount', '%'): lambda v, src, tgt: v / 100 * src.item.ship.getModifiedItemAttr('shieldCapacity'),
+        ('shieldAmountT0', '%'): lambda v, src, tgt: None if v is None else v / 100 * src.item.ship.getModifiedItemAttr('shieldCapacity'),
+        # Needed only for "x mark" support, to convert EHP x into normalized value
+        ('shieldAmount', 'EHP'): lambda v, src, tgt: v / src.item.damagePattern.effectivify(src.item, 1, 'shield')}
+    _limiters = {
+        'shieldAmount': lambda src, tgt: (0, src.item.ship.getModifiedItemAttr('shieldCapacity')),
+        'shieldAmountT0': lambda src, tgt: (0, src.item.ship.getModifiedItemAttr('shieldCapacity'))}
+    _getters = {
+        ('time', 'shieldAmount'): Time2ShieldAmountGetter,
+        ('time', 'shieldRegen'): Time2ShieldRegenGetter,
+        ('shieldAmount', 'shieldAmount'): ShieldAmount2ShieldAmountGetter,
+        ('shieldAmount', 'shieldRegen'): ShieldAmount2ShieldRegenGetter}
+    _denormalizers = {
+        ('shieldAmount', '%'): lambda v, src, tgt: v * 100 / src.item.ship.getModifiedItemAttr('shieldCapacity'),
+        ('shieldAmount', 'EHP'): lambda v, src, tgt: src.item.damagePattern.effectivify(src.item, v, 'shield'),
+        ('shieldRegen', 'EHP/s'): lambda v, src, tgt: src.item.damagePattern.effectivify(src.item, v, 'shield')}
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.isEffective = gui.mainFrame.MainFrame.getInstance().statsPane.nameViewMap['resistancesViewFull'].showEffective