Bump version

New Crowdin updates

.appveyor.yml

@@ -1,135 +1,129 @@
-environment:
-  global:
-    # SDK v7.0 MSVC Express 2008's SetEnv.cmd script will fail if the
-    # /E:ON and /V:ON options are not enabled in the batch script intepreter
-    # See: http://stackoverflow.com/a/13751649/163740
-    CMD_IN_ENV: "cmd /E:ON /V:ON /C .\\appveyor\\run_with_env.cmd"
+image:
+  - Visual Studio 2019
+  - macos
+clone_depth: 400
 
-  matrix:
+for:
+  -
+    matrix:
+      only:
+        - image: Visual Studio 2019
+    environment:
+      PYTHON: "C:\\Python37-x64"
+    # Should be enabled only for build process debugging
+    # init:
+    #   - ps: iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1'))
+    install:
+      - ps: echo("OS version:")
+      - ps: "[System.Environment]::OSVersion.Version"
 
-    - PYTHON: "C:\\Python36"
-      PYTHON_VERSION: "3.6.x"
-      PYTHON_ARCH: "32"
-init:
-  - ps: iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1'))
-install:
-  # If there is a newer build queued for the same PR, cancel this one.
-  # The AppVeyor 'rollout builds' option is supposed to serve the same
-  # purpose but it is problematic because it tends to cancel builds pushed
-  # directly to master instead of just PR builds (or the converse).
-  # credits: JuliaLang developers.
-  - ps: if ($env:APPVEYOR_PULL_REQUEST_NUMBER -and $env:APPVEYOR_BUILD_NUMBER -ne ((Invoke-RestMethod `
-        https://ci.appveyor.com/api/projects/$env:APPVEYOR_ACCOUNT_NAME/$env:APPVEYOR_PROJECT_SLUG/history?recordsNumber=50).builds | `
-        Where-Object pullRequestId -eq $env:APPVEYOR_PULL_REQUEST_NUMBER)[0].buildNumber) { `
-          throw "There are newer queued builds for this pull request, failing early." }
+      - ps: echo("Filesystem - root:")
+      - ps: "ls \"C:\\\""
 
-  - ECHO "Filesystem root:"
-  - ps: "ls \"C:/\""
+      - ps: echo("Filesystem - projects root:")
+      - ps: "ls \"C:\\projects\\\""
 
-  - ECHO "Filesystem projects root:"
-  - ps: "ls \"C:\\projects\\\""
+      - ps: echo("Filesystem - pyfa root:")
+      - ps: "ls \"C:\\projects\\$env:APPVEYOR_PROJECT_SLUG\\\""
 
-  - ECHO "Filesystem pyfa root:"
-  - ps: "ls \"C:\\projects\\$env:APPVEYOR_PROJECT_SLUG\""
+      - ps: echo("Filesystem - installed SDKs:")
+      - ps: "ls \"C:\\Program Files (x86)\\Windows Kits\\\""
 
-  - ECHO "Installed SDKs:"
-  - ps: "ls \"C:/Program Files/Microsoft SDKs/Windows\""
+      # Prepend newly installed Python to the PATH of this build (this cannot be
+      # done from inside the powershell script as it would require to restart
+      # the parent CMD process).
+      - cmd: "SET PATH=%PYTHON%;%PYTHON%\\Scripts;%PATH%"
+      - cmd: "appveyor DownloadFile https://github.com/mlocati/gettext-iconv-windows/releases/download/v0.20.2-v1.16/gettext0.20.2-iconv1.16-shared-64.zip"
+      - cmd: "7z x gettext0.20.2-iconv1.16-shared-64.zip -ogettext"
+      - cmd: "SET PATH=gettext;%PATH%"
 
-  # Prepend newly installed Python to the PATH of this build (this cannot be
-  # done from inside the powershell script as it would require to restart
-  # the parent CMD process).
-  - "SET PATH=%PYTHON%;%PYTHON%\\Scripts;%PATH%"
+      - cmd: "python --version"
+      - cmd: "python -c \"import struct; print(struct.calcsize('P') * 8)\""
 
-  - "python --version"
-  - "python -c \"import struct; print(struct.calcsize('P') * 8)\""
+      # Upgrade to the latest version of pip to avoid it displaying warnings
+      # about it being out of date.
+      - cmd: "python -m pip install --upgrade pip"
 
-  # Upgrade to the latest version of pip to avoid it displaying warnings
-  # about it being out of date.
-  - "pip install --disable-pip-version-check --user --upgrade pip"
-
-  # Install the build dependencies of the project. If some dependencies contain
-  # compiled extensions and are not provided as pre-built wheel packages,
-  # 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"
-
-before_build:
-    # directory that will contain the built files
-  - ps: $env:PYFA_DIST_DIR = "c:\projects\$env:APPVEYOR_PROJECT_SLUG\dist"
-  - ps: $env:PYFA_VERSION = (python ./scripts/dump_version.py)
-  - ps: echo("pyfa version ")
-  - ps: echo ($env:PYFA_VERSION)
-
-build_script:
-  - ECHO "Build pyfa:"
-
-  ##########
-  # PyInstaller - create binaries for pyfa
-  ##########
-  # Build command for PyInstaller
-  - "python -m PyInstaller --noupx --clean --windowed --noconsole -y pyfa.spec"
-  # Copy over manifest (See pyfa-org/pyfa#1622)
-  - ps: xcopy /y dist_assets\win\pyfa.exe.manifest $env:PYFA_DIST_DIR\pyfa\
-  # Not really sure if this is needed, but why not
-  - ps: xcopy /y dist_assets\win\Microsoft.VC90.CRT.manifest $env:PYFA_DIST_DIR\pyfa\
-
-  ##########
-  # InnoScript EXE building
-  # This is in a separate script because I don't feel like copying over the logic to AppVeyor script right now...
-  ##########
-  - "python dist_assets/win/dist.py"
-  - ps: dir $env:PYFA_DIST_DIR/
-  #- ECHO "Build pyfa (Debug):"
-  #- copy C:\projects\pyfa\dist_assets\win\pyfa_debug.spec C:\projects\pyfa\pyfa_debug.spec
-  #- "pyinstaller.exe --clean --noconfirm --windowed --upx-dir=C:\\projects\\pyfa\\scripts\\upx.exe C:\\projects\\pyfa\\pyfa_debug.spec"
-
-build: on
-
-after_build:
-  - ps: "ls \"./\""
-  #- ps: "ls \"C:\\projects\\pyfa\\build\\pyfa\\\""
-#  - ps: "ls \"C:\\projects\\$env:APPVEYOR_PROJECT_SLUG\\build\\exe.win32-2.7\\\""
-  # Zip
-  # APPVEYOR_PULL_REQUEST_NUMBER -and $env:APPVEYOR_BUILD_NUMBER
-  #- 7z a build.zip -r C:\projects\pyfa\build\pyfa\*.*
-  - ps: 7z a "pyfa-$env:PYFA_VERSION-win.zip" -r "$env:PYFA_DIST_DIR\pyfa\*.*"
-  #- 7z a pyfa_debug.zip -r C:\projects\pyfa\dist\pyfa_debug\*.*
-
-on_success:
-  # Do nothing right now
-
-test_script:
-  #- tox
-  #- "py.test --cov=./"
-  # Run the project tests
-  # - "%CMD_IN_ENV% python C:/projects/eve-gnosis/setup.py nosetests"
-
-after_test:
-  # If tests are successful, create binary packages for the project.
-  # - "%CMD_IN_ENV% python setup.py bdist_wheel"
-  # - "%CMD_IN_ENV% python setup.py bdist_wininst"
-  # - "%CMD_IN_ENV% python setup.py bdist_msi"
-  # - ps: "ls dist"
-
-artifacts:
-  # Archive the generated packages in the ci.appveyor.com build report.
-  - path: pyfa*-win.zip
-  - path: pyfa*-win.exe
-  #- path: pyfa_debug.zip
-  #  name: Pyfa_debug
-
-deploy:
-  tag: $(pyfa_version)
-  release: pyfa $(pyfa_version)
-  description: 'Release description'
-  provider: GitHub
-  auth_token:
-    secure: BfNHO66ff5hVx2O2ORbl49X0U/5h2V2T0IuRZDwm7fd1HvsVluF0wRCbl29oRp1M
-  draft: true
-  on:
-    APPVEYOR_REPO_TAG: true        # deploy on tag push only
-#on_success:
-#  - TODO: upload the content of dist/*.whl to a public wheelhouse
-#
+      # Install the build dependencies of the project. If some dependencies contain
+      # compiled extensions and are not provided as pre-built wheel packages,
+      # pip will build them from source using the MSVC compiler matching the
+      # target Python version and architecture
+      - ps: echo("Install pip requirements:")
+      # This one is needed to build wxpython 4.0.6 on windows
+      - cmd: "python -m pip install pathlib2"
+      - cmd: "python -m pip install -r requirements.txt"
+      - cmd: "python -m pip install PyInstaller==3.6"
+    before_build:
+        # directory that will contain the built files
+      - ps: $env:PYFA_DIST_DIR = "c:\projects\$env:APPVEYOR_PROJECT_SLUG\dist"
+      - ps: $env:PYFA_VERSION = (python ./scripts/dump_version.py)
+      - ps: echo("pyfa version $env:PYFA_VERSION")
+    build_script:
+      - ps: echo("Build pyfa:")
+      - ps: Get-ChildItem locale/*.po -Recurse -File| Foreach {msgen $_.fullname -o $_.fullname}
+        # Build language files
+      - cmd: "python scripts/compile_lang.py"
+        # Dump language progress
+      - cmd: "python scripts/dump_crowdin_progress.py"
+        # Build gamedata DB
+      - cmd: "python db_update.py"
+      # Build command for PyInstaller
+      - cmd: "python -m PyInstaller --noupx --clean --windowed --noconsole -y pyfa.spec"
+      # Copy over manifest (See pyfa-org/pyfa#1622)
+      - ps: xcopy /y dist_assets\win\pyfa.exe.manifest $env:PYFA_DIST_DIR\pyfa\
+      # InnoScript EXE building. This is in a separate script because I don't feel like copying over the logic to AppVeyor script right now...
+      - cmd: "python dist_assets/win/dist.py"
+      - ps: dir $env:PYFA_DIST_DIR/
+    after_build:
+      - ps: "ls \"./\""
+      - ps: 7z a "pyfa-$env:PYFA_VERSION-win.zip" -r "$env:PYFA_DIST_DIR\pyfa\*"
+    artifacts:
+      - path: pyfa*-win.zip
+      - path: pyfa*-win.exe
+    deploy:
+      tag: $(pyfa_version)
+      release: pyfa $(pyfa_version)
+      description: 'Release description'
+      provider: GitHub
+      auth_token:
+        secure: M94o0xMtzxrvlKpqMcXU2KfbJdd3aYJ3UxWzePUz/pkT1/Ojiis052CiLsLVyzJg
+      draft: true
+      force_update: false
+      # deploy on tag push only
+      on:
+        APPVEYOR_REPO_TAG: true
+  -
+    matrix:
+      only:
+        - image: macos
+    # Should be enabled only for build process debugging
+    init:
+    #   - sh: curl -sflL 'https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-ssh.sh' | bash -e -
+      - sh: source ~/venv3.7/bin/activate
+    install:
+      - sh: bash scripts/osx-setup.sh
+    build_script:
+      - sh: bash scripts/osx-translations.sh
+      - sh: python3 scripts/compile_lang.py
+      - sh: python3 scripts/dump_crowdin_progress.py
+      - sh: python3 db_update.py
+    after_build:
+      - sh: export PYFA_VERSION="$(python3 scripts/dump_version.py)"
+      - sh: bash scripts/osx-package.sh
+    artifacts:
+      - path: dist/pyfa*-mac.zip
+    before_deploy:
+      - sh: export RELEASE_PKG_FILE=$(ls *.deb)
+      - sh: echo "deploying $RELEASE_PKG_FILE to GitHub releases"
+    deploy:
+      tag: $PYFA_VERSION
+      release: pyfa $PYFA_VERSION
+      description: 'Release description'
+      provider: GitHub
+      auth_token:
+        secure: M94o0xMtzxrvlKpqMcXU2KfbJdd3aYJ3UxWzePUz/pkT1/Ojiis052CiLsLVyzJg
+      draft: true
+      force_update: false
+      # deploy on tag push only
+      on:
+        APPVEYOR_REPO_TAG: true

.gitattributes

@@ -1,11 +1,9 @@
 # Set the default behavior, in case people don't have core.autocrlf set.
 * text=auto
-
 # Explicitly declare text files you want to always be normalized and converted
 # to native line endings on checkout.
 # *.c text
 # *.h text
-
 # Declare files that will always have CRLF line endings on checkout.
 # Source files
 # ============
@@ -15,7 +13,6 @@
 *.pyw 		text eol=crlf
 *.pyx  		text eol=crlf
 pyfa.py     text eol=lf
-
 # Denote all files that are truly binary and should not be modified.
 # Binary files
 # ============
@@ -25,12 +22,10 @@ pyfa.py     text eol=lf
 *.pyc 		binary
 *.pyd		binary
 *.pyo 		binary
-
 # Note: .db, .p, and .pkl files are associated
 # with the python modules ``pickle``, ``dbm.*``,
 # ``shelve``, ``marshal``, ``anydbm``, & ``bsddb``
 # (among others).
-
 # Denote all files that are truly binary and should not be modified.
 # Image files
 # ============
@@ -38,3 +33,4 @@ pyfa.py     text eol=lf
 *.jpg binary
 *.icns binary
 *.ico binary
+

.gitignore

@@ -67,7 +67,6 @@ coverage.xml
 
 # Translations
 *.mo
-*.pot
 
 # Django stuff:
 *.log
@@ -123,3 +122,4 @@ gitversion
 *.swp
 
 *.fsdbinary
+/locale/progress.json

.travis.yml

@@ -1,29 +0,0 @@
-os: linux
-language: python
-python:
-  - 3.6
-matrix:
-  include:
-  - os: osx
-    osx_image: xcode7.3
-    language: generic
-    env: PYTHON=3.6.1
-before_install:
-  - bash scripts/setup-osx.sh
-install:
-  - export PYFA_VERSION="$(python3 scripts/dump_version.py)"
-  - bash scripts/package-osx.sh
-before_deploy:
-  - export RELEASE_PKG_FILE=$(ls *.deb)
-  - echo "deploying $RELEASE_PKG_FILE to GitHub releases"
-deploy:
-  provider: releases
-  api_key:
-    secure: Xfu0xApoB0zUPLXl29aYUulVC3iA4/3bXQwwADKCfAKZwxgNon4dLbO7Rie5/7Ukf2POL0KwmRaQGN3kOr+XSoIVTE4M5sXxnhiaaLGKQ+48hDizLE6JuXcZGJvkxUaghaTzIdCwHsG7VGBsPfQgfGsjJcfBp8tFNLmRyM/Jpsr8T6BR2MxtBIEUVy8zrOWFNZqnmWrY2pWMsB9fYt3JFNdpqeIgRAYqbBsBcZQ1MngLTi3ztuYS5IaF+lk06RrnBlHmUsJu/5nCvIpvPvD0i2BLZ3Uu0+Fn+8QWUgjJEL9MNseXZMXynu05xd8YRk7Ajc9CUrzQIIbAktyteYp85kE3pUJHmrMLcXhh7nqkwttR5/47Zwa3OLJLJFKBxMx6wY5jFkJjkV08850B7aWrmTFl/Eqc3Q5nZMuiEt3wFRbjxHi9h1mTN/fkxfRRHg8u3ENGPR+ZPiFC3J18qtks/B/hsKjjHvZP1i79OYlET4V/zyLyyQkCbpDaARQANuotLYJyZ7tH+KWEyRsvTi0M9Yev9mNNw6aI4vzh4HfkEhvcvnWnYwckPj1dnjQ573Qpw0Z9wsconoWfHAn+hBDt3+YLMrrFZl++mCRskHH1mZChX3aGMDi49zD0kfxBUkYPOAhguc6PwudBxHUZP+O6T/SoHylff6EizCE/k5dGeAk=
-  file_glob: true
-  file: "dist/pyfa-*.zip"
-  skip_cleanup: true
-  draft: true
-  on:
-    tags: true
-    repo: pyfa-org/Pyfa

CONTRIBUTING.md

@@ -0,0 +1,107 @@
+# Contribution
+
+## Requirements
+
+- Python 3.7
+- 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
+```
+
+Build translations and database:
+```
+python scripts\compile_lang.py
+python db_update.py
+```
+
+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,34 +23,33 @@ $ 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/derivitives: 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:
+* 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
+    * [Gitter chat](https://gitter.im/pyfa-org/Pyfa): @blitzmann
     * Email: sable.blitzmann@gmail.com
 
 ## CCP Copyright Notice

_development/Pyfa_CodeStyle.xml

@@ -3,7 +3,6 @@
   <option name="RIGHT_MARGIN" value="165" />
   <Python>
     <option name="NEW_LINE_AFTER_COLON" value="true" />
-    <option name="DICT_ALIGNMENT" value="2" />
     <option name="DICT_NEW_LINE_AFTER_LEFT_BRACE" value="true" />
     <option name="DICT_NEW_LINE_BEFORE_RIGHT_BRACE" value="true" />
     <option name="USE_CONTINUATION_INDENT_FOR_ARGUMENTS" value="true" />

_development/Pyfa_Inspections.xml

@@ -1,54 +1,61 @@
-<profile version="1.0">
-  <option name="myName" value="Pyfa" />
-  <inspection_tool class="IgnoreUnusedEntry" enabled="false" level="UNUSED ENTRY" enabled_by_default="false" />
-  <inspection_tool class="InconsistentLineSeparators" enabled="true" level="ERROR" enabled_by_default="true" />
-  <inspection_tool class="ProblematicWhitespace" enabled="true" level="WARNING" enabled_by_default="true" />
-  <inspection_tool class="PyBehaveInspection" enabled="true" level="WARNING" enabled_by_default="true" />
-  <inspection_tool class="PyClassicStyleClassInspection" enabled="true" level="WARNING" enabled_by_default="true" />
-  <inspection_tool class="PyCompatibilityInspection" enabled="true" level="WARNING" enabled_by_default="true">
-    <option name="ourVersions">
-      <value>
-        <list size="1">
-          <item index="0" class="java.lang.String" itemvalue="2.7" />
+  <profile version="1.0">
+    <option name="myName" value="Pyfa" />
+    <inspection_tool class="IgnoreUnusedEntry" enabled="false" level="UNUSED ENTRY" enabled_by_default="false" />
+    <inspection_tool class="InconsistentLineSeparators" enabled="true" level="ERROR" enabled_by_default="true" />
+    <inspection_tool class="ProblematicWhitespace" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="PyBehaveInspection" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="PyClassicStyleClassInspection" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="PyCompatibilityInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ourVersions">
+        <value>
+          <list size="1">
+            <item index="0" class="java.lang.String" itemvalue="2.7" />
+          </list>
+        </value>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyMissingTypeHintsInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
+    <inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredPackages">
+        <value>
+          <list size="1">
+            <item index="0" class="java.lang.String" itemvalue="wxPython" />
+          </list>
+        </value>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyPep8Inspection" enabled="true" level="TYPO" enabled_by_default="true">
+      <option name="ignoredErrors">
+        <list>
+          <option value="E203" />
+          <option value="E127" />
+          <option value="E128" />
+          <option value="E126" />
         </list>
-      </value>
-    </option>
-  </inspection_tool>
-  <inspection_tool class="PyMissingTypeHintsInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
-  <inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
-    <option name="ignoredPackages">
-      <value>
-        <list size="1">
-          <item index="0" class="java.lang.String" itemvalue="wxPython" />
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyPep8NamingInspection" enabled="true" level="TYPO" enabled_by_default="true">
+      <option name="ignoredErrors">
+        <list>
+          <option value="N802" />
+          <option value="N806" />
+          <option value="N803" />
+          <option value="N814" />
         </list>
-      </value>
-    </option>
-  </inspection_tool>
-  <inspection_tool class="PyPep8Inspection" enabled="true" level="TYPO" enabled_by_default="true">
-    <option name="ignoredErrors">
-      <list>
-        <option value="E203" />
-        <option value="E127" />
-        <option value="E128" />
-        <option value="E126" />
-      </list>
-    </option>
-  </inspection_tool>
-  <inspection_tool class="PyPep8NamingInspection" enabled="true" level="TYPO" enabled_by_default="true">
-    <option name="ignoredErrors">
-      <list>
-        <option value="N802" />
-        <option value="N806" />
-        <option value="N803" />
-        <option value="N814" />
-      </list>
-    </option>
-  </inspection_tool>
-  <inspection_tool class="PyShadowingBuiltinsInspection" enabled="true" level="WARNING" enabled_by_default="true" />
-  <inspection_tool class="PyShadowingNamesInspection" enabled="true" level="WARNING" enabled_by_default="true" />
-  <inspection_tool class="SpellCheckingInspection" enabled="false" level="TYPO" enabled_by_default="false">
-    <option name="processCode" value="true" />
-    <option name="processLiterals" value="true" />
-    <option name="processComments" value="true" />
-  </inspection_tool>
-</profile>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyShadowingBuiltinsInspection" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="PyShadowingNamesInspection" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredIdentifiers">
+        <list>
+          <option value="_" />
+        </list>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="SpellCheckingInspection" enabled="false" level="TYPO" enabled_by_default="false">
+      <option name="processCode" value="true" />
+      <option name="processLiterals" value="true" />
+      <option name="processComments" value="true" />
+    </inspection_tool>
+  </profile>

_development/helpers.py

@@ -49,6 +49,8 @@ def DBInMemory_test():
         gamedata_version = gamedata_session.execute(
             "SELECT `field_value` FROM `metadata` WHERE `field_name` LIKE 'client_build'"
         ).fetchone()[0]
+    except (KeyboardInterrupt, SystemExit):
+        raise
     except Exception as e:
         print("Missing gamedata version.")
         gamedata_version = None
@@ -72,7 +74,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, 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,15 @@ 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
+language = None
 
 ESI_CACHE = 'esi_cache'
 
@@ -49,6 +53,8 @@ LOGLEVEL_MAP = {
     "debug": DEBUG,
 }
 
+CATALOG = 'lang'
+
 slotColourMap = {
     FittingSlot.LOW: wx.Colour(250, 235, 204),  # yellow = low slots
     FittingSlot.MED: wx.Colour(188, 215, 241),  # blue   = mid slots
@@ -96,11 +102,14 @@ def defPaths(customSavePath=None):
     global savePath
     global saveDB
     global gameDB
+    global imgsZIP
     global saveInRoot
     global logPath
     global cipher
     global clientHash
     global version
+    global experimentalFeatures
+    global language
 
     pyfalog.debug("Configuring Pyfa")
 
@@ -113,7 +122,7 @@ def defPaths(customSavePath=None):
     # Version data
 
     with open(os.path.join(pyfaPath, "version.yml"), 'r') as file:
-        data = yaml.load(file, Loader=yaml.FullLoader)
+        data = yaml.load(file, Loader=yaml.SafeLoader)
         version = data['version']
 
     # Where we store the saved fits etc, default is the current users home directory
@@ -155,6 +164,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 +175,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
 
@@ -172,9 +189,15 @@ def defPaths(customSavePath=None):
     eos.config.gamedata_connectionstring = "sqlite:///" + gameDB + "?check_same_thread=False"
 
     # initialize the settings
-    from service.settings import EOSSettings
+    from service.settings import EOSSettings, LocaleSettings
     eos.config.settings = EOSSettings.getInstance().EOSSettings  # this is kind of confusing, but whatever
 
+    # set langauge, taking the passed argument or falling back to what's saved in the settings
+    localeSettings = LocaleSettings.getInstance()
+    language = language or localeSettings.get('locale')
+
+    # sets the lang for eos, using the mapped langauge.
+    eos.config.set_lang(localeSettings.get_eos_locale())
 
 def defLogging():
     global debug
@@ -220,6 +243,8 @@ def defLogging():
                         # reset=False,
                 )
             ])
+    except (KeyboardInterrupt, SystemExit):
+        raise
     except:
         print("Critical error attempting to setup logging. Falling back to console only.")
         logging_setup = NestedSetup([
@@ -233,7 +258,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

crowdin.yml

@@ -0,0 +1,3 @@
+files:
+  - source: /locale/*.pot
+    translation: /locale/%locale_with_underscore%/LC_MESSAGES/lang.po

db_update.py

@@ -0,0 +1,611 @@
+#!/usr/bin/env python3
+#======================================================================
+# Copyright (C) 2012 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 3 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 functools
+import itertools
+import json
+import os
+import re
+import sqlite3
+import sys
+
+
+# todo: need to set the EOS language to en, becasuse this assumes it's being run within an English context
+# Need to know what that would do if called from pyfa
+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 = 4
+
+
+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.0.json')) as f:
+            data_version = next((r['field_value'] for r in json.load(f) if r['field_name'] == 'client_build'))
+    except (KeyboardInterrupt, SystemExit):
+        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, SystemExit):
+        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 update_db():
+
+    print('Building gamedata DB...')
+
+    if os.path.isfile(DB_PATH):
+        os.remove(DB_PATH)
+
+    import eos.db
+    import eos.gamedata
+    import eos.config
+
+    # Create the database tables
+    eos.db.gamedata_meta.create_all()
+
+    def _readData(minerName, jsonName, keyIdName=None):
+        compiled_data = None
+        for i in itertools.count(0):
+            try:
+                with open(os.path.join(JSON_DIR, minerName, '{}.{}.json'.format(jsonName, i)), encoding='utf-8') as f:
+                    rawData = json.load(f)
+                    if i == 0:
+                        compiled_data = {} if type(rawData) == dict else []
+                    if type(rawData) == dict:
+                        compiled_data.update(rawData)
+                    else:
+                        compiled_data.extend(rawData)
+            except FileNotFoundError:
+                break
+
+        if not keyIdName:
+            return compiled_data
+        # IDs in keys, rows in values
+        data = []
+        for k, v in compiled_data.items():
+            row = {}
+            row.update(v)
+            if keyIdName not in row:
+                row[keyIdName] = int(k)
+            data.append(row)
+        return data
+
+    def _addRows(data, cls, fieldMap=None):
+        if fieldMap is None:
+            fieldMap = {}
+        for row in data:
+            instance = cls()
+            for k, v in row.items():
+                if isinstance(v, str):
+                    v = v.strip()
+                setattr(instance, fieldMap.get(k, k), v)
+            eos.db.gamedata_session.add(instance)
+
+    def processEveTypes():
+        print('processing evetypes')
+        data = _readData('fsd_lite', 'evetypes', keyIdName='typeID')
+        for row in data:
+            if (
+                # Apparently people really want Civilian modules available
+                (row['typeName_en-us'].startswith('Civilian') and "Shuttle" not in row['typeName_en-us']) or
+                row['typeName_en-us'] == 'Capsule' or
+                row['groupID'] == 4033  # destructible effect beacons
+            ):
+                row['published'] = True
+            # Nearly useless and clutter search results too much
+            elif (
+                row['typeName_en-us'].startswith('Limited Synth ') or
+                row['typeName_en-us'].endswith(' Filament') and (
+                    "'Needlejack'" not in row['typeName_en-us'] and
+                    "'Devana'" not in row['typeName_en-us'] and
+                    "'Pochven'" not in row['typeName_en-us'] and
+                    "'Extraction'" not in row['typeName_en-us'] and
+                    "'Krai Veles'" not in row['typeName_en-us'] and
+                    "'Krai Perun'" not in row['typeName_en-us'] and
+                    "'Krai Svarog'" not in row['typeName_en-us']
+                )
+            ):
+                row['published'] = False
+
+        newData = []
+        for row in data:
+            if (
+                row['published'] or
+                # group Ship Modifiers, for items like tactical t3 ship modes
+                row['groupID'] == 1306 or
+                # Micro Bombs (Fighters)
+                row['typeID'] in (41549, 41548, 41551, 41550) or
+                # Abyssal weather (environment)
+                row['groupID'] in (
+                    1882,
+                    1975,
+                    1971,
+                    1983)  # the "container" for the abyssal environments
+            ):
+                newData.append(row)
+        map = {'typeName_en-us': 'typeName', 'description_en-us': '_description'}
+        map.update({'description'+v: '_description'+v for (k, v) in eos.config.translation_mapping.items() if k != 'en'})
+        _addRows(newData, eos.gamedata.Item, fieldMap=map)
+        return newData
+
+    def processEveGroups():
+        print('processing evegroups')
+        data = _readData('fsd_lite', 'evegroups', keyIdName='groupID')
+        map = {'groupName_en-us': 'name'}
+        map.update({'groupName'+v: 'name'+v for (k, v) in eos.config.translation_mapping.items() if k != 'en'})
+        _addRows(data, eos.gamedata.Group, fieldMap=map)
+        return data
+
+    def processEveCategories():
+        print('processing evecategories')
+        data = _readData('fsd_lite', 'evecategories', keyIdName='categoryID')
+        map = { 'categoryName_en-us': 'name' }
+        map.update({'categoryName'+v: 'name'+v for (k, v) in eos.config.translation_mapping.items() if k != 'en'})
+        _addRows(data, eos.gamedata.Category, fieldMap=map)
+
+    def processDogmaAttributes():
+        print('processing dogmaattributes')
+        data = _readData('fsd_binary', 'dogmaattributes', keyIdName='attributeID')
+        map = {
+            'displayName_en-us': 'displayName',
+            # 'tooltipDescription_en-us': 'tooltipDescription'
+        }
+        _addRows(data, eos.gamedata.AttributeInfo, fieldMap=map)
+
+    def processDogmaTypeAttributes(eveTypesData):
+        print('processing dogmatypeattributes')
+        data = _readData('fsd_binary', 'typedogma', keyIdName='typeID')
+        eveTypeIds = set(r['typeID'] for r in eveTypesData)
+        newData = []
+        seenKeys = set()
+
+        def checkKey(key):
+            if key in seenKeys:
+                return False
+            seenKeys.add(key)
+            return True
+
+        for typeData in data:
+            if typeData['typeID'] not in eveTypeIds:
+                continue
+            for row in typeData.get('dogmaAttributes', ()):
+                row['typeID'] = typeData['typeID']
+                if checkKey((row['typeID'], row['attributeID'])):
+                    newData.append(row)
+        for row in eveTypesData:
+            for attrId, attrName in {4: 'mass', 38: 'capacity', 161: 'volume', 162: 'radius'}.items():
+                if attrName in row and checkKey((row['typeID'], attrId)):
+                    newData.append({'typeID': row['typeID'], 'attributeID': attrId, 'value': row[attrName]})
+
+        _addRows(newData, eos.gamedata.Attribute)
+        return newData
+
+    def processDynamicItemAttributes():
+        print('processing dynamicitemattributes')
+        data = _readData('fsd_binary', 'dynamicitemattributes')
+        for mutaID, mutaData in data.items():
+            muta = eos.gamedata.DynamicItem()
+            muta.typeID = mutaID
+            muta.resultingTypeID = mutaData['inputOutputMapping'][0]['resultingType']
+            eos.db.gamedata_session.add(muta)
+
+            for x in mutaData['inputOutputMapping'][0]['applicableTypes']:
+                item = eos.gamedata.DynamicItemItem()
+                item.typeID = mutaID
+                item.applicableTypeID = x
+                eos.db.gamedata_session.add(item)
+
+            for attrID, attrData in mutaData['attributeIDs'].items():
+                attr = eos.gamedata.DynamicItemAttribute()
+                attr.typeID = mutaID
+                attr.attributeID = attrID
+                attr.min = attrData['min']
+                attr.max = attrData['max']
+                eos.db.gamedata_session.add(attr)
+
+    def processDogmaEffects():
+        print('processing dogmaeffects')
+        data = _readData('fsd_binary', 'dogmaeffects', keyIdName='effectID')
+        _addRows(data, eos.gamedata.Effect, fieldMap={'resistanceAttributeID': 'resistanceID'})
+
+    def processDogmaTypeEffects(eveTypesData):
+        print('processing dogmatypeeffects')
+        data = _readData('fsd_binary', 'typedogma', keyIdName='typeID')
+        eveTypeIds = set(r['typeID'] for r in eveTypesData)
+        newData = []
+        for typeData in data:
+            if typeData['typeID'] not in eveTypeIds:
+                continue
+            for row in typeData.get('dogmaEffects', ()):
+                row['typeID'] = typeData['typeID']
+                newData.append(row)
+        _addRows(newData, eos.gamedata.ItemEffect)
+        return newData
+
+    def processDogmaUnits():
+        print('processing dogmaunits')
+        data = _readData('fsd_binary', 'dogmaunits', keyIdName='unitID')
+        _addRows(data, eos.gamedata.Unit, fieldMap={
+            'name': 'unitName',
+            'displayName_en-us': 'displayName'
+        })
+
+    def processMarketGroups():
+        print('processing marketgroups')
+        data = _readData('fsd_binary', 'marketgroups', keyIdName='marketGroupID')
+        map = {
+            'name_en-us': 'marketGroupName',
+            'description_en-us': '_description',
+        }
+        map.update({'name'+v: 'marketGroupName'+v for (k, v) in eos.config.translation_mapping.items() if k != 'en'})
+        map.update({'description' + v: '_description' + v for (k, v) in eos.config.translation_mapping.items() if k != 'en'})
+        _addRows(data, eos.gamedata.MarketGroup, fieldMap=map)
+
+    def processMetaGroups():
+        print('processing metagroups')
+        data = _readData('fsd_binary', 'metagroups', keyIdName='metaGroupID')
+        map = {'name_en-us': 'metaGroupName'}
+        map.update({'name' + v: 'metaGroupName' + v for (k, v) in eos.config.translation_mapping.items() if k != 'en'})
+        _addRows(data, eos.gamedata.MetaGroup, fieldMap=map)
+
+    def processCloneGrades():
+        print('processing clonegrades')
+        data = _readData('fsd_lite', 'clonegrades')
+
+        newData = []
+        # December, 2017 - CCP decided to use only one set of skill levels for alpha clones. However, this is still
+        # represented in the data as a skillset per race. To ensure that all skills are the same, we store them in a way
+        # that we can check to make sure all races have the same skills, as well as skill levels
+        check = {}
+        for ID in data:
+            for skill in data[ID]['skills']:
+                newData.append({
+                    'alphaCloneID': int(ID),
+                    'alphaCloneName': 'Alpha Clone',
+                    'typeID': skill['typeID'],
+                    'level': skill['level']})
+                if ID not in check:
+                    check[ID] = {}
+                check[ID][int(skill['typeID'])] = int(skill['level'])
+        if not functools.reduce(lambda a, b: a if a == b else False, [v for _, v in check.items()]):
+            raise Exception('Alpha Clones not all equal')
+        newData = [x for x in newData if x['alphaCloneID'] == 1]
+        if len(newData) == 0:
+            raise Exception('Alpha Clone processing failed')
+
+        tmp = []
+        for row in newData:
+            if row['alphaCloneID'] not in tmp:
+                cloneParent = eos.gamedata.AlphaClone()
+                setattr(cloneParent, 'alphaCloneID', row['alphaCloneID'])
+                setattr(cloneParent, 'alphaCloneName', row['alphaCloneName'])
+                eos.db.gamedata_session.add(cloneParent)
+                tmp.append(row['alphaCloneID'])
+        _addRows(newData, eos.gamedata.AlphaCloneSkill)
+
+    def processTraits():
+        print('processing traits')
+        data = _readData('phobos', 'traits')
+
+        def convertSection(sectionData):
+            sectionLines = []
+            headerText = '<b>{}</b>'.format(sectionData['header'])
+            sectionLines.append(headerText)
+            for bonusData in sectionData['bonuses']:
+                prefix = '{} '.format(bonusData['number']) if 'number' in bonusData else ''
+                bonusText = '{}{}'.format(prefix, bonusData['text'].replace('\u00B7', '\u2022 '))
+                sectionLines.append(bonusText)
+            sectionLine = '<br />\n'.join(sectionLines)
+            return sectionLine
+
+        newData = []
+        for row in data:
+            try:
+                newRow = {
+                    'typeID': row['typeID'],
+                }
+                for (k, v) in eos.config.translation_mapping.items():
+                    if v == '':
+                        v = '_en-us'
+                    typeLines = []
+                    traitData = row['traits{}'.format(v)]
+                    for skillData in sorted(traitData.get('skills', ()), key=lambda i: i['header']):
+                        typeLines.append(convertSection(skillData))
+                    if 'role' in traitData:
+                        typeLines.append(convertSection(traitData['role']))
+                    if 'misc' in traitData:
+                        typeLines.append(convertSection(traitData['misc']))
+                    traitLine = '<br />\n<br />\n'.join(typeLines)
+                    newRow['traitText{}'.format(v)] = traitLine
+
+                newData.append(newRow)
+            except:
+                pass
+        _addRows(newData, eos.gamedata.Traits, fieldMap={'traitText_en-us': 'traitText'})
+
+    def processMetadata():
+        print('processing metadata')
+        data = _readData('phobos', 'metadata')
+        _addRows(data, eos.gamedata.MetaData)
+
+    def processReqSkills(eveTypesData):
+        print('processing requiredskillsfortypes')
+
+        def composeReqSkills(raw):
+            reqSkills = {}
+            for skillTypeID, skillLevel in raw.items():
+                reqSkills[int(skillTypeID)] = skillLevel
+            return reqSkills
+
+        eveTypeIds = set(r['typeID'] for r in eveTypesData)
+        data = _readData('fsd_binary', 'requiredskillsfortypes')
+        reqsByItem = {}
+        itemsByReq = {}
+        for typeID, skillreqData in data.items():
+            typeID = int(typeID)
+            if typeID not in eveTypeIds:
+                continue
+            for skillTypeID, skillLevel in composeReqSkills(skillreqData).items():
+                reqsByItem.setdefault(typeID, {})[skillTypeID] = skillLevel
+                itemsByReq.setdefault(skillTypeID, {})[typeID] = skillLevel
+        for item in eos.db.gamedata_session.query(eos.gamedata.Item).all():
+            if item.typeID in reqsByItem:
+                item.reqskills = json.dumps(reqsByItem[item.typeID])
+            if item.typeID in itemsByReq:
+                item.requiredfor = json.dumps(itemsByReq[item.typeID])
+
+    def processReplacements(eveTypesData, eveGroupsData, dogmaTypeAttributesData, dogmaTypeEffectsData):
+        print('finding item replacements')
+
+        def compareAttrs(attrs1, attrs2):
+            # Consider items as different if they have no attrs
+            if len(attrs1) == 0 and len(attrs2) == 0:
+                return False
+            if set(attrs1) != set(attrs2):
+                return False
+            if all(attrs1[aid] == attrs2[aid] for aid in attrs1):
+                return True
+            return False
+
+        skillReqAttribs = {
+            182: 277,
+            183: 278,
+            184: 279,
+            1285: 1286,
+            1289: 1287,
+            1290: 1288}
+        skillReqAttribsFlat = set(skillReqAttribs.keys()).union(skillReqAttribs.values())
+        # Get data on type groups
+        # Format: {type ID: group ID}
+        typesGroups = {}
+        for row in eveTypesData:
+            typesGroups[row['typeID']] = row['groupID']
+        # Get data on item effects
+        # Format: {type ID: set(effect, IDs)}
+        typesEffects = {}
+        for row in dogmaTypeEffectsData:
+            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 dogmaTypeAttributesData:
+            attributeID = row['attributeID']
+            if attributeID in skillReqAttribsFlat:
+                typeSkillAttribs = typesSkillAttribs.setdefault(row['typeID'], {})
+                typeSkillAttribs[row['attributeID']] = row['value']
+            # Ignore these attributes for comparison purposes
+            elif attributeID in (
+                # We do not need mass as it affects final ship stats only when carried by ship itself
+                # (and we're not going to replace ships), but it's wildly inconsistent for other items,
+                # which otherwise would be the same
+                4,  # mass
+                124,  # mainColor
+                162,  # radius
+                422,  # techLevel
+                633,  # metaLevel
+                1692,  # metaGroupID
+                1768  # typeColorScheme
+            ):
+                continue
+            else:
+                typeNormalAttribs = typesNormalAttribs.setdefault(row['typeID'], {})
+                typeNormalAttribs[row['attributeID']] = row['value']
+        # Get data on skill requirements
+        # Format: {type ID: {skill type ID: skill level}}
+        typesSkillReqs = {}
+        for typeID, typeAttribs in typesSkillAttribs.items():
+            typeSkillAttribs = typesSkillAttribs.get(typeID, {})
+            if not typeSkillAttribs:
+                continue
+            typeSkillReqs = typesSkillReqs.setdefault(typeID, {})
+            for skillreqTypeAttr, skillreqLevelAttr in skillReqAttribs.items():
+                try:
+                    skillType = int(typeSkillAttribs[skillreqTypeAttr])
+                    skillLevel = int(typeSkillAttribs[skillreqLevelAttr])
+                except (KeyError, ValueError):
+                    continue
+                typeSkillReqs[skillType] = skillLevel
+        # Format: {group ID: category ID}
+        groupCategories = {}
+        for row in eveGroupsData:
+            groupCategories[row['groupID']] = row['categoryID']
+        # As EVE affects various types mostly depending on their group or skill requirements,
+        # we're going to group various types up this way
+        # Format: {(group ID, frozenset(skillreq, type, IDs), frozenset(type, effect, IDs): [type ID, {attribute ID: attribute value}]}
+        groupedData = {}
+        for row in eveTypesData:
+            typeID = row['typeID']
+            # Ignore items outside of categories we need
+            if groupCategories[typesGroups[typeID]] not in (
+                6,  # Ship
+                7,  # Module
+                8,  # Charge
+                18,  # Drone
+                20,  # Implant
+                22,  # Deployable
+                23,  # Starbase
+                32,  # Subsystem
+                35,  # Decryptors
+                65,  # Structure
+                66,  # Structure Module
+                87,  # Fighter
+            ):
+                continue
+            typeAttribs = typesNormalAttribs.get(typeID, {})
+            # Ignore items w/o attributes
+            if not typeAttribs:
+                continue
+            # We need only skill types, not levels for keys
+            typeSkillreqs = frozenset(typesSkillReqs.get(typeID, {}))
+            typeGroup = typesGroups[typeID]
+            typeEffects = frozenset(typesEffects.get(typeID, ()))
+            groupData = groupedData.setdefault((typeGroup, typeSkillreqs, typeEffects), [])
+            groupData.append((typeID, typeAttribs))
+        # Format: {type ID: set(type IDs)}
+        replacements = {}
+        # Now, go through composed groups and for every item within it
+        # find items which are the same
+        for groupData in groupedData.values():
+            for type1, type2 in itertools.combinations(groupData, 2):
+                if compareAttrs(type1[1], type2[1]):
+                    replacements.setdefault(type1[0], set()).add(type2[0])
+                    replacements.setdefault(type2[0], set()).add(type1[0])
+        # Update DB session with data we generated
+        for item in eos.db.gamedata_session.query(eos.gamedata.Item).all():
+            itemReplacements = replacements.get(item.typeID)
+            if itemReplacements is not None:
+                item.replacements = ','.join('{}'.format(tid) for tid in sorted(itemReplacements))
+
+    def processImplantSets(eveTypesData):
+        print('composing implant sets')
+        # Includes only implants which can be considered part of sets, not all implants
+        implant_groups = (300, 1730)
+        specials = {'Genolution': ('Genolution Core Augmentation', r'CA-\d+')}
+        implantSets = {}
+        for row in eveTypesData:
+            if not row.get('published'):
+                continue
+            if row.get('groupID') not in implant_groups:
+                continue
+            typeName = row.get('typeName_en-us', '')
+            # Regular sets matching
+            m = re.match('(?P<grade>(High|Mid|Low)-grade) (?P<set>\w+) (?P<implant>(Alpha|Beta|Gamma|Delta|Epsilon|Omega))', typeName, re.IGNORECASE)
+            if m:
+                implantSets.setdefault((m.group('grade'), m.group('set')), set()).add(row['typeID'])
+            # Special set matching
+            for setHandle, (setName, implantPattern) in specials.items():
+                pattern = '(?P<set>{}) (?P<implant>{})'.format(setName, implantPattern)
+                m = re.match(pattern, typeName)
+                if m:
+                    implantSets.setdefault((None, setHandle), set()).add(row['typeID'])
+                    break
+        data = []
+        for (gradeName, setName), implants in implantSets.items():
+            if len(implants) < 2:
+                continue
+            implants = ','.join('{}'.format(tid) for tid in sorted(implants))
+            row = {'setName': setName, 'gradeName': gradeName, 'implants': implants}
+            data.append(row)
+        _addRows(data, eos.gamedata.ImplantSet)
+
+    eveTypesData = processEveTypes()
+    eveGroupsData = processEveGroups()
+    processEveCategories()
+    processDogmaAttributes()
+    dogmaTypeAttributesData = processDogmaTypeAttributes(eveTypesData)
+    processDynamicItemAttributes()
+    processDogmaEffects()
+    dogmaTypeEffectsData = processDogmaTypeEffects(eveTypesData)
+    processDogmaUnits()
+    processMarketGroups()
+    processMetaGroups()
+    processCloneGrades()
+    processTraits()
+    processMetadata()
+
+    eos.db.gamedata_session.flush()
+    processReqSkills(eveTypesData)
+    processReplacements(eveTypesData, eveGroupsData, dogmaTypeAttributesData, dogmaTypeEffectsData)
+    processImplantSets(eveTypesData)
+
+    # 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.flush()
+
+    # 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
+    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
+
+    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)
+
+    eos.db.gamedata_session.commit()
+    eos.db.gamedata_engine.execute('VACUUM')
+
+    print('done')
+
+
+if __name__ == '__main__':
+    update_db()

dist_assets/mac/pyfa.spec

@@ -20,6 +20,7 @@ added_files = [
              ('../../imgs/renders/*.png', 'imgs/renders'),
              ('../../dist_assets/win/pyfa.ico', '.'),
              ('../../service/jargon/*.yaml', 'service/jargon'),
+             ('../../locale', 'locale'),
              (requests.certs.where(), '.'),  # is this needed anymore?
              ('../../eve.db', '.'),
              ('../../README.md', '.'),
@@ -29,7 +30,9 @@ added_files = [
 
 
 import_these = [
-    'numpy.core._dtype_ctypes'  # https://github.com/pyinstaller/pyinstaller/issues/3982
+    'numpy.core._dtype_ctypes',  # https://github.com/pyinstaller/pyinstaller/issues/3982
+    'sqlalchemy.ext.baked',  # windows build doesn't launch without if when using sqlalchemy 1.3.x
+    'pkg_resources.py2_warn'  # issue 2156
 ]
 
 icon = os.path.join(os.getcwd(), "dist_assets", "mac", "pyfa.icns")
@@ -86,4 +89,4 @@ app = BUNDLE(
         'CFBundleDisplayName': 'pyfa',
         'CFBundleIdentifier': 'org.pyfaorg.pyfa',
     }
-)
+)

dist_assets/pyinstaller_hooks/hook-matplotlib.backends.py

@@ -1,78 +0,0 @@
-# This apes hook-matplotlib.backends.py, but REMOVES backends, all but
-# the ones in the list below.
-# Courtesy of https://github.com/bpteague/cytoflow/blob/70f9291/packaging/hook-matplotlib.backends.py
-
-KEEP = ["WXAgg", "WX", "agg"]
-
-from PyInstaller.compat import is_darwin
-from PyInstaller.utils.hooks import (
-    eval_statement, exec_statement, logger)
-
-
-def get_matplotlib_backend_module_names():
-    """
-    List the names of all matplotlib backend modules importable under the
-    current Python installation.
-    Returns
-    ----------
-    list
-        List of the fully-qualified names of all such modules.
-    """
-    # Statement safely importing a single backend module.
-    import_statement = """
-import os, sys
-# Preserve stdout.
-sys_stdout = sys.stdout
-try:
-    # Redirect output printed by this importation to "/dev/null", preventing
-    # such output from being erroneously interpreted as an error.
-    with open(os.devnull, 'w') as dev_null:
-        sys.stdout = dev_null
-        __import__('%s')
-# If this is an ImportError, print this exception's message without a traceback.
-# ImportError messages are human-readable and require no additional context.
-except ImportError as exc:
-    sys.stdout = sys_stdout
-    print(exc)
-# Else, print this exception preceded by a traceback. traceback.print_exc()
-# prints to stderr rather than stdout and must not be called here!
-except Exception:
-    sys.stdout = sys_stdout
-    import traceback
-    print(traceback.format_exc())
-"""
-
-    # List of the human-readable names of all available backends.
-    backend_names = eval_statement(
-        'import matplotlib; print(matplotlib.rcsetup.all_backends)')
-
-    # List of the fully-qualified names of all importable backend modules.
-    module_names = []
-
-    # If the current system is not OS X and the "CocoaAgg" backend is available,
-    # remove this backend from consideration. Attempting to import this backend
-    # on non-OS X systems halts the current subprocess without printing output
-    # or raising exceptions, preventing its reliable detection.
-    if not is_darwin and 'CocoaAgg' in backend_names:
-        backend_names.remove('CocoaAgg')
-
-    # For safety, attempt to import each backend in a unique subprocess.
-    for backend_name in backend_names:
-        if backend_name in KEEP:
-            continue
-
-        module_name = 'matplotlib.backends.backend_%s' % backend_name.lower()
-        stdout = exec_statement(import_statement % module_name)
-
-        # If no output was printed, this backend is importable.
-        if not stdout:
-            module_names.append(module_name)
-            logger.info('  Matplotlib backend "%s": removed' % backend_name)
-
-    return module_names
-
-# Freeze all importable backends, as PyInstaller is unable to determine exactly
-# which backends are required by the current program.
-e=get_matplotlib_backend_module_names()
-print(e)
-excludedimports = e

dist_assets/win/Microsoft.VC90.CRT.manifest

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
-<noInheritable/>
-<assemblyIdentity
-    type="win32"
-    name="Microsoft.VC90.CRT"
-    version="9.0.21022.8"
-    processorArchitecture="x86"
-    publicKeyToken="1fc8b3b9a1e18e3b"/>
-<file name="MSVCR90.DLL"/>
-<file name="MSVCM90.DLL"/>
-<file name="MSVCP90.DLL"/>
-</assembly>

dist_assets/win/dist.py

@@ -8,13 +8,13 @@ import yaml
 
 
 with open("version.yml", 'r') as file:
-    data = yaml.load(file, Loader=yaml.FullLoader)
+    data = yaml.load(file, Loader=yaml.SafeLoader)
     version = data['version']
 
 os.environ["PYFA_DIST_DIR"] = os.path.join(os.getcwd(), 'dist')
 
 os.environ["PYFA_VERSION"] = version
-iscc = "C:\Program Files (x86)\Inno Setup 5\ISCC.exe" # inno script location via wine
+iscc = "C:\Program Files (x86)\Inno Setup 6\ISCC.exe"
 
 source = os.path.join(os.environ["PYFA_DIST_DIR"], "pyfa")
 

dist_assets/win/pyfa-setup.iss

@@ -15,10 +15,6 @@
 #define MyAppURL "https://github.com/pyfa-org/Pyfa/"
 #define MyAppExeName "pyfa.exe"
 
-; What version starts with the new structure (1.x.0). This is used to determine if we run directory structure cleanup
-#define MajorVersionFlag 2
-#define MinorVersionFlag 0
-
 #ifndef MyOutputFile
     #define MyOutputFile LowerCase(StringChange(MyAppName+'-'+MyAppVersion+'-win', " ", "-"))
 #endif
@@ -30,7 +26,6 @@
 #endif
 
 [Setup]
-
 ; NOTE: The value of AppId uniquely identifies this application.
 ; Do not use the same AppId value in installers for other applications.
 ; (To generate a new GUID, click Tools | Generate GUID inside the IDE.)
@@ -41,6 +36,9 @@ AppPublisher={#MyAppPublisher}
 AppPublisherURL={#MyAppURL}
 AppSupportURL={#MyAppURL}
 AppUpdatesURL={#MyAppURL}
+ArchitecturesAllowed=x64
+ArchitecturesInstallIn64BitMode=x64
+CloseApplications=yes
 DefaultDirName={pf}\{#MyAppName}
 DefaultGroupName={#MyAppName}
 AllowNoIcons=yes
@@ -49,7 +47,6 @@ OutputDir={#MyOutputDir}
 OutputBaseFilename={#MyOutputFile}
 SetupIconFile={#MyAppDir}\pyfa.ico
 SolidCompression=yes
-CloseApplications=yes
 
 [Languages]
 Name: "english"; MessagesFile: "compiler:Default.isl"
@@ -83,6 +80,7 @@ Type: files; Name: "{app}\*.pyc"
 
 [Code]
 
+/////////////////////////////////////////////////////////////////////
 function IsAppRunning(const FileName : string): Boolean;
 var
     FSWbemLocator: Variant;
@@ -99,6 +97,7 @@ begin
     FSWbemLocator := Unassigned;
 end;
 
+/////////////////////////////////////////////////////////////////////
 procedure RemoveFromVirtualStore;
 var
     VirtualStore,FileName,FilePath:String;
@@ -115,11 +114,12 @@ begin
     end;
 end;
 
+/////////////////////////////////////////////////////////////////////
 function PrepareToInstall(var NeedsRestart: Boolean): String;
 begin
   if(IsAppRunning( 'pyfa.exe' )) then
     begin
-      Result := 'Please close pyfa before continuing. When closed, please go back to the previous step and continue.';
+      Result := 'Please close pyfa before continuing. When closed, please go back to the previous step and continue. If you have named this installer pyfa.exe, please rename it and restart installation';
     end
   else
     begin
@@ -127,54 +127,61 @@ begin
     end
 end;
 
-function GetUninstallString: string;
+/////////////////////////////////////////////////////////////////////
+function GetUninstallString(): String;
 var
-  sUnInstPath: string;
+  sUnInstPath: String;
   sUnInstallString: String;
 begin
-  Result := '';
   sUnInstPath := ExpandConstant('Software\Microsoft\Windows\CurrentVersion\Uninstall\{{3DA39096-C08D-49CD-90E0-1D177F32C8AA}_is1'); //Your App GUID/ID
   sUnInstallString := '';
   if not RegQueryStringValue(HKLM, sUnInstPath, 'UninstallString', sUnInstallString) then
-    RegQueryStringValue(HKCU, sUnInstPath, 'UninstallString', sUnInstallString);
+    if not RegQueryStringValue(HKCU, sUnInstPath, 'UninstallString', sUnInstallString) then
+      if not RegQueryStringValue(HKLM32, sUnInstPath, 'UninstallString', sUnInstallString) then
+        RegQueryStringValue(HKCU32, sUnInstPath, 'UninstallString', sUnInstallString);
   Result := sUnInstallString;
 end;
 
-function IsUpgrade: Boolean;
+/////////////////////////////////////////////////////////////////////
+function UnInstallOldVersion(): Integer;
+var
+  sUnInstallString: String;
+  iResultCode: Integer;
+begin
+// Return Values:
+// 1 - uninstall string is empty
+// 2 - error executing the UnInstallString
+// 3 - successfully executed the UnInstallString
+
+  // default return value
+  Result := 0;
+
+  // get the uninstall string of the old app
+  sUnInstallString := GetUninstallString();
+  if sUnInstallString <> '' then begin
+    sUnInstallString := RemoveQuotes(sUnInstallString);
+    if Exec(sUnInstallString, '/SILENT /NORESTART /SUPPRESSMSGBOXES','', SW_HIDE, ewWaitUntilTerminated, iResultCode) then
+      Result := 3
+    else
+      Result := 2;
+  end else
+    Result := 1;
+end;
+
+/////////////////////////////////////////////////////////////////////
+function IsUpgrade(): Boolean;
 begin
   Result := (GetUninstallString() <> '');
 end;
 
-function InitializeSetup: Boolean;
-var
-  V: Integer;
-  iResultCode: Integer;
-  sUnInstallString: string;
-  iOldVersionMajor: Cardinal;
-  iOldVersionMinor: Cardinal;
+/////////////////////////////////////////////////////////////////////
+procedure CurStepChanged(CurStep: TSetupStep);
 begin
-  Result := True; // in case when no previous version is found
-  if RegValueExists(HKEY_LOCAL_MACHINE,'Software\Microsoft\Windows\CurrentVersion\Uninstall\{3DA39096-C08D-49CD-90E0-1D177F32C8AA}_is1', 'UninstallString') then  //Your App GUID/ID
+  if (CurStep=ssInstall) then
   begin
-    RegQueryDWordValue(HKEY_LOCAL_MACHINE,
-      'Software\Microsoft\Windows\CurrentVersion\Uninstall\{3DA39096-C08D-49CD-90E0-1D177F32C8AA}_is1',
-      'MajorVersion', iOldVersionMajor);
-    RegQueryDWordValue(HKEY_LOCAL_MACHINE,
-      'Software\Microsoft\Windows\CurrentVersion\Uninstall\{3DA39096-C08D-49CD-90E0-1D177F32C8AA}_is1',
-      'MinorVersion', iOldVersionMinor);
-    if (iOldVersionMajor < {#MajorVersionFlag}) or ((iOldVersionMajor = {#MajorVersionFlag}) and (iOldVersionMinor < {#MinorVersionFlag})) then // If old version with old structure is installed.
+    if (IsUpgrade()) then
     begin
-      V := MsgBox(ExpandConstant('An old version of pyfa was detected. Due to recent changes in the application structure, you must uninstall the previous version first. This will not affect your user data (saved fittings, characters, etc.). Do you want to uninstall now?'), mbInformation, MB_YESNO); //Custom Message if App installed
-      if V = IDYES then
-      begin
-        sUnInstallString := GetUninstallString();
-        sUnInstallString :=  RemoveQuotes(sUnInstallString);
-        Exec(ExpandConstant(sUnInstallString), '', '', SW_SHOW, ewWaitUntilTerminated, iResultCode);
-        Result := True; //if you want to proceed after uninstall
-                  //Exit; //if you want to quit after uninstall
-      end
-      else
-        Result := False; //when older version present and not uninstalled
+      UnInstallOldVersion();
     end;
   end;
 end;

dist_assets/win/pyfa.exe.manifest

@@ -8,11 +8,6 @@
       </requestedPrivileges>
     </security>
   </trustInfo>
-  <dependency>
-    <dependentAssembly>
-      <assemblyIdentity type="win32" name="Microsoft.VC90.CRT" version="9.0.21022.8" processorArchitecture="x86" publicKeyToken="1fc8b3b9a1e18e3b"></assemblyIdentity>
-    </dependentAssembly>
-  </dependency>
   <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
     <application>
       <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>

dist_assets/win/pyfa.spec

@@ -17,10 +17,9 @@ added_files = [
              ('../../imgs/gui/*.gif', 'imgs/gui'),
              ('../../imgs/icons/*.png', 'imgs/icons'),
              ('../../imgs/renders/*.png', 'imgs/renders'),
-             ('../../service/jargon/*.yaml', 'service/jargon'), 
+             ('../../service/jargon/*.yaml', 'service/jargon'),
              ('../../dist_assets/win/pyfa.ico', '.'),
              ('../../dist_assets/win/pyfa.exe.manifest', '.'),
-             ('../../dist_assets/win/Microsoft.VC90.CRT.manifest', '.'),
              (requests.certs.where(), '.'),  # is this needed anymore?
              ('../../eve.db', '.'),
              ('../../README.md', '.'),
@@ -29,7 +28,9 @@ added_files = [
              ]
 
 import_these = [
-    'numpy.core._dtype_ctypes'  # https://github.com/pyinstaller/pyinstaller/issues/3982
+    'numpy.core._dtype_ctypes',  # https://github.com/pyinstaller/pyinstaller/issues/3982
+    'sqlalchemy.ext.baked',  # windows build doesn't launch without if when using sqlalchemy 1.3.x
+    'pkg_resources.py2_warn'  # issue 2156
 ]
 
 # Walk directories that do dynamic importing

dist_assets/win/pyfa_debug.spec

@@ -1,83 +0,0 @@
-# -*- mode: python -*-
-
-# Note: This script is provided AS-IS for those that may be interested.
-# pyfa does not currently support pyInstaller (or any other build process) 100% at the moment
-
-# Command line to build:
-# (Run from directory where pyfa.py and pyfa.spec lives.)
-# c:\Python27\scripts\pyinstaller.exe --clean --noconfirm --windowed --upx-dir=.\scripts\upx.exe pyfa.spec
-
-# Don't forget to change the path to where your pyfa.py and pyfa.spec lives
-#  pathex=['C:\\Users\\Ebag333\\Documents\\GitHub\\Ebag333\\Pyfa'],
-
-import os
-
-block_cipher = None
-
-added_files = [
-             ( 'imgs/gui/*.png', 'imgs/gui' ),
-             ( 'imgs/gui/*.gif', 'imgs/gui' ),
-             ( 'imgs/icons/*.png', 'imgs/icons' ),
-             ( 'imgs/renders/*.png', 'imgs/renders' ),
-             ( 'dist_assets/win/pyfa.ico', '.' ),
-             ( 'dist_assets/cacert.pem', '.' ),
-             ( 'eve.db', '.' ),
-             ( 'README.md', '.' ),
-             ( 'LICENSE', '.' ),
-             ]
-
-import_these = []
-
-# Walk eos.effects and add all effects so we can import them properly
-for root, folders, files in os.walk("eos/effects"):
-    for file_ in files:
-        if file_.endswith(".py") and not file_.startswith("_"):
-            mod_name = "{}.{}".format(
-                root.replace("/", "."),
-                file_.split(".py")[0],
-            )
-            import_these.append(mod_name)
-
-a = Analysis(
-             ['pyfa.py'],
-             pathex=['C:\\projects\\pyfa\\'],
-             binaries=[],
-             datas=added_files,
-             hiddenimports=import_these,
-             hookspath=[],
-             runtime_hooks=[],
-             excludes=[],
-             win_no_prefer_redirects=False,
-             win_private_assemblies=False,
-             cipher=block_cipher,
-             )
-
-pyz = PYZ(
-          a.pure,
-          a.zipped_data,
-          cipher=block_cipher,
-          )
-
-exe = EXE(pyz,
-          a.scripts,
-          exclude_binaries=True,
-          debug=True,
-          console=True,
-          strip=False,
-          upx=True,
-          name='pyfa_debug',
-          icon='dist_assets/win/pyfa.ico',
-          onefile=False,
-          )
-
-coll = COLLECT(
-               exe,
-               a.binaries,
-               a.zipfiles,
-               a.datas,
-               strip=False,
-               upx=True,
-               onefile=False,
-               name='pyfa_debug',
-               icon='dist_assets/win/pyfa.ico',
-               )

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/config.py

@@ -13,6 +13,24 @@ saveddataCache = True
 gamedata_version = ""
 gamedata_date = ""
 gamedata_connectionstring = 'sqlite:///' + realpath(join(dirname(abspath(__file__)), "..", "eve.db"))
+
+lang = ""
+
+# Maps supported langauges to their suffix in the database
+translation_mapping = {
+    "en": "",
+    "fr": "_fr",
+    # "it": "_it",
+    "ja": "_ja",
+    "ko": "_ko",
+    "ru": "_ru",
+    "zh": "_zh",
+}
+
+def set_lang(i18n_lang):
+    global lang
+    lang = translation_mapping.get(i18n_lang, translation_mapping.get("en"))
+
 pyfalog.debug("Gamedata connection string: {0}", gamedata_connectionstring)
 
 if istravis is True or hasattr(sys, '_called_from_test'):

eos/const.py

@@ -90,6 +90,26 @@ 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
+class FitSystemSecurity(IntEnum):
+    HISEC = 0
+    LOWSEC = 1
+    NULLSEC = 2
+    WSPACE = 3
+
+
+@unique
+class Operator(IntEnum):
+    PREASSIGN = 0
+    PREINCREASE = 1
+    MULTIPLY = 2
+    POSTINCREASE = 3
+    FORCE = 4

eos/db/__init__.py

@@ -17,34 +17,66 @@
 # along with eos.  If not, see <http://www.gnu.org/licenses/>.
 # ===============================================================================
 
+import re
 import threading
 
-from sqlalchemy import MetaData, create_engine
-from sqlalchemy.orm import sessionmaker
+from sqlalchemy import MetaData, create_engine, event
+from sqlalchemy.orm import sessionmaker, scoped_session
 
 from . import migration
 from eos import config
 from logbook import Logger
 
+
 pyfalog = Logger(__name__)
 pyfalog.info("Initializing database")
 pyfalog.info("Gamedata connection: {0}", config.gamedata_connectionstring)
 pyfalog.info("Saveddata connection: {0}", config.saveddata_connectionstring)
 
+
 class ReadOnlyException(Exception):
     pass
 
 
+def re_fn(expr, item):
+    try:
+        reg = re.compile(expr, re.IGNORECASE)
+    except (SystemExit, KeyboardInterrupt):
+        raise
+    except:
+        return False
+    return reg.search(item) is not None
+
+
+pyfalog.debug('Initializing gamedata')
 gamedata_connectionstring = config.gamedata_connectionstring
 if callable(gamedata_connectionstring):
     gamedata_engine = create_engine("sqlite://", creator=gamedata_connectionstring, echo=config.debug)
 else:
     gamedata_engine = create_engine(gamedata_connectionstring, echo=config.debug)
 
+
+@event.listens_for(gamedata_engine, 'connect')
+def create_functions(dbapi_connection, connection_record):
+    dbapi_connection.create_function('regexp', 2, re_fn)
+
+
 gamedata_meta = MetaData()
 gamedata_meta.bind = gamedata_engine
-gamedata_session = sessionmaker(bind=gamedata_engine, autoflush=False, expire_on_commit=False)()
+GamedataSession = scoped_session(sessionmaker(bind=gamedata_engine, autoflush=False, expire_on_commit=False))
+gamedata_session = GamedataSession()
 
+gamedata_sessions = {threading.get_ident(): gamedata_session}
+
+
+def get_gamedata_session():
+    thread_id = threading.get_ident()
+    if thread_id not in gamedata_sessions:
+        gamedata_sessions[thread_id] = GamedataSession()
+    return gamedata_sessions[thread_id]
+
+
+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:
@@ -54,12 +86,15 @@ try:
     config.gamedata_date = gamedata_session.execute(
         "SELECT `field_value` FROM `metadata` WHERE `field_name` LIKE 'dump_time'"
     ).fetchone()[0]
+except (KeyboardInterrupt, SystemExit):
+    raise
 except Exception as e:
     pyfalog.warning("Missing gamedata version.")
     pyfalog.critical(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 +111,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
+from eos.db.gamedata import alphaClones, attribute, category, effect, group, item, marketGroup, metaData, metaGroup, queries, traits, unit, dynamicAttributes, implantSet
+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
+from eos.db.saveddata import booster, cargo, character, damagePattern, databaseRepair, drone, fighter, fit, implant, implantSet, \
+    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/__init__.py

@@ -1,2 +1,2 @@
 __all__ = ["attribute", "category", "effect", "group", "metaData", "dynamicAttributes",
-           "item", "marketGroup", "metaGroup", "unit", "alphaClones"]
+           "item", "marketGroup", "metaGroup", "unit", "alphaClones", "implantSet"]

eos/db/gamedata/attribute.py

@@ -23,7 +23,7 @@ from sqlalchemy.orm import relation, mapper, synonym, deferred
 
 from eos.db import gamedata_meta
 from eos.gamedata import Attribute, AttributeInfo, Unit
-
+import eos.config
 typeattributes_table = Table("dgmtypeattribs", gamedata_meta,
                              Column("value", Float),
                              Column("typeID", Integer, ForeignKey("invtypes.typeID"), primary_key=True, index=True),
@@ -36,11 +36,11 @@ attributes_table = Table("dgmattribs", gamedata_meta,
                          Column("maxAttributeID", Integer, ForeignKey("dgmattribs.attributeID")),
                          Column("description", Unicode),
                          Column("published", Boolean),
-                         Column("displayName", String),
+                         *[Column("displayName{}".format(lang), String) for lang in eos.config.translation_mapping.values()],
                          Column("highIsGood", Boolean),
                          Column("iconID", Integer),
                          Column("attributeCategory", Integer),
-                         Column("tooltipDescription", Integer),
+                         # Column("tooltipDescription", Integer), # deprecated...?
                          Column("unitID", Integer, ForeignKey("dgmunits.unitID")))
 
 mapper(Attribute, typeattributes_table,
@@ -51,14 +51,14 @@ mapper(AttributeInfo, attributes_table,
            "unit"       : relation(Unit),
            "ID"         : synonym("attributeID"),
            "name"       : synonym("attributeName"),
-           "description": deferred(attributes_table.c.description)
+           "description": deferred(attributes_table.c.description),
        })
 
 Attribute.ID = association_proxy("info", "attributeID")
 Attribute.name = association_proxy("info", "attributeName")
 Attribute.description = association_proxy("info", "description")
 Attribute.published = association_proxy("info", "published")
-Attribute.displayName = association_proxy("info", "displayName")
+Attribute.displayName = association_proxy("info", "displayName{}".format(eos.config.lang))
 Attribute.highIsGood = association_proxy("info", "highIsGood")
 Attribute.iconID = association_proxy("info", "iconID")
 Attribute.icon = association_proxy("info", "icon")

eos/db/gamedata/category.py

@@ -22,17 +22,18 @@ from sqlalchemy.orm import deferred, mapper, synonym
 
 from eos.db import gamedata_meta
 from eos.gamedata import Category
+import eos.config
 
 categories_table = Table("invcategories", gamedata_meta,
                          Column("categoryID", Integer, primary_key=True),
-                         Column("categoryName", String),
-                         Column("description", String),
+                         *[Column("name{}".format(lang), String) for lang in eos.config.translation_mapping.values()],
+                         # Column("description", String), # deprecated
                          Column("published", Boolean),
                          Column("iconID", Integer))
 
 mapper(Category, categories_table,
        properties={
            "ID"         : synonym("categoryID"),
-           "name"       : synonym("categoryName"),
-           "description": deferred(categories_table.c.description)
+           "displayName": synonym("name{}".format(eos.config.lang)),
+           # "description": deferred(categories_table.c.description) # deprecated
        })

eos/db/gamedata/group.py

@@ -22,11 +22,12 @@ from sqlalchemy.orm import relation, mapper, synonym, deferred, backref
 
 from eos.db import gamedata_meta
 from eos.gamedata import Category, Group
+import eos.config
 
 groups_table = Table("invgroups", gamedata_meta,
                      Column("groupID", Integer, primary_key=True),
-                     Column("groupName", String),
-                     Column("description", String),
+                     *[Column("name{}".format(lang), String) for lang in eos.config.translation_mapping.values()],
+                     # Column("description", String), # deprecated
                      Column("published", Boolean),
                      Column("categoryID", Integer, ForeignKey("invcategories.categoryID")),
                      Column("iconID", Integer))
@@ -35,6 +36,6 @@ mapper(Group, groups_table,
        properties={
            "category"   : relation(Category, backref=backref("groups", cascade="all,delete")),
            "ID"         : synonym("groupID"),
-           "name"       : synonym("groupName"),
-           "description": deferred(groups_table.c.description)
+           "displayName"       : synonym("name{}".format(eos.config.lang)),
+           # "description": deferred(groups_table.c.description) # deprecated
        })

eos/db/gamedata/implantSet.py

@@ -0,0 +1,33 @@
+# ===============================================================================
+# 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 sqlalchemy import Column, String, Integer, Table
+from sqlalchemy.orm import mapper, synonym
+
+from eos.db import gamedata_meta
+from eos.gamedata import ImplantSet
+
+implant_set_table = Table("implantsets", gamedata_meta,
+                          Column("setID", Integer, primary_key=True),
+                          Column("setName", String),
+                          Column("gradeName", String),
+                          Column("implants", String))
+
+mapper(ImplantSet, implant_set_table,
+       properties={"ID": synonym("setID")})

eos/db/gamedata/item.py

@@ -25,46 +25,58 @@ 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
+
+import eos.config
 
 items_table = Table("invtypes", gamedata_meta,
                     Column("typeID", Integer, primary_key=True),
-                    Column("typeName", String, index=True),
-                    Column("description", String),
+                    *[Column("typeName{}".format(lang), String, index=True) for lang in eos.config.translation_mapping.values()],
+                    *[Column("typeDescription{}".format(lang), String) for lang in eos.config.translation_mapping.values()],
                     Column("raceID", Integer),
                     Column("factionID", Integer),
-                    Column("volume", Float),
-                    Column("mass", Float),
-                    Column("capacity", Float),
                     Column("published", Boolean),
                     Column("marketGroupID", Integer, ForeignKey("invmarketgroups.marketGroupID")),
                     Column("iconID", Integer),
                     Column("graphicID", Integer),
                     Column("groupID", Integer, ForeignKey("invgroups.groupID"), index=True),
-                    Column("replacements", String))
+                    Column("metaLevel", Integer),
+                    Column("metaGroupID", Integer, ForeignKey("invmetagroups.metaGroupID"), index=True),
+                    Column("variationParentTypeID", Integer, ForeignKey("invtypes.typeID"), index=True),
+                    Column("replacements", String),
+                    Column("reqskills", String),
+                    Column("requiredfor", String),
+                    )
 
-from .metaGroup import metatypes_table  # noqa
 from .traits import traits_table  # noqa
 
-mapper(Item, items_table,
-       properties={
-           "group"            : relation(Group, backref=backref("items", cascade="all,delete")),
+props = {
+           "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),
-           "ID"               : synonym("typeID"),
-           "name"             : synonym("typeName"),
-           "description"      : deferred(items_table.c.description),
-           "traits"           : relation(Traits,
-                                         primaryjoin=traits_table.c.typeID == items_table.c.typeID,
-                                         uselist=False),
-           "mutaplasmids": relation(DynamicItem,
-                   primaryjoin=dynamicApplicable_table.c.applicableTypeID == items_table.c.typeID,
-                   secondaryjoin=dynamicApplicable_table.c.typeID == DynamicItem.typeID,
-                   secondary=dynamicApplicable_table,
-                   backref="applicableItems")
-       })
+           "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{}".format(eos.config.lang)),
+           "description" : synonym("_description{}".format(eos.config.lang)),
+           "traits": relation(
+               Traits,
+               primaryjoin=traits_table.c.typeID == items_table.c.typeID,
+               uselist=False
+           ),
+           "mutaplasmids": relation(
+               DynamicItem,
+               primaryjoin=dynamicApplicable_table.c.applicableTypeID == items_table.c.typeID,
+               secondaryjoin=dynamicApplicable_table.c.typeID == DynamicItem.typeID,
+               secondary=dynamicApplicable_table,
+               backref="applicableItems"
+           )
+}
+
+# Create deferred columns shadowing all the description fields. The literal `description` property will dynamically
+# be assigned as synonym to one of these
+props.update({'_description' + v: deferred(items_table.c['typeDescription' + v]) for (k, v) in eos.config.translation_mapping.items()})
+
+mapper(Item, items_table, properties=props)
 
 Item.category = association_proxy("group", "category")

eos/db/gamedata/marketGroup.py

@@ -22,22 +22,34 @@ from sqlalchemy.orm import relation, mapper, synonym, deferred
 
 from eos.db import gamedata_meta
 from eos.gamedata import Item, MarketGroup
+import eos.config
 
 marketgroups_table = Table("invmarketgroups", gamedata_meta,
                            Column("marketGroupID", Integer, primary_key=True),
-                           Column("marketGroupName", String),
-                           Column("description", String),
+                           *[Column("marketGroupName{}".format(lang), String) for lang in eos.config.translation_mapping.values()],
+                           *[Column("marketGroupDescription{}".format(lang), String) for lang in eos.config.translation_mapping.values()],
                            Column("hasTypes", Boolean),
                            Column("parentGroupID", Integer,
-                                  ForeignKey("invmarketgroups.marketGroupID", initially="DEFERRED", deferrable=True)),
+                                ForeignKey("invmarketgroups.marketGroupID", initially="DEFERRED", deferrable=True)),
                            Column("iconID", Integer))
 
-mapper(MarketGroup, marketgroups_table,
-       properties={
-           "items"      : relation(Item, backref="marketGroup"),
-           "parent"     : relation(MarketGroup, backref="children",
-                                   remote_side=[marketgroups_table.c.marketGroupID]),
-           "ID"         : synonym("marketGroupID"),
-           "name"       : synonym("marketGroupName"),
-           "description": deferred(marketgroups_table.c.description)
-        })
+props = {
+    "items": relation(Item, backref="marketGroup"),
+    "parent": relation(MarketGroup, backref="children", remote_side=[marketgroups_table.c.marketGroupID]),
+    "ID": synonym("marketGroupID"),
+    "name": synonym("marketGroupName{}".format(eos.config.lang)),
+    "description": synonym("_description{}".format(eos.config.lang)),
+}
+
+# Create deferred columns shadowing all the description fields. The literal `description` property will dynamically
+# be assigned as synonym to one of these
+# this is mostly here to allow the db_update to be language-agnostic
+# todo: determine if we ever use market group descriptions... can we just get with of these?
+props.update({'_description' + v: deferred(marketgroups_table.c['marketGroupDescription' + v]) for (k, v) in eos.config.translation_mapping.items()})
+
+mapper(
+    MarketGroup,
+    marketgroups_table,
+    properties=props
+)
+

eos/db/gamedata/metaGroup.py

@@ -17,35 +17,25 @@
 # 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
+import eos.config
 
-metagroups_table = Table("invmetagroups", gamedata_meta,
-                         Column("metaGroupID", Integer, primary_key=True),
-                         Column("metaGroupName", String))
+metagroups_table = Table(
+    "invmetagroups",
+    gamedata_meta,
+    Column("metaGroupID", Integer, primary_key=True),
+    *[Column("metaGroupName{}".format(lang), String) for lang in eos.config.translation_mapping.values()],
+)
 
-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")
+mapper(
+    MetaGroup,
+    metagroups_table,
+    properties={
+        "ID"  : synonym("metaGroupID"),
+        "name": synonym("metaGroupName{}".format(eos.config.lang))
+    }
+)

eos/db/gamedata/queries.py

@@ -22,11 +22,11 @@ from sqlalchemy.orm import aliased, exc, join
 from sqlalchemy.sql import and_, or_, select
 
 import eos.config
-from eos.db import gamedata_session
+from eos.db import get_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
+from eos.gamedata import AlphaClone, Attribute, AttributeInfo, Category, DynamicItem, Group, Item, MarketGroup, MetaData, MetaGroup, ImplantSet
 
 cache = {}
 configVal = getattr(eos.config, "gamedataCache", None)
@@ -64,7 +64,7 @@ else:
         return deco
 
 
-def sqlizeString(line):
+def sqlizeNormalString(line):
     # Escape backslashes first, as they will be as escape symbol in queries
     # Then escape percent and underscore signs
     # Finally, replace generic wildcards with sql-style wildcards
@@ -79,28 +79,39 @@ itemNameMap = {}
 def getItem(lookfor, eager=None):
     if isinstance(lookfor, int):
         if eager is None:
-            item = gamedata_session.query(Item).get(lookfor)
+            item = get_gamedata_session().query(Item).get(lookfor)
         else:
-            item = gamedata_session.query(Item).options(*processEager(eager)).filter(Item.ID == lookfor).first()
+            item = get_gamedata_session().query(Item).options(*processEager(eager)).filter(Item.ID == lookfor).first()
     elif isinstance(lookfor, str):
         if lookfor in itemNameMap:
             id = itemNameMap[lookfor]
             if eager is None:
-                item = gamedata_session.query(Item).get(id)
+                item = get_gamedata_session().query(Item).get(id)
             else:
-                item = gamedata_session.query(Item).options(*processEager(eager)).filter(Item.ID == id).first()
+                item = get_gamedata_session().query(Item).options(*processEager(eager)).filter(Item.ID == id).first()
         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
+            item = get_gamedata_session().query(Item).options(*processEager(eager)).filter(Item.typeName == lookfor).first()
+            if item is not None:
+                itemNameMap[lookfor] = item.ID
     else:
         raise TypeError("Need integer or string as argument")
     return item
 
+@cachedQuery(1, "itemIDs")
+def getItems(itemIDs, eager=None):
+    if not isinstance(itemIDs, (tuple, list, set)) or not all(isinstance(t, int) for t in itemIDs):
+        raise TypeError("Need iterable of integers as argument")
+    if eager is None:
+        items = get_gamedata_session().query(Item).filter(Item.ID.in_(itemIDs)).all()
+    else:
+        items = get_gamedata_session().query(Item).options(*processEager(eager)).filter(Item.ID.in_(itemIDs)).all()
+    return items
+
 
 def getMutaplasmid(lookfor, eager=None):
     if isinstance(lookfor, int):
-        item = gamedata_session.query(DynamicItem).filter(DynamicItem.ID == lookfor).first()
+        item = get_gamedata_session().query(DynamicItem).filter(DynamicItem.ID == lookfor).first()
     else:
         raise TypeError("Need integer as argument")
     return item
@@ -108,7 +119,7 @@ def getMutaplasmid(lookfor, eager=None):
 
 def getItemWithBaseItemAttribute(lookfor, baseItemID, eager=None):
     # A lot of this is described in more detail in #1597
-    item = gamedata_session.query(Item).get(lookfor)
+    item = get_gamedata_session().query(Item).get(lookfor)
     base = getItem(baseItemID)
 
     # we have to load all attributes for this object, otherwise we'll lose access to them when we expunge.
@@ -124,7 +135,7 @@ def getItemWithBaseItemAttribute(lookfor, baseItemID, eager=None):
     # Expunge the item form the session. This is required to have different Abyssal / Base combinations loaded in memory.
     # Without expunging it, once one Abyssal Web is created, SQLAlchmey will use it for all others. We don't want this,
     # we want to generate a completely new object to work with
-    gamedata_session.expunge(item)
+    get_gamedata_session().expunge(item)
     return item
 
 
@@ -147,7 +158,7 @@ def getItems(lookfor, eager=None):
 
     if len(toGet) > 0:
         # Get items that aren't currently cached, and store them in the cache
-        items = gamedata_session.query(Item).filter(Item.ID.in_(toGet)).all()
+        items = get_gamedata_session().query(Item).filter(Item.ID.in_(toGet)).all()
         for item in items:
             cache[(item.ID, None)] = item
         results += items
@@ -161,9 +172,9 @@ def getItems(lookfor, eager=None):
 def getAlphaClone(lookfor, eager=None):
     if isinstance(lookfor, int):
         if eager is None:
-            item = gamedata_session.query(AlphaClone).get(lookfor)
+            item = get_gamedata_session().query(AlphaClone).get(lookfor)
         else:
-            item = gamedata_session.query(AlphaClone).options(*processEager(eager)).filter(AlphaClone.ID == lookfor).first()
+            item = get_gamedata_session().query(AlphaClone).options(*processEager(eager)).filter(AlphaClone.ID == lookfor).first()
     else:
         raise TypeError("Need integer as argument")
     return item
@@ -171,7 +182,7 @@ def getAlphaClone(lookfor, eager=None):
 
 def getAlphaCloneList(eager=None):
     eager = processEager(eager)
-    clones = gamedata_session.query(AlphaClone).options(*eager).all()
+    clones = get_gamedata_session().query(AlphaClone).options(*eager).all()
     return clones
 
 
@@ -182,20 +193,21 @@ groupNameMap = {}
 def getGroup(lookfor, eager=None):
     if isinstance(lookfor, int):
         if eager is None:
-            group = gamedata_session.query(Group).get(lookfor)
+            group = get_gamedata_session().query(Group).get(lookfor)
         else:
-            group = gamedata_session.query(Group).options(*processEager(eager)).filter(Group.ID == lookfor).first()
+            group = get_gamedata_session().query(Group).options(*processEager(eager)).filter(Group.ID == lookfor).first()
     elif isinstance(lookfor, str):
         if lookfor in groupNameMap:
             id = groupNameMap[lookfor]
             if eager is None:
-                group = gamedata_session.query(Group).get(id)
+                group = get_gamedata_session().query(Group).get(id)
             else:
-                group = gamedata_session.query(Group).options(*processEager(eager)).filter(Group.ID == id).first()
+                group = get_gamedata_session().query(Group).options(*processEager(eager)).filter(Group.ID == id).first()
         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
+            group = get_gamedata_session().query(Group).options(*processEager(eager)).filter(Group.name == lookfor).first()
+            if group is not None:
+                groupNameMap[lookfor] = group.ID
     else:
         raise TypeError("Need integer or string as argument")
     return group
@@ -208,23 +220,24 @@ categoryNameMap = {}
 def getCategory(lookfor, eager=None):
     if isinstance(lookfor, int):
         if eager is None:
-            category = gamedata_session.query(Category).get(lookfor)
+            category = get_gamedata_session().query(Category).get(lookfor)
         else:
-            category = gamedata_session.query(Category).options(*processEager(eager)).filter(
+            category = get_gamedata_session().query(Category).options(*processEager(eager)).filter(
                     Category.ID == lookfor).first()
     elif isinstance(lookfor, str):
         if lookfor in categoryNameMap:
             id = categoryNameMap[lookfor]
             if eager is None:
-                category = gamedata_session.query(Category).get(id)
+                category = get_gamedata_session().query(Category).get(id)
             else:
-                category = gamedata_session.query(Category).options(*processEager(eager)).filter(
+                category = get_gamedata_session().query(Category).options(*processEager(eager)).filter(
                         Category.ID == id).first()
         else:
             # Category names are unique, so we can use first() instead of one()
-            category = gamedata_session.query(Category).options(*processEager(eager)).filter(
+            category = get_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
@@ -237,41 +250,55 @@ metaGroupNameMap = {}
 def getMetaGroup(lookfor, eager=None):
     if isinstance(lookfor, int):
         if eager is None:
-            metaGroup = gamedata_session.query(MetaGroup).get(lookfor)
+            metaGroup = get_gamedata_session().query(MetaGroup).get(lookfor)
         else:
-            metaGroup = gamedata_session.query(MetaGroup).options(*processEager(eager)).filter(
+            metaGroup = get_gamedata_session().query(MetaGroup).options(*processEager(eager)).filter(
                     MetaGroup.ID == lookfor).first()
     elif isinstance(lookfor, str):
         if lookfor in metaGroupNameMap:
             id = metaGroupNameMap[lookfor]
             if eager is None:
-                metaGroup = gamedata_session.query(MetaGroup).get(id)
+                metaGroup = get_gamedata_session().query(MetaGroup).get(id)
             else:
-                metaGroup = gamedata_session.query(MetaGroup).options(*processEager(eager)).filter(
+                metaGroup = get_gamedata_session().query(MetaGroup).options(*processEager(eager)).filter(
                         MetaGroup.ID == id).first()
         else:
             # 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
+            metaGroup = get_gamedata_session().query(MetaGroup).options(*processEager(eager)).filter(
+                    MetaGroup.metaGroupName == lookfor).first()
+            if metaGroup is not None:
+                metaGroupNameMap[lookfor] = metaGroup.ID
     else:
         raise TypeError("Need integer or string as argument")
     return metaGroup
 
 
+def getMetaGroups():
+    return get_gamedata_session().query(MetaGroup).all()
+
+
 @cachedQuery(1, "lookfor")
 def getMarketGroup(lookfor, eager=None):
     if isinstance(lookfor, int):
         if eager is None:
-            marketGroup = gamedata_session.query(MarketGroup).get(lookfor)
+            marketGroup = get_gamedata_session().query(MarketGroup).get(lookfor)
         else:
-            marketGroup = gamedata_session.query(MarketGroup).options(*processEager(eager)).filter(
+            marketGroup = get_gamedata_session().query(MarketGroup).options(*processEager(eager)).filter(
                     MarketGroup.ID == lookfor).first()
     else:
         raise TypeError("Need integer as argument")
     return marketGroup
 
 
+def getMarketTreeNodeIds(rootNodeIds):
+    allIds = set()
+    addedIds = set(rootNodeIds)
+    while addedIds:
+        allIds.update(addedIds)
+        addedIds = {mg.ID for mg in get_gamedata_session().query(MarketGroup).filter(MarketGroup.parentGroupID.in_(addedIds))}
+    return allIds
+
+
 @cachedQuery(2, "where", "filter")
 def getItemsByCategory(filter, where=None, eager=None):
     if isinstance(filter, int):
@@ -282,7 +309,7 @@ def getItemsByCategory(filter, where=None, eager=None):
         raise TypeError("Need integer or string as argument")
 
     filter = processWhere(filter, where)
-    return gamedata_session.query(Item).options(*processEager(eager)).join(Item.group, Group.category).filter(
+    return get_gamedata_session().query(Item).options(*processEager(eager)).join(Item.group, Group.category).filter(
             filter).all()
 
 
@@ -297,9 +324,9 @@ def searchItems(nameLike, where=None, join=None, eager=None):
     if not hasattr(join, "__iter__"):
         join = (join,)
 
-    items = gamedata_session.query(Item).options(*processEager(eager)).join(*join)
+    items = get_gamedata_session().query(Item).options(*processEager(eager)).join(*join)
     for token in nameLike.split(' '):
-        token_safe = "%{0}%".format(sqlizeString(token))
+        token_safe = "%{0}%".format(sqlizeNormalString(token))
         if where is not None:
             items = items.filter(and_(Item.name.like(token_safe, escape="\\"), where))
         else:
@@ -308,14 +335,35 @@ def searchItems(nameLike, where=None, join=None, eager=None):
     return items
 
 
+@cachedQuery(3, "tokens", "where", "join")
+def searchItemsRegex(tokens, where=None, join=None, eager=None):
+    if not isinstance(tokens, (tuple, list)) or not all(isinstance(t, str) for t in tokens):
+        raise TypeError("Need tuple or list of strings as argument")
+
+    if join is None:
+        join = tuple()
+
+    if not hasattr(join, "__iter__"):
+        join = (join,)
+
+    items = get_gamedata_session().query(Item).options(*processEager(eager)).join(*join)
+    for token in tokens:
+        if where is not None:
+            items = items.filter(and_(Item.name.op('regexp')(token), where))
+        else:
+            items = items.filter(Item.name.op('regexp')(token))
+    items = items.limit(100).all()
+    return items
+
+
 @cachedQuery(3, "where", "nameLike", "join")
 def searchSkills(nameLike, where=None, eager=None):
     if not isinstance(nameLike, str):
         raise TypeError("Need string as argument")
 
-    items = gamedata_session.query(Item).options(*processEager(eager)).join(Item.group, Group.category)
+    items = get_gamedata_session().query(Item).options(*processEager(eager)).join(Item.group, Group.category)
     for token in nameLike.split(' '):
-        token_safe = "%{0}%".format(sqlizeString(token))
+        token_safe = "%{0}%".format(sqlizeNormalString(token))
         if where is not None:
             items = items.filter(and_(Item.name.like(token_safe, escape="\\"), Category.ID == 16, where))
         else:
@@ -333,11 +381,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 = get_gamedata_session().query(Item).options(*processEager(eager)).filter(filter).all()
 
     if vars:
         return vars
@@ -345,7 +391,7 @@ def getVariations(itemids, groupIDs=None, where=None, eager=None):
         itemfilter = or_(*(groups_table.c.groupID == groupID for groupID in groupIDs))
         filter = processWhere(itemfilter, where)
         joinon = items_table.c.groupID == groups_table.c.groupID
-        vars = gamedata_session.query(Item).options(*processEager(eager)).join((groups_table, joinon)).filter(
+        vars = get_gamedata_session().query(Item).options(*processEager(eager)).join((groups_table, joinon)).filter(
                 filter).all()
 
     return vars
@@ -360,7 +406,7 @@ def getAttributeInfo(attr, eager=None):
     else:
         raise TypeError("Need integer or string as argument")
     try:
-        result = gamedata_session.query(AttributeInfo).options(*processEager(eager)).filter(filter).one()
+        result = get_gamedata_session().query(AttributeInfo).options(*processEager(eager)).filter(filter).one()
     except exc.NoResultFound:
         result = None
     return result
@@ -369,7 +415,7 @@ def getAttributeInfo(attr, eager=None):
 @cachedQuery(1, "field")
 def getMetaData(field):
     if isinstance(field, str):
-        data = gamedata_session.query(MetaData).get(field)
+        data = get_gamedata_session().query(MetaData).get(field)
     else:
         raise TypeError("Need string as argument")
     return data
@@ -388,12 +434,12 @@ def directAttributeRequest(itemIDs, attrIDs):
                and_(Attribute.attributeID.in_(attrIDs), Item.typeID.in_(itemIDs)),
                from_obj=[join(Attribute, Item)])
 
-    result = gamedata_session.execute(q).fetchall()
+    result = get_gamedata_session().execute(q).fetchall()
     return result
 
 
 def getAbyssalTypes():
-    return set([r.resultingTypeID for r in gamedata_session.query(DynamicItem.resultingTypeID).distinct()])
+    return set([r.resultingTypeID for r in get_gamedata_session().query(DynamicItem.resultingTypeID).distinct()])
 
 
 @cachedQuery(1, "itemID")
@@ -401,9 +447,9 @@ def getDynamicItem(itemID, eager=None):
     try:
         if isinstance(itemID, int):
             if eager is None:
-                result = gamedata_session.query(DynamicItem).filter(DynamicItem.ID == itemID).one()
+                result = get_gamedata_session().query(DynamicItem).filter(DynamicItem.ID == itemID).one()
             else:
-                result = gamedata_session.query(DynamicItem).options(*processEager(eager)).filter(DynamicItem.ID == itemID).one()
+                result = get_gamedata_session().query(DynamicItem).options(*processEager(eager)).filter(DynamicItem.ID == itemID).one()
         else:
             raise TypeError("Need integer as argument")
     except exc.NoResultFound:
@@ -411,23 +457,7 @@ def getDynamicItem(itemID, eager=None):
     return result
 
 
-def getRequiredFor(itemID, attrMapping):
-    Attribute1 = aliased(Attribute)
-    Attribute2 = aliased(Attribute)
-
-    skillToLevelClauses = []
-
-    for attrSkill, attrLevel in attrMapping.items():
-        skillToLevelClauses.append(and_(Attribute1.attributeID == attrSkill, Attribute2.attributeID == attrLevel))
-
-    queryOr = or_(*skillToLevelClauses)
-
-    q = select((Attribute2.typeID, Attribute2.value),
-               and_(Attribute1.value == itemID, queryOr),
-               from_obj=[
-                   join(Attribute1, Attribute2, Attribute1.typeID == Attribute2.typeID)
-               ])
-
-    result = gamedata_session.execute(q).fetchall()
-
-    return result
+@cachedQuery(1, "lookfor")
+def getAllImplantSets():
+    implantSets = get_gamedata_session().query(ImplantSet).all()
+    return implantSets

eos/db/gamedata/traits.py

@@ -1,11 +1,21 @@
 from sqlalchemy import Column, Table, Integer, String, ForeignKey
-from sqlalchemy.orm import mapper
+from sqlalchemy.orm import mapper, synonym
 
 from eos.db import gamedata_meta
 from eos.gamedata import Traits
+import eos.config
 
-traits_table = Table("invtraits", gamedata_meta,
-                     Column("typeID", Integer, ForeignKey("invtypes.typeID"), primary_key=True),
-                     Column("traitText", String))
+traits_table = Table(
+    "invtraits",
+    gamedata_meta,
+    Column("typeID", Integer, ForeignKey("invtypes.typeID"), primary_key=True),
+    *[Column("traitText{}".format(lang), String) for lang in eos.config.translation_mapping.values()],
+)
 
-mapper(Traits, traits_table)
+mapper(
+    Traits,
+    traits_table,
+    properties={
+        "display": synonym("traitText{}".format(eos.config.lang)),
+    }
+)

eos/db/gamedata/unit.py

@@ -22,11 +22,13 @@ from sqlalchemy.orm import mapper, synonym
 
 from eos.db import gamedata_meta
 from eos.gamedata import Unit
+import eos.config
 
 groups_table = Table("dgmunits", gamedata_meta,
                      Column("unitID", Integer, primary_key=True),
                      Column("unitName", String),
-                     Column("displayName", String))
+                     *[Column("displayName{}".format(lang), String) for lang in eos.config.translation_mapping.values()],
+                     )
 
 mapper(Unit, groups_table,
        properties={

eos/db/migrations/__init__.py

@@ -8,43 +8,25 @@ many upgrade files as there are database versions (version 5 would include
 upgrade files 1-5)
 """
 
-import pkgutil
 import re
 
+from eos.utils.pyinst_support import iterNamespace
+
 updates = {}
 appVersion = 0
 
 prefix = __name__ + "."
 
-# load modules to work based with and without pyinstaller
-# from: https://github.com/webcomics/dosage/blob/master/dosagelib/loader.py
-# see: https://github.com/pyinstaller/pyinstaller/issues/1905
-
-# load modules using iter_modules()
-# (should find all filters in normal build, but not pyinstaller)
-module_names = [m[1] for m in pkgutil.iter_modules(__path__, prefix)]
-
-# special handling for PyInstaller
-importers = map(pkgutil.get_importer, __path__)
-toc = set()
-for i in importers:
-    if hasattr(i, 'toc'):
-        toc |= i.toc
-
-for elm in toc:
-    if elm.startswith(prefix):
-        module_names.append(elm)
-
-for modname in module_names:
+for modName in iterNamespace(__name__, __path__):
     # loop through python files, extracting update number and function, and
     # adding it to a list
-    modname_tail = modname.rsplit('.', 1)[-1]
-    module = __import__(modname, fromlist=True)
+    modname_tail = modName.rsplit('.', 1)[-1]
     m = re.match("^upgrade(?P<index>\d+)$", modname_tail)
     if not m:
         continue
     index = int(m.group("index"))
     appVersion = max(appVersion, index)
+    module = __import__(modName, fromlist=True)
     upgrade = getattr(module, "upgrade", False)
     if upgrade:
         updates[index] = upgrade

eos/db/migrations/upgrade17.py

@@ -33,9 +33,13 @@ def upgrade(saveddata_engine):
                 try:
                     saveddata_session.execute(commandFits_table.insert(),
                                               {"boosterID": value, "boostedID": boosted, "active": 1})
+                except (KeyboardInterrupt, SystemExit):
+                    raise
                 except Exception:
                     pass
         saveddata_session.commit()
+    except (KeyboardInterrupt, SystemExit):
+        raise
     except:
         # Shouldn't fail unless you have updated database without the old fleet schema and manually modify the database version
         # If it does, simply fail. Fleet data migration isn't critically important here

eos/db/migrations/upgrade25.py

@@ -4235,6 +4235,8 @@ def upgrade(saveddata_engine):
 
             # And last but not least, delete the last subsystem
             saveddata_engine.execute("DELETE FROM modules WHERE ID = ?", (oldModules[4][0],))
+        except (KeyboardInterrupt, SystemExit):
+            raise
         except:
             # if something fails, fuck it, we tried. It'll default to the generic conversion below
             continue

eos/db/migrations/upgrade31.py

@@ -0,0 +1,15 @@
+"""
+Migration 31
+
+- added fit system security column
+"""
+
+
+import sqlalchemy
+
+
+def upgrade(saveddata_engine):
+    try:
+        saveddata_engine.execute("SELECT systemSecurity FROM fits LIMIT 1")
+    except sqlalchemy.exc.DatabaseError:
+        saveddata_engine.execute("ALTER TABLE fits ADD COLUMN systemSecurity INT")

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/migrations/upgrade35.py

@@ -0,0 +1,166 @@
+"""
+Migration 35
+
+- Remove builtin damage patterns and target profiles from the database
+"""
+
+import sqlalchemy
+
+
+dmgPatterns = (
+    'Uniform',
+    '[Bombs]Concussion Bomb',
+    '[Bombs]Electron Bomb',
+    '[Bombs]Scorch Bomb',
+    '[Bombs]Shrapnel Bomb',
+    '[Exotic Plasma]Baryon',
+    '[Exotic Plasma]Meson',
+    '[Exotic Plasma]Tetryon',
+    '[Exotic Plasma][T2] Mystic',
+    '[Exotic Plasma][T2] Occult',
+    '[Frequency Crystals]Gamma',
+    '[Frequency Crystals]Infrared',
+    '[Frequency Crystals]Microwave',
+    '[Frequency Crystals]Multifrequency',
+    '[Frequency Crystals]Radio',
+    '[Frequency Crystals]Standard',
+    '[Frequency Crystals]Ultraviolet',
+    '[Frequency Crystals]Xray',
+    '[Frequency Crystals][T2] Aurora',
+    '[Frequency Crystals][T2] Conflagration',
+    '[Frequency Crystals][T2] Gleam',
+    '[Frequency Crystals][T2] Scorch',
+    '[Generic]EM',
+    '[Generic]Explosive',
+    '[Generic]Kinetic',
+    '[Generic]Thermal',
+    '[Hybrid Charges]Antimatter',
+    '[Hybrid Charges]Iridium',
+    '[Hybrid Charges]Iron',
+    '[Hybrid Charges]Lead',
+    '[Hybrid Charges]Plutonium',
+    '[Hybrid Charges]Thorium',
+    '[Hybrid Charges]Tungsten',
+    '[Hybrid Charges]Uranium',
+    '[Hybrid Charges][T2] Javelin',
+    '[Hybrid Charges][T2] Null',
+    '[Hybrid Charges][T2] Spike',
+    '[Hybrid Charges][T2] Void',
+    '[Missiles]Inferno',
+    '[Missiles]Mjolnir',
+    '[Missiles]Nova',
+    '[Missiles]Scourge',
+    '[Missiles][Structure) Standup Missile',
+    '[Missiles][Structure] Standup Missile',
+    '[NPC][Asteroid] Angel Cartel',
+    '[NPC][Asteroid] Blood Raiders',
+    '[NPC][Asteroid] Guristas',
+    '[NPC][Asteroid] Rogue Drone',
+    '[NPC][Asteroid] Sanshas Nation',
+    '[NPC][Asteroid] Serpentis',
+    '[NPC][Burner] Ashimmu (Blood Raiders)',
+    '[NPC][Burner] Cruor (Blood Raiders)',
+    '[NPC][Burner] Daredevil (Serpentis)',
+    '[NPC][Burner] Dramiel (Angel)',
+    '[NPC][Burner] Enyo',
+    '[NPC][Burner] Hawk',
+    '[NPC][Burner] Jaguar',
+    '[NPC][Burner] Sentinel',
+    '[NPC][Burner] Succubus (Sanshas Nation)',
+    '[NPC][Burner] Talos',
+    '[NPC][Burner] Vengeance',
+    '[NPC][Burner] Worm (Guristas)',
+    '[NPC][Deadspace] Angel Cartel',
+    '[NPC][Deadspace] Blood Raiders',
+    '[NPC][Deadspace] Guristas',
+    '[NPC][Deadspace] Rogue Drone',
+    '[NPC][Deadspace] Sanshas Nation',
+    '[NPC][Deadspace] Serpentis',
+    '[NPC][Mission] Amarr Empire',
+    '[NPC][Mission] CONCORD',
+    '[NPC][Mission] Caldari State',
+    '[NPC][Mission] Gallente Federation',
+    '[NPC][Mission] Khanid',
+    '[NPC][Mission] Minmatar Republic',
+    '[NPC][Mission] Mordus Legion',
+    '[NPC][Mission] Thukker',
+    '[NPC][Other] Sansha Incursion',
+    '[NPC][Other] Sleepers',
+    '[Projectile Ammo]Carbonized Lead',
+    '[Projectile Ammo]Depleted Uranium',
+    '[Projectile Ammo]EMP',
+    '[Projectile Ammo]Fusion',
+    '[Projectile Ammo]Nuclear',
+    '[Projectile Ammo]Phased Plasma',
+    '[Projectile Ammo]Proton',
+    '[Projectile Ammo]Titanium Sabot',
+    '[Projectile Ammo][T2] Barrage',
+    '[Projectile Ammo][T2] Hail',
+    '[Projectile Ammo][T2] Quake',
+    '[Projectile Ammo][T2] Tremor')
+
+tgtProfiles = (
+    'Uniform (25%)',
+    'Uniform (50%)',
+    'Uniform (75%)',
+    'Uniform (90%)',
+    '[NPC][Asteroid] Angel Cartel',
+    '[NPC][Asteroid] Blood Raiders',
+    '[NPC][Asteroid] Guristas',
+    '[NPC][Asteroid] Rogue Drones',
+    '[NPC][Asteroid] Sanshas Nation',
+    '[NPC][Asteroid] Serpentis',
+    '[NPC][Burner] Ashimmu (Blood Raiders)',
+    '[NPC][Burner] Cruor (Blood Raiders)',
+    '[NPC][Burner] Daredevil (Serpentis)',
+    '[NPC][Burner] Dramiel (Angel)',
+    '[NPC][Burner] Enyo',
+    '[NPC][Burner] Hawk',
+    '[NPC][Burner] Jaguar',
+    '[NPC][Burner] Sentinel',
+    '[NPC][Burner] Succubus (Sanshas Nation)',
+    '[NPC][Burner] Talos',
+    '[NPC][Burner] Vengeance',
+    '[NPC][Burner] Worm (Guristas)',
+    '[NPC][Deadspace] Angel Cartel',
+    '[NPC][Deadspace] Blood Raiders',
+    '[NPC][Deadspace] Guristas',
+    '[NPC][Deadspace] Rogue Drones',
+    '[NPC][Deadspace] Sanshas Nation',
+    '[NPC][Deadspace] Serpentis',
+    '[NPC][Mission] Amarr Empire',
+    '[NPC][Mission] CONCORD',
+    '[NPC][Mission] Caldari State',
+    '[NPC][Mission] Gallente Federation',
+    '[NPC][Mission] Khanid',
+    '[NPC][Mission] Minmatar Republic',
+    '[NPC][Mission] Mordus Legion',
+    '[NPC][Other] Sansha Incursion',
+    '[NPC][Other] Sleeper',
+    '[T1 Resist]Armor',
+    '[T1 Resist]Armor (+T2 DCU)',
+    '[T1 Resist]Hull',
+    '[T1 Resist]Hull (+T2 DCU)',
+    '[T1 Resist]Shield',
+    '[T1 Resist]Shield (+T2 DCU)',
+    '[T2 Resist]Amarr (Armor)',
+    '[T2 Resist]Amarr (Shield)',
+    '[T2 Resist]Caldari (Armor)',
+    '[T2 Resist]Caldari (Shield)',
+    '[T2 Resist]Gallente (Armor)',
+    '[T2 Resist]Gallente (Shield)',
+    '[T2 Resist]Minmatar (Armor)',
+    '[T2 Resist]Minmatar (Shield)')
+
+
+def upgrade(saveddata_engine):
+    saveddata_engine.execute('DELETE FROM damagePatterns WHERE name in ({});'.format(', '.join('\'{}\''.format(n) for n in dmgPatterns)))
+    saveddata_engine.execute('DELETE FROM targetResists WHERE name in ({});'.format(', '.join('\'{}\''.format(n) for n in tgtProfiles)))
+    try:
+        saveddata_engine.execute("SELECT builtinDamagePatternID FROM fits LIMIT 1")
+    except sqlalchemy.exc.DatabaseError:
+        saveddata_engine.execute("ALTER TABLE fits ADD COLUMN builtinDamagePatternID INT;")
+    try:
+        saveddata_engine.execute("SELECT builtinTargetResistsID FROM fits LIMIT 1")
+    except sqlalchemy.exc.DatabaseError:
+        saveddata_engine.execute("ALTER TABLE fits ADD COLUMN builtinTargetResistsID INT;")

eos/db/migrations/upgrade36.py

@@ -0,0 +1,84 @@
+"""
+Migration 36
+
+- Shield Booster, Armor Repairer and Capacitor Transfer tiericide
+"""
+
+CONVERSIONS = {
+    6441: (  # Small Clarity Ward Enduring Shield Booster
+        6443,  # Small Converse Deflection Catalyzer
+    ),
+    6437: (  # Small C5-L Compact Shield Booster
+        6439,  # Small Neutron Saturation Injector I
+    ),
+    10868: (  # Medium Clarity Ward Enduring Shield Booster
+        10870,  # Medium Converse Deflection Catalyzer
+    ),
+    10872: (  # Medium C5-L Compact Shield Booster
+        10866,  # Medium Neutron Saturation Injector I
+    ),
+    10876: (  # Large Clarity Ward Enduring Shield Booster
+        10878,  # Large Converse Deflection Catalyzer
+    ),
+    10880: (  # Large C5-L Compact Shield Booster
+        10874,  # Large Neutron Saturation Injector I
+    ),
+    10884: (  # X-Large Clarity Ward Enduring Shield Booster
+        10886,  # X-Large Converse Deflection Catalyzer
+    ),
+    10888: (  # X-Large C5-L Compact Shield Booster
+        10882,  # X-Large Neutron Saturation Injector I
+    ),
+    4533: (  # Small ACM Compact Armor Repairer
+        4531,  # Small Inefficient Armor Repair Unit
+    ),
+    4529: (  # Small I-a Enduring Armor Repairer
+        4535,  # Small Automated Carapace Restoration
+    ),
+    4573: (  # Medium ACM Compact Armor Repairer
+        4571,  # Medium Inefficient Armor Repair Unit
+    ),
+    4569: (  # Medium I-a Enduring Armor Repairer
+        4575,  # Medium Automated Carapace Restoration
+    ),
+    22889: (  # 'Meditation' Medium Armor Repairer I
+        4579,  # Medium Nano Armor Repair Unit I
+    ),
+    4613: (  # Large ACM Compact Armor Repairer
+        4611,  # Large Inefficient Armor Repair Unit
+    ),
+    4609: (  # Large I-a Enduring Armor Repairer
+        4615,  # Large Automated Carapace Restoration
+    ),
+    22891: (  # 'Protest' Large Armor Repairer I
+        4621,  # Large 'Reprieve' Vestment Reconstructer I
+    ),
+    5093: (  # Small Radiative Scoped Remote Capacitor Transmitter
+        5087,  # Small Partial E95a Remote Capacitor Transmitter
+    ),
+    5091: (  # Small Inductive Compact Remote Capacitor Transmitter
+        5089,  # Small Murky Remote Capacitor Transmitter
+    ),
+    16489: (  # Medium Radiative Scoped Remote Capacitor Transmitter
+        16493,  # Medium Partial E95b Remote Capacitor Transmitter
+    ),
+    16495: (  # Medium Inductive Compact Remote Capacitor Transmitter
+        16491,  # Medium Murky Remote Capacitor Transmitter
+    ),
+    16481: (  # Large Radiative Scoped Remote Capacitor Transmitter
+        16485,  # Large Partial E95c Remote Capacitor Transmitter
+    ),
+    16487: (  # Large Inductive Compact Remote Capacitor Transmitter
+        16483,  # Large Murky Remote Capacitor Transmitter
+    )
+}
+
+
+def upgrade(saveddata_engine):
+    # Convert modules
+    for replacement_item, list in CONVERSIONS.items():
+        for retired_item in list:
+            saveddata_engine.execute('UPDATE "modules" SET "itemID" = ? WHERE "itemID" = ?',
+                                     (replacement_item, retired_item))
+            saveddata_engine.execute('UPDATE "cargo" SET "itemID" = ? WHERE "itemID" = ?',
+                                     (replacement_item, retired_item))

eos/db/migrations/upgrade37.py

@@ -0,0 +1,44 @@
+"""
+Migration 37
+
+- Capacitor Booster tiericide
+"""
+
+CONVERSIONS = {
+    4959: (  # 'Seed' Micro Capacitor Booster I
+        4957,  # Micro Brief Capacitor Overcharge I
+        4961,  # Micro Tapered Capacitor Infusion I
+        4955,  # Micro F-RX Prototype Capacitor Boost
+        3556,  # Micro Capacitor Booster I
+        3558,  # Micro Capacitor Booster II
+        15774,  # Ammatar Navy Micro Capacitor Booster
+        14180,  # Dark Blood Micro Capacitor Booster
+        14182,  # True Sansha Micro Capacitor Booster
+        15782,  # Imperial Navy Micro Capacitor Booster
+    ),
+    5011: (  # Small F-RX Compact Capacitor Booster
+        5009,  # Small Brief Capacitor Overcharge I
+        5013,  # Small Tapered Capacitor Infusion I
+        5007,  # Small F-RX Prototype Capacitor Boost
+    ),
+    4833: (  # Medium F-RX Compact Capacitor Booster
+        4831,  # Medium Brief Capacitor Overcharge I
+        4835,  # Medium Tapered Capacitor Infusion I
+        4829,  # Medium F-RX Prototype Capacitor Boost
+    ),
+    5051: (  # Heavy F-RX Compact Capacitor Booster
+        5049,  # Heavy Brief Capacitor Overcharge I
+        5053,  # Heavy Tapered Capacitor Infusion I
+        5047,  # Heavy F-RX Prototype Capacitor Boost
+    )
+}
+
+
+def upgrade(saveddata_engine):
+    # Convert modules
+    for replacement_item, list in CONVERSIONS.items():
+        for retired_item in list:
+            saveddata_engine.execute('UPDATE "modules" SET "itemID" = ? WHERE "itemID" = ?',
+                                     (replacement_item, retired_item))
+            saveddata_engine.execute('UPDATE "cargo" SET "itemID" = ? WHERE "itemID" = ?',
+                                     (replacement_item, retired_item))

eos/db/migrations/upgrade38.py

@@ -0,0 +1,42 @@
+"""
+Migration 38
+
+- Armor hardener tiericide
+"""
+
+CONVERSIONS = {
+    16357: (  # Experimental Enduring EM Armor Hardener I
+        16353,  # Upgraded Armor EM Hardener I
+    ),
+    16365: (  # Experimental Enduring Explosive Armor Hardener I
+        16361,  # Upgraded Armor Explosive Hardener I
+    ),
+    16373: (  # Experimental Enduring Kinetic Armor Hardener I
+        16369,  # Upgraded Armor Kinetic Hardener I
+    ),
+    16381: (  # Experimental Enduring Thermal Armor Hardener I
+        16377,  # Upgraded Armor Thermal Hardener I
+    ),
+    16359: (  # Prototype Compact EM Armor Hardener I
+        16355,  # Limited Armor EM Hardener I
+    ),
+    16367: (  # Prototype Compact Explosive Armor Hardener I
+        16363,  # Limited Armor Explosive Hardener I
+    ),
+    16375: (  # Prototype Compact Kinetic Armor Hardener I
+        16371,  # Limited Armor Kinetic Hardener I
+    ),
+    16383: (  # Prototype Compact Thermal Armor Hardener I
+        16379,  # Limited Armor Thermal Hardener I
+    )
+}
+
+
+def upgrade(saveddata_engine):
+    # Convert modules
+    for replacement_item, list in CONVERSIONS.items():
+        for retired_item in list:
+            saveddata_engine.execute('UPDATE "modules" SET "itemID" = ? WHERE "itemID" = ?',
+                                     (replacement_item, retired_item))
+            saveddata_engine.execute('UPDATE "cargo" SET "itemID" = ? WHERE "itemID" = ?',
+                                     (replacement_item, retired_item))

eos/db/migrations/upgrade39.py

@@ -0,0 +1,34 @@
+"""
+Migration 39
+
+- Shield amplifier tiericide
+- CCP getting rid of DB TDs due to exploits
+"""
+
+CONVERSIONS = {
+    1798: (  # 'Basic' EM Shield Amplifier
+        9562,  # Supplemental EM Ward Amplifier
+    ),
+    1804: (  # 'Basic' Explosive Shield Amplifier
+        9574,  # Supplemental Explosive Deflection Amplifier
+    ),
+    1802: (  # 'Basic' Kinetic Shield Amplifier
+        9570,  # Supplemental Kinetic Deflection Amplifier
+    ),
+    1800: (  # 'Basic' Thermal Shield Amplifier
+        9566,  # Supplemental Thermal Dissipation Amplifier
+    ),
+    22933: (  # 'Investor' Tracking Disruptor I
+        32416,  # Dark Blood Tracking Disruptor
+    )
+}
+
+
+def upgrade(saveddata_engine):
+    # Convert modules
+    for replacement_item, list in CONVERSIONS.items():
+        for retired_item in list:
+            saveddata_engine.execute('UPDATE "modules" SET "itemID" = ? WHERE "itemID" = ?',
+                                     (replacement_item, retired_item))
+            saveddata_engine.execute('UPDATE "cargo" SET "itemID" = ? WHERE "itemID" = ?',
+                                     (replacement_item, retired_item))

eos/db/migrations/upgrade40.py

@@ -0,0 +1,18 @@
+"""
+Migration 40
+
+Imports all item conversions since Migration 28 and runs them against module.baseItemID. This column seems to have been
+forgotten about since it's been added.
+
+"""
+from .upgrade36 import CONVERSIONS as u36
+from .upgrade37 import CONVERSIONS as u37
+from .upgrade38 import CONVERSIONS as u38
+from .upgrade39 import CONVERSIONS as u39
+
+def upgrade(saveddata_engine):
+    for conversions in [u36, u37, u38, u39]:
+        for replacement_item, list in conversions.items():
+            for retired_item in list:
+                saveddata_engine.execute('UPDATE "modules" SET "baseItemID" = ? WHERE "baseItemID" = ?',
+                               (replacement_item, retired_item))

eos/db/migrations/upgrade41.py

@@ -0,0 +1,50 @@
+"""
+Migration 41
+
+- Resistance plating tiericide
+"""
+
+CONVERSIONS = {
+    16345: (  # Upgraded Layered Coating I
+        16347,  # Limited Layered Plating I
+        16349,  # 'Scarab' Layered Plating I
+        16351,  # 'Grail' Layered Plating I
+    ),
+    16305: (  # Upgraded Multispectrum Coating I
+        16307,  # Limited Adaptive Nano Plating I
+        16309,  # 'Collateral' Adaptive Nano Plating I
+        16311,  # 'Refuge' Adaptive Nano Plating I
+    ),
+    16329: (  # Upgraded EM Coating I
+        16331,  # Limited EM Plating I
+        16333,  # 'Contour' EM Plating I
+        16335,  # 'Spiegel' EM Plating I
+    ),
+    16321: (  # Upgraded Explosive Coating I
+        16323,  # Limited Explosive Plating I
+        16325,  # Experimental Explosive Plating I
+        16319,  # 'Aegis' Explosive Plating I
+    ),
+    16313: (  # Upgraded Kinetic Coating I
+        16315,  # Limited Kinetic Plating I
+        16317,  # Experimental Kinetic Plating I
+        16327,  # 'Element' Kinetic Plating I
+    ),
+    16337: (  # Upgraded Thermal Coating I
+        16339,  # Limited Thermal Plating I
+        16341,  # Experimental Thermal Plating I
+        16343,  # Prototype Thermal Plating I
+    )
+}
+
+
+def upgrade(saveddata_engine):
+    # Convert modules
+    for replacement_item, list in CONVERSIONS.items():
+        for retired_item in list:
+            saveddata_engine.execute('UPDATE "modules" SET "itemID" = ? WHERE "itemID" = ?',
+                                     (replacement_item, retired_item))
+            saveddata_engine.execute('UPDATE "modules" SET "baseItemID" = ? WHERE "baseItemID" = ?',
+                                     (replacement_item, retired_item))
+            saveddata_engine.execute('UPDATE "cargo" SET "itemID" = ? WHERE "itemID" = ?',
+                                     (replacement_item, retired_item))

eos/db/migrations/upgrade42.py

@@ -0,0 +1,50 @@
+"""
+Migration 42
+
+- Resistance membrane tiericide
+"""
+
+CONVERSIONS = {
+    16391: (  # Compact Multispectrum Energized Membrane
+        16389,  # Experimental Energized Adaptive Nano Membrane I
+        16387,  # Limited Energized Adaptive Nano Membrane I
+        16385,  # Upgraded Energized Adaptive Nano Membrane I
+    ),
+    16423: (  # Compact Layered Energized Membrane
+        16421,  # Experimental Energized Armor Layering Membrane I
+        16419,  # Limited Energized Armor Layering Membrane I
+        16417,  # Upgraded Energized Armor Layering Membrane I
+    ),
+    16415: (  # Compact EM Energized Membrane
+        16413,  # Experimental Energized EM Membrane I
+        16411,  # Limited Energized EM Membrane I
+        16409,  # Upgraded Energized EM Membrane I
+    ),
+    16407: (  # Compact Explosive Energized Membrane
+        16405,  # Experimental Energized Explosive Membrane I
+        16403,  # Limited Energized Explosive Membrane I
+        16401,  # Upgraded Energized Explosive Membrane I
+    ),
+    16399: (  # Compact Kinetic Energized Membrane
+        16397,  # Experimental Energized Kinetic Membrane I
+        16395,  # Limited Energized Kinetic Membrane I
+        16393,  # Upgraded Energized Kinetic Membrane I
+    ),
+    16431: (  # Compact Thermal Energized Membrane
+        16429,  # Experimental Energized Thermal Membrane I
+        16427,  # Limited Energized Thermal Membrane I
+        16425,  # Upgraded Energized Thermal Membrane I
+    )
+}
+
+
+def upgrade(saveddata_engine):
+    # Convert modules
+    for replacement_item, list in CONVERSIONS.items():
+        for retired_item in list:
+            saveddata_engine.execute('UPDATE "modules" SET "itemID" = ? WHERE "itemID" = ?',
+                                     (replacement_item, retired_item))
+            saveddata_engine.execute('UPDATE "modules" SET "baseItemID" = ? WHERE "baseItemID" = ?',
+                                     (replacement_item, retired_item))
+            saveddata_engine.execute('UPDATE "cargo" SET "itemID" = ? WHERE "itemID" = ?',
+                                     (replacement_item, retired_item))

eos/db/migrations/upgrade43.py

@@ -0,0 +1,26 @@
+"""
+Migration 43
+
+- Shield booster amplifier tiericide
+"""
+
+CONVERSIONS = {
+    16533: (  # Stalwart Restrained Shield Boost Amplifier
+        16531,  # 5a Prototype Shield Support I
+    ),
+    16535: (  # Copasetic Compact Shield Boost Amplifier
+        16529,  # Ionic Field Accelerator I
+    ),
+}
+
+
+def upgrade(saveddata_engine):
+    # Convert modules
+    for replacement_item, list in CONVERSIONS.items():
+        for retired_item in list:
+            saveddata_engine.execute('UPDATE "modules" SET "itemID" = ? WHERE "itemID" = ?',
+                                     (replacement_item, retired_item))
+            saveddata_engine.execute('UPDATE "modules" SET "baseItemID" = ? WHERE "baseItemID" = ?',
+                                     (replacement_item, retired_item))
+            saveddata_engine.execute('UPDATE "cargo" SET "itemID" = ? WHERE "itemID" = ?',
+                                     (replacement_item, retired_item))

eos/db/migrations/upgrade44.py

@@ -0,0 +1,25 @@
+"""
+Migration 44
+
+- Signal distortion amplifier tiericide
+"""
+
+CONVERSIONS = {
+    25565: (  # Hypnos Compact Signal Distortion Amplifier I
+        25571,  # Initiated Signal Distortion Amplifier I
+        25569,  # Induced Signal Distortion Amplifier I
+        25567,  # Compulsive Signal Distortion Amplifier I
+    ),
+}
+
+
+def upgrade(saveddata_engine):
+    # Convert modules
+    for replacement_item, list in CONVERSIONS.items():
+        for retired_item in list:
+            saveddata_engine.execute('UPDATE "modules" SET "itemID" = ? WHERE "itemID" = ?',
+                                     (replacement_item, retired_item))
+            saveddata_engine.execute('UPDATE "modules" SET "baseItemID" = ? WHERE "baseItemID" = ?',
+                                     (replacement_item, retired_item))
+            saveddata_engine.execute('UPDATE "cargo" SET "itemID" = ? WHERE "itemID" = ?',
+                                     (replacement_item, retired_item))

eos/db/saveddata/__init__.py

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

eos/db/saveddata/booster.py

@@ -24,11 +24,12 @@ import datetime
 from eos.db import saveddata_meta
 from eos.saveddata.booster import Booster
 from eos.saveddata.boosterSideEffect import BoosterSideEffect
+from eos.saveddata.fit import Fit
 
 boosters_table = Table("boosters", saveddata_meta,
                        Column("ID", Integer, primary_key=True),
                        Column("itemID", Integer),
-                       Column("fitID", Integer, ForeignKey("fits.ID"), nullable=False),
+                       Column("fitID", Integer, ForeignKey("fits.ID"), nullable=False, index=True),
                        Column("active", Boolean),
                        Column("created", DateTime, nullable=True, default=datetime.datetime.now),
                        Column("modified", DateTime, nullable=True, onupdate=datetime.datetime.now),
@@ -44,6 +45,7 @@ booster_side_effect_table = Table("boosterSideEffects", saveddata_meta,
 
 mapper(Booster, boosters_table,
        properties={
+        "owner": relation(Fit),
         "_Booster__sideEffects": relation(
             BoosterSideEffect,
             backref="booster",

eos/db/saveddata/character.py

@@ -23,7 +23,7 @@ import datetime
 
 from eos.db import saveddata_meta
 from eos.db.saveddata.implant import charImplants_table
-from eos.effectHandlerHelpers import HandledImplantBoosterList, HandledSsoCharacterList
+from eos.effectHandlerHelpers import HandledImplantList, HandledSsoCharacterList
 from eos.saveddata.implant import Implant
 from eos.saveddata.user import User
 from eos.saveddata.character import Character, Skill
@@ -75,7 +75,7 @@ mapper(Character, characters_table,
                    cascade="all,delete-orphan"),
            "_Character__implants"    : relation(
                    Implant,
-                   collection_class=HandledImplantBoosterList,
+                   collection_class=HandledImplantList,
                    cascade='all,delete-orphan',
                    backref='character',
                    single_parent=True,

eos/db/saveddata/damagePattern.py

@@ -17,23 +17,27 @@
 # 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
 
 from eos.db import saveddata_meta
 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("ownerID", ForeignKey("users.ID"), nullable=True),
-                             Column("created", DateTime, nullable=True, default=datetime.datetime.now),
-                             Column("modified", DateTime, nullable=True, onupdate=datetime.datetime.now)
-                             )
+damagePatterns_table = Table(
+    'damagePatterns',
+    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(DamagePattern, damagePatterns_table)
+mapper(
+    DamagePattern,
+    damagePatterns_table,
+    properties={'rawName': damagePatterns_table.c.name})

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
@@ -31,7 +31,7 @@ from eos.db.saveddata.drone import drones_table
 from eos.db.saveddata.fighter import fighters_table
 from eos.db.saveddata.implant import fitImplants_table
 from eos.db.saveddata.module import modules_table
-from eos.effectHandlerHelpers import HandledDroneCargoList, HandledImplantBoosterList, HandledModuleList, HandledProjectedDroneList, HandledProjectedModList
+from eos.effectHandlerHelpers import HandledDroneCargoList, HandledImplantList, HandledBoosterList, HandledModuleList, HandledProjectedDroneList, HandledProjectedModList
 from eos.saveddata.booster import Booster
 from eos.saveddata.cargo import Cargo
 from eos.saveddata.character import Character
@@ -41,9 +41,10 @@ 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
 
+
 fits_table = Table("fits", saveddata_meta,
                    Column("ID", Integer, primary_key=True),
                    Column("ownerID", ForeignKey("users.ID"), nullable=True, index=True),
@@ -52,14 +53,17 @@ fits_table = Table("fits", saveddata_meta,
                    Column("timestamp", Integer, nullable=False),
                    Column("characterID", ForeignKey("characters.ID"), nullable=True),
                    Column("damagePatternID", ForeignKey("damagePatterns.ID"), nullable=True),
+                   Column("builtinDamagePatternID", Integer, nullable=True),
                    Column("booster", Boolean, nullable=False, index=True, default=0),
                    Column("targetResistsID", ForeignKey("targetResists.ID"), nullable=True),
+                   Column("builtinTargetResistsID", Integer, nullable=True),
                    Column("modeID", Integer, nullable=True),
                    Column("implantLocation", Integer, nullable=False),
                    Column("notes", String, nullable=True),
                    Column("ignoreRestrictions", Boolean, default=0),
                    Column("created", DateTime, nullable=True, default=datetime.datetime.now),
-                   Column("modified", DateTime, nullable=True, default=datetime.datetime.now, onupdate=datetime.datetime.now)
+                   Column("modified", DateTime, nullable=True, default=datetime.datetime.now, onupdate=datetime.datetime.now),
+                   Column("systemSecurity", Integer, nullable=True)
                    )
 
 projectedFits_table = Table("projectedFits", saveddata_meta,
@@ -68,7 +72,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,
@@ -80,7 +85,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
@@ -111,7 +117,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
@@ -183,9 +189,8 @@ mapper(es_Fit, fits_table,
            "shipID": fits_table.c.shipID,
            "_Fit__boosters": relation(
                    Booster,
-                   collection_class=HandledImplantBoosterList,
+                   collection_class=HandledBoosterList,
                    cascade='all, delete, delete-orphan',
-                   backref='owner',
                    single_parent=True),
            "_Fit__drones": relation(
                    Drone,
@@ -219,7 +224,7 @@ mapper(es_Fit, fits_table,
                    primaryjoin=and_(fighters_table.c.fitID == fits_table.c.ID, fighters_table.c.projected == True)),  # noqa
            "_Fit__implants": relation(
                    Implant,
-                   collection_class=HandledImplantBoosterList,
+                   collection_class=HandledImplantList,
                    cascade='all, delete, delete-orphan',
                    backref='owner',
                    single_parent=True,
@@ -229,8 +234,10 @@ mapper(es_Fit, fits_table,
            "_Fit__character": relation(
                    Character,
                    backref="fits"),
-           "_Fit__damagePattern": relation(DamagePattern),
-           "_Fit__targetResists": relation(TargetResists),
+           "_Fit__userDamagePattern": relation(DamagePattern),
+           "_Fit__builtinDamagePatternID": fits_table.c.builtinDamagePatternID,
+           "_Fit__userTargetProfile": relation(TargetProfile),
+           "_Fit__builtinTargetProfileID": fits_table.c.builtinTargetResistsID,
            "projectedOnto": projectedFitSourceRel,
            "victimOf": relationship(
                    ProjectedFit,

eos/db/saveddata/implantSet.py

@@ -23,7 +23,7 @@ import datetime
 
 from eos.db import saveddata_meta
 from eos.db.saveddata.implant import implantsSetMap_table
-from eos.effectHandlerHelpers import HandledImplantBoosterList
+from eos.effectHandlerHelpers import HandledImplantList
 from eos.saveddata.implant import Implant
 from eos.saveddata.implantSet import ImplantSet
 
@@ -38,7 +38,7 @@ mapper(ImplantSet, implant_set_table,
        properties={
            "_ImplantSet__implants": relation(
                    Implant,
-                   collection_class=HandledImplantBoosterList,
+                   collection_class=HandledImplantList,
                    cascade='all, delete, delete-orphan',
                    backref='set',
                    single_parent=True,

eos/db/saveddata/loadDefaultDatabaseValues.py

@@ -1,198 +0,0 @@
-# ===============================================================================
-# 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.db
-from eos.saveddata.damagePattern import DamagePattern as es_DamagePattern
-from eos.saveddata.targetResists import TargetResists as es_TargetResists
-
-
-class ImportError(Exception):
-    pass
-
-
-class DefaultDatabaseValues(object):
-    def __init__(self):
-        pass
-
-    instance = None
-
-    @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]Concussion Bomb", "0", "0", "6400", "0"],
-                             ["[Bombs]Electron Bomb", "6400", "0", "0", "0"],
-                             ["[Bombs]Scorch Bomb", "0", "6400", "0", "0"],
-                             ["[Bombs]Shrapnel Bomb", "0", "0", "0", "6400"],
-                             ["[Frequency Crystals][T2] Gleam", "56", "56", "0", "0"],
-                             ["[Frequency Crystals][T2] Aurora", "40", "24", "0", "0"],
-                             ["[Frequency Crystals][T2] Scorch", "72", "16", "0", "0"],
-                             ["[Frequency Crystals][T2] Conflagration", "61.6", "61.6", "0", "0"],
-                             ["[Frequency Crystals]Gamma", "61.6", "35.2", "0", "0"],
-                             ["[Frequency Crystals]Infrared", "44", "17.6", "0", "0"],
-                             ["[Frequency Crystals]Microwave", "35.2", "17.6", "0", "0"],
-                             ["[Frequency Crystals]Multifrequency", "61.6", "44", "0", "0"],
-                             ["[Frequency Crystals]Radio", "44", "0", "0", "0"],
-                             ["[Frequency Crystals]Standard", "44", "26.4", "0", "0"],
-                             ["[Frequency Crystals]Ultraviolet", "52.8", "26.4", "0", "0"],
-                             ["[Frequency Crystals]Xray", "52.8", "35.2", "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]Iridium", "0", "28.8", "38.4", "0"],
-                             ["[Hybrid Charges]Iron", "0", "19.2", "28.8", "0"],
-                             ["[Hybrid Charges]Lead", "0", "28.8", "48", "0"],
-                             ["[Hybrid Charges]Plutonium", "0", "48", "57.6", "0"],
-                             ["[Hybrid Charges]Thorium", "0", "38.4", "48", "0"],
-                             ["[Hybrid Charges]Tungsten", "0", "19.2", "38.4", "0"],
-                             ["[Hybrid Charges]Uranium", "0", "38.4", "57.6", "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] Tremor", "0", "0", "24", "40"],
-                             ["[Projectile Ammo][T2] Quake", "0", "0", "40", "72"],
-                             ["[Projectile Ammo][T2] Hail", "0", "0", "26.4", "96.8"],
-                             ["[Projectile Ammo][T2] Barrage", "0", "0", "40", "48"],
-                             ["[Projectile Ammo]Carbonized Lead", "0", "0", "35.2", "8.8"],
-                             ["[Projectile Ammo]Depleted Uranium", "0", "26.4", "17.6", "26.4"],
-                             ["[Projectile Ammo]EMP", "79.2", "0", "8.8", "17.6"],
-                             ["[Projectile Ammo]Fusion", "0", "0", "17.6", "88"],
-                             ["[Projectile Ammo]Nuclear", "0", "0", "8.8", "35.2"],
-                             ["[Projectile Ammo]Phased Plasma", "0", "88", "17.6", "0"],
-                             ["[Projectile Ammo]Proton", "26.4", "0", "17.6", "0"],
-                             ["[Projectile Ammo]Titanium Sabot", "0", "0", "52.8", "176"],
-                             ["[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
-            damageProfile = eos.db.getDamagePattern(name)
-            if damageProfile is None:
-                damageProfile = es_DamagePattern(em, therm, kin, exp)
-                damageProfile.name = name
-                eos.db.save(damageProfile)
-
-    @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"]]
-
-        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"]]
-
-        for damageProfileRow in damageProfileList:
-            name, em, therm, kin, exp = damageProfileRow
-            damageProfile = eos.db.getDamagePattern(name)
-            if damageProfile is None:
-                damageProfile = es_DamagePattern(em, therm, kin, exp)
-                damageProfile.name = name
-                eos.db.save(damageProfile)

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
 
@@ -402,28 +413,28 @@ def getDamagePattern(lookfor, eager=None):
         eager = processEager(eager)
         with sd_lock:
             pattern = saveddata_session.query(DamagePattern).options(*eager).filter(
-                    DamagePattern.name == lookfor).first()
+                    DamagePattern.rawName == lookfor).first()
     else:
         raise TypeError("Need integer or string as argument")
     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.rawName == 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
@@ -459,7 +470,7 @@ def searchFits(nameLike, where=None, eager=None):
     filter = processWhere(Fit.name.like(nameLike, escape="\\"), where)
     eager = processEager(eager)
     with sd_lock:
-        fits = removeInvalid(saveddata_session.query(Fit).options(*eager).filter(filter).all())
+        fits = removeInvalid(saveddata_session.query(Fit).options(*eager).filter(filter).limit(100).all())
 
     return fits
 
@@ -549,6 +560,8 @@ def commit():
     with sd_lock:
         try:
             saveddata_session.commit()
+        except (KeyboardInterrupt, SystemExit):
+            raise
         except Exception:
             saveddata_session.rollback()
             exc_info = sys.exc_info()
@@ -559,6 +572,8 @@ def flush():
     with sd_lock:
         try:
             saveddata_session.flush()
+        except (KeyboardInterrupt, SystemExit):
+            raise
         except Exception:
             saveddata_session.rollback()
             exc_info = sys.exc_info()

eos/db/saveddata/targetProfile.py

@@ -22,18 +22,30 @@ from sqlalchemy.orm import mapper
 import datetime
 
 from eos.db import saveddata_meta
-from eos.saveddata.targetResists import TargetResists
+from eos.saveddata.targetProfile import TargetProfile
 
-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)
+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={
+        'rawName': targetProfiles_table.c.name,
+        '_maxVelocity': targetProfiles_table.c.maxVelocity,
+        '_signatureRadius': targetProfiles_table.c.signatureRadius,
+        '_radius': targetProfiles_table.c.radius})

eos/effectHandlerHelpers.py

@@ -17,8 +17,11 @@
 # along with eos.  If not, see <http://www.gnu.org/licenses/>.
 # ===============================================================================
 
+
 from logbook import Logger
-from utils.deprecated import deprecated
+from sqlalchemy.orm.attributes import flag_dirty
+from sqlalchemy.orm.collections import collection
+
 
 pyfalog = Logger(__name__)
 
@@ -106,12 +109,14 @@ class HandledList(list):
 
     def remove(self, thing):
         # We must flag it as modified, otherwise it not be removed from the database
-        # @todo: flag_modified isn't in os x skel. need to rebuild to include
-        # flag_modified(thing, "itemID")
-        if thing.isInvalid:  # see GH issue #324
-            thing.itemID = 0
+        flag_dirty(thing)
         list.remove(self, thing)
 
+    def sort(self, *args, **kwargs):
+        # We need it here to prevent external users from accidentally sorting the list as alot of
+        # external logic relies on keeping modules at their places
+        raise NotImplementedError
+
 
 class HandledModuleList(HandledList):
 
@@ -125,76 +130,90 @@ class HandledModuleList(HandledList):
                     emptyPosition = currPos
 
         if emptyPosition < len(self):
-            del self[emptyPosition]
             mod.position = emptyPosition
-            HandledList.insert(self, emptyPosition, mod)
+            self.__toModule(emptyPosition, mod)
             if mod.isInvalid:
-                self.remove(mod)
-            return
-
-        self.appendIgnoreEmpty(mod)
+                self.__toDummy(mod.position)
+        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)
+
+    def replace(self, idx, mod):
+        try:
+            oldMod = self[idx]
+        except IndexError:
             return
+        self.__toModule(idx, mod)
+        if mod.isInvalid:
+            self.__toModule(idx, oldMod)
 
     def replaceRackPosition(self, rackPosition, mod):
         listPositions = []
-        for currMod in self:
+        for currPos in range(len(self)):
+            currMod = self[currPos]
             if currMod.slot == mod.slot:
-                listPositions.append(currMod.position)
+                listPositions.append(currPos)
         listPositions.sort()
         try:
             modListPosition = listPositions[rackPosition]
         except IndexError:
             self.appendIgnoreEmpty(mod)
         else:
-            self.toDummy(modListPosition)
-            if not mod.isEmpty:
-                self.toModule(modListPosition, mod)
+            oldMod = self[modListPosition]
+            if mod.isEmpty:
+                self.__toDummy(modListPosition)
+            else:
+                self.__toModule(modListPosition, mod)
+                # If new module cannot be appended, restore old state
                 if mod.isInvalid:
-                    self.toDummy(modListPosition)
+                    if oldMod.isEmpty:
+                        self.__toDummy(modListPosition)
+                    else:
+                        self.__toModule(modListPosition, oldMod)
 
-    def insert(self, index, mod):
-        mod.position = index
-        i = index
+    def insert(self, idx, mod):
+        mod.position = idx
+        i = idx
         while i < len(self):
             self[i].position += 1
             i += 1
-        HandledList.insert(self, index, mod)
+        HandledList.insert(self, idx, mod)
+        if mod.isInvalid:
+            self.remove(mod)
 
     def remove(self, mod):
         HandledList.remove(self, mod)
         oldPos = mod.position
-
         mod.position = None
         for i in range(oldPos, len(self)):
             self[i].position -= 1
 
-    def toDummy(self, index):
+    def free(self, idx):
+        self.__toDummy(idx)
+
+    def __toDummy(self, index):
         mod = self[index]
         if not mod.isEmpty:
             dummy = mod.buildEmpty(mod.slot)
             dummy.position = index
             self[index] = dummy
+            mod.position = None
 
-    def toModule(self, index, mod):
+    def __toModule(self, index, mod):
+        oldMod = self[index]
         mod.position = index
         self[index] = mod
-
-    @deprecated
-    def freeSlot(self, slot):
-        for i in range(len(self)):
-            mod = self[i]
-            if mod.getModifiedItemAttr("subSystemSlot") == slot:
-                self.toDummy(i)
-                break
+        oldMod.position = None
 
 
 class HandledDroneCargoList(HandledList):
+
     def find(self, item):
         for o in self:
             if o.item == item:
@@ -206,35 +225,99 @@ class HandledDroneCargoList(HandledList):
 
     def append(self, thing):
         HandledList.append(self, thing)
+        if thing.isInvalid:
+            self.remove(thing)
 
+    def insert(self, idx, thing):
+        HandledList.insert(self, idx, thing)
         if thing.isInvalid:
             self.remove(thing)
 
 
-class HandledImplantBoosterList(HandledList):
-    def append(self, thing):
-        if thing.isInvalid:
-            HandledList.append(self, thing)
-            self.remove(thing)
+class HandledImplantList(HandledList):
+
+    def append(self, implant):
+        if implant.isInvalid:
+            HandledList.append(self, implant)
+            self.remove(implant)
             return
+        if self.__slotCheck(implant):
+            HandledList.append(self, implant)
+            self.remove(implant)
+            return
+        HandledList.append(self, implant)
 
-        self.makeRoom(thing)
-        HandledList.append(self, thing)
+    def insert(self, idx, implant):
+        if implant.isInvalid:
+            HandledList.insert(self, idx, implant)
+            self.remove(implant)
+            return
+        if self.__slotCheck(implant):
+            HandledList.insert(self, idx, implant)
+            self.remove(implant)
+            return
+        HandledList.insert(self, idx, implant)
 
-    def makeRoom(self, thing):
+    def makeRoom(self, implant):
         # if needed, remove booster that was occupying slot
-        oldObj = next((m for m in self if m.slot == thing.slot), None)
-        if oldObj:
-            pyfalog.info("Slot {0} occupied with {1}, replacing with {2}", thing.slot, oldObj.item.name,
-                         thing.item.name)
-            itemID = oldObj.itemID
+        oldObj = next((i for i in self if i.slot == implant.slot), None)
+        if oldObj is not None:
+            pyfalog.info("Slot {0} occupied with {1}, replacing with {2}", implant.slot, oldObj.item.name, implant.item.name)
+            position = self.index(oldObj)
+            from gui.fitCommands.helpers import ImplantInfo
+            implantInfo = ImplantInfo.fromImplant(oldObj)
             oldObj.itemID = 0  # hack to remove from DB. See GH issue #324
             self.remove(oldObj)
-            return itemID
-        return None
+            return position, implantInfo
+        return None, None
+
+    def __slotCheck(self, implant):
+        return any(i.slot == implant.slot for i in self)
+
+
+class HandledBoosterList(HandledList):
+
+    def append(self, booster):
+        if booster.isInvalid:
+            HandledList.append(self, booster)
+            self.remove(booster)
+            return
+        if self.__slotCheck(booster):
+            HandledList.append(self, booster)
+            self.remove(booster)
+            return
+        HandledList.append(self, booster)
+
+    def insert(self, idx, booster):
+        if booster.isInvalid:
+            HandledList.insert(self, idx, booster)
+            self.remove(booster)
+            return
+        if self.__slotCheck(booster):
+            HandledList.insert(self, idx, booster)
+            self.remove(booster)
+            return
+        HandledList.insert(self, idx, booster)
+
+    def makeRoom(self, booster):
+        # if needed, remove booster that was occupying slot
+        oldObj = next((b for b in self if b.slot == booster.slot), None)
+        if oldObj is not None:
+            pyfalog.info("Slot {0} occupied with {1}, replacing with {2}", booster.slot, oldObj.item.name, booster.item.name)
+            position = self.index(oldObj)
+            from gui.fitCommands.helpers import BoosterInfo
+            boosterInfo = BoosterInfo.fromBooster(oldObj)
+            oldObj.itemID = 0  # hack to remove from DB. See GH issue #324
+            self.remove(oldObj)
+            return position, boosterInfo
+        return None, None
+
+    def __slotCheck(self, booster):
+        return any(b.slot == booster.slot for b in self)
 
 
 class HandledSsoCharacterList(list):
+
     def append(self, character):
         old = next((x for x in self if x.client == character.client), None)
         if old is not None:
@@ -245,6 +328,7 @@ class HandledSsoCharacterList(list):
 
 
 class HandledProjectedModList(HandledList):
+
     def append(self, proj):
         if proj.isInvalid:
             # we must include it before we remove it. doing it this way ensures
@@ -252,14 +336,21 @@ class HandledProjectedModList(HandledList):
             HandledList.append(self, proj)
             self.remove(proj)
             return
-
         proj.projected = True
-
-        if proj.isExclusiveSystemEffect:
-            self.makeRoom(proj)
-
         HandledList.append(self, proj)
+        # Remove non-projectable modules
+        if not proj.item.isType("projected") and not proj.isExclusiveSystemEffect:
+            self.remove(proj)
 
+    def insert(self, idx, proj):
+        if proj.isInvalid:
+            # we must include it before we remove it. doing it this way ensures
+            # rows and relationships in database are removed as well
+            HandledList.insert(self, idx, proj)
+            self.remove(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)
@@ -269,27 +360,41 @@ class HandledProjectedModList(HandledList):
         return next((m for m in self if m.isExclusiveSystemEffect), None)
 
     def makeRoom(self, proj):
-        # remove other system effects - only 1 per fit plz
-        oldEffect = self.currentSystemEffect
+        if proj.isExclusiveSystemEffect:
+            # remove other system effects - only 1 per fit plz
+            mod = self.currentSystemEffect
 
-        if oldEffect:
-            pyfalog.info("System effect occupied with {0}, replacing with {1}", oldEffect.item.name, proj.item.name)
-            self.remove(oldEffect)
-            return oldEffect.itemID
-        return None
+            if mod:
+                pyfalog.info("System effect occupied with {0}, removing it to make space for {1}".format(mod.item.name, proj.item.name))
+                position = self.index(mod)
+                # We need to pack up this info, so whatever...
+                from gui.fitCommands.helpers import ModuleInfo
+                modInfo = ModuleInfo.fromModule(mod)
+                self.remove(mod)
+                return position, modInfo
+        return None, None
 
 
 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
+
+    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
 
 
-class HandledItem(object):
+class HandledItem:
     def preAssignItemAttr(self, *args, **kwargs):
         self.itemModifiedAttributes.preAssign(*args, **kwargs)
 
@@ -306,7 +411,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/gamedata.py

@@ -18,7 +18,8 @@
 # ===============================================================================
 
 
-from collections import OrderedDict
+import json
+import re
 
 from logbook import Logger
 from sqlalchemy.orm import reconstructor
@@ -32,6 +33,10 @@ from .eqBase import EqBase
 pyfalog = Logger(__name__)
 
 
+def _t(x):
+    return x
+
+
 class Effect(EqBase):
     """
     The effect handling class, it is used to proxy and load effect handler code,
@@ -140,12 +145,24 @@ class Effect(EqBase):
         Whether this effect is implemented in code or not,
         unimplemented effects simply do nothing at all when run
         """
+        if not self.__generated:
+            self.__generateHandler()
+
         return self.__effectDef is not None
 
+    @property
+    def dealsDamage(self):
+        if not self.__generated:
+            self.__generateHandler()
+        return self.__dealsDamage
+
     def isType(self, type):
         """
         Check if this effect is of the passed type
         """
+        if not self.__generated:
+            self.__generateHandler()
+
         return self.type is not None and type in self.type
 
     def __generateHandler(self):
@@ -160,6 +177,7 @@ class Effect(EqBase):
             self.__handler = getattr(effectDef, "handler", eos.effects.BaseEffect.handler)
             self.__runTime = getattr(effectDef, "runTime", "normal")
             self.__activeByDefault = getattr(effectDef, "activeByDefault", True)
+            self.__dealsDamage = effectDef.dealsDamage
             effectType = getattr(effectDef, "type", None)
             effectType = effectType if isinstance(effectType, tuple) or effectType is None else (effectType,)
             self.__type = effectType
@@ -168,6 +186,7 @@ class Effect(EqBase):
             self.__handler = eos.effects.DummyEffect.handler
             self.__runTime = "normal"
             self.__activeByDefault = True
+            self.__dealsDamage = False
             self.__type = None
             pyfalog.debug("ImportError generating handler: {0}", e)
         except AttributeError as e:
@@ -175,12 +194,16 @@ class Effect(EqBase):
             self.__handler = eos.effects.DummyEffect.handler
             self.__runTime = "normal"
             self.__activeByDefault = True
+            self.__dealsDamage = False
             self.__type = None
             pyfalog.error("AttributeError generating handler: {0}", e)
+        except (KeyboardInterrupt, SystemExit):
+            raise
         except Exception as e:
             self.__handler = eos.effects.DummyEffect.handler
             self.__runTime = "normal"
             self.__activeByDefault = True
+            self.__dealsDamage = False
             self.__type = None
             pyfalog.critical("Exception generating handler:")
             pyfalog.critical(e)
@@ -193,57 +216,58 @@ class Effect(EqBase):
 
         try:
             return self.__effectDef.get(key, None)
+        except (KeyboardInterrupt, SystemExit):
+            raise
         except:
             return getattr(self.__effectDef, key, None)
 
 
 class Item(EqBase):
-    MOVE_ATTRS = (4,  # Mass
-                  38,  # Capacity
-                  161)  # Volume
-
-    MOVE_ATTR_INFO = None
-
     ABYSSAL_TYPES = None
 
-    @classmethod
-    def getMoveAttrInfo(cls):
-        info = getattr(cls, "MOVE_ATTR_INFO", None)
-        if info is None:
-            cls.MOVE_ATTR_INFO = info = []
-            for id in cls.MOVE_ATTRS:
-                info.append(eos.db.getAttributeInfo(id))
-
-        return info
-
-    def moveAttrs(self):
-        self.__moved = True
-        for info in self.getMoveAttrInfo():
-            val = getattr(self, info.name, 0)
-            if val != 0:
-                attr = Attribute()
-                attr.info = info
-                attr.value = val
-                self.__attributes[info.name] = attr
-
     @reconstructor
     def init(self):
         self.__race = None
         self.__requiredSkills = None
         self.__requiredFor = None
-        self.__moved = False
         self.__offensive = None
         self.__assistive = None
         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 customName(self):
+        return re.sub(_t('Caustic'), _t('Tachyon'), self.name)
+
     @property
     def attributes(self):
-        if not self.__moved:
-            self.moveAttrs()
-
         return self.__attributes
 
+    @property
+    def attribsWithOverrides(self):
+        overrides = self.overrides
+        attribs = {}
+        for aname, attr in self.attributes.items():
+            if aname in overrides:
+                attribs[aname] = overrides[aname]
+            else:
+                attribs[aname] = attr
+        return attribs
+
     def getAttribute(self, key, default=None):
         if key in self.attributes:
             return self.attributes[key].value
@@ -283,50 +307,26 @@ class Item(EqBase):
         eos.db.saveddata_session.delete(override)
         eos.db.commit()
 
-    srqIDMap = {182: 277, 183: 278, 184: 279, 1285: 1286, 1289: 1287, 1290: 1288}
-
     @property
     def requiredSkills(self):
         if self.__requiredSkills is None:
-            requiredSkills = OrderedDict()
-            self.__requiredSkills = requiredSkills
-            # Map containing attribute IDs we may need for required skills
-            # { requiredSkillX : requiredSkillXLevel }
-            combinedAttrIDs = set(self.srqIDMap.keys()).union(set(self.srqIDMap.values()))
-            # Map containing result of the request
-            # { attributeID : attributeValue }
-            skillAttrs = {}
-            # Get relevant attribute values from db (required skill IDs and levels) for our item
-            for attrInfo in eos.db.directAttributeRequest((self.ID,), tuple(combinedAttrIDs)):
-                attrID = attrInfo[1]
-                attrVal = attrInfo[2]
-                skillAttrs[attrID] = attrVal
-            # Go through all attributeID pairs
-            for srqIDAtrr, srqLvlAttr in self.srqIDMap.items():
-                # Check if we have both in returned result
-                if srqIDAtrr in skillAttrs and srqLvlAttr in skillAttrs:
-                    skillID = int(skillAttrs[srqIDAtrr])
-                    skillLvl = skillAttrs[srqLvlAttr]
-                    # Fetch item from database and fill map
-                    item = eos.db.getItem(skillID)
-                    requiredSkills[item] = skillLvl
+            self.__requiredSkills = {}
+            if self.reqskills:
+                for skillTypeID, skillLevel in json.loads(self.reqskills).items():
+                    skillItem = eos.db.getItem(int(skillTypeID))
+                    if skillItem:
+                        self.__requiredSkills[skillItem] = skillLevel
         return self.__requiredSkills
 
     @property
     def requiredFor(self):
         if self.__requiredFor is None:
-            self.__requiredFor = dict()
-
-            # Map containing attribute IDs we may need for required skills
-
-            # Get relevant attribute values from db (required skill IDs and levels) for our item
-            q = eos.db.getRequiredFor(self.ID, self.srqIDMap)
-
-            for itemID, lvl in q:
-                # Fetch item from database and fill map
-                item = eos.db.getItem(itemID)
-                self.__requiredFor[item] = lvl
-
+            self.__requiredFor = {}
+            if self.requiredfor:
+                for typeID, skillLevel in json.loads(self.requiredfor).items():
+                    requiredForItem = eos.db.getItem(int(typeID))
+                    if requiredForItem:
+                        self.__requiredFor[requiredForItem] = skillLevel
         return self.__requiredFor
 
     factionMap = {
@@ -342,7 +342,8 @@ class Item(EqBase):
         500016: "sisters",
         500018: "mordu",
         500019: "sansha",
-        500020: "serpentis"
+        500020: "serpentis",
+        500026: "triglavian"
     }
 
     @property
@@ -350,7 +351,11 @@ class Item(EqBase):
         if self.__race is None:
 
             try:
-                if self.category.categoryName == 'Structure':
+                if (
+                    self.category.name == 'Structure' or
+                    # Here until CCP puts their shit together
+                    self.name in ("Thunderchild", "Stormbringer", "Skybreaker")
+                ):
                     self.__race = "upwell"
                 else:
                     self.__race = self.factionMap[self.factionID]
@@ -368,6 +373,7 @@ class Item(EqBase):
                     9  : "guristas",  # Caldari + Gallente
                     10 : "angelserp",  # Minmatar + Gallente, final race depends on the order of skills
                     12 : "sisters",  # Amarr + Gallente
+                    15 : "concord",
                     16 : "jove",
                     32 : "sansha",  # Incrusion Sansha
                     128: "ore",
@@ -425,7 +431,7 @@ class Item(EqBase):
     def requiresSkill(self, skill, level=None):
         for s, l in self.requiredSkills.items():
             if isinstance(skill, str):
-                if s.name == skill and (level is None or l == level):
+                if s.typeName == skill and (level is None or l == level):
                     return True
 
             elif isinstance(skill, int) and (level is None or l == level):
@@ -471,13 +477,49 @@ class Item(EqBase):
     def getAbyssalTypes(cls):
         cls.ABYSSAL_TYPES = eos.db.getAbyssalTypes()
 
+    @property
+    def isModule(self):
+        return self.category.name in ('Module', 'Structure Module')
+
+    @property
+    def isSubsystem(self):
+        return self.category.name == 'Subsystem'
+
     @property
     def isCharge(self):
-        return self.category.name == "Charge"
+        return self.category.name == 'Charge'
+
+    @property
+    def isCommodity(self):
+        return self.category.name == 'Commodity'
+
+    @property
+    def isDrone(self):
+        return self.category.name == 'Drone'
+
+    @property
+    def isFighter(self):
+        return self.category.name == 'Fighter'
+
+    @property
+    def isImplant(self):
+        return self.category.name == 'Implant' and self.group.name != 'Booster'
+
+    @property
+    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))
+        return "Item(ID={}, name={}, display={}) at {}".format(
+                self.ID, self.typeName, self.name, hex(id(self))
         )
 
 
@@ -539,18 +581,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):
@@ -682,5 +719,15 @@ class Unit(EqBase):
 
         return value
 
+
 class Traits(EqBase):
     pass
+
+
+class ImplantSet(EqBase):
+
+    @property
+    def fullName(self):
+        if not self.gradeName:
+            return self.setName
+        return '{} {}'.format(self.gradeName, self.setName)

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,194 +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
-            for ability in fighter.abilities:
-                if ability.dealsDamage and ability.active:
-                    multiplier = self.calculateFighterMissileMultiplier(ability, data)
-                    dps = ability.getDps(targetResists=fit.targetResists).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,49 +17,96 @@
 # 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 getBaseAttrValue(self, key, default=0):
-        """
-        Gets base value in this order:
-        Mutated value > override value > attribute value
-        """
+    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):
         return_value = self.itemModifiedAttributes.getOriginal(key)
-
         return return_value or default
 
 
-class ChargeAttrShortcut(object):
+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):
+        return_value = self.chargeModifiedAttributes.getOriginal(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
 
     def __init__(self, fit=None, parent=None):
+        self.__fit = fit
         self.parent = parent
-        self.fit = fit
         # Stores original values of the entity
         self.__original = None
         # Modified values during calculations
@@ -67,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 = {}
@@ -94,6 +145,22 @@ class ModifiedAttributeDict(collections.MutableMapping):
         self.__penalizedMultipliers.clear()
         self.__postIncreases.clear()
 
+    @property
+    def fit(self):
+        # self.fit is usually set during fit calculations when the item is registered with the fit. However,
+        # under certain circumstances, an effect will not work as it will try to modify an item which has NOT
+        # yet been registered and thus has not had self.fit set. In this case, use the modules owner attribute
+        # to point to the correct fit. See GH Issue #434
+        if self.__fit is not None:
+            return self.__fit
+        if hasattr(self.parent, 'owner'):
+            return self.parent.owner
+        return None
+
+    @fit.setter
+    def fit(self, fit):
+        self.__fit = fit
+
     @property
     def original(self):
         return self.__original
@@ -121,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:
@@ -158,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
 
@@ -185,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:
@@ -195,13 +315,13 @@ class ModifiedAttributeDict(collections.MutableMapping):
             if attrInfo is None:
                 cappingId = cappingAttrKeyCache[key] = None
             else:
-                # see GH issue #620
-                cappingId = cappingAttrKeyCache[key] = attrInfo.maxAttributeID
+                cappingId = attrInfo.maxAttributeID
             if cappingId is None:
                 cappingKey = None
             else:
                 cappingAttrInfo = getAttributeInfo(cappingId)
                 cappingKey = None if cappingAttrInfo is None else cappingAttrInfo.name
+                cappingAttrKeyCache[key] = cappingKey
 
         if cappingKey:
             cappingValue = self.original.get(cappingKey, self.__calculateValue(cappingKey))
@@ -215,40 +335,59 @@ class ModifiedAttributeDict(collections.MutableMapping):
         if force is not None:
             if cappingValue is not None:
                 force = min(force, cappingValue)
-            if key in (50, 30, 48, 11):
+            if key in ("cpu", "power", "cpuOutput", "powerOutput"):
                 force = round(force, 2)
             return force
         # Grab our values if they're there, otherwise we'll take default values
         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
-
-        val = self.__intermediary.get(key,
-                                      self.__preAssigns.get(key,
-                                                            self.getOriginal(key, default)
-                                                            )
-                                      )
+        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]
@@ -266,11 +405,13 @@ 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:
             val = min(val, cappingValue)
-        if key in (50, 30, 48, 11):
+        if key in ("cpu", "power", "cpuOutput", "powerOutput"):
             val = round(val, 2)
         return val
 
@@ -282,14 +423,7 @@ class ModifiedAttributeDict(collections.MutableMapping):
         with the fit and thus get the correct affector. Returns skill level to
         be used to modify modifier. See GH issue #101
         """
-        fit = self.fit
-        if not fit:
-            # self.fit is usually set during fit calculations when the item is registered with the fit. However,
-            # under certain circumstances, an effect will not work as it will try to modify an item which has NOT
-            # yet been registered and thus has not had self.fit set. In this case, use the modules owner attribute
-            # to point to the correct fit. See GH Issue #434
-            fit = self.parent.owner
-        skill = fit.character.getSkill(skillName)
+        skill = self.fit.character.getSkill(skillName)
         self.__tmpModifier = skill
         return skill.level
 
@@ -299,17 +433,18 @@ 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
-        if self.fit is None:
+        fit = self.fit
+        if fit is None:
             return
         # Create dictionary for given attribute and give it alias
         if attributeName not in self.__affectedBy:
             self.__affectedBy[attributeName] = {}
         affs = self.__affectedBy[attributeName]
-        origin = self.fit.getOrigin()
-        fit = origin if origin and origin != self.fit else self.fit
+        origin = fit.getOrigin()
+        fit = origin if origin and origin != fit else fit
         # If there's no set for current fit in dictionary, create it
         if fit not in affs:
             affs[fit] = []
@@ -321,16 +456,16 @@ class ModifiedAttributeDict(collections.MutableMapping):
             modifier = self.__tmpModifier
             self.__tmpModifier = None
         else:
-            modifier = self.fit.getModifier()
+            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"""
@@ -343,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")
@@ -352,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
@@ -362,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:
@@ -382,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):
@@ -159,6 +159,6 @@ class Booster(HandledItem, ItemAttrShortcut):
                 sideEffect.active = sideEffectStates[sideEffect.effectID]
 
     def __repr__(self):
-        return "Booster(ID={}, name={}) at {}".format(
-            self.item.ID, self.item.name, hex(id(self))
-        )
+        if self.item is not None:
+            return f"Booster(ID={self.item.ID}, name={self.item.name}) at {hex(id(self))}"
+        return f"Booster(ID={self.itemID}) at {hex(id(self))}"

eos/saveddata/boosterSideEffect.py

@@ -21,10 +21,13 @@ from logbook import Logger
 
 from sqlalchemy.orm import reconstructor
 
+from eos.utils.round import roundToPrec
+
+
 pyfalog = Logger(__name__)
 
 
-class BoosterSideEffect(object):
+class BoosterSideEffect:
 
     def __init__(self, effect):
         """Initialize from the program"""
@@ -56,9 +59,8 @@ class BoosterSideEffect(object):
     @property
     def name(self):
         return "{0}% {1}".format(
-            self.booster.getModifiedItemAttr(self.attr),
-            self.__effect.getattr('displayName') or self.__effect.name,
-        )
+            roundToPrec(self.booster.getModifiedItemAttr(self.attr), 5),
+            self.__effect.getattr('displayName') or self.__effect.name)
 
     @property
     def attr(self):

eos/saveddata/character.py

@@ -27,12 +27,12 @@ from sqlalchemy.orm import validates, reconstructor
 import eos
 import eos.db
 import eos.config
-from eos.effectHandlerHelpers import HandledItem, HandledImplantBoosterList
+from eos.effectHandlerHelpers import HandledItem, HandledImplantList
 
 pyfalog = Logger(__name__)
 
 
-class Character(object):
+class Character:
     __itemList = None
     __itemIDMap = None
     __itemNameMap = None
@@ -51,7 +51,7 @@ class Character(object):
             for item in self.getSkillList():
                 self.addSkill(Skill(self, item.ID, self.defaultLevel))
 
-        self.__implants = HandledImplantBoosterList()
+        self.__implants = HandledImplantList()
 
     @reconstructor
     def init(self):
@@ -96,7 +96,7 @@ class Character(object):
         if cls.__itemNameMap is None:
             map = {}
             for skill in cls.getSkillList():
-                map[skill.name] = skill
+                map[skill.typeName] = skill
 
             cls.__itemNameMap = map
 
@@ -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

@@ -18,21 +18,195 @@
 # ===============================================================================
 
 import re
+from collections import OrderedDict
+
+from sqlalchemy.orm import reconstructor
+
 import eos.db
 
 
-class DamagePattern(object):
-    DAMAGE_TYPES = ("em", "thermal", "kinetic", "explosive")
+def _t(x):
+    return x
+
+
+def _c(x):
+    return '[' + x + ']'
+
+
+# Order is significant here - UI uses order as-is for built-in patterns
+BUILTINS = OrderedDict([
+    (-1, (_t('Uniform'), 25, 25, 25, 25)),
+    (-2, (_c(_t('Generic')) + _t('EM'), 1, 0, 0, 0)),
+    (-3, (_c(_t('Generic')) + _t('Thermal'), 0, 1, 0, 0)),
+    (-4, (_c(_t('Generic')) + _t('Kinetic'), 0, 0, 1, 0)),
+    (-5, (_c(_t('Generic')) + _t('Explosive'), 0, 0, 0, 1)),
+    (-6, (_c(_t('Frequency Crystals')) + '|' + _t('[T2] Aurora'), 5, 3, 0, 0)),
+    (-7, (_c(_t('Frequency Crystals')) + '|' + _t('[T2] Scorch'), 9, 2, 0, 0)),
+    (-8, (_c(_t('Frequency Crystals')) + _t('Radio'), 5, 0, 0, 0)),
+    (-9, (_c(_t('Frequency Crystals')) + _t('Microwave'), 4, 2, 0, 0)),
+    (-10, (_c(_t('Frequency Crystals')) + _t('Infrared'), 5, 2, 0, 0)),
+    (-11, (_c(_t('Frequency Crystals')) + _t('Standard'), 5, 3, 0, 0)),
+    (-12, (_c(_t('Frequency Crystals')) + _t('Ultraviolet'), 6, 3, 0, 0)),
+    (-13, (_c(_t('Frequency Crystals')) + _t('Xray'), 6, 4, 0, 0)),
+    (-14, (_c(_t('Frequency Crystals')) + _t('Gamma'), 7, 4, 0, 0)),
+    (-15, (_c(_t('Frequency Crystals')) + _t('Multifrequency'), 7, 5, 0, 0)),
+    (-16, (_c(_t('Frequency Crystals')) + '|' + _t('[T2] Gleam'), 7, 7, 0, 0)),
+    (-17, (_c(_t('Frequency Crystals')) + '|' + _t('[T2] Conflagration'), 7.7, 7.7, 0, 0)),
+    # Different sizes of plasma do different damage ratios, the values here
+    # are average of ratios across sizes
+    (-18, (_c(_t('Exotic Plasma')) + '|' + _t('[T2] Mystic'), 0, 66319, 0, 33681)),
+    (-19, (_c(_t('Exotic Plasma')) + _t('Meson'), 0, 60519, 0, 39481)),
+    (-20, (_c(_t('Exotic Plasma')) + _t('Baryon'), 0, 59737, 0, 40263)),
+    (-21, (_c(_t('Exotic Plasma')) + _t('Tetryon'), 0, 69208, 0, 30792)),
+    (-22, (_c(_t('Exotic Plasma')) + '|' + _t('[T2] Occult'), 0, 55863, 0, 44137)),
+    (-23, (_c(_t('Hybrid Charges')) + '|' + _t('[T2] Spike'), 0, 4, 4, 0)),
+    (-24, (_c(_t('Hybrid Charges')) + '|' + _t('[T2] Null'), 0, 6, 5, 0)),
+    (-25, (_c(_t('Hybrid Charges')) + _t('Iron'), 0, 2, 3, 0)),
+    (-26, (_c(_t('Hybrid Charges')) + _t('Tungsten'), 0, 2, 4, 0)),
+    (-27, (_c(_t('Hybrid Charges')) + _t('Iridium'), 0, 3, 4, 0)),
+    (-28, (_c(_t('Hybrid Charges')) + _t('Lead'), 0, 3, 5, 0)),
+    (-29, (_c(_t('Hybrid Charges')) + _t('Thorium'), 0, 4, 5, 0)),
+    (-30, (_c(_t('Hybrid Charges')) + _t('Uranium'), 0, 4, 6, 0)),
+    (-31, (_c(_t('Hybrid Charges')) + _t('Plutonium'), 0, 5, 6, 0)),
+    (-32, (_c(_t('Hybrid Charges')) + _t('Antimatter'), 0, 5, 7, 0)),
+    (-33, (_c(_t('Hybrid Charges')) + '|' + _t('[T2] Javelin'), 0, 8, 6, 0)),
+    (-34, (_c(_t('Hybrid Charges')) + '|' + _t('[T2] Void'), 0, 7.7, 7.7, 0)),
+    (-35, (_c(_t('Projectile Ammo')) + '|' + _t('[T2] Tremor'), 0, 0, 3, 5)),
+    (-36, (_c(_t('Projectile Ammo')) + '|' + _t('[T2] Barrage'), 0, 0, 5, 6)),
+    (-37, (_c(_t('Projectile Ammo')) + _t('Carbonized Lead'), 0, 0, 4, 1)),
+    (-38, (_c(_t('Projectile Ammo')) + _t('Nuclear'), 0, 0, 1, 4)),
+    (-39, (_c(_t('Projectile Ammo')) + _t('Proton'), 3, 0, 2, 0)),
+    (-40, (_c(_t('Projectile Ammo')) + _t('Depleted Uranium'), 0, 3, 2, 3)),
+    (-41, (_c(_t('Projectile Ammo')) + _t('Titanium Sabot'), 0, 0, 6, 2)),
+    (-42, (_c(_t('Projectile Ammo')) + _t('EMP'), 9, 0, 1, 2)),
+    (-43, (_c(_t('Projectile Ammo')) + _t('Phased Plasma'), 0, 10, 2, 0)),
+    (-44, (_c(_t('Projectile Ammo')) + _t('Fusion'), 0, 0, 2, 10)),
+    (-45, (_c(_t('Projectile Ammo')) + '|' + _t('[T2] Quake'), 0, 0, 5, 9)),
+    (-46, (_c(_t('Projectile Ammo')) + '|' + _t('[T2] Hail'), 0, 0, 3.3, 12.1)),
+    (-47, (_c(_t('Missiles')) + _t('Mjolnir'), 1, 0, 0, 0)),
+    (-48, (_c(_t('Missiles')) + _t('Inferno'), 0, 1, 0, 0)),
+    (-49, (_c(_t('Missiles')) + _t('Scourge'), 0, 0, 1, 0)),
+    (-50, (_c(_t('Missiles')) + _t('Nova'), 0, 0, 0, 1)),
+    (-51, (_c(_t('Bombs')) + _t('Electron Bomb'), 6400, 0, 0, 0)),
+    (-52, (_c(_t('Bombs')) + _t('Scorch Bomb'), 0, 6400, 0, 0)),
+    (-53, (_c(_t('Bombs')) + _t('Concussion Bomb'), 0, 0, 6400, 0)),
+    (-54, (_c(_t('Bombs')) + _t('Shrapnel Bomb'), 0, 0, 0, 6400)),
+    # Source: ticket #2067 and #2265
+    (-55, (_c(_t('NPC')) + _c(_t('Abyssal')) + _t('All'), 126, 427, 218, 230)),
+    (-109, (_c(_t('NPC')) + _c(_t('Abyssal')) + _t('Angel'), 450, 72, 80, 398)),
+    (-107, (_c(_t('NPC')) + _c(_t('Abyssal')) + _t('Concord'), 53, 559, 94, 295)),
+    (-56, (_c(_t('NPC')) + _c(_t('Abyssal')) + _t('Drifter'), 250, 250, 250, 250)),
+    (-57, (_c(_t('NPC')) + _c(_t('Abyssal')) + _t('Drones'), 250, 250, 250, 250)),
+    (-58, (_c(_t('NPC')) + _c(_t('Abyssal')) + _t('Overmind'), 0, 410, 590, 0)),
+    (-108, (_c(_t('NPC')) + _c(_t('Abyssal')) + _t('Sansha'), 569, 431, 0, 0)),
+    (-59, (_c(_t('NPC')) + _c(_t('Abyssal')) + _t('Seeker'), 402, 402, 98, 98)),
+    (-60, (_c(_t('NPC')) + _c(_t('Abyssal')) + _t('Sleeper'), 313, 313, 187, 187)),
+    (-61, (_c(_t('NPC')) + _c(_t('Abyssal')) + _t('Triglavian'), 0, 615, 0, 385)),
+    (-62, (_c(_t('NPC')) + _c(_t('Asteroid')) + _t('Angel Cartel'), 1838, 562, 2215, 3838)),
+    (-63, (_c(_t('NPC')) + _c(_t('Asteroid')) + _t('Blood Raiders'), 5067, 4214, 0, 0)),
+    (-64, (_c(_t('NPC')) + _c(_t('Asteroid')) + _t('Guristas'), 0, 1828, 7413, 0)),
+    (-65, (_c(_t('NPC')) + _c(_t('Asteroid')) + _t('Rogue Drone'), 394, 666, 1090, 1687)),
+    (-66, (_c(_t('NPC')) + _c(_t('Asteroid')) + _t('Sanshas Nation'), 5586, 4112, 0, 0)),
+    (-67, (_c(_t('NPC')) + _c(_t('Asteroid')) + _t('Serpentis'), 0, 5373, 4813, 0)),
+    (-68, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Cruor (Blood Raiders)'), 90, 90, 0, 0)),
+    (-69, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Dramiel (Angel)'), 55, 0, 20, 96)),
+    (-70, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Daredevil (Serpentis)'), 0, 110, 154, 0)),
+    (-71, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Succubus (Sanshas Nation)'), 135, 30, 0, 0)),
+    (-72, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Worm (Guristas)'), 0, 0, 228, 0)),
+    (-73, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Enyo'), 0, 147, 147, 0)),
+    (-74, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Hawk'), 0, 0, 247, 0)),
+    (-75, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Jaguar'), 36, 0, 50, 182)),
+    (-76, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Vengeance'), 232, 0, 0, 0)),
+    (-77, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Ashimmu (Blood Raiders)'), 260, 100, 0, 0)),
+    (-78, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Talos'), 0, 413, 413, 0)),
+    (-79, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Sentinel'), 0, 75, 0, 90)),
+    (-80, (_c(_t('NPC')) + _c(_t('Deadspace')) + _t('Angel Cartel'), 369, 533, 1395, 3302)),
+    (-81, (_c(_t('NPC')) + _c(_t('Deadspace')) + _t('Blood Raiders'), 6040, 5052, 10, 15)),
+    (-82, (_c(_t('NPC')) + _c(_t('Deadspace')) + _t('Guristas'), 0, 1531, 9680, 0)),
+    (-83, (_c(_t('NPC')) + _c(_t('Deadspace')) + _t('Rogue Drone'), 276, 1071, 1069, 871)),
+    (-84, (_c(_t('NPC')) + _c(_t('Deadspace')) + _t('Sanshas Nation'), 3009, 2237, 0, 0)),
+    (-85, (_c(_t('NPC')) + _c(_t('Deadspace')) + _t('Serpentis'), 0, 3110, 1929, 0)),
+    # Source: ticket #2067
+    (-86, (_c(_t('NPC')) + _c(_t('Invasion')) + _c(_t('Triglavian Entities')) + _t('Dread'), 0, 417, 0, 583)),
+    (-87, (_c(_t('NPC')) + _c(_t('Invasion')) + _c(_t('Triglavian Entities')) + _t('Normal Subcaps'), 0, 610, 0, 390)),
+    # To avoid errors on msgfmt, we have to mark that '0%' is meaning literally 0% with no-python-format.
+    # See also: https://github.com/vslavik/poedit/issues/645
+    (-88, (_c(_t('NPC')) + _c(_t('Invasion')) + _c(_t('Triglavian Entities')) +
+           # xgettext:no-python-format
+           _t('Subcaps w/missiles 0% spool up'), 367, 155, 367, 112)),
+    (-89, (_c(_t('NPC')) + _c(_t('Invasion')) + _c(_t('Triglavian Entities')) +
+           # xgettext:no-python-format
+           _t('Subcaps w/missiles 50% spool up'), 291, 243, 291, 175)),
+    (-90, (_c(_t('NPC')) + _c(_t('Invasion')) + _c(_t('Triglavian Entities')) +
+           # xgettext:no-python-format
+           _t('Subcaps w/missiles 100% spool up'), 241, 301, 241, 217)),
+    (-91, (_c(_t('NPC')) + _c(_t('Invasion')) + _c(_t('Amarr EDENCOM Entities')) + _t('Dread/Subcaps'), 583, 417, 0, 0)),
+    (-92, (_c(_t('NPC')) + _c(_t('Invasion')) + _c(_t('Caldari EDENCOM Entities')) + _t('Dread'), 1000, 0, 0, 0)),
+    (-93, (_c(_t('NPC')) + _c(_t('Invasion')) + _c(_t('Caldari EDENCOM Entities')) + _t('Subcaps'), 511, 21, 29, 440)),
+    (-94, (_c(_t('NPC')) + _c(_t('Invasion')) + _c(_t('Gallente EDENCOM Entities')) + _t('Dread/Subcaps'), 0, 417, 583, 0)),
+    (-95, (_c(_t('NPC')) + _c(_t('Invasion')) + _c(_t('Minmatar EDENCOM Entities')) + _t('Dread'), 0, 0, 583, 417)),
+    (-96, (_c(_t('NPC')) + _c(_t('Invasion')) + _c(_t('Minmatar EDENCOM Entities')) + _t('Subcaps'), 302, 136, 328, 234)),
+    (-110, (_c(_t('NPC')) + _c(_t('Invasion')) + _t('Drifter Entities'), 250, 250, 250, 250)),
+    (-112, (_c(_t('NPC')) + _c(_t('Invasion')) + _t('Sleeper Entities'), 265, 265, 235, 235)),
+    (-111, (_c(_t('NPC')) + _c(_t('Invasion')) + _t('Rogue Drone Entities'), 250, 250, 250, 250)),
+    (-97, (_c(_t('NPC')) + _c(_t('Mission')) + _t('Amarr Empire'), 4464, 3546, 97, 0)),
+    (-98, (_c(_t('NPC')) + _c(_t('Mission')) + _t('Caldari State'), 0, 2139, 4867, 0)),
+    (-99, (_c(_t('NPC')) + _c(_t('Mission')) + _t('CONCORD'), 336, 134, 212, 412)),
+    (-100, (_c(_t('NPC')) + _c(_t('Mission')) + _t('Gallente Federation'), 9, 3712, 2758, 0)),
+    (-101, (_c(_t('NPC')) + _c(_t('Mission')) + _t('Khanid'), 612, 483, 43, 6)),
+    (-102, (_c(_t('NPC')) + _c(_t('Mission')) + _t('Minmatar Republic'), 1024, 388, 1655, 4285)),
+    (-103, (_c(_t('NPC')) + _c(_t('Mission')) + _t('Mordus Legion'), 25, 262, 625, 0)),
+    (-104, (_c(_t('NPC')) + _c(_t('Mission')) + _t('Thukker'), 0, 52, 10, 79)),
+    (-105, (_c(_t('NPC')) + _t('Sansha Incursion'), 1682, 1347, 3678, 3678)),
+    (-106, (_c(_t('NPC')) + _t('Sleepers'), 1472, 1472, 1384, 1384))])
+
+
+class DamagePattern:
+    DAMAGE_TYPES = ('em', 'thermal', 'kinetic', 'explosive')
+    _builtins = None
 
     def __init__(self, *args, **kwargs):
+        self.builtin = False
         self.update(*args, **kwargs)
 
+    @reconstructor
+    def init(self):
+        self.builtin = False
+
     def update(self, emAmount=25, thermalAmount=25, kineticAmount=25, explosiveAmount=25):
         self.emAmount = emAmount
         self.thermalAmount = thermalAmount
         self.kineticAmount = kineticAmount
         self.explosiveAmount = explosiveAmount
 
+    @classmethod
+    def getBuiltinList(cls):
+        if cls._builtins is None:
+            cls.__generateBuiltins()
+        return list(cls._builtins.values())
+
+    @classmethod
+    def getBuiltinById(cls, id):
+        if cls._builtins is None:
+            cls.__generateBuiltins()
+        return cls._builtins.get(id)
+
+    @classmethod
+    def getDefaultBuiltin(cls):
+        if cls._builtins is None:
+            cls.__generateBuiltins()
+        return cls._builtins.get(-1)
+
+    @classmethod
+    def __generateBuiltins(cls):
+        cls._builtins = OrderedDict()
+        for id, (rawName, em, therm, kin, explo) in BUILTINS.items():
+            pattern = DamagePattern(emAmount=em, thermalAmount=therm, kineticAmount=kin, explosiveAmount=explo)
+            pattern.ID = id
+            pattern.rawName = rawName
+            pattern.builtin = True
+            cls._builtins[id] = pattern
+
     def calculateEhp(self, fit):
         ehp = {}
         for (type, attr) in (('shield', 'shieldCapacity'), ('armor', 'armorHP'), ('hull', 'hp')):
@@ -48,7 +222,8 @@ class DamagePattern(object):
             "armorRepair": "armor",
             "armorRepairPreSpool": "armor",
             "armorRepairFullSpool": "armor",
-            "hullRepair": "hull"}
+            "hullRepair": "hull"
+        }
         ereps = {}
         for field in tankInfo:
             if field in typeMap:
@@ -72,12 +247,21 @@ class DamagePattern(object):
         return amount / (specificDivider or 1)
 
     importMap = {
-        "em"   : "em",
+        "em": "em",
         "therm": "thermal",
-        "kin"  : "kinetic",
-        "exp"  : "explosive"
+        "kin": "kinetic",
+        "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)
@@ -89,7 +273,7 @@ class DamagePattern(object):
         lookup = {}
         current = eos.db.getDamagePatternList()
         for pattern in current:
-            lookup[pattern.name] = pattern
+            lookup[pattern.rawName] = pattern
 
         for line in lines:
             try:
@@ -98,6 +282,8 @@ class DamagePattern(object):
                 line = line.split('#', 1)[0]  # allows for comments
                 type, data = line.rsplit('=', 1)
                 type, data = type.strip(), data.split(',')
+            except (KeyboardInterrupt, SystemExit):
+                raise
             except:
                 # Data isn't in correct format, continue to next line
                 continue
@@ -112,6 +298,8 @@ class DamagePattern(object):
             for index, val in enumerate(data):
                 try:
                     fields["%sAmount" % cls.DAMAGE_TYPES[index]] = int(val)
+                except (KeyboardInterrupt, SystemExit):
+                    raise
                 except:
                     continue
 
@@ -122,7 +310,7 @@ class DamagePattern(object):
                     eos.db.save(pattern)
                 else:
                     pattern = DamagePattern(**fields)
-                    pattern.name = name.strip()
+                    pattern.rawName = name.strip()
                     eos.db.save(pattern)
                 patterns.append(pattern)
 
@@ -138,11 +326,41 @@ class DamagePattern(object):
         out += "# Values are in following format:\n"
         out += "# DamageProfile = [name],[EM amount],[Thermal amount],[Kinetic amount],[Explosive amount]\n\n"
         for dp in patterns:
-            out += cls.EXPORT_FORMAT % (dp.name, dp.emAmount, dp.thermalAmount, dp.kineticAmount, dp.explosiveAmount)
+            out += cls.EXPORT_FORMAT % (dp.rawName, dp.emAmount, dp.thermalAmount, dp.kineticAmount, dp.explosiveAmount)
 
         return out.strip()
 
+    @property
+    def name(self):
+        return self.rawName
+
+    @property
+    def fullName(self):
+        categories, tail = self.__parseRawName()
+        return '{}{}'.format(''.join('[{}]'.format(c) for c in categories), tail)
+
+    @property
+    def shortName(self):
+        return self.__parseRawName()[1]
+
+    @property
+    def hierarchy(self):
+        return self.__parseRawName()[0]
+
+    def __parseRawName(self):
+        categories = []
+        remainingName = self.rawName.strip() if self.rawName else ''
+        while True:
+            start, end = remainingName.find('['), remainingName.find(']')
+            if start == -1 or end == -1:
+                return categories, remainingName
+            splitter = remainingName.find('|')
+            if splitter != -1 and splitter == start - 1:
+                return categories, remainingName[1:]
+            categories.append(remainingName[start + 1:end])
+            remainingName = remainingName[end + 1:].strip()
+
     def __deepcopy__(self, memo):
         p = DamagePattern(self.emAmount, self.thermalAmount, self.kineticAmount, self.explosiveAmount)
-        p.name = "%s copy" % self.name
+        p.rawName = "%s copy" % self.rawName
         return p

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", "durationHighisGood"):
+                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,45 +177,65 @@ class Drone(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
             explosive=volley.explosive * dpsFactor)
         return dps
 
-    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
+    def isRemoteRepping(self, ignoreState=False):
+        repParams = self.getRepAmountParameters(ignoreState=ignoreState)
+        for rrData in repParams.values():
+            if rrData:
+                return True
+        return False
 
-    def changeType(self, typeID):
-        self.itemID = typeID
-        self.init()
+    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):
+        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
 
@@ -240,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()
@@ -263,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
@@ -271,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 \
@@ -278,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()
@@ -314,3 +364,11 @@ class Drone(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
         if self.item.groupID in fitDroneGroupLimits:
             return True
         return False
+
+    def canDealDamage(self, ignoreState=False):
+        if self.item is None:
+            return False
+        for effect in self.item.effects.values():
+            if effect.dealsDamage and (ignoreState or self.amountActive > 0):
+                return True
+        return False

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()
 
@@ -93,7 +99,7 @@ class Fighter(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
         self.__itemModifiedAttributes = ModifiedAttributeDict()
         self.__chargeModifiedAttributes = ModifiedAttributeDict()
 
-        if len(self.abilities) != len(self.item.effects):
+        if {a.effectID for a in self.abilities} != {e.ID for e in self.item.effects.values()}:
             self.__abilities = []
             for ability in self.__getAbilities():
                 self.__abilities.append(ability)
@@ -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,88 +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):
-        if not self.active or self.amountActive <= 0:
-            return DmgTypes(0, 0, 0, 0)
-        # Analyze cooldowns when reload is factored in
-        if self.owner.factorReload:
-            activeTimes = []
-            reloadTimes = []
-            peakEm = 0
-            peakTherm = 0
-            peakKin = 0
-            peakExp = 0
-            steadyEm = 0
-            steadyTherm = 0
-            steadyKin = 0
-            steadyExp = 0
-            for ability in self.abilities:
-                abilityDps = ability.getDps(targetResists=targetResists)
-                # Peak dps
-                peakEm += abilityDps.em
-                peakTherm += abilityDps.thermal
-                peakKin += abilityDps.kinetic
-                peakExp += abilityDps.explosive
-                # Infinite use - add to steady dps
-                if ability.numShots == 0:
-                    steadyEm += abilityDps.em
-                    steadyTherm += abilityDps.thermal
-                    steadyKin += abilityDps.kinetic
-                    steadyExp += abilityDps.explosive
-                else:
-                    activeTimes.append(ability.numShots * ability.cycleTime)
-                    reloadTimes.append(ability.reloadTime)
-            steadyDps = DmgTypes(steadyEm, steadyTherm, steadyKin, steadyExp)
-            if len(activeTimes) > 0:
-                shortestActive = sorted(activeTimes)[0]
-                longestReload = sorted(reloadTimes, reverse=True)[0]
-                peakDps = DmgTypes(peakEm, peakTherm, peakKin, peakExp)
-                peakAdjustFactor = shortestActive / (shortestActive + longestReload)
-                peakDpsAdjusted = DmgTypes(
-                    em=peakDps.em * peakAdjustFactor,
-                    thermal=peakDps.thermal * peakAdjustFactor,
-                    kinetic=peakDps.kinetic * peakAdjustFactor,
-                    explosive=peakDps.explosive * peakAdjustFactor)
-                dps = max(steadyDps, peakDpsAdjusted, key=lambda d: d.total)
-                return dps
+    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(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 getDpsPerEffect(self, targetProfile=None):
+        if not self.active or self.amount <= 0:
+            return {}
+        cycleParams = self.getCycleParametersPerEffectOptimizedDps(targetProfile=targetProfile)
+        dpsMap = {}
+        for ability in self.abilities:
+            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:
-                return steadyDps
-        # Just sum all abilities when not taking reload into consideration
-        else:
-            em = 0
-            therm = 0
-            kin = 0
-            exp = 0
-            for ability in self.abilities:
-                abilityDps = ability.getDps(targetResists=targetResists)
-                em += abilityDps.em
-                therm += abilityDps.thermal
-                kin += abilityDps.kinetic
-                exp += abilityDps.explosive
-            return DmgTypes(em, therm, kin, exp)
+                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):
@@ -281,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),
@@ -289,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:
@@ -320,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
 
@@ -331,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
@@ -339,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
@@ -372,3 +441,15 @@ class Fighter(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
             return False
 
         return True
+
+    def canDealDamage(self, ignoreState=False, ignoreAbilityState=False):
+        if self.item is None:
+            return False
+        if not self.active and not ignoreState:
+            return False
+        for ability in self.abilities:
+            if not ability.active and not ignoreAbilityState:
+                continue
+            if ability.effect.dealsDamage:
+                return True
+        return False

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):
@@ -105,20 +112,9 @@ class FighterAbility(object):
     @property
     def cycleTime(self):
         speed = self.fighter.getModifiedItemAttr("{}Duration".format(self.attrPrefix))
-
-        # Factor in reload
-        '''
-        reload = self.reloadTime
-
-        if self.fighter.owner.factorReload:
-            numShots = self.numShots
-            # Speed here already takes into consideration reactivation time
-            speed = (speed * numShots + reload) / numShots if numShots > 0 else speed
-        '''
-
         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":
@@ -131,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,
@@ -152,5 +149,4 @@ class FighterAbility(object):
         return dps
 
     def clear(self):
-        self.__dps = None
-        self.__volley = None
+        pass

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

@@ -19,13 +19,13 @@
 
 from copy import deepcopy
 
-from eos.effectHandlerHelpers import HandledImplantBoosterList
+from eos.effectHandlerHelpers import HandledImplantList
 
 
-class ImplantSet(object):
+class ImplantSet:
     def __init__(self, name=None):
         self.name = name
-        self.__implants = HandledImplantBoosterList()
+        self.__implants = HandledImplantList()
 
     @property
     def implants(self):

eos/saveddata/mode.py

@@ -22,12 +22,12 @@ from eos.modifiedAttributeDict import ModifiedAttributeDict, ItemAttrShortcut
 
 
 class Mode(ItemAttrShortcut, HandledItem):
-    def __init__(self, item):
 
+    def __init__(self, item, owner=None):
         if item.group.name != "Ship Modifiers":
             raise ValueError(
                     'Passed item "%s" (category: (%s)) is not a Ship Modifier' % (item.name, item.category.name))
-
+        self.owner = owner
         self.__item = item
         self.__itemModifiedAttributes = ModifiedAttributeDict()
         self.__itemModifiedAttributes.original = self.item.attributes
@@ -52,4 +52,13 @@ 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)
+        return copy
+
+    def __repr__(self):
+        return "Mode(ID={}, name={}) at {}".format(
+                self.item.ID, self.item.name, hex(id(self))
+        )

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__)
 
@@ -61,7 +64,9 @@ ProjectedSystem = {
 class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
     """An instance of this class represents a module together with its charge and modified attributes"""
     MINING_ATTRIBUTES = ("miningAmount",)
-    SYSTEM_GROUPS = ("Effect Beacon", "MassiveEnvironments", "Abyssal Hazards", "Non-Interactable Object")
+    SYSTEM_GROUPS = (
+        "Effect Beacon", "MassiveEnvironments", "Abyssal Hazards",
+        "Non-Interactable Object", "Destructible Effect Beacon")
 
     def __init__(self, item, baseItem=None, mutaplasmid=None):
         """Initialize a module from the program"""
@@ -89,6 +94,7 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
         self.__charge = None
 
         self.projected = False
+        self.projectionRange = None
         self.state = FittingModuleState.ONLINE
         self.build()
 
@@ -133,7 +139,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
@@ -192,22 +198,38 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
         # todo: validate baseItem as well if it's set.
         if self.isEmpty:
             return False
-        return self.__item is None or \
-               (self.__item.category.name not in ("Module", "Subsystem", "Structure Module") and
-                self.__item.group.name not in self.SYSTEM_GROUPS) or \
-               (self.item.isAbyssal and (not self.baseItemID or not self.mutaplasmidID))
+        if self.__item is None:
+            return True
+        if (
+            self.__item.category.name not in ("Module", "Subsystem", "Structure Module")
+            and self.__item.group.name not in self.SYSTEM_GROUPS
+        ):
+            return True
+        if (
+            self.__item.category.name == "Structure Module"
+            and self.__item.group.name == "Quantum Cores"
+        ):
+            return True
+        if self.item.isAbyssal and not self.isMutated:
+            return True
+        if self.isMutated and not self.__mutaplasmid:
+            return True
+        return False
 
     @property
     def isMutated(self):
-        return self.baseItemID or self.mutaplasmidID
+        return self.baseItemID and self.mutaplasmidID
 
     @property
     def numCharges(self):
-        if self.charge is None:
+        return self.getNumCharges(self.charge)
+
+    def getNumCharges(self, charge):
+        if charge is None:
             charges = 0
         else:
-            chargeVolume = self.charge.volume
-            containerCapacity = self.item.capacity
+            chargeVolume = charge.attributes['volume'].value
+            containerCapacity = self.item.attributes['capacity'].value
             if chargeVolume is None or containerCapacity is None:
                 charges = 0
             else:
@@ -235,8 +257,19 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
 
     @property
     def modPosition(self):
-        if self.owner:
-            return self.owner.modules.index(self) if not self.isProjected else self.owner.projectedModules.index(self)
+        return self.getModPosition()
+
+    def getModPosition(self, fit=None):
+        # Pass in fit for reliability. When it's not passed, we rely on owner and owner
+        # is set by sqlalchemy during flush
+        fit = fit if fit is not None else self.owner
+        if fit:
+            container = fit.projectedModules if self.isProjected else fit.modules
+            try:
+                return container.index(self)
+            except ValueError:
+                return None
+        return None
 
     @property
     def isProjected(self):
@@ -246,7 +279,9 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
 
     @property
     def isExclusiveSystemEffect(self):
-        return self.item.group.name in ("Effect Beacon", "Non-Interactable Object", "MassiveEnvironments")
+        # See issue #2258
+        # return self.item.group.name in ("Effect Beacon", "Non-Interactable Object", "MassiveEnvironments")
+        return False
 
     @property
     def isCapitalSize(self):
@@ -272,7 +307,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
@@ -285,7 +320,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
@@ -299,31 +334,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):
@@ -385,8 +457,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:
@@ -394,91 +470,168 @@ 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 canDealDamage(self, ignoreState=False):
+        if self.isEmpty:
+            return False
+        for effect in self.item.effects.values():
+            if effect.dealsDamage and (
+                ignoreState or
+                effect.isType('offline') or
+                (effect.isType('passive') and self.state >= FittingModuleState.ONLINE) or
+                (effect.isType('active') and self.state >= FittingModuleState.ACTIVE) or
+                (effect.isType('overheat') and self.state >= FittingModuleState.OVERHEATED)
+            ):
+                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, getSpreadDPS=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)
-        return dps
+            em=dmgDuringCycle.em * dpsFactor,
+            thermal=dmgDuringCycle.thermal * dpsFactor,
+            kinetic=dmgDuringCycle.kinetic * dpsFactor,
+            explosive=dmgDuringCycle.explosive * dpsFactor)
+        if not getSpreadDPS:
+            return dps
+        return {'em':dmgDuringCycle.em * dpsFactor,
+                'therm': dmgDuringCycle.thermal * dpsFactor,
+                'kin': dmgDuringCycle.kinetic * dpsFactor,
+                'exp': dmgDuringCycle.explosive * dpsFactor}
 
-    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)
@@ -535,6 +688,8 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
         if not fits and fit.ignoreRestrictions:
             self.restrictionOverridden = True
             fits = True
+        elif fits and fit.ignoreRestrictions:
+            self.restrictionOverridden = False
 
         return fits
 
@@ -552,6 +707,8 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
         if self.slot == FittingSlot.SUBSYSTEM:
             subSlot = self.getModifiedItemAttr("subSystemSlot")
             for mod in fit.modules:
+                if mod is self:
+                    continue
                 if mod.getModifiedItemAttr("subSystemSlot") == subSlot:
                     return False
 
@@ -566,7 +723,7 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
             current = 0  # if self.owner != fit else -1  # Disabled, see #1278
             for mod in fit.modules:
                 if (mod.item and mod.item.groupID == self.item.groupID and
-                        self.modPosition != mod.modPosition):
+                        self.getModPosition(fit) != mod.getModPosition(fit)):
                     current += 1
 
             if current >= max:
@@ -574,7 +731,7 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
 
         # Check this only if we're told to do so
         if hardpointLimit:
-            if fit.getHardpointsFree(self.hardpoint) < 1:
+            if fit.getHardpointsFree(self.hardpoint) < (1 if self.owner != fit else 0):
                 return False
 
         return True
@@ -586,39 +743,59 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
         # Check if we're within bounds
         if state < -1 or state > 2:
             return False
-        elif state >= FittingModuleState.ACTIVE and not self.item.isType("active"):
+        elif state >= FittingModuleState.ACTIVE and (not self.item.isType("active") or self.getModifiedItemAttr('activationBlocked') > 0):
             return False
         elif state == FittingModuleState.OVERHEATED and not self.item.isType("overheat"):
             return False
+        # Some destructible effect beacons contain active effects, hardcap those at online state
+        elif state > FittingModuleState.ONLINE and self.slot == FittingSlot.SYSTEM:
+            return False
         else:
             return True
 
+    def getMaxState(self, proposedState=None):
+        states = sorted((s for s in FittingModuleState if proposedState is None or s <= proposedState), reverse=True)
+        for state in states:
+            if self.isValidState(state):
+                return state
+
     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
@@ -629,18 +806,18 @@ 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):
         # Check sizes, if 'charge size > module volume' it won't fit
         if charge is None:
             return True
-        chargeVolume = charge.volume
-        moduleCapacity = self.item.capacity
+        chargeVolume = charge.attributes['volume'].value
+        moduleCapacity = self.item.attributes['capacity'].value
         if chargeVolume is not None and moduleCapacity is not None and chargeVolume > moduleCapacity:
             return False
 
@@ -725,7 +902,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
@@ -733,7 +910,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
@@ -750,28 +927,22 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
             context = ("module",)
             projected = False
 
-        # if gang:
-        #     context += ("commandRun",)
+        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:
                 for effect in self.charge.effects.values():
-                    if effect.runTime == runTime and \
-                            effect.activeByDefault and \
-                            (effect.isType("offline") or
-                             (effect.isType("passive") and self.state >= FittingModuleState.ONLINE) or
-                             (effect.isType("active") and self.state >= FittingModuleState.ACTIVE)) and \
-                            (not gang or (gang and effect.isType("gang"))):
-
-                        chargeContext = ("moduleCharge",)
-                        # For gang effects, we pass in the effect itself as an argument. However, to avoid going through
-                        # all the effect files and defining this argument, do a simple try/catch here and be done with it.
-                        # @todo: possibly fix this
-                        try:
-                            effect.handler(fit, self, chargeContext, effect=effect)
-                        except:
-                            effect.handler(fit, self, chargeContext)
+                    if (
+                        effect.runTime == runTime and
+                        effect.activeByDefault and (
+                            effect.isType("offline") or
+                            (effect.isType("passive") and self.state >= FittingModuleState.ONLINE) or
+                            (effect.isType("active") and self.state >= FittingModuleState.ACTIVE)) and
+                        (not gang or (gang and effect.isType("gang")))
+                    ):
+                        contexts = ("moduleCharge",)
+                        effect.handler(fit, self, contexts, projectionRange, effect=effect)
 
         if self.item:
             if self.state >= FittingModuleState.OVERHEATED:
@@ -781,7 +952,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 \
@@ -791,60 +962,71 @@ 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):
         speed = max(
                 self.getModifiedItemAttr("speed", 0),  # Most weapons
                 self.getModifiedItemAttr("duration", 0),  # Most average modules
+                self.getModifiedItemAttr("durationHighisGood", 0),  # Most average modules
                 self.getModifiedItemAttr("durationSensorDampeningBurstProjector", 0),
                 self.getModifiedItemAttr("durationTargetIlluminationBurstProjector", 0),
                 self.getModifiedItemAttr("durationECMJammerBurstProjector", 0),
@@ -864,7 +1046,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
@@ -873,7 +1058,6 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
 
     @staticmethod
     def getProposedState(mod, click, proposedState=None):
-        # todo: instead of passing in module, make this a instanced function.
         pyfalog.debug("Get proposed state for module.")
         if mod.slot == FittingSlot.SUBSYSTEM or mod.isEmpty:
             return FittingModuleState.ONLINE
@@ -892,14 +1076,16 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
         elif click == "ctrl":
             state = FittingModuleState.OFFLINE
         else:
-            state = transitionMap[currState]
-            if not mod.isValidState(state):
-                state = -1
+            try:
+                state = transitionMap[currState]
+            except KeyError:
+                state = min(transitionMap)
+            # If passive module tries to transition into online and fails,
+            # put it to passive instead
+            if not mod.isValidState(state) and currState == FittingModuleState.ONLINE:
+                state = FittingModuleState.OFFLINE
 
-        if mod.isValidState(state):
-            return state
-        else:
-            return currState
+        return mod.getMaxState(proposedState=state)
 
     def __deepcopy__(self, memo):
         item = self.item
@@ -909,6 +1095,9 @@ class Module(HandledItem, HandledCharge, ItemAttrShortcut, ChargeAttrShortcut):
             copy = Module(self.item, self.baseItem, self.mutaplasmid)
         copy.charge = self.charge
         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)
@@ -918,10 +1107,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/mutator.py

@@ -73,24 +73,25 @@ class Mutator(EqBase):
             self.dynamicAttribute = next(a for a in self.module.mutaplasmid.attributes if a.attributeID == self.attrID)
             # base attribute links to the base ite's attribute for this mutated definition (contains original, base value)
             self.baseAttribute = self.module.item.attributes[self.dynamicAttribute.name]
+        except (KeyboardInterrupt, SystemExit):
+            raise
         except:
             self.module = None
 
     @validates("value")
     def validator(self, key, val):
         """ Validates values as properly falling within the range of the modules' Mutaplasmid """
+        if self.baseValue == 0:
+            return 0
         mod = val / self.baseValue
 
         if self.minMod <= mod <= self.maxMod:
             # sweet, all good
             returnVal = val
         else:
-            # need to fudge the numbers a bit. Go with the value closest to base
-            if val >= 0:
-                returnVal = min(self.maxValue, max(self.minValue, val))
-            else:
-                returnVal = max(self.maxValue, min(self.minValue, val))
-
+            actualMin = min(self.minValue, self.maxValue)
+            actualMax = max(self.minValue, self.maxValue)
+            returnVal = min(actualMax, max(actualMin, val))
         return returnVal
 
     @property
@@ -116,15 +117,24 @@ class Mutator(EqBase):
 
     @property
     def baseValue(self):
-        return self.baseAttribute.value
+        try:
+            return self.baseAttribute.value
+        except AttributeError:
+            return 0
 
     @property
     def minValue(self):
-        return self.minMod * self.baseAttribute.value
+        try:
+            return self.minMod * self.baseAttribute.value
+        except AttributeError:
+            return 0
 
     @property
     def maxValue(self):
-        return self.maxMod * self.baseAttribute.value
+        try:
+            return self.maxMod * self.baseAttribute.value
+        except AttributeError:
+            return 0
 
     @property
     def attribute(self):

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

@@ -38,14 +38,13 @@ class Ship(ItemAttrShortcut, HandledItem):
         "maxTargetsLockedFromSkills": 2,
         "droneControlRange": 20000,
         "cloaked": False,
-        "siege": False
         # We also have speedLimit for Entosis Link, but there seems to be an
         # issue with naming it exactly "speedLimit" due to unknown reasons.
         # Regardless, we don't have to put it here anyways - it will come up
         # as None unless the Entosis effect sets it.
     }
 
-    def __init__(self, item, parent=None):
+    def __init__(self, item, owner=None):
         self.validate(item)
 
         self.__item = item
@@ -58,9 +57,7 @@ class Ship(ItemAttrShortcut, HandledItem):
         if "maximumRangeCap" in self.__itemModifiedAttributes.original:
             cappingAttrKeyCache["maxTargetRange"] = "maximumRangeCap"
 
-        # there are occasions when we need to get to the parent fit of the ship, such as when we need the character
-        # skills for ship-role gang boosts (Titans)
-        self.parent = parent
+        self.owner = owner
         self.commandBonus = 0
 
     def validate(self, item):
@@ -101,9 +98,9 @@ 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):
+    def validateModeItem(self, item, owner=None):
         """ Checks if provided item is a valid mode """
         items = self.__modeItems
 
@@ -111,7 +108,7 @@ class Ship(ItemAttrShortcut, HandledItem):
             # if we have items, then we are in a tactical destroyer and must have a mode
             if item is None or item not in items:
                 # If provided item is invalid mode, force new one
-                return Mode(items[0])
+                return Mode(items[0], owner=owner)
             return Mode(item)
         return None
 

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

@@ -0,0 +1,454 @@
+# ===============================================================================
+# 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/>.
+# ===============================================================================
+
+import math
+import re
+from collections import OrderedDict
+
+from logbook import Logger
+from sqlalchemy.orm import reconstructor
+
+import eos.db
+
+pyfalog = Logger(__name__)
+
+
+def _t(x):
+    return x
+
+
+def _c(x):
+    return '[' + x + ']'
+
+
+BUILTINS = OrderedDict([
+    # 0 is taken by ideal target profile, composed manually in one of TargetProfile methods
+    (-1, (_t('Uniform (25%)'), 0.25, 0.25, 0.25, 0.25)),
+    (-2, (_t('Uniform (50%)'), 0.50, 0.50, 0.50, 0.50)),
+    (-3, (_t('Uniform (75%)'), 0.75, 0.75, 0.75, 0.75)),
+    (-4, (_t('Uniform (90%)'), 0.90, 0.90, 0.90, 0.90)),
+    (-5, (_c(_t('T1 Resist')) + _t('Shield'), 0.0, 0.20, 0.40, 0.50)),
+    (-6, (_c(_t('T1 Resist')) + _t('Armor'), 0.50, 0.45, 0.25, 0.10)),
+    (-7, (_c(_t('T1 Resist')) + _t('Hull'), 0.33, 0.33, 0.33, 0.33)),
+    (-8, (_c(_t('T1 Resist')) + _t('Shield (+T2 DCU)'), 0.125, 0.30, 0.475, 0.562)),
+    (-9, (_c(_t('T1 Resist')) + _t('Armor (+T2 DCU)'), 0.575, 0.532, 0.363, 0.235)),
+    (-10, (_c(_t('T1 Resist')) + _t('Hull (+T2 DCU)'), 0.598, 0.598, 0.598, 0.598)),
+    (-11, (_c(_t('T2 Resist')) + _t('Amarr (Shield)'), 0.0, 0.20, 0.70, 0.875)),
+    (-12, (_c(_t('T2 Resist')) + _t('Amarr (Armor)'), 0.50, 0.35, 0.625, 0.80)),
+    (-13, (_c(_t('T2 Resist')) + _t('Caldari (Shield)'), 0.20, 0.84, 0.76, 0.60)),
+    (-14, (_c(_t('T2 Resist')) + _t('Caldari (Armor)'), 0.50, 0.8625, 0.625, 0.10)),
+    (-15, (_c(_t('T2 Resist')) + _t('Gallente (Shield)'), 0.0, 0.60, 0.85, 0.50)),
+    (-16, (_c(_t('T2 Resist')) + _t('Gallente (Armor)'), 0.50, 0.675, 0.8375, 0.10)),
+    (-17, (_c(_t('T2 Resist')) + _t('Minmatar (Shield)'), 0.75, 0.60, 0.40, 0.50)),
+    (-18, (_c(_t('T2 Resist')) + _t('Minmatar (Armor)'), 0.90, 0.675, 0.25, 0.10)),
+    (-19, (_c(_t('NPC')) + _c(_t('Asteroid')) + _t('Angel Cartel'), 0.54, 0.42, 0.37, 0.32)),
+    (-20, (_c(_t('NPC')) + _c(_t('Asteroid')) + _t('Blood Raiders'), 0.34, 0.39, 0.45, 0.52)),
+    (-21, (_c(_t('NPC')) + _c(_t('Asteroid')) + _t('Guristas'), 0.55, 0.35, 0.3, 0.48)),
+    (-22, (_c(_t('NPC')) + _c(_t('Asteroid')) + _t('Rogue Drones'), 0.35, 0.38, 0.44, 0.49)),
+    (-23, (_c(_t('NPC')) + _c(_t('Asteroid')) + _t('Sanshas Nation'), 0.35, 0.4, 0.47, 0.53)),
+    (-24, (_c(_t('NPC')) + _c(_t('Asteroid')) + _t('Serpentis'), 0.49, 0.38, 0.29, 0.51)),
+    (-25, (_c(_t('NPC')) + _c(_t('Deadspace')) + _t('Angel Cartel'), 0.59, 0.48, 0.4, 0.32)),
+    (-26, (_c(_t('NPC')) + _c(_t('Deadspace')) + _t('Blood Raiders'), 0.31, 0.39, 0.47, 0.56)),
+    (-27, (_c(_t('NPC')) + _c(_t('Deadspace')) + _t('Guristas'), 0.57, 0.39, 0.31, 0.5)),
+    (-28, (_c(_t('NPC')) + _c(_t('Deadspace')) + _t('Rogue Drones'), 0.42, 0.42, 0.47, 0.49)),
+    (-29, (_c(_t('NPC')) + _c(_t('Deadspace')) + _t('Sanshas Nation'), 0.31, 0.39, 0.47, 0.56)),
+    (-30, (_c(_t('NPC')) + _c(_t('Deadspace')) + _t('Serpentis'), 0.49, 0.38, 0.29, 0.56)),
+    (-31, (_c(_t('NPC')) + _c(_t('Mission')) + _t('Amarr Empire'), 0.34, 0.38, 0.42, 0.46)),
+    (-32, (_c(_t('NPC')) + _c(_t('Mission')) + _t('Caldari State'), 0.51, 0.38, 0.3, 0.51)),
+    (-33, (_c(_t('NPC')) + _c(_t('Mission')) + _t('CONCORD'), 0.47, 0.46, 0.47, 0.47)),
+    (-34, (_c(_t('NPC')) + _c(_t('Mission')) + _t('Gallente Federation'), 0.51, 0.38, 0.31, 0.52)),
+    (-35, (_c(_t('NPC')) + _c(_t('Mission')) + _t('Khanid'), 0.51, 0.42, 0.36, 0.4)),
+    (-36, (_c(_t('NPC')) + _c(_t('Mission')) + _t('Minmatar Republic'), 0.51, 0.46, 0.41, 0.35)),
+    (-37, (_c(_t('NPC')) + _c(_t('Mission')) + _t('Mordus Legion'), 0.32, 0.48, 0.4, 0.62)),
+    (-38, (_c(_t('NPC')) + _c(_t('Other')) + _t('Sleeper'), 0.61, 0.61, 0.61, 0.61)),
+    (-39, (_c(_t('NPC')) + _c(_t('Other')) + _t('Sansha Incursion'), 0.65, 0.63, 0.64, 0.65)),
+    (-40, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Cruor (Blood Raiders)'), 0.8, 0.73, 0.69, 0.67)),
+    (-41, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Dramiel (Angel)'), 0.35, 0.48, 0.61, 0.68)),
+    (-42, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Daredevil (Serpentis)'), 0.69, 0.59, 0.59, 0.43)),
+    (-43, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Succubus (Sanshas Nation)'), 0.35, 0.48, 0.61, 0.68)),
+    (-44, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Worm (Guristas)'), 0.48, 0.58, 0.69, 0.74)),
+    (-45, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Enyo'), 0.58, 0.72, 0.86, 0.24)),
+    (-46, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Hawk'), 0.3, 0.86, 0.79, 0.65)),
+    (-47, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Jaguar'), 0.78, 0.65, 0.48, 0.56)),
+    (-48, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Vengeance'), 0.66, 0.56, 0.75, 0.86)),
+    (-49, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Ashimmu (Blood Raiders)'), 0.8, 0.76, 0.68, 0.7)),
+    (-50, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Talos'), 0.68, 0.59, 0.59, 0.43)),
+    (-51, (_c(_t('NPC')) + _c(_t('Burner')) + _t('Sentinel'), 0.58, 0.45, 0.52, 0.66)),
+    # Source: ticket #2067
+    (-52, (_c(_t('NPC')) + _c(_t('Invasion')) + _t('Triglavian Entities'), 0.422, 0.367, 0.453, 0.411)),
+    (-53, (_c(_t('NPC')) + _c(_t('Invasion')) + _t('Amarr EDENCOM Entities'), 0.360, 0.310, 0.441, 0.602)),
+    (-54, (_c(_t('NPC')) + _c(_t('Invasion')) + _t('Caldari EDENCOM Entities'), 0.303, 0.610, 0.487, 0.401)),
+    (-55, (_c(_t('NPC')) + _c(_t('Invasion')) + _t('Gallente EDENCOM Entities'), 0.383, 0.414, 0.578, 0.513)),
+    (-56, (_c(_t('NPC')) + _c(_t('Invasion')) + _t('Minmatar EDENCOM Entities'), 0.620, 0.422, 0.355, 0.399)),
+    (-57, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Dark Matter All Tiers')) + _t('Drones'), 0.439, 0.522, 0.529, 0.435)),
+    (-58, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Dark Matter All Tiers')) + _t('Overmind'), 0.643, 0.593, 0.624, 0.639)),
+    (-59, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Dark Matter All Tiers')) + _t('Seeker'), 0.082, 0.082, 0.082, 0.082)),
+    (-60, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Dark Matter All Tiers')) + _t('Triglavian'), 0.494, 0.41, 0.464, 0.376)),
+    (-61, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Dark Matter All Tiers')) + _t('Drifter'), 0.415, 0.415, 0.415, 0.415)),
+    (-62, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Dark Matter All Tiers')) + _t('Sleeper'), 0.435, 0.435, 0.435, 0.435)),
+    (-63, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Dark Matter All Tiers')) + _t('All'), 0.508, 0.474, 0.495, 0.488)),
+    (-64, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T0/T1/T2')) + _t('Drones'), 0.323, 0.522, 0.529, 0.435)),
+    (-65, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T0/T1/T2')) + _t('Overmind'), 0.542, 0.593, 0.624, 0.639)),
+    (-66, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T0/T1/T2')) + _t('Seeker'), 0, 0.082, 0.082, 0.082)),
+    (-67, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T0/T1/T2')) + _t('Triglavian'), 0.356, 0.41, 0.464, 0.376)),
+    (-68, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T0/T1/T2')) + _t('Drifter'), 0.277, 0.415, 0.415, 0.415)),
+    (-69, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T0/T1/T2')) + _t('Sleeper'), 0.329, 0.435, 0.435, 0.435)),
+    (-70, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T0/T1/T2')) + _t('All'), 0.381, 0.474, 0.495, 0.488)),
+    (-71, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T3 (Some T5 Rooms)')) + _t('Drones'), 0.255, 0.522, 0.529, 0.435)),
+    (-72, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T3 (Some T5 Rooms)')) + _t('Overmind'), 0.48, 0.593, 0.624, 0.639)),
+    (-73, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T3 (Some T5 Rooms)')) + _t('Seeker'), 0, 0.082, 0.082, 0.0822)),
+    (-74, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T3 (Some T5 Rooms)')) + _t('Triglavian'), 0.268, 0.41, 0.464, 0.376)),
+    (-75, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T3 (Some T5 Rooms)')) + _t('Drifter'), 0.191, 0.415, 0.415, 0.415)),
+    (-76, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T3 (Some T5 Rooms)')) + _t('Sleeper'), 0.268, 0.435, 0.435, 0.435)),
+    (-77, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T3 (Some T5 Rooms)')) + _t('All'), 0.308, 0.474, 0.495, 0.488)),
+    (-78, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T4/T5/T6')) + _t('Drones'), 0.193, 0.522, 0.529, 0.435)),
+    (-79, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T4/T5/T6')) + _t('Overmind'), 0.423, 0.593, 0.624, 0.639)),
+    (-80, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T4/T5/T6')) + _t('Seeker'), 0, 0.082, 0.082, 0.082)),
+    (-81, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T4/T5/T6')) + _t('Triglavian'), 0.206, 0.41, 0.464, 0.376)),
+    (-82, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T4/T5/T6')) + _t('Drifter'), 0.111, 0.415, 0.415, 0.415)),
+    (-83, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T4/T5/T6')) + _t('Sleeper'), 0.215, 0.435, 0.435, 0.435)),
+    (-84, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T4/T5/T6')) + _t('All'), 0.247, 0.474, 0.495, 0.488)),
+    (-85, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T0/T1/T2')) + _t('Drones'), 0.461, 0.425, 0.541, 0.443)),
+    (-86, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T0/T1/T2')) + _t('Overmind'), 0.666, 0.489, 0.634, 0.646)),
+    (-87, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T0/T1/T2')) + _t('Seeker'), 0.084, 0, 0.084, 0.084)),
+    (-88, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T0/T1/T2')) + _t('Triglavian'), 0.537, 0.269, 0.489, 0.371)),
+    (-89, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T0/T1/T2')) + _t('Drifter'), 0.43, 0.289, 0.43, 0.43)),
+    (-90, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T0/T1/T2')) + _t('Sleeper'), 0.512, 0.402, 0.512, 0.512)),
+    (-91, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T0/T1/T2')) + _t('All'), 0.537, 0.352, 0.512, 0.495)),
+    (-92, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T3 (Some T5 Rooms)')) + _t('Drones'), 0.461, 0.36, 0.541, 0.443)),
+    (-93, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T3 (Some T5 Rooms)')) + _t('Overmind'), 0.666, 0.413, 0.634, 0.646)),
+    (-94, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T3 (Some T5 Rooms)')) + _t('Seeker'), 0.084, 0, 0.084, 0.084)),
+    (-95, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T3 (Some T5 Rooms)')) + _t('Triglavian'), 0.537, 0.166, 0.489, 0.371)),
+    (-96, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T3 (Some T5 Rooms)')) + _t('Drifter'), 0.43, 0.201, 0.43, 0.43)),
+    (-97, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T3 (Some T5 Rooms)')) + _t('Sleeper'), 0.512, 0.337, 0.512, 0.512)),
+    (-98, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T3 (Some T5 Rooms)')) + _t('All'), 0.537, 0.269, 0.512, 0.495)),
+    (-99, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T4/T5/T6')) + _t('Drones'), 0.461, 0.305, 0.541, 0.443)),
+    (-100, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T4/T5/T6')) + _t('Overmind'), 0.666, 0.345, 0.634, 0.646)),
+    (-101, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T4/T5/T6')) + _t('Seeker'), 0.084, 0, 0.084, 0.084)),
+    (-102, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T4/T5/T6')) + _t('Triglavian'), 0.537, 0.085, 0.489, 0.371)),
+    (-103, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T4/T5/T6')) + _t('Drifter'), 0.43, 0.117, 0.43, 0.43)),
+    (-104, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T4/T5/T6')) + _t('Sleeper'), 0.512, 0.276, 0.512, 0.512)),
+    (-105, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T4/T5/T6')) + _t('All'), 0.537, 0.201, 0.512, 0.495)),
+    (-106, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T0/T1/T2')) + _t('Drones'), 0.439, 0.522, 0.417, 0.435)),
+    (-107, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T0/T1/T2')) + _t('Overmind'), 0.643, 0.593, 0.511, 0.639)),
+    (-108, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T0/T1/T2')) + _t('Seeker'), 0.082, 0.082, 0, 0.082)),
+    (-109, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T0/T1/T2')) + _t('Triglavian'), 0.494, 0.41, 0.304, 0.376)),
+    (-110, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T0/T1/T2')) + _t('Drifter'), 0.415, 0.415, 0.277, 0.415)),
+    (-111, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T0/T1/T2')) + _t('Sleeper'), 0.435, 0.435, 0.329, 0.435)),
+    (-112, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T0/T1/T2')) + _t('All'), 0.508, 0.474, 0.359, 0.488)),
+    (-113, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T3 (Some T5 Rooms)')) + _t('Drones'), 0.439, 0.522, 0.351, 0.435)),
+    (-114, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T3 (Some T5 Rooms)')) + _t('Overmind'), 0.643, 0.593, 0.435, 0.639)),
+    (-115, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T3 (Some T5 Rooms)')) + _t('Seeker'), 0.082, 0.082, 0, 0.082)),
+    (-116, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T3 (Some T5 Rooms)')) + _t('Triglavian'), 0.494, 0.41, 0.198, 0.376)),
+    (-117, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T3 (Some T5 Rooms)')) + _t('Drifter'), 0.415, 0.415, 0.191, 0.415)),
+    (-118, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T3 (Some T5 Rooms)')) + _t('Sleeper'), 0.435, 0.435, 0.268, 0.435)),
+    (-119, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T3 (Some T5 Rooms)')) + _t('All'), 0.508, 0.474, 0.276, 0.488)),
+    (-120, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T4/T5/T6')) + _t('Drones'), 0.439, 0.522, 0.293, 0.435)),
+    (-121, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T4/T5/T6')) + _t('Overmind'), 0.643, 0.593, 0.362, 0.639)),
+    (-122, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T4/T5/T6')) + _t('Seeker'), 0.082, 0.082, 0, 0.082)),
+    (-123, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T4/T5/T6')) + _t('Triglavian'), 0.494, 0.41, 0.122, 0.376)),
+    (-124, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T4/T5/T6')) + _t('Drifter'), 0.415, 0.415, 0.111, 0.415)),
+    (-125, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T4/T5/T6')) + _t('Sleeper'), 0.435, 0.435, 0.215, 0.435)),
+    (-126, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T4/T5/T6')) + _t('All'), 0.508, 0.474, 0.208, 0.488)),
+    (-127, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T0/T1/T2')) + _t('Drones'), 0.449, 0.54, 0.549, 0.336)),
+    (-128, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T0/T1/T2')) + _t('Overmind'), 0.619, 0.574, 0.612, 0.522)),
+    (-129, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T0/T1/T2')) + _t('Seeker'), 0.085, 0.085, 0.085, 0)),
+    (-130, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T0/T1/T2')) + _t('Triglavian'), 0.477, 0.4, 0.461, 0.202)),
+    (-131, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T0/T1/T2')) + _t('Drifter'), 0.437, 0.437, 0.437, 0.295)),
+    (-132, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T0/T1/T2')) + _t('Sleeper'), 0.435, 0.435, 0.435, 0.329)),
+    (-133, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T0/T1/T2')) + _t('All'), 0.493, 0.468, 0.492, 0.35)),
+    (-134, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T3 (Some T5 Rooms)')) + _t('Drones'), 0.449, 0.54, 0.549, 0.264)),
+    (-135, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T3 (Some T5 Rooms)')) + _t('Overmind'), 0.619, 0.574, 0.612, 0.449)),
+    (-136, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T3 (Some T5 Rooms)')) + _t('Seeker'), 0.085, 0.085, 0.085, 0)),
+    (-137, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T3 (Some T5 Rooms)')) + _t('Triglavian'), 0.477, 0.4, 0.461, 0.081)),
+    (-138, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T3 (Some T5 Rooms)')) + _t('Drifter'), 0.437, 0.437, 0.437, 0.206)),
+    (-139, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T3 (Some T5 Rooms)')) + _t('Sleeper'), 0.435, 0.435, 0.435, 0.268)),
+    (-140, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T3 (Some T5 Rooms)')) + _t('All'), 0.493, 0.468, 0.492, 0.264)),
+    (-141, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T4/T5/T6')) + _t('Drones'), 0.449, 0.54, 0.549, 0.197)),
+    (-142, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T4/T5/T6')) + _t('Overmind'), 0.619, 0.574, 0.612, 0.379)),
+    (-143, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T4/T5/T6')) + _t('Seeker'), 0.085, 0.085, 0.085, 0)),
+    (-144, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T4/T5/T6')) + _t('Triglavian'), 0.477, 0.4, 0.461, 0.034)),
+    (-145, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T4/T5/T6')) + _t('Drifter'), 0.437, 0.437, 0.437, 0.121)),
+    (-146, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T4/T5/T6')) + _t('Sleeper'), 0.435, 0.435, 0.435, 0.215)),
+    (-147, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T4/T5/T6')) + _t('All'), 0.493, 0.468, 0.492, 0.196)),
+    # Source: ticket #2265
+    (-148, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Dark Matter All Tiers')) + _t('Concord'), 0.324, 0.318, 0.369, 0.372)),
+    (-149, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Dark Matter All Tiers')) + _t('Sansha'), 0.137, 0.331, 0.332, 0.322)),
+    (-150, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Dark Matter All Tiers')) + _t('Angel'), 0.582, 0.508, 0.457, 0.416)),
+    (-151, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T0/T1/T2')) + _t('Concord'), 0.121, 0.318, 0.369, 0.372)),
+    (-152, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T0/T1/T2')) + _t('Sansha'), 0.034, 0.331, 0.332, 0.322)),
+    (-153, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T0/T1/T2')) + _t('Angel'), 0.456, 0.508, 0.457, 0.416)),
+    (-154, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T3 (Some T5 Rooms)')) + _t('Concord'), 0.025, 0.318, 0.369, 0.372)),
+    (-155, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T3 (Some T5 Rooms)')) + _t('Sansha'), 0.018, 0.331, 0.332, 0.322)),
+    (-156, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T3 (Some T5 Rooms)')) + _t('Angel'), 0.373, 0.508, 0.457, 0.416)),
+    (-157, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T4/T5/T6')) + _t('Concord'), 0.008, 0.318, 0.369, 0.372)),
+    (-158, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T4/T5/T6')) + _t('Sansha'), 0.009, 0.331, 0.332, 0.322)),
+    (-159, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Electrical T4/T5/T6')) + _t('Angel'), 0.3, 0.508, 0.457, 0.416)),
+    (-160, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T0/T1/T2')) + _t('Concord'), 0.324, 0.107, 0.369, 0.372)),
+    (-161, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T0/T1/T2')) + _t('Sansha'), 0.148, 0.181, 0.329, 0.328)),
+    (-162, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T0/T1/T2')) + _t('Angel'), 0.587, 0.342, 0.439, 0.39)),
+    (-163, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T3 (Some T5 Rooms)')) + _t('Concord'), 0.324, 0.016, 0.369, 0.372)),
+    (-164, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T3 (Some T5 Rooms)')) + _t('Sansha'), 0.148, 0.14, 0.329, 0.328)),
+    (-165, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T3 (Some T5 Rooms)')) + _t('Angel'), 0.587, 0.241, 0.439, 0.39)),
+    (-166, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T4/T5/T6')) + _t('Concord'), 0.324, 0.004, 0.369, 0.372)),
+    (-167, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T4/T5/T6')) + _t('Sansha'), 0.148, 0.106, 0.329, 0.328)),
+    (-168, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Firestorm T4/T5/T6')) + _t('Angel'), 0.587, 0.172, 0.439, 0.39)),
+    (-169, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T0/T1/T2')) + _t('Concord'), 0.324, 0.318, 0.18, 0.372)),
+    (-170, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T0/T1/T2')) + _t('Sansha'), 0.137, 0.331, 0.166, 0.322)),
+    (-171, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T0/T1/T2')) + _t('Angel'), 0.582, 0.508, 0.295, 0.416)),
+    (-172, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T3 (Some T5 Rooms)')) + _t('Concord'), 0.324, 0.318, 0.089, 0.372)),
+    (-173, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T3 (Some T5 Rooms)')) + _t('Sansha'), 0.137, 0.331, 0.108, 0.322)),
+    (-174, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T3 (Some T5 Rooms)')) + _t('Angel'), 0.582, 0.508, 0.203, 0.416)),
+    (-175, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T4/T5/T6')) + _t('Concord'), 0.324, 0.318, 0.068, 0.372)),
+    (-176, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T4/T5/T6')) + _t('Sansha'), 0.137, 0.331, 0.073, 0.322)),
+    (-177, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Exotic T4/T5/T6')) + _t('Angel'), 0.582, 0.508, 0.14, 0.416)),
+    (-178, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T0/T1/T2')) + _t('Concord'), 0.324, 0.318, 0.369, 0.203)),
+    (-179, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T0/T1/T2')) + _t('Sansha'), 0.137, 0.355, 0.352, 0.16)),
+    (-180, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T0/T1/T2')) + _t('Angel'), 0.59, 0.528, 0.477, 0.286)),
+    (-181, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T3 (Some T5 Rooms)')) + _t('Concord'), 0.324, 0.318, 0.369, 0.112)),
+    (-182, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T3 (Some T5 Rooms)')) + _t('Sansha'), 0.137, 0.355, 0.352, 0.05)),
+    (-183, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T3 (Some T5 Rooms)')) + _t('Angel'), 0.59, 0.528, 0.477, 0.197)),
+    (-184, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T4/T5/T6')) + _t('Concord'), 0.324, 0.318, 0.369, 0.086)),
+    (-185, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T4/T5/T6')) + _t('Sansha'), 0.137, 0.355, 0.352, 0)),
+    (-186, (_c(_t('NPC')) + _c(_t('Abyssal')) + _c(_t('Gamma T4/T5/T6')) + _t('Angel'), 0.59, 0.528, 0.477, 0.126)),
+    (-187, (_c(_t('NPC')) + _c(_t('Invasion')) + _t('Drifter Entities'), 0.128, 0.375, 0.383, 0.383)),
+    (-188, (_c(_t('NPC')) + _c(_t('Invasion')) + _t('Rogue Drone Entities'), 0.104, 0.147, 0.147, 0.102)),
+    (-189, (_c(_t('NPC')) + _c(_t('Invasion')) + _t('Sleeper Entities'), 0.563, 0.563, 0.563, 0.563))])
+
+
+class TargetProfile:
+    # also determined import/export order - VERY IMPORTANT
+    DAMAGE_TYPES = ('em', 'thermal', 'kinetic', 'explosive')
+    _idealTarget = None
+    _builtins = None
+
+    def __init__(self, *args, **kwargs):
+        self.builtin = False
+        self.update(*args, **kwargs)
+
+    @reconstructor
+    def init(self):
+        self.builtin = False
+
+    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
+
+    @classmethod
+    def getBuiltinList(cls):
+        if cls._builtins is None:
+            cls.__generateBuiltins()
+        return list(cls._builtins.values())
+
+    @classmethod
+    def getBuiltinById(cls, id):
+        if cls._builtins is None:
+            cls.__generateBuiltins()
+        return cls._builtins.get(id)
+
+    @classmethod
+    def __generateBuiltins(cls):
+        cls._builtins = OrderedDict()
+        for id, data in BUILTINS.items():
+            rawName = data[0]
+            data = data[1:]
+            profile = TargetProfile(*data)
+            profile.ID = id
+            profile.rawName = rawName
+            profile.builtin = True
+            cls._builtins[id] = profile
+
+    @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.rawName = _t('Ideal Target')
+            cls._idealTarget.ID = 0
+            cls._idealTarget.builtin = True
+        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):
+        lines = re.split('[\n\r]+', text)
+        patterns = []
+        numPatterns = 0
+
+        # 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.getTargetProfileList()
+        for pattern in current:
+            lookup[pattern.rawName] = pattern
+
+        for line in lines:
+            try:
+                if line.strip()[0] == "#":  # comments
+                    continue
+                line = line.split('#', 1)[0]  # allows for comments
+                type, data = line.rsplit('=', 1)
+                type, data = type.strip(), [d.strip() for d in data.split(',')]
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except:
+                pyfalog.warning("Data isn't in correct format, continue to next line.")
+                continue
+
+            if type not in ("TargetProfile", "TargetResists"):
+                continue
+
+            numPatterns += 1
+            name, dataRes, dataMisc = data[0], data[1:5], data[5:8]
+            fields = {}
+
+            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
+                except (KeyboardInterrupt, SystemExit):
+                    raise
+                except:
+                    pyfalog.warning("Caught unhandled exception in import patterns.")
+                    continue
+
+            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 = TargetProfile(**fields)
+                    pattern.rawName = name.strip()
+                    eos.db.save(pattern)
+                patterns.append(pattern)
+
+        eos.db.commit()
+
+        return patterns, numPatterns
+
+    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 += "# 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.rawName,
+                dp.emAmount * 100,
+                dp.thermalAmount * 100,
+                dp.kineticAmount * 100,
+                dp.explosiveAmount * 100,
+                dp.maxVelocity,
+                dp.signatureRadius,
+                dp.radius
+            )
+
+        return out.strip()
+
+    @property
+    def name(self):
+        return self.rawName
+
+    @property
+    def fullName(self):
+        categories, tail = self.__parseRawName()
+        return '{}{}'.format(''.join('[{}]'.format(c) for c in categories), tail)
+
+    @property
+    def shortName(self):
+        return self.__parseRawName()[1]
+
+    @property
+    def hierarchy(self):
+        return self.__parseRawName()[0]
+
+    def __parseRawName(self):
+        hierarchy = []
+        remainingName = self.rawName.strip() if self.rawName else ''
+        while True:
+            start, end = remainingName.find('['), remainingName.find(']')
+            if start == -1 or end == -1:
+                return hierarchy, remainingName
+            splitter = remainingName.find('|')
+            if splitter != -1 and splitter == start - 1:
+                return hierarchy, remainingName[1:]
+            hierarchy.append(remainingName[start + 1:end])
+            remainingName = remainingName[end + 1:].strip()
+
+    def __deepcopy__(self, memo):
+        p = TargetProfile(
+                self.emAmount, self.thermalAmount, self.kineticAmount, self.explosiveAmount,
+                self._maxVelocity, self._signatureRadius, self._radius)
+        p.rawName = "%s copy" % self.rawName
+        return p

eos/saveddata/targetResists.py

@@ -1,116 +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/>.
-# ===============================================================================
-
-import re
-from logbook import Logger
-import eos.db
-
-pyfalog = Logger(__name__)
-
-
-class TargetResists(object):
-    # 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):
-        self.emAmount = emAmount
-        self.thermalAmount = thermalAmount
-        self.kineticAmount = kineticAmount
-        self.explosiveAmount = explosiveAmount
-
-    @classmethod
-    def importPatterns(cls, text):
-        lines = re.split('[\n\r]+', text)
-        patterns = []
-        numPatterns = 0
-
-        # 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()
-        for pattern in current:
-            lookup[pattern.name] = pattern
-
-        for line in lines:
-            try:
-                if line.strip()[0] == "#":  # comments
-                    continue
-                line = line.split('#', 1)[0]  # allows for comments
-                type, data = line.rsplit('=', 1)
-                type, data = type.strip(), data.split(',')
-            except:
-                pyfalog.warning("Data isn't in correct format, continue to next line.")
-                continue
-
-            if type != "TargetResists":
-                continue
-
-            numPatterns += 1
-            name, data = data[0], data[1:5]
-            fields = {}
-
-            for index, val in enumerate(data):
-                val = float(val)
-                try:
-                    assert 0 <= val <= 100
-                    fields["%sAmount" % cls.DAMAGE_TYPES[index]] = val / 100
-                except:
-                    pyfalog.warning("Caught unhandled exception in import patterns.")
-                    continue
-
-            if len(fields) == 4:  # 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.name = name.strip()
-                    eos.db.save(pattern)
-                patterns.append(pattern)
-
-        eos.db.commit()
-
-        return patterns, numPatterns
-
-    EXPORT_FORMAT = "TargetResists = %s,%.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"
-        for dp in patterns:
-            out += cls.EXPORT_FORMAT % (
-                dp.name,
-                dp.emAmount * 100,
-                dp.thermalAmount * 100,
-                dp.kineticAmount * 100,
-                dp.explosiveAmount * 100
-            )
-
-        return out.strip()
-
-    def __deepcopy__(self, memo):
-        p = TargetResists(self.emAmount, self.thermalAmount, self.kineticAmount, self.explosiveAmount)
-        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/pyinst_support.py

@@ -0,0 +1,39 @@
+"""
+Slightly modified version of function taken from here:
+https://github.com/pyinstaller/pyinstaller/issues/1905#issuecomment-525221546
+"""
+
+
+import pkgutil
+
+
+def iterNamespace(name, path):
+    """Pyinstaller-compatible namespace iteration.
+
+    Yields the name of all modules found at a given Fully-qualified path.
+
+    To have it running with pyinstaller, it requires to ensure a hook inject the
+    "hidden" modules from your plugins folder inside the executable:
+
+    - if your plugins are under the ``myappname/pluginfolder`` module
+    - create a file ``specs/hook-<myappname.pluginfolder>.py``
+    - content of this file should be:
+
+        .. code-block:: python
+
+            from PyInstaller.utils.hooks import collect_submodules
+            hiddenimports = collect_submodules('<myappname.pluginfolder>')
+    """
+    prefix = name + "."
+    for p in pkgutil.iter_modules(path, prefix):
+        yield p[1]
+
+    # special handling when the package is bundled with PyInstaller 3.5
+    # See https://github.com/pyinstaller/pyinstaller/issues/1905#issuecomment-445787510
+    toc = set()
+    for importer in pkgutil.iter_importers(name.partition(".")[0]):
+        if hasattr(importer, 'toc'):
+            toc |= importer.toc
+    for name in toc:
+        if name.startswith(prefix):
+            yield name

eos/utils/round.py

@@ -0,0 +1,27 @@
+import math
+
+
+def roundToPrec(val, prec, nsValue=None):
+    """
+    nsValue: custom value which should be used to determine normalization shift
+    """
+    # We're not rounding integers anyway
+    # Also make sure that we do not ask to calculate logarithm of zero
+    if int(val) == val:
+        return int(val)
+    roundFactor = int(prec - math.floor(math.log10(abs(val if nsValue is None else nsValue))) - 1)
+    # But we don't want to round integers
+    if roundFactor < 0:
+        roundFactor = 0
+    # Do actual rounding
+    val = round(val, roundFactor)
+    # Make sure numbers with .0 part designating float don't get through
+    if int(val) == val:
+        val = int(val)
+    return val
+
+
+def roundDec(val, prec):
+    if int(val) == val:
+        return int(val)
+    return round(val, prec)

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,14 @@
 # ===============================================================================
 
 
+from eos.utils.float import floatUnerr
+from utils.repr import makeReprStr
+
+
+def _t(x):
+    return x
+
+
 class DmgTypes:
     """Container for damage data stats."""
 
@@ -39,12 +47,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 +78,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 = [_t('em'), _t('th'), _t('kin'), _t('exp')] if short else [_t('em'), _t('thermal'), _t('kinetic'), _t('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