feat: Add config for flesh spells: fleshSpellsCauseSlowness, diamondFleshArmorBonus, diamondFleshArmorToughnessBonus, ironFleshArmorBonus, oakFleshArmorBonus, oakFleshHealthBonus

- Add condenserAmountMultiplier setting with default value 1.0

.forge/update.json

@@ -1,7 +1,7 @@
 {
     "homepage": "https://www.curseforge.com/minecraft/mc-mods/electroblobs-wizardry",
     "promos": {
-        "1.12.2-latest": "4.3.10",
-        "1.12.2-recommended": "4.3.10"
+        "1.12.2-latest": "4.3.15",
+        "1.12.2-recommended": "4.3.15"
     }
 }

build.gradle

@@ -1,64 +1,130 @@
+import groovy.json.JsonOutput
+
 buildscript {
     repositories {
-        jcenter()
-        maven { url = "http://files.minecraftforge.net/maven" }
+        gradlePluginPortal()
+        maven {
+            name 'MinecraftForge'
+            url 'https://maven.minecraftforge.net/'
+        }
+        maven {
+            name 'Garden of Fancy'
+            url 'https://maven.gofancy.wtf/releases'
+        }
+        //fallback for fancygradle maven
+        //mavenLocal()
+        maven {
+            name 'Sponge'
+            url 'https://repo.spongepowered.org/repository/maven-public/'
+        }
     }
     dependencies {
-        classpath 'net.minecraftforge.gradle:ForgeGradle:2.3-SNAPSHOT'
+        classpath 'net.minecraftforge.gradle:ForgeGradle:5.+'
+        classpath 'org.ajoberstar.grgit:grgit-gradle:3.1.1'
+        classpath group: 'wtf.gofancy.fancygradle', name: 'wtf.gofancy.fancygradle.gradle.plugin', version: '1.1.+'
+    }
+
+    repositories.each {
+        if (it instanceof MavenArtifactRepository && it.url.toString() == "https://files.minecraftforge.net/maven") {
+            it.url = "https://maven.minecraftforge.net"
+        }
     }
 }
-apply plugin: 'net.minecraftforge.gradle.forge'
-//Only edit below this line, the above code adds and enables the necessary things for Forge to be setup.
+
+apply plugin: 'net.minecraftforge.gradle'
+apply plugin: 'idea'
+apply plugin: 'maven-publish'
+apply plugin: org.ajoberstar.grgit.gradle.GrgitPlugin
+apply plugin: 'wtf.gofancy.fancygradle'
 
 
-version = "4.3.10"
+version = "4.3.15"
 group= "electroblob.wizardry"// http://maven.apache.org/guides/mini/guide-naming-conventions.html
 archivesBaseName = "ElectroblobsWizardry"
 
-sourceCompatibility = targetCompatibility = "1.8" // Need this here so eclipse task generates correctly.
-compileJava {
-    sourceCompatibility = targetCompatibility = "1.8"
+sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = '1.8' // Need this here so eclipse task generates correctly.
+
+
+minecraft {
+    // The mappings can be changed at any time, and must be in the following format.
+    // snapshot_YYYYMMDD   Snapshot are built nightly.
+    // stable_#            Stables are built at the discretion of the MCP team.
+    // Use non-default mappings at your own risk. they may not always work.
+    // Simply re-run your setup task after changing the mappings to update your workspace.
+    //mappings channel: 'snapshot', version: '20171003-1.12'
+    mappings channel: "stable", version: "39-1.12"
+    // makeObfSourceJar = false // an Srg named sources jar is made by default. uncomment this to disable.
+
+    // accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg')
+
+    // Default run configurations.
+    // These can be tweaked, removed, or duplicated as needed.
+
+    def argsz = ['--username', 'WinDanesz', '--user', 'WinDanesz', '--uuid', '7faee354-8c60-4f5c-9862-fc0ce5f7f575']
+    runs {
+        client {
+            workingDirectory project.file('run')
+
+            // Recommended logging data for a userdev environment
+            property 'forge.logging.markers', 'SCAN,REGISTRIES,REGISTRYDUMP'
+
+            // Recommended logging level for the console
+            property 'forge.logging.console.level', 'info'
+            args argsz
+        }
+
+        server {
+
+            // Recommended logging data for a userdev environment
+            property 'forge.logging.markers', 'SCAN,REGISTRIES,REGISTRYDUMP'
+
+            // Recommended logging level for the console
+            property 'forge.logging.console.level', 'info'
+        }
+    }
 }
 
 repositories {
+    google()
+    mavenCentral()
     maven {
-        // location of the maven that hosts JEI files
-        name = "Progwml6 maven"
-        url = "http://dvs1.progwml6.com/files/maven"
+        url = uri('https://www.cursemaven.com')
+        content {
+            includeGroup 'curse.maven'
+        }
     }
     maven {
-        // location of a maven mirror for JEI files, as a fallback
-        name = "ModMaven"
-        url = "modmaven.k-4u.nl"
+        name = 'Modrinth'
+        url = uri('https://api.modrinth.com/maven')
+        content {
+            includeGroup 'maven.modrinth'
+        }
     }
     maven {
-        name = "Curseforge Maven"
-        url = "https://minecraft.curseforge.com/api/maven/"
+        name = 'Sponge'
+        url = uri('https://repo.spongepowered.org/maven')
+    }
+    maven {
+        url = uri('https://maven.blamejared.com')
+    }
+    maven {
+        url = uri('https://m2.dv8tion.net/releases')
+    }
+    maven {
+        url = uri('https://jitpack.io')
     }
-}
-
-minecraft {
-    version = "1.12.2-14.23.5.2847"
-    runDir = "run"
-    
-    // the mappings can be changed at any time, and must be in the following format.
-    // snapshot_YYYYMMDD   snapshot are built nightly.
-    // stable_#            stables are built at the discretion of the MCP team.
-    // Use non-default mappings at your own risk. they may not always work.
-    // simply re-run your setup task after changing the mappings to update your workspace.
-    mappings = "stable_39"
-    // makeObfSourceJar = false // an Srg named sources jar is made by default. uncomment this to disable.
 }
 
 dependencies {
-
-    // Compile against the JEI API but do not include it at runtime
-    deobfProvided "mezz.jei:jei_${mc_version}:${jei_version}:api"
-    // At runtime, use the full JEI jar
-    runtime "mezz.jei:jei_${mc_version}:${jei_version}"
-
-    deobfCompile "baubles:Baubles:${mc_version_short}:${baubles_version}"
-    deobfCompile "antique-atlas:antiqueatlas:${mc_version}:${antique_atlas_version}"
+    //// MC version ////
+    // Specify the version of Minecraft to use, If this is any group other then 'net.minecraft' it is assumed
+    // that the dep is a ForgeGradle 'patcher' dependency. And it's patches will be applied.
+    // The userdev artifact is a special name and will get all sorts of transformations applied to it.
+    minecraft "net.minecraftforge:forge:${project.mc_version}-${project.forge_version}"
+    //// MC version ////
+    implementation fg.deobf("curse.maven:baubles-${baubles_projectid}:${baubles_fileid}")
+    implementation fg.deobf("mezz.jei:jei_${mc_version}:${jei_version}")
+    implementation fg.deobf("curse.maven:antique-atlas-${antiqueatlas_projectid}:${antiqueatlas_fileid}")
 
 }
 
@@ -68,20 +134,19 @@ task deobfJar(type: Jar) {
 }
 
 processResources {
-    // this will ensure that this task is redone when the versions change.
-    inputs.property "version", project.version
-    inputs.property "mcversion", project.minecraft.version
-
-    // replace stuff in mcmod.info, nothing else
+    // replace tokens in mcmod.info, and pack.mcmeta
     from(sourceSets.main.resources.srcDirs) {
+        include 'pack.mcmeta'
         include 'mcmod.info'
-                
-        // replace version and mcversion
-        expand 'version':project.version, 'mcversion':project.minecraft.version
     }
-        
-    // copy everything else except the mcmod.info
-    from(sourceSets.main.resources.srcDirs) {
-        exclude 'mcmod.info'
+
+    duplicatesStrategy = 'include'
+}
+
+fancyGradle {
+    patches {
+        resources
+        coremods
+        asm
     }
 }

gradle.properties

@@ -1,8 +1,22 @@
 # Sets default memory used for gradle commands. Can be overridden by user or command line properties.
 # This is required to provide enough memory for the Minecraft decompilation process.
 org.gradle.jvmargs=-Xmx3G
+mod_id=ebwizardry
 mc_version=1.12.2
 mc_version_short=1.12
 jei_version=4.15.0.291
 baubles_version=1.5.2
-antique_atlas_version=4.6.3
+antique_atlas_version=4.6.3
+forge_version=14.23.5.2860
+mappings_version=39
+mappings_channel=stable
+mappings_mc_version=1.12
+baubles_projectid=227083
+baubles_fileid=2518667
+jei_projectid=238222
+artemislib_projectid=313590
+artemislib_version=1.0.6
+artemislib_fileid=2741812
+antiqueatlas_projectid=227795
+antiqueatlas_fileid=2823030
+org.gradle.daemon=false

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.3-all.zip
 zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.9-bin.zip
+zipStorePath=wrapper/dists

gradlew

@@ -1,172 +1,232 @@
-#!/usr/bin/env sh
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
 
 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
 # Attempt to set APP_HOME
+
 # Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
 done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
 
 APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
+APP_BASE_NAME=${0##*/}
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
 warn () {
     echo "$*"
-}
+} >&2
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
+    JAVACMD=java
     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=$((i+1))
-    done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
 fi
 
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=$(save "$@")
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
 
-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
 fi
 
-exec "$JAVACMD" "$@"
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -1,3 +1,19 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
 @if "%DEBUG%" == "" @echo off
 @rem ##########################################################################
 @rem
@@ -13,15 +29,18 @@ if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
 
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if "%ERRORLEVEL%" == "0" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -35,7 +54,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -45,28 +64,14 @@ echo location of your Java installation.
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
 :execute
 @rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
+
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell
@@ -81,4 +86,4 @@ exit /b 1
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal
 
-:omega
+:omega

src/main/java/electroblob/wizardry/Settings.java

@@ -138,6 +138,12 @@ public final class Settings {
 			new ResourceLocation(Wizardry.MODID, "shrine_5"),
 			new ResourceLocation(Wizardry.MODID, "shrine_6"),
 			new ResourceLocation(Wizardry.MODID, "shrine_7")};
+	/** <b>[Server-only]</b> Whether conquered shrines should regenerate after a period of time. */
+	public boolean shrineRegenerationEnabled = true;
+	/** <b>[Server-only]</b> Time in minutes for a conquered shrine to regenerate. */
+	public int shrineRegenerationTime = 1;
+	/** <b>[Server-only]</b> Whether players can loot shrines multiple times. If false, each player can only loot each shrine once. */
+	public boolean shrineAllowMultipleLoot = false;
 	/** <b>[Server-only]</b> List of dimension ids in which to generate library ruins. */
 	public int[] libraryDimensions = {0};
 	/** <b>[Server-only]</b> The rarity of library ruins, used by the world generator. Larger numbers are rarer. */
@@ -198,6 +204,13 @@ public final class Settings {
 	public boolean playerBlockDamage = true;
 	/** <b>[Server-only]</b> Whether spells cast by dispensers can destroy blocks in the world. */
 	public boolean dispenserBlockDamage = true;
+	/** <b>[Server-only]</b> Whether damage should be registered with the old system (wizardry_magic/indirect_wizardry_magic) prefixed damage with the elements like
+	 * necromancy_indirect_wizardry_magic, necromancy_wizardry_magic*/
+	public boolean damageTypePerElement = false;
+	/** <b>[Server-only]</b> Whether spell books are consumed when they are bound to a wand.*/
+	public boolean singleUseSpellBooks = false;
+	/** <b>[Server-only]</b> Whether to prevent binding the same spell to a wand multiple times*/
+	public boolean preventBindingSameSpellTwiceToWands = false;
 	/** <b>[Server-only]</b> Whether to revert to the old wand upgrade system, which only requires tomes of arcana. */
 	public boolean legacyWandLevelling = false;
 	/** <b>[Server-only]</b> Whether to tweak the blindness effect to reduce follow distance when used on non-players. */
@@ -208,6 +221,8 @@ public final class Settings {
 	public boolean wandsMustBeHeldToDecrementCooldown = false;
 	/** <b>[Server-only]</b> Whether to enable Wizardry mob loot injection. Allows an easier switch instead of blacklisting all entities. */
 	public boolean injectMobDrops = true;
+	/** <b>[Server-only]</b> The time in ticks after which recent spell casts expire and no longer count toward progression penalties. */
+	public int recentSpellExpiryTime = 1200;
 	/**
 	 * <b>[Server-only]</b> List of registry names of entities which summoned creatures are allowed to attack, in addition
 	 * to the defaults.
@@ -251,6 +266,26 @@ public final class Settings {
 	/** <b>[Server-only]</b> List of registry names of biomes in which wizardry's hostile mobs cannot spawn. */
 	public ResourceLocation[] mobSpawnBiomeBlacklist = toResourceLocations("mushroom_island", "mushroom_island_shore");
 
+	// Mana and upgrade constants
+	/** <b>[Server-only]</b> The amount of mana a crystal shard is worth */
+	public int manaPerShard = 10;
+	/** <b>[Server-only]</b> The amount of mana each magic crystal is worth */
+	public int manaPerCrystal = 100;
+	/** <b>[Server-only]</b> The amount of mana a grand magic crystal is worth */
+	public int grandCrystalMana = 400;
+	/** <b>[Server-only]</b> The maximum number of one type of wand upgrade which can be applied to a wand. */
+	public int upgradeStackLimit = 3;
+	/** <b>[Server-only]</b> The bonus amount of wand upgrades that can be applied to a non-elemental wand. */
+	public int nonElementalUpgradeBonus = 3;
+	/** <b>[Server-only]</b> The fraction by which maximum charge is increased for each level of storage upgrade. */
+	public float storageIncreasePerLevel = 0.15f;
+	/** <b>[Server-only]</b> The amount of mana given for a kill for each level of siphon upgrade. */
+	public int siphonManaPerLevel = 5;
+	/** <b>[Server-only]</b> The number of ticks between each mana increase for wands with the condenser upgrade. */
+	public int condenserTickInterval = 50;
+	/** <b>[Server-only]</b> The number of spell slots a wand has with no attunement upgrades applied. */
+	public int baseSpellSlots = 5;
+
 	// Commands (these don't need synchronising since typing a command always queries the server).
 	/**
 	 * <b>[Server-only]</b> The maximum allowed multiplier for the /cast command. This limit is here to stop people from
@@ -324,6 +359,34 @@ public final class Settings {
 	public double forfeitChance = 0.2;
 	/** <b>[Synchronised]</b> Progression requirements for upgrading a wand to each tier. */
 	public int[] progressionRequirements = {1500, 3500, 6000};
+
+	// Integer wrappers for tier values
+	public Integer noviceMaxCharge = 700;
+	public Integer apprenticeMaxCharge = 1000;
+	public Integer advancedMaxCharge = 1500;
+	public Integer masterMaxCharge = 2500;
+	
+	public Integer noviceUpgradeLimit = 3;
+	public Integer apprenticeUpgradeLimit = 5;
+	public Integer advancedUpgradeLimit = 7;
+	public Integer masterUpgradeLimit = 9;
+	
+	/** <b>[Synchronised]</b> Multiplier for condenser upgrade mana regeneration amount */
+	public double condenserAmountMultiplier = 1.0;
+	/** <b>[Synchronised]</b> Whether flesh spells (DiamondFlesh, IronFlesh, OakFlesh) apply slowness */
+	public boolean fleshSpellsCauseSlowness = true;
+
+	/** <b>[Synchronised]</b> Armor bonus for DiamondFlesh spell */
+	public double diamondFleshArmorBonus = 4.0;
+	/** <b>[Synchronised]</b> Armor toughness bonus for DiamondFlesh spell */
+	public double diamondFleshArmorToughnessBonus = 3.0;
+	/** <b>[Synchronised]</b> Armor bonus for IronFlesh spell */
+	public double ironFleshArmorBonus = 4.0;
+	/** <b>[Synchronised]</b> Armor bonus for OakFlesh spell */
+	public double oakFleshArmorBonus = 3.0;
+	/** <b>[Synchronised]</b> Health bonus for OakFlesh spell */
+	public double oakFleshHealthBonus = 0.2;
+
 	/**
 	 * <b>[Synchronised]</b> The maximum number of blocks a bookshelf can be from an arcane workbench or lectern to be
 	 * able to link to it.
@@ -390,6 +453,8 @@ public final class Settings {
 	/** <b>[Client-only]</b> Whether to initialise the handbook's data. Setting this to false will break the in-game handbook, but might help with some
 	 * startup crashes */
 	public boolean loadHandbook = true;
+	/** <b>[Client-only]</b> Whether to allow the Arcane Workbench and lectern search field to lose focus and start unfocused. */
+	public boolean unfocusedSearchBars = false;
 	/** <b>[Client-only]</b> The position of the spell HUD. */
 	public GuiPosition spellHUDPosition = GuiPosition.BOTTOM_LEFT;
 
@@ -516,9 +581,32 @@ public final class Settings {
 		setupArtefactsConfig();
 		setupResistancesConfig();
 
+		// Update the constants with new values
+		updateConstantsFromSettings();
+
 		config.save();
 	}
 
+	/** Updates the Constants class with the current settings values */
+	public void updateConstantsFromSettings(){
+		electroblob.wizardry.constants.Constants.MANA_PER_SHARD = this.manaPerShard;
+		electroblob.wizardry.constants.Constants.MANA_PER_CRYSTAL = this.manaPerCrystal;
+		electroblob.wizardry.constants.Constants.GRAND_CRYSTAL_MANA = this.grandCrystalMana;
+		electroblob.wizardry.constants.Constants.UPGRADE_STACK_LIMIT = this.upgradeStackLimit;
+		electroblob.wizardry.constants.Constants.NON_ELEMENTAL_UPGRADE_BONUS = this.nonElementalUpgradeBonus;
+		electroblob.wizardry.constants.Constants.COOLDOWN_REDUCTION_PER_LEVEL = (float) this.cooldownReductionPerLevel;
+		electroblob.wizardry.constants.Constants.STORAGE_INCREASE_PER_LEVEL = this.storageIncreasePerLevel;
+		electroblob.wizardry.constants.Constants.POTENCY_INCREASE_PER_TIER = (float) this.potencyIncreasePerTier;
+		electroblob.wizardry.constants.Constants.DURATION_INCREASE_PER_LEVEL = (float) this.durationIncreasePerLevel;
+		electroblob.wizardry.constants.Constants.RANGE_INCREASE_PER_LEVEL = (float) this.rangeIncreasePerLevel;
+		electroblob.wizardry.constants.Constants.BLAST_RADIUS_INCREASE_PER_LEVEL = (float) this.blastIncreasePerLevel;
+		electroblob.wizardry.constants.Constants.FROST_SLOWNESS_PER_LEVEL = (float) this.frostSlownessIncreasePerLevel;
+		electroblob.wizardry.constants.Constants.SIPHON_MANA_PER_LEVEL = this.siphonManaPerLevel;
+		electroblob.wizardry.constants.Constants.CONDENSER_TICK_INTERVAL = this.condenserTickInterval;
+		electroblob.wizardry.item.ItemWand.BASE_SPELL_SLOTS = this.baseSpellSlots;
+		electroblob.wizardry.data.WizardData.MAX_RECENT_SPELLS = this.baseSpellSlots;
+	}
+
 	void checkForRedundantOptions(String categoryName, Collection<String> validKeys){
 
 		ConfigCategory category = config.getCategory(categoryName);
@@ -625,6 +713,85 @@ public final class Settings {
 		dispenserBlockDamage = property.getBoolean();
 		propOrder.add(property.getName());
 
+		property = config.get(GAMEPLAY_CATEGORY, "damageTypePerElement", false,
+				"Whether damage should be registered with the old system (wizardry_magic/indirect_wizardry_magic) prefixed damage with the elements like "
+						+ "necromancy_indirect_wizardry_magic, necromancy_wizardry_magic. This is disabled by default to not break existing modpacks." 
+						+ "The intention of this setting is to allow differentiating various damage types for e.g. the Distinct Damage Descriptions mod");
+		property.setLanguageKey("config." + Wizardry.MODID + ".damage_type_per_element");
+		Wizardry.proxy.setToNamedBooleanEntry(property);
+		damageTypePerElement = property.getBoolean();
+		propOrder.add(property.getName());
+
+		property = config.get(GAMEPLAY_CATEGORY, "singleUseSpellBooks", false,
+				"Whether spell books are consumed when they are bound to a wand.");
+		property.setLanguageKey("config." + Wizardry.MODID + ".single_use_spell_books");
+		Wizardry.proxy.setToNamedBooleanEntry(property);
+		singleUseSpellBooks = property.getBoolean();
+		propOrder.add(property.getName());
+
+		property = config.get(GAMEPLAY_CATEGORY, "preventBindingSameSpellTwiceToWands", false,
+				"Whether to prevent binding the same spell to a wand multiple times");
+		property.setLanguageKey("config." + Wizardry.MODID + ".prevent_binding_same_spell_twice_to_wands");
+		Wizardry.proxy.setToNamedBooleanEntry(property);
+		preventBindingSameSpellTwiceToWands = property.getBoolean();
+		propOrder.add(property.getName());
+
+		property = config.get(GAMEPLAY_CATEGORY, "manaPerShard", 10,
+				"The amount of mana a crystal shard is worth.", 1, 1000);
+		property.setLanguageKey("config." + Wizardry.MODID + ".mana_per_shard");
+		Wizardry.proxy.setToNumberSliderEntry(property);
+		manaPerShard = property.getInt();
+		propOrder.add(property.getName());
+
+		property = config.get(GAMEPLAY_CATEGORY, "manaPerCrystal", 100,
+				"The amount of mana each magic crystal is worth.", 1, 10000);
+		property.setLanguageKey("config." + Wizardry.MODID + ".mana_per_crystal");
+		Wizardry.proxy.setToNumberSliderEntry(property);
+		manaPerCrystal = property.getInt();
+		propOrder.add(property.getName());
+
+		property = config.get(GAMEPLAY_CATEGORY, "grandCrystalMana", 400,
+				"The amount of mana a grand magic crystal is worth.", 1, 10000);
+		property.setLanguageKey("config." + Wizardry.MODID + ".grand_crystal_mana");
+		Wizardry.proxy.setToNumberSliderEntry(property);
+		grandCrystalMana = property.getInt();
+		propOrder.add(property.getName());
+
+		property = config.get(GAMEPLAY_CATEGORY, "upgradeStackLimit", 3,
+				"The maximum number of one type of wand upgrade which can be applied to a wand.", 1, 10);
+		property.setLanguageKey("config." + Wizardry.MODID + ".upgrade_stack_limit");
+		Wizardry.proxy.setToNumberSliderEntry(property);
+		upgradeStackLimit = property.getInt();
+		propOrder.add(property.getName());
+
+		property = config.get(GAMEPLAY_CATEGORY, "nonElementalUpgradeBonus", 3,
+				"The bonus amount of wand upgrades that can be applied to a non-elemental wand.", 0, 10);
+		property.setLanguageKey("config." + Wizardry.MODID + ".non_elemental_upgrade_bonus");
+		Wizardry.proxy.setToNumberSliderEntry(property);
+		nonElementalUpgradeBonus = property.getInt();
+		propOrder.add(property.getName());
+
+		property = config.get(GAMEPLAY_CATEGORY, "siphonManaPerLevel", 5,
+				"The amount of mana given for a kill for each level of siphon upgrade.", 0, 100);
+		property.setLanguageKey("config." + Wizardry.MODID + ".siphon_mana_per_level");
+		Wizardry.proxy.setToNumberSliderEntry(property);
+		siphonManaPerLevel = property.getInt();
+		propOrder.add(property.getName());
+
+		property = config.get(GAMEPLAY_CATEGORY, "condenserTickInterval", 50,
+				"The number of ticks between each mana increase for wands with the condenser upgrade.", 1, 1000);
+		property.setLanguageKey("config." + Wizardry.MODID + ".condenser_tick_interval");
+		Wizardry.proxy.setToNumberSliderEntry(property);
+		condenserTickInterval = property.getInt();
+		propOrder.add(property.getName());
+
+		property = config.get(GAMEPLAY_CATEGORY, "baseSpellSlots", 5,
+				"The number of spell slots a wand has with no attunement upgrades applied.", 1, 5);
+		property.setLanguageKey("config." + Wizardry.MODID + ".base_spell_slots");
+		Wizardry.proxy.setToNumberSliderEntry(property);
+		baseSpellSlots = property.getInt();
+		propOrder.add(property.getName());
+
 		property = config.get(GAMEPLAY_CATEGORY, "playersMoveEachOther", true,
 				"Whether to allow players to move other players around using magic.");
 		property.setLanguageKey("config." + Wizardry.MODID + ".players_move_each_other");
@@ -749,6 +916,122 @@ public final class Settings {
 		progressionRequirements = property.getIntList();
 		propOrder.add(property.getName());
 
+		property = config.get(DIFFICULTY_CATEGORY, "tierMaxCharges", new int[]{700, 1000, 1500, 2500},
+				"Maximum mana each tier can store (novice, apprentice, advanced, master respectively).");
+		property.setLanguageKey("config." + Wizardry.MODID + ".tier_max_charges");
+		property.setRequiresWorldRestart(true);
+		//tierMaxCharges = property.getIntList();
+		propOrder.add(property.getName());
+
+		// Individual tier configuration
+		property = config.get(DIFFICULTY_CATEGORY, "noviceMaxCharge", 700,
+				"Maximum mana a novice wand can store.");
+		property.setLanguageKey("config." + Wizardry.MODID + ".novice_max_charge");
+		property.setRequiresWorldRestart(true);
+		noviceMaxCharge = property.getInt();
+		propOrder.add(property.getName());
+
+		property = config.get(DIFFICULTY_CATEGORY, "apprenticeMaxCharge", 1000,
+				"Maximum mana an apprentice wand can store.");
+		property.setLanguageKey("config." + Wizardry.MODID + ".apprentice_max_charge");
+		property.setRequiresWorldRestart(true);
+		apprenticeMaxCharge = property.getInt();
+		propOrder.add(property.getName());
+
+		property = config.get(DIFFICULTY_CATEGORY, "advancedMaxCharge", 1500,
+				"Maximum mana an advanced wand can store.");
+		property.setLanguageKey("config." + Wizardry.MODID + ".advanced_max_charge");
+		property.setRequiresWorldRestart(true);
+		advancedMaxCharge = property.getInt();
+		propOrder.add(property.getName());
+
+		property = config.get(DIFFICULTY_CATEGORY, "masterMaxCharge", 2500,
+				"Maximum mana a master wand can store.");
+		property.setLanguageKey("config." + Wizardry.MODID + ".master_max_charge");
+		property.setRequiresWorldRestart(true);
+		masterMaxCharge = property.getInt();
+		propOrder.add(property.getName());
+
+		property = config.get(DIFFICULTY_CATEGORY, "noviceUpgradeLimit", 3,
+				"Maximum number of upgrades a novice wand can have.");
+		property.setLanguageKey("config." + Wizardry.MODID + ".novice_upgrade_limit");
+		property.setRequiresWorldRestart(true);
+		noviceUpgradeLimit = property.getInt();
+		propOrder.add(property.getName());
+
+		property = config.get(DIFFICULTY_CATEGORY, "apprenticeUpgradeLimit", 5,
+				"Maximum number of upgrades an apprentice wand can have.");
+		property.setLanguageKey("config." + Wizardry.MODID + ".apprentice_upgrade_limit");
+		property.setRequiresWorldRestart(true);
+		apprenticeUpgradeLimit = property.getInt();
+		propOrder.add(property.getName());
+
+		property = config.get(DIFFICULTY_CATEGORY, "advancedUpgradeLimit", 7,
+				"Maximum number of upgrades an advanced wand can have.");
+		property.setLanguageKey("config." + Wizardry.MODID + ".advanced_upgrade_limit");
+		property.setRequiresWorldRestart(true);
+		advancedUpgradeLimit = property.getInt();
+		propOrder.add(property.getName());
+
+		property = config.get(DIFFICULTY_CATEGORY, "masterUpgradeLimit", 9,
+				"Maximum number of upgrades a master wand can have.");
+		property.setLanguageKey("config." + Wizardry.MODID + ".master_upgrade_limit");
+		property.setRequiresWorldRestart(true);
+		masterUpgradeLimit = property.getInt();
+		propOrder.add(property.getName());
+
+		property = config.get(DIFFICULTY_CATEGORY, "condenserAmountMultiplier", 1.0,
+				"Multiplier for condenser upgrade mana regeneration amount. Higher values make condensers more effective.");
+		property.setLanguageKey("config." + Wizardry.MODID + ".condenser_amount_multiplier");
+		property.setRequiresWorldRestart(true);
+		condenserAmountMultiplier = property.getDouble();
+		propOrder.add(property.getName());
+
+		property = config.get(DIFFICULTY_CATEGORY, "fleshSpellsCauseSlowness", true,
+				"Whether flesh spells (DiamondFlesh, IronFlesh, OakFlesh) apply slowness. When disabled, these spells only provide their defensive benefits without movement penalty.");
+		property.setLanguageKey("config." + Wizardry.MODID + ".flesh_spells_cause_slowness");
+		Wizardry.proxy.setToNamedBooleanEntry(property);
+		property.requiresMcRestart();
+		fleshSpellsCauseSlowness = property.getBoolean();
+		propOrder.add(property.getName());
+
+		property = config.get(DIFFICULTY_CATEGORY, "diamondFleshArmorBonus", 4.0,
+				"Armor bonus provided by the DiamondFlesh spell.");
+		property.setLanguageKey("config." + Wizardry.MODID + ".diamond_flesh_armor_bonus");
+		property.setRequiresWorldRestart(true);
+		diamondFleshArmorBonus = property.getDouble();
+		propOrder.add(property.getName());
+
+		property = config.get(DIFFICULTY_CATEGORY, "diamondFleshArmorToughnessBonus", 3.0,
+				"Armor toughness bonus provided by the DiamondFlesh spell.");
+		property.setLanguageKey("config." + Wizardry.MODID + ".diamond_flesh_armor_toughness_bonus");
+		property.setRequiresWorldRestart(true);
+		diamondFleshArmorToughnessBonus = property.getDouble();
+		propOrder.add(property.getName());
+
+		property = config.get(DIFFICULTY_CATEGORY, "ironFleshArmorBonus", 4.0,
+				"Armor bonus provided by the IronFlesh spell.");
+		property.setLanguageKey("config." + Wizardry.MODID + ".iron_flesh_armor_bonus");
+		property.setRequiresWorldRestart(true);
+		ironFleshArmorBonus = property.getDouble();
+		propOrder.add(property.getName());
+
+		property = config.get(DIFFICULTY_CATEGORY, "oakFleshArmorBonus", 3.0,
+				"Armor bonus provided by the OakFlesh spell.");
+		property.setLanguageKey("config." + Wizardry.MODID + ".oak_flesh_armor_bonus");
+		property.setRequiresWorldRestart(true);
+		oakFleshArmorBonus = property.getDouble();
+		propOrder.add(property.getName());
+
+		property = config.get(DIFFICULTY_CATEGORY, "oakFleshHealthBonus", 0.2,
+				"Health bonus provided by the OakFlesh spell (as a multiplier, e.g., 0.2 = 20% increase).");
+		property.setLanguageKey("config." + Wizardry.MODID + ".oak_flesh_health_bonus");
+		property.setRequiresWorldRestart(true);
+		oakFleshHealthBonus = property.getDouble();
+		propOrder.add(property.getName());
+
+
+
 		// These two aren't sliders because using a slider makes it difficult to fine-tune the numbers; the nature of a
 		// scaling factor means that 0.5 is as big a change as 2.0, so whilst a slider is fine for increasing the
 		// damage, it doesn't give fine enough control for values less than 1.
@@ -834,6 +1117,14 @@ public final class Settings {
 		injectMobDrops = property.getBoolean();
 		propOrder.add(property.getName());
 
+		property = config.get(TWEAKS_CATEGORY, "recentSpellExpiryTime", 1200,
+				"The time in ticks after which recent spell casts expire and no longer count toward progression penalties. Default is 1200 ticks (1 minute). Lower values make progression penalties shorter-lived, higher values make them last longer.",
+				60, 72000); // Between 3 seconds and 1 hour
+		property.setLanguageKey("config." + Wizardry.MODID + ".recent_spell_expiry_time");
+		Wizardry.proxy.setToNumberSliderEntry(property);
+		recentSpellExpiryTime = property.getInt();
+		propOrder.add(property.getName());
+
 		property = config.get(TWEAKS_CATEGORY, "mobLootTableWhitelist", new String[0], "Whitelist for loot tables to inject additional mob drops (as specified in loot_tables/entities/mob_additions.json) into. Wizardry makes a best guess as to which loot tables belong to hostile mobs, but this may not always be correct or appropriate; add loot table locations (not entity IDs) to this list to manually include them.");
 		property.setLanguageKey("config." + Wizardry.MODID + ".mob_loot_table_whitelist");
 		property.setRequiresMcRestart(true);
@@ -944,10 +1235,17 @@ public final class Settings {
 		property = config.get(TWEAKS_CATEGORY, "cooldown_reduction_per_level", 0.15,
 				"The fraction by which cooldowns are reduced for each level of cooldown upgrade.",
 				0.05, Integer.MAX_VALUE); // Sure, I mean you COULD set it to 2^31-1... what could possibly go wrong?
-		property.setLanguageKey("config." + Wizardry.MODID + ".cast_command_multiplier_limit");
+		property.setLanguageKey("config." + Wizardry.MODID + ".cooldown_reduction_per_level");
 		cooldownReductionPerLevel = property.getDouble();
 		propOrder.add(property.getName());
 
+		property = config.get(TWEAKS_CATEGORY, "storage_increase_per_level", 0.15,
+				"The fraction by which maximum charge is increased for each level of storage upgrade.",
+				0.05, Integer.MAX_VALUE);
+		property.setLanguageKey("config." + Wizardry.MODID + ".storage_increase_per_level");
+		storageIncreasePerLevel = (float) property.getDouble();
+		propOrder.add(property.getName());
+
 		property = config.get(TWEAKS_CATEGORY, "potency_increase_per_tier", 0.15,
 				"The fraction by which potency is increased for each tier of matching wand. May cause extreme lag with high values!",
 				0.05, Integer.MAX_VALUE);
@@ -1082,6 +1380,22 @@ public final class Settings {
 		shrineFiles = getResourceLocationList(property);
 		propOrder.add(property.getName());
 
+		property = config.get(WORLDGEN_CATEGORY, "shrineRegenerationEnabled", false, "Whether conquered shrines should regenerate after a period of time. When disabled, shrines remain conquered permanently.");
+		property.setLanguageKey("config." + Wizardry.MODID + ".shrine_regeneration_enabled");
+		shrineRegenerationEnabled = property.getBoolean();
+		propOrder.add(property.getName());
+
+		property = config.get(WORLDGEN_CATEGORY, "shrineRegenerationTime", 20, "Time in minutes for a conquered shrine to regenerate. Minimum 1 minute, maximum 1440 minutes (24 hours).", 1, 1440);
+		property.setLanguageKey("config." + Wizardry.MODID + ".shrine_regeneration_time");
+		Wizardry.proxy.setToNumberSliderEntry(property);
+		shrineRegenerationTime = property.getInt();
+		propOrder.add(property.getName());
+
+		property = config.get(WORLDGEN_CATEGORY, "shrineAllowMultipleLoot", false, "Whether players can loot shrines multiple times. If false, each player can only loot each shrine once until it regenerates.");
+		property.setLanguageKey("config." + Wizardry.MODID + ".shrine_allow_multiple_loot");
+		shrineAllowMultipleLoot = property.getBoolean();
+		propOrder.add(property.getName());
+
 		property = config.get(WORLDGEN_CATEGORY, "libraryDimensions", new int[]{0}, "List of dimension ids in which library ruins will generate. Remove all dimensions to disable library ruins completely.");
 		property.setLanguageKey("config." + Wizardry.MODID + ".library_dimensions");
 		property.setRequiresWorldRestart(true);
@@ -1173,13 +1487,19 @@ public final class Settings {
 		Wizardry.proxy.setToNamedBooleanEntry(property);
 		showChargeMeter = property.getBoolean();
 		propOrder.add(property.getName());
-
 		property = config.get(CLIENT_CATEGORY, "loadHandbook", true, "Whether to initialise the in-game handbook. Setting this to false will brick the in-game handbook, but it might help if you have startup crashes.");
 		property.setLanguageKey("config." + Wizardry.MODID + ".load_handbook");
 		property.setRequiresWorldRestart(false);
 		Wizardry.proxy.setToNamedBooleanEntry(property);
 		loadHandbook = property.getBoolean();
 		propOrder.add(property.getName());
+		
+		property = config.get(CLIENT_CATEGORY, "unfocusedSearchBars", false, "Whether to allow the Arcane Workbench and lectern search field to lose focus and start unfocused. If true, the search field won't automatically capture keyboard input.");
+		property.setLanguageKey("config." + Wizardry.MODID + ".unfocused_search_bars");
+		property.setRequiresWorldRestart(false);
+		Wizardry.proxy.setToNamedBooleanEntry(property);
+		unfocusedSearchBars = property.getBoolean();
+		propOrder.add(property.getName());
 
 		property = config.get(CLIENT_CATEGORY, "spellHUDPosition", GuiPosition.BOTTOM_LEFT.name, "The position of the spell HUD.", GuiPosition.names);
 		property.setLanguageKey("config." + Wizardry.MODID + ".spell_hud_position");
@@ -1341,6 +1661,18 @@ public final class Settings {
 		}
 		propOrder.add(property.getName());
 
+		property = config.get(RESISTANCES_CATEGORY, "mobsImmuneToMagic", new String[]{},
+				"List of names of entities that are immune to magic, in addition to the defaults. Add mod creatures to this list if you want them to be immune to magic damage and they aren't already. SoundLoopSpellEntity names are not case sensitive. For mod entities, prefix with the mod ID (e.g. " + Wizardry.MODID + ":wizard).");
+		property.setLanguageKey("config." + Wizardry.MODID + ".mobs_immune_to_magic");
+		property.setRequiresMcRestart(true);
+		// Wizardry.proxy.setToEntityNameEntry(property);
+		// Converts all strings in the list to lower case, to ignore case sensitivity, and trims them.
+		for(int i = 0; i < property.getStringList().length; i++){
+			property.getStringList()[i] = property.getStringList()[i].toLowerCase(Locale.ROOT).trim();
+			MagicDamage.addEntityImmunity(EntityList.getClass(new ResourceLocation(property.getStringList()[i])),
+					DamageType.MAGIC);
+		}
+		propOrder.add(property.getName());
 		property = config.get(RESISTANCES_CATEGORY, "mobsImmuneToWither", new String[]{},
 				"List of names of entities that are immune to wither effects, in addition to the defaults. Add mod creatures to this list if you want them to be immune to withering magic and they aren't already. SoundLoopSpellEntity names are not case sensitive. For mod entities, prefix with the mod ID (e.g. " + Wizardry.MODID + ":wizard).");
 		property.setLanguageKey("config." + Wizardry.MODID + ".mobs_immune_to_wither");

src/main/java/electroblob/wizardry/Wizardry.java

@@ -82,7 +82,7 @@ public class Wizardry {
 	 * 1.x.x represents Minecraft 1.7.x versions, 2.x.x represents Minecraft 1.10.x versions, 3.x.x represents Minecraft
 	 * 1.11.x versions, and so on.
 	 */
-	public static final String VERSION = "4.3.10";
+	public static final String VERSION = "4.3.15";
 
 	/**
 	 * Json file used by Forge's built-in <a href="https://mcforge.readthedocs.io/en/1.12.x/gettingstarted/autoupdate/">update checker</a>.
@@ -130,7 +130,6 @@ public class Wizardry {
 
 		configDirectory = new File(event.getModConfigurationDirectory(), Wizardry.MODID);
 		settings.initConfig(event);
-		proxy.registerResourceReloadListeners();
 
 		Calendar calendar = Calendar.getInstance();
 		tisTheSeason = calendar.get(Calendar.MONTH) + 1 == 12 && calendar.get(Calendar.DAY_OF_MONTH) >= 24
@@ -161,9 +160,13 @@ public class Wizardry {
 
 	@EventHandler
 	public void init(FMLInitializationEvent event){
+		proxy.registerResourceReloadListeners();
 
 		settings.initConfigExtras();
 
+		// Update constants with configured values
+		settings.updateConstantsFromSettings();
+
 		// World generators
 		// Weight is a misnomer, it's actually the priority (where lower numbers get generated first)
 		// Literally nothing on typical 'weight' values here, there isn't even an upper limit

src/main/java/electroblob/wizardry/block/BlockPedestal.java

@@ -1,5 +1,6 @@
 package electroblob.wizardry.block;
 
+import electroblob.wizardry.Wizardry;
 import electroblob.wizardry.constants.Element;
 import electroblob.wizardry.registry.WizardryTabs;
 import electroblob.wizardry.tileentity.TileEntityShrineCore;
@@ -81,11 +82,25 @@ public class BlockPedestal extends Block implements ITileEntityProvider {
 
 	@Override
 	public float getBlockHardness(IBlockState state, World world, BlockPos pos){
+		// If shrine regeneration is enabled, make pedestal blocks with shrine cores unbreakable to prevent exploitation
+		if(!world.isRemote && Wizardry.settings != null && Wizardry.settings.shrineRegenerationEnabled){
+			TileEntity tileEntity = world.getTileEntity(pos);
+			if(tileEntity instanceof TileEntityShrineCore){
+				return -1; // Unbreakable if it has a shrine core
+			}
+		}
 		return state.getValue(NATURAL) ? -1 : super.getBlockHardness(state, world, pos);
 	}
 
 	@Override
 	public float getExplosionResistance(World world, BlockPos pos, @Nullable Entity exploder, Explosion explosion){
+		// If shrine regeneration is enabled, make pedestal blocks with shrine cores unbreakable to prevent exploitation
+		if(!world.isRemote && Wizardry.settings != null && Wizardry.settings.shrineRegenerationEnabled){
+			TileEntity tileEntity = world.getTileEntity(pos);
+			if(tileEntity instanceof TileEntityShrineCore){
+				return 6000000.0F; // Unbreakable if it has a shrine core
+			}
+		}
 		return world.getBlockState(pos).getValue(NATURAL) ? 6000000.0F : super.getExplosionResistance(world, pos, exploder, explosion);
 	}
 

src/main/java/electroblob/wizardry/block/BlockStatue.java

@@ -191,7 +191,7 @@ public class BlockStatue extends Block implements ITileEntityProvider {
 	// Making this an instance method means it works equally well for both types of statue
 	public boolean convertToStatue(EntityLiving target, @Nullable EntityLivingBase caster, int duration){
 		
-		if(target.deathTime > 0) return false;
+		if(target.deathTime > 0 || target.world.isRemote) return false;
 
 		BlockPos pos = new BlockPos(target);
 		World world = target.world;

src/main/java/electroblob/wizardry/client/WizardryClientEventHandler.java

@@ -3,10 +3,8 @@ package electroblob.wizardry.client;
 import electroblob.wizardry.client.renderer.overlay.RenderBlinkEffect;
 import electroblob.wizardry.data.DispenserCastingData;
 import electroblob.wizardry.data.SpellEmitterData;
-import electroblob.wizardry.item.ItemArtefact;
-import electroblob.wizardry.item.ItemFlamecatcher;
-import electroblob.wizardry.item.ItemSpectralBow;
-import electroblob.wizardry.item.ItemWand;
+import electroblob.wizardry.data.WizardData;
+import electroblob.wizardry.item.*;
 import electroblob.wizardry.potion.PotionSlowTime;
 import electroblob.wizardry.registry.WizardryItems;
 import electroblob.wizardry.registry.WizardryPotions;
@@ -15,7 +13,9 @@ import electroblob.wizardry.spell.SixthSense;
 import electroblob.wizardry.spell.SlowTime;
 import electroblob.wizardry.spell.Transience;
 import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiMainMenu;
 import net.minecraft.client.gui.ScaledResolution;
+import net.minecraft.client.gui.inventory.GuiContainer;
 import net.minecraft.client.renderer.BufferBuilder;
 import net.minecraft.client.renderer.GlStateManager;
 import net.minecraft.client.renderer.Tessellator;
@@ -26,10 +26,7 @@ import net.minecraft.tileentity.TileEntity;
 import net.minecraft.tileentity.TileEntityDispenser;
 import net.minecraft.util.ResourceLocation;
 import net.minecraft.world.World;
-import net.minecraftforge.client.event.FOVUpdateEvent;
-import net.minecraftforge.client.event.InputUpdateEvent;
-import net.minecraftforge.client.event.MouseEvent;
-import net.minecraftforge.client.event.RenderHandEvent;
+import net.minecraftforge.client.event.*;
 import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import net.minecraftforge.fml.common.gameevent.TickEvent;
@@ -120,6 +117,7 @@ public final class WizardryClientEventHandler {
 			Minecraft.getMinecraft().player.prevRotationPitch = 0;
 			Minecraft.getMinecraft().player.rotationYaw = 0;
 			Minecraft.getMinecraft().player.rotationPitch = 0;
+
 		}
 	}
 
@@ -133,10 +131,10 @@ public final class WizardryClientEventHandler {
 			event.getMovementInput().jump = false;
 			event.getMovementInput().sneak = false;
 		}
-
+		
 		if(ItemArtefact.isArtefactActive(event.getEntityPlayer(), WizardryItems.charm_move_speed)
 				&& event.getEntityPlayer().isHandActive()
-				&& event.getEntityPlayer().getActiveItemStack().getItem() instanceof ItemWand){
+				&& event.getEntityPlayer().getActiveItemStack().getItem() instanceof ISpellCastingItem){
 			// Normally speed is set to 20% when using items, this makes it 80%
 			event.getMovementInput().moveStrafe *= 4;
 			event.getMovementInput().moveForward *= 4;
@@ -187,6 +185,17 @@ public final class WizardryClientEventHandler {
 		}
 	}
 
+	@SubscribeEvent
+	public static void onGuiOpenEvent(GuiOpenEvent event){
+
+		if(Minecraft.getMinecraft().player != null && event.getGui() instanceof GuiContainer) {
+			WizardData data = WizardData.get(Minecraft.getMinecraft().player);
+			if (data != null && data.getVariable(Possession.POSSESSEE_KEY) != null) {
+				event.setCanceled(true);
+			}
+		}
+	}
+
 	/**
 	 * Renders an overlay across the entire screen.
 	 * @param resolution The screen resolution

src/main/java/electroblob/wizardry/client/gui/GuiArcaneWorkbench.java

@@ -93,6 +93,7 @@ public class GuiArcaneWorkbench extends GuiContainer {
 	private ContainerArcaneWorkbench arcaneWorkbenchContainer;
 
 	private GuiButton applyBtn;
+	private GuiButton clearBtn;
 	private GuiButton[] sortButtons = new GuiButton[3];
 
 	private GuiTextField searchField;
@@ -126,6 +127,7 @@ public class GuiArcaneWorkbench extends GuiContainer {
 
 		this.buttonList.clear();
 		this.buttonList.add(this.applyBtn = new GuiButtonApply(0, this.width / 2 + 64, this.height / 2 + 3));
+		this.buttonList.add(this.clearBtn = new GuiButtonClear(0, this.width / 2 + 64, this.height / 2 - 16));
 		this.buttonList.add(sortButtons[0] = new GuiButtonSpellSort(1, this.guiLeft - 44, this.guiTop + 8, ISpellSortable.SortType.TIER, arcaneWorkbenchContainer, this));
 		this.buttonList.add(sortButtons[1] = new GuiButtonSpellSort(2, this.guiLeft - 31, this.guiTop + 8, ISpellSortable.SortType.ELEMENT, arcaneWorkbenchContainer, this));
 		this.buttonList.add(sortButtons[2] = new GuiButtonSpellSort(3, this.guiLeft - 18, this.guiTop + 8, ISpellSortable.SortType.ALPHABETICAL, arcaneWorkbenchContainer, this));
@@ -135,8 +137,8 @@ public class GuiArcaneWorkbench extends GuiContainer {
 		this.searchField.setEnableBackgroundDrawing(false);
 		this.searchField.setVisible(true);
 		this.searchField.setTextColor(16777215);
-		this.searchField.setCanLoseFocus(false);
-		this.searchField.setFocused(true);
+		this.searchField.setCanLoseFocus(Wizardry.settings.unfocusedSearchBars); // false by default
+		this.searchField.setFocused(!Wizardry.settings.unfocusedSearchBars); // true by default
 
 		this.tooltipElements.clear();
 		this.tooltipElements.add(new TooltipElementItemName(new Style().setColor(TextFormatting.WHITE), LINE_SPACING_WIDE));
@@ -205,6 +207,7 @@ public class GuiArcaneWorkbench extends GuiContainer {
 
 		// Show/hide the relevant gui elements
 		this.applyBtn.enabled = centreSlot.getHasStack();
+		this.clearBtn.enabled = centreSlot.getHasStack() && centreSlot.getStack().getItem() instanceof IWorkbenchItem && ((IWorkbenchItem) centreSlot.getStack().getItem()).isClearable();
 		for(GuiButton button : this.sortButtons) button.visible = arcaneWorkbenchContainer.hasBookshelves();
 		this.searchField.setVisible(arcaneWorkbenchContainer.hasBookshelves());
 
@@ -428,6 +431,16 @@ public class GuiArcaneWorkbench extends GuiContainer {
 
 	// Controls
 
+	@Override
+	protected void mouseClicked(int mouseX, int mouseY, int mouseButton) throws IOException {
+		super.mouseClicked(mouseX, mouseY, mouseButton);
+		if (this.searchField != null) {
+			this.searchField.mouseClicked(mouseX, mouseY, mouseButton);
+			// Set focus depending on whether the click was inside the search field
+			this.searchField.setFocused(this.searchField.isFocused());
+		}
+	}
+
 	@Override
 	protected void actionPerformed(GuiButton button){
 
@@ -444,6 +457,17 @@ public class GuiArcaneWorkbench extends GuiContainer {
 				animationTimer = 20;
 			}
 
+			if(button == clearBtn){
+				// Packet building
+				IMessage msg = new PacketControlInput.Message(PacketControlInput.ControlType.CLEAR_BUTTON);
+				WizardryPacketHandler.net.sendToServer(msg);
+				// Sound
+				Minecraft.getMinecraft().getSoundHandler().playSound(PositionedSoundRecord.getMasterRecord(
+						WizardrySounds.BLOCK_ARCANE_WORKBENCH_SPELLBIND, 0.8f));
+				// Animation
+				animationTimer = 20;
+			}
+
 			if(button instanceof GuiButtonSpellSort) this.arcaneWorkbenchContainer.setSortType(((GuiButtonSpellSort)button).sortType);
 		}
 	}
@@ -1006,4 +1030,36 @@ public class GuiArcaneWorkbench extends GuiContainer {
 		}
 	}
 
+	private static class GuiButtonClear extends GuiButton {
+
+		public GuiButtonClear(int id, int x, int y){
+			super(id, x, y, 16, 16, I18n.format("container." + Wizardry.MODID + ":arcane_workbench.clear"));
+		}
+
+		@Override
+		public void drawButton(Minecraft minecraft, int mouseX, int mouseY, float partialTicks){
+
+			// Whether the button is highlighted
+			this.hovered = mouseX >= this.x && mouseY >= this.y && mouseX < this.x + this.width && mouseY < this.y + this.height;
+
+			int k = 72;
+			int l = 236;
+			//int colour = 14737632;
+
+			if(this.enabled){
+				if(this.hovered){
+					k += this.width * 2;
+					//colour = 16777120;
+				}
+			}else{
+				k += this.width;
+				//colour = 10526880;
+			}
+
+			DrawingUtils.drawTexturedRect(this.x, this.y, k, l, this.width, this.height, TEXTURE_WIDTH, TEXTURE_HEIGHT);
+			//this.drawCenteredString(minecraft.fontRenderer, this.displayString, this.x + this.width / 2,
+			//		this.y + (this.height - 8) / 2, colour);
+		}
+	}
+
 }

src/main/java/electroblob/wizardry/client/gui/GuiLectern.java

@@ -184,9 +184,8 @@ public class GuiLectern extends GuiSpellInfo implements ISpellSortable {
 		this.searchField.setEnableBackgroundDrawing(false);
 		this.searchField.setVisible(true);
 		this.searchField.setTextColor(16777215);
-		this.searchField.setCanLoseFocus(false);
-		this.searchField.setFocused(true);
-
+		this.searchField.setCanLoseFocus(Wizardry.settings.unfocusedSearchBars); // false by default
+		this.searchField.setFocused(!Wizardry.settings.unfocusedSearchBars); // true by default
 		refreshAvailableSpells(); // Must be done last
 
 	}
@@ -269,8 +268,13 @@ public class GuiLectern extends GuiSpellInfo implements ISpellSortable {
 
 	@Override
 	protected void mouseClicked(int mouseX, int mouseY, int mouseButton) throws IOException {
-		super.mouseClicked(mouseX, mouseY, mouseButton);
-		searchNeedsClearing = true;
+	   super.mouseClicked(mouseX, mouseY, mouseButton);
+	   if (this.searchField != null) {
+		   this.searchField.mouseClicked(mouseX, mouseY, mouseButton);
+		   // Set focus depending on whether the click was inside the search field
+		   this.searchField.setFocused(this.searchField.isFocused());
+	   }
+	   searchNeedsClearing = true;
 	}
 
 	@Override

src/main/java/electroblob/wizardry/client/gui/handbook/GuiWizardHandbook.java

@@ -33,9 +33,13 @@ import java.awt.*;
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
-import java.util.List;
-import java.util.*;
 import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
 
 /**
  * GUI class for the wizard's handbook. Like any GUI class, this is instantiated each time the book is opened. As of
@@ -55,6 +59,8 @@ public class GuiWizardHandbook extends GuiScreen {
 
 	private static final ResourceLocation DEFAULT = new ResourceLocation(Wizardry.MODID, "texts/handbook_en_us.json");
 
+	private static List<String> ADDONS = new ArrayList<>();
+
 	static final ResourceLocation texture = new ResourceLocation(Wizardry.MODID, "textures/gui/handbook/handbook.png");
 
 	/** Global Gson instance for the handbook. */
@@ -406,9 +412,10 @@ public class GuiWizardHandbook extends GuiScreen {
 			return;
 		}
 
-		IResource handbookFile = getHandbookResource(manager);
+	//	IResource handbookFile = getHandbookResource(manager);
+		List<IResource> handbookFiles = getHandbookResource(manager);
 
-		if(handbookFile != null){
+		if(!handbookFiles.isEmpty()){
 
 			// Wipes all the maps before repopulating them
 			images.clear();
@@ -418,28 +425,31 @@ public class GuiWizardHandbook extends GuiScreen {
 
 			bookmarkSection = null; // Also need to wipe the reference to the old bookmarked section
 
-			BufferedReader reader = new BufferedReader(new InputStreamReader(handbookFile.getInputStream(), StandardCharsets.UTF_8));
+			for (IResource handbookFile : handbookFiles) {
 
-			JsonElement je = gson.fromJson(reader, JsonElement.class);
-			JsonObject json = je.getAsJsonObject();
+				BufferedReader reader = new BufferedReader(new InputStreamReader(handbookFile.getInputStream(), StandardCharsets.UTF_8));
 
-			JsonUtils.getJsonObject(json, "colours").entrySet().forEach(e -> colours.put(e.getKey(),
-					Color.decode(e.getValue().getAsString()).getRGB()));
+				JsonElement je = gson.fromJson(reader, JsonElement.class);
+				JsonObject json = je.getAsJsonObject();
 
-			// Repopulates the remaining maps
-			Image.populate(images, json);
-			CraftingRecipe.populate(recipes, json);
-			Section.populate(sections, json);
+				JsonUtils.getJsonObject(json, "colours").entrySet().forEach(e -> colours.put(e.getKey(),
+						Color.decode(e.getValue().getAsString()).getRGB()));
 
-			sectionList = Collections.unmodifiableList(new ArrayList<>(sections.values()));
+				// Repopulates the remaining maps
+				Image.populate(images, json);
+				CraftingRecipe.populate(recipes, json);
+				Section.populate(sections, json);
 
-			if(sections.isEmpty()){
-				Wizardry.logger.warn("Handbook has no sections! Aborting loading...");
-				return;
+				sectionList = Collections.unmodifiableList(new ArrayList<>(sections.values()));
+
+				if(sections.isEmpty()){
+					Wizardry.logger.warn("Handbook has no sections! Aborting loading...");
+					return;
+				}
+
+				bookmarkSection = JsonUtils.getString(json, "bookmark_start_section");
+				if(!sections.containsKey(bookmarkSection)) throw new JsonSyntaxException("Section with id " + bookmarkSection + " is undefined");
 			}
-
-			bookmarkSection = JsonUtils.getString(json, "bookmark_start_section");
-			if(!sections.containsKey(bookmarkSection)) throw new JsonSyntaxException("Section with id " + bookmarkSection + " is undefined");
 		}
 
 		// The first resource load on startup is done before the packet handler is loaded
@@ -455,16 +465,17 @@ public class GuiWizardHandbook extends GuiScreen {
 	 * @param manager The resource manager instance to use.
 	 * @return The handbook JSON file, as an IResource, or null if it was not found.
 	 */
-	private static IResource getHandbookResource(IResourceManager manager){
+	private static List<IResource> getHandbookResource(IResourceManager manager){
 
 		// TODO: Implement resource pack stacking to allow addon mods and texture packs to add/overwrite content
 
 		IResource handbookFile = null;
+		List<IResource> handbookFiles = new ArrayList<>();
 
 		try{
 			handbookFile = manager.getResource(new ResourceLocation(Wizardry.MODID, "texts/handbook_"
 					+ Minecraft.getMinecraft().getLanguageManager().getCurrentLanguage().getLanguageCode() + ".json"));
-		}catch(IOException e){
+		}catch(Exception e){
 
 			Wizardry.logger.info("Wizard handbook JSON file missing for the current language (" + Minecraft.getMinecraft()
 					.getLanguageManager().getCurrentLanguage() + "). Using default (English-US) instead.");
@@ -476,7 +487,29 @@ public class GuiWizardHandbook extends GuiScreen {
 			}
 		}
 
-		return handbookFile;
+		handbookFiles.add(handbookFile);
+
+		for (String modid : ADDONS) {
+			// Addons
+			Wizardry.logger.info("Registering addon Wizard's Handbook contents for " + modid);
+			try{
+				handbookFile = manager.getResource(new ResourceLocation(modid, "texts/handbook_"
+						+ Minecraft.getMinecraft().getLanguageManager().getCurrentLanguage().getLanguageCode() + ".json"));
+			}catch(Exception e){
+
+				Wizardry.logger.info("Wizard handbook JSON file missing for the current language (" + Minecraft.getMinecraft()
+						.getLanguageManager().getCurrentLanguage() + "). Using default (English-US) instead.");
+
+				try{
+					handbookFile = manager.getResource(new ResourceLocation(modid, "texts/handbook_en_us.json"));
+				}catch(IOException x){
+					Wizardry.logger.error("Couldn't find file: " + DEFAULT + ". The file may be missing; please try re-downloading and reinstalling Wizardry.", x);
+				}
+			}
+			handbookFiles.add(handbookFile);
+		}
+
+		return handbookFiles;
 	}
 
 	// Controls
@@ -576,4 +609,9 @@ public class GuiWizardHandbook extends GuiScreen {
 		sections.values().forEach(s -> s.updateUnlockStatus(showToasts, completedAdvancements));
 	}
 
+	public static void registerAddonHandbookContent(String modid) {
+		if (!ADDONS.contains(modid)) {
+			ADDONS.add(modid);
+		}
+	}
 }

src/main/java/electroblob/wizardry/client/gui/handbook/Section.java

@@ -299,7 +299,7 @@ class Section {
 						String suffix = "";
 
 						// Account for trailing punctuation, except in languages that don't use spaces such as Chinese
-						boolean spaceless = SPACELESS_LANGUAGES.contains(Minecraft.getMinecraft().getLanguageManager().getCurrentLanguage().getLanguageCode());
+						boolean spaceless = SPACELESS_LANGUAGES.contains(Minecraft.getMinecraft().getLanguageManager().getCurrentLanguage() == null ? "en_us" : Minecraft.getMinecraft().getLanguageManager().getCurrentLanguage().getLanguageCode());
 						if(!spaceless) paragraph.substring(linkEnd).split("\\s", 2)[0].substring(1); // substring(1) to remove the @
 
 						// The index of the single page currently being formatted, relative to the section

src/main/java/electroblob/wizardry/client/renderer/overlay/RenderSixthSense.java

@@ -60,10 +60,12 @@ public class RenderSixthSense {
 
 		Minecraft mc = Minecraft.getMinecraft();
 		RenderManager renderManager = event.getRenderer().getRenderManager();
+		float effectRadius = Spells.sixth_sense.getProperty(Spell.EFFECT_RADIUS).floatValue();
+		float distance = event.getEntity().getDistance(mc.player);
 
 		if(mc.player.isPotionActive(WizardryPotions.sixth_sense) && !(event.getEntity() instanceof EntityArmorStand)
 				&& event.getEntity() != mc.player && mc.player.getActivePotionEffect(WizardryPotions.sixth_sense) != null
-				&& event.getEntity().getDistance(mc.player) < Spells.sixth_sense.getProperty(Spell.EFFECT_RADIUS).floatValue()
+				&& distance < effectRadius
 				* (1 + mc.player.getActivePotionEffect(WizardryPotions.sixth_sense).getAmplifier() * Constants.RANGE_INCREASE_PER_LEVEL)){
 
 			Tessellator tessellator = Tessellator.getInstance();
@@ -87,7 +89,13 @@ public class RenderSixthSense {
 			GlStateManager.rotate(180 - renderManager.playerViewY, 0.0F, 1.0F, 0.0F);
 			GlStateManager.rotate(yaw, 1.0F, 0.0F, 0.0F);
 
-			GlStateManager.color(1, 1, 1, 1);
+			//Decreases the opacity of the marker after 80% of the effect distance
+			float alpha = 1f;
+			float f = 5 * (1f - distance / effectRadius);
+			if (f <= 1) {
+				alpha = f;
+			}
+			GlStateManager.color(1, 1, 1, alpha);
 
 			ResourceLocation texture = PASSIVE_MOB_MARKER_TEXTURE;
 

src/main/java/electroblob/wizardry/constants/Constants.java

@@ -8,40 +8,40 @@ public final class Constants {
 
 	/** The amount of mana a crystal shard is worth */
 	// 100 doesn't divide nicely by 9 so we're calling this 10. I guess you lose a little bit by smashing a crystal.
-	public static final int MANA_PER_SHARD = 10;
+	public static int MANA_PER_SHARD;
 	/** The amount of mana each magic crystal is worth */
-	public static final int MANA_PER_CRYSTAL = 100;
+	public static int MANA_PER_CRYSTAL;
 	/** The amount of mana a grand magic crystal is worth */
-	public static final int GRAND_CRYSTAL_MANA = 400;
+	public static int GRAND_CRYSTAL_MANA;
 	/** The maximum number of one type of wand upgrade which can be applied to a wand. */
-	public static final int UPGRADE_STACK_LIMIT = 3;
+	public static int UPGRADE_STACK_LIMIT;
 	/** The bonus amount of wand upgrades that can be applied to a non-elemental wand. */
-	public static final int NON_ELEMENTAL_UPGRADE_BONUS = 3;
+	public static int NON_ELEMENTAL_UPGRADE_BONUS;
 	/** The fraction by which cooldowns are reduced for each level of cooldown upgrade. */
-	public static float COOLDOWN_REDUCTION_PER_LEVEL = 0.15f;
+	public static float COOLDOWN_REDUCTION_PER_LEVEL;
 	/** The fraction by which maximum charge is increased for each level of storage upgrade. */
-	public static final float STORAGE_INCREASE_PER_LEVEL = 0.15f;
+	public static float STORAGE_INCREASE_PER_LEVEL;
 	/** The fraction by which potency is increased for each tier of matching wand. */
-	public static float POTENCY_INCREASE_PER_TIER = 0.15f;
+	public static float POTENCY_INCREASE_PER_TIER;
 	/** The fraction by which spell duration is increased for each level of duration upgrade. */
-	public static float DURATION_INCREASE_PER_LEVEL = 0.25f;
+	public static float DURATION_INCREASE_PER_LEVEL;
 	/** The fraction by which spell range is increased for each level of range upgrade. */
-	public static float RANGE_INCREASE_PER_LEVEL = 0.25f;
+	public static float RANGE_INCREASE_PER_LEVEL;
 	/** The fraction by which spell blast radius is increased for each level of range upgrade. */
-	public static float BLAST_RADIUS_INCREASE_PER_LEVEL = 0.25f;
+	public static float BLAST_RADIUS_INCREASE_PER_LEVEL;
 	/** The fraction by which movement speed is reduced per level of frost effect. */
-	public static final double FROST_SLOWNESS_PER_LEVEL = 0.5;
+	public static double FROST_SLOWNESS_PER_LEVEL;
 	/** The fraction by which movement speed is reduced per level of decay effect. */
 	public static final double DECAY_SLOWNESS_PER_LEVEL = 0.2;
 	/** The fraction by which dig speed is reduced per level of frostbite effect. */
 	public static final float FROST_FATIGUE_PER_LEVEL = 0.45f;
 	/** The number of ticks between each mana increase for wands with the condenser upgrade. */
-	public static final int CONDENSER_TICK_INTERVAL = 50;
+	public static int CONDENSER_TICK_INTERVAL;
 	/**
 	 * The amount of mana given for a kill for each level of siphon upgrade. A random amount from 0 to this number - 1
 	 * is also added. See {@link WizardryEventHandler#onLivingDeathEvent} for more details.
 	 */
-	public static final int SIPHON_MANA_PER_LEVEL = 5;
+	public static int SIPHON_MANA_PER_LEVEL;
 	/**
 	 * The number of ticks between the spawning of patches of decay when an entity has the decay effect. Note that decay
 	 * won't spawn again if something is already standing in it.
@@ -51,11 +51,19 @@ public final class Constants {
 
 	// making this as an update to the existing values to not break addons directly relying on the fields
 	static {
-		POTENCY_INCREASE_PER_TIER = (float) Wizardry.settings.potencyIncreasePerTier;
+		MANA_PER_SHARD = Wizardry.settings.manaPerShard;
+		MANA_PER_CRYSTAL = Wizardry.settings.manaPerCrystal;
+		GRAND_CRYSTAL_MANA = Wizardry.settings.grandCrystalMana;
+		UPGRADE_STACK_LIMIT = Wizardry.settings.upgradeStackLimit;
+		NON_ELEMENTAL_UPGRADE_BONUS = Wizardry.settings.nonElementalUpgradeBonus;
 		COOLDOWN_REDUCTION_PER_LEVEL = (float) Wizardry.settings.cooldownReductionPerLevel;
+		STORAGE_INCREASE_PER_LEVEL = Wizardry.settings.storageIncreasePerLevel;
+		POTENCY_INCREASE_PER_TIER = (float) Wizardry.settings.potencyIncreasePerTier;
 		DURATION_INCREASE_PER_LEVEL = (float) Wizardry.settings.durationIncreasePerLevel;
 		RANGE_INCREASE_PER_LEVEL = (float) Wizardry.settings.rangeIncreasePerLevel;
 		BLAST_RADIUS_INCREASE_PER_LEVEL = (float) Wizardry.settings.blastIncreasePerLevel;
-		RANGE_INCREASE_PER_LEVEL = (float) Wizardry.settings.frostSlownessIncreasePerLevel;
+		FROST_SLOWNESS_PER_LEVEL = (float) Wizardry.settings.frostSlownessIncreasePerLevel;
+		SIPHON_MANA_PER_LEVEL = Wizardry.settings.siphonManaPerLevel;
+		CONDENSER_TICK_INTERVAL = Wizardry.settings.condenserTickInterval;
 	}
 }

src/main/java/electroblob/wizardry/constants/Tier.java

@@ -10,10 +10,10 @@ import java.util.Random;
 
 public enum Tier {
 
-	NOVICE(700, 3, 12, new Style().setColor(TextFormatting.WHITE), "novice"),
-	APPRENTICE(1000, 5, 5, new Style().setColor(TextFormatting.AQUA), "apprentice"),
-	ADVANCED(1500, 7, 2, new Style().setColor(TextFormatting.DARK_BLUE), "advanced"),
-	MASTER(2500, 9, 1, new Style().setColor(TextFormatting.DARK_PURPLE), "master");
+	NOVICE(Wizardry.settings.noviceMaxCharge, Wizardry.settings.noviceUpgradeLimit, 12, new Style().setColor(TextFormatting.WHITE), "novice"),
+	APPRENTICE(Wizardry.settings.apprenticeMaxCharge, Wizardry.settings.apprenticeUpgradeLimit, 5, new Style().setColor(TextFormatting.AQUA), "apprentice"),
+	ADVANCED(Wizardry.settings.advancedMaxCharge, Wizardry.settings.advancedUpgradeLimit, 2, new Style().setColor(TextFormatting.DARK_BLUE), "advanced"),
+	MASTER(Wizardry.settings.masterMaxCharge, Wizardry.settings.masterUpgradeLimit, 1, new Style().setColor(TextFormatting.DARK_PURPLE), "master");
 
 	/** Maximum mana a wand of this tier can store. */
 	public final int maxCharge;

src/main/java/electroblob/wizardry/data/IStoredVariable.java

@@ -64,6 +64,11 @@ public interface IStoredVariable<T> extends IVariable<T> {
 			this.ticker = (p, t) -> t; // Initialise this with a do-nothing function, can be overwritten later
 		}
 
+		@Override
+		public String getKey() {
+			return key;
+		}
+
 		/**
 		 * Replaces this variable's update method with the given update function. <i>Beware of auto-unboxing of
 		 * primitive types! For lambda expressions, check the second parameter isn't null before operating on it.

src/main/java/electroblob/wizardry/data/IVariable.java

@@ -47,7 +47,10 @@ public interface IVariable<T> {
 	 */
 	void write(ByteBuf buf, T value);
 
+	String getKey();
+
 	/**
+	 *
 	 * Reads this variable's value from the given {@link ByteBuf}.
 	 */
 	T read(ByteBuf buf);
@@ -110,6 +113,11 @@ public interface IVariable<T> {
 			// NYI
 		}
 
+		@Override
+		public String getKey() {
+			return "none"; // we don't mind as these are never synced (electroblob.wizardry.data.IVariable.Variable.isSynced)
+		}
+
 		@Override
 		public T read(ByteBuf buf){
 			return null; // NYI

src/main/java/electroblob/wizardry/data/WizardData.java

@@ -47,6 +47,7 @@ import javax.annotation.Nullable;
 import java.lang.ref.WeakReference;
 import java.util.*;
 import java.util.stream.Collectors;
+import java.util.AbstractMap.SimpleEntry;
 
 /**
  * Capability-based replacement for the old ExtendedPlayer class from 1.7.10. This has been reworked to leave minimum
@@ -73,7 +74,7 @@ public class WizardData implements INBTSerializable<NBTTagCompound> {
 	private static final Set<IStoredVariable> storedVariables = new HashSet<>();
 
 	/** The maximum number of recent spells to track. */
-	public static final int MAX_RECENT_SPELLS = ItemWand.BASE_SPELL_SLOTS;
+	public static int MAX_RECENT_SPELLS;
 
 	private static final int IMBUEMENT_UPDATE_INTERVAL = 20;
 
@@ -126,7 +127,7 @@ public class WizardData implements INBTSerializable<NBTTagCompound> {
 	 * be modified via {@link WizardData#setVariable(IVariable, Object)}, which (as a method) is able to enforce it. */
 	private final Map<IVariable, Object> spellData;
 
-	private Queue<Spell> recentSpells;
+	private Queue<SimpleEntry<Spell, Long>> recentSpells;
 
 	// This one is still necessary, because I can't override the equip animation for items that aren't from Wizardry.
 	// Leaving this for now because merging it into the spell data system will be more tricky
@@ -199,9 +200,14 @@ public class WizardData implements INBTSerializable<NBTTagCompound> {
 	}
 
 	/** Returns a set containing the registered {@link IStoredVariable} objects for which {@link IVariable#isSynced()}
-	 * returns true. Used internally for packet reading. */
-	public static Set<IVariable> getSyncedVariables(){
-		return storedVariables.stream().filter(IVariable::isSynced).collect(Collectors.toSet());
+	 * returns true, ordered by their keys obtained from {@link IVariable#getKey()}. Used internally for packets. */
+	public static Set<IVariable> getSyncedVariablesOrderedByKey(){
+		Comparator<IVariable> keyComparator = Comparator.comparing(IVariable::getKey);
+
+		return storedVariables.stream()
+				.filter(IVariable::isSynced)
+				.sorted(keyComparator)
+				.collect(Collectors.toCollection(LinkedHashSet::new));
 	}
 
 	/**
@@ -289,15 +295,19 @@ public class WizardData implements INBTSerializable<NBTTagCompound> {
 	 * @param spell The spell to be tracked.
 	 */
 	public void trackRecentSpell(Spell spell){
-		this.recentSpells.add(spell);
+		this.recentSpells.add(new SimpleEntry<>(spell, player.world.getTotalWorldTime()));
 	}
 
 	/**
 	 * Returns the number of times the given spell is tracked in this player's recently-cast spells.
+	 * Only counts spells cast within the configured expiry time.
 	 * @param spell The spell to count casts for.
 	 */
 	public int countRecentCasts(Spell spell){
-		return (int)this.recentSpells.stream().filter(s -> s == spell).count(); // We know this can't be more than 5
+		long currentTime = player.world.getTotalWorldTime();
+		return (int)this.recentSpells.stream()
+				.filter(entry -> entry.getKey() == spell && (currentTime - entry.getValue()) < Wizardry.settings.recentSpellExpiryTime)
+				.count(); // We know this can't be more than 5
 	}
 
 	// Imbuements
@@ -508,6 +518,12 @@ public class WizardData implements INBTSerializable<NBTTagCompound> {
 		if(player.ticksExisted % IMBUEMENT_UPDATE_INTERVAL == 0) updateImbuedItems();
 		updateContinuousSpellCasting();
 
+		// Clean up expired recent spells every 60 ticks (1 second)
+		if(player.ticksExisted % 60 == 0) {
+			long currentTime = player.world.getTotalWorldTime();
+			this.recentSpells.removeIf(entry -> (currentTime - entry.getValue()) >= Wizardry.settings.recentSpellExpiryTime);
+		}
+
 		this.spellData.forEach((k, v) -> this.spellData.put(k, k.update(player, v)));
 		this.spellData.keySet().removeIf(k -> k.canPurge(player, this.spellData.get(k)));
 	}
@@ -574,7 +590,15 @@ public class WizardData implements INBTSerializable<NBTTagCompound> {
 
 		properties.setInteger("maxTierReached", maxTierReached.ordinal());
 
-		NBTExtras.storeTagSafely(properties, "recentSpells", NBTExtras.listToNBT(recentSpells, s -> new NBTTagInt(s.metadata())));
+		// Serialize recent spells with timestamps as compound tags
+		NBTTagList recentSpellsList = new NBTTagList();
+		for(SimpleEntry<Spell, Long> entry : recentSpells) {
+			NBTTagCompound spellTag = new NBTTagCompound();
+			spellTag.setInteger("spellId", entry.getKey().metadata());
+			spellTag.setLong("timestamp", entry.getValue());
+			recentSpellsList.appendTag(spellTag);
+		}
+		NBTExtras.storeTagSafely(properties, "recentSpells", recentSpellsList);
 
 		storedVariables.forEach(k -> k.write(properties, this.spellData.get(k)));
 
@@ -601,8 +625,14 @@ public class WizardData implements INBTSerializable<NBTTagCompound> {
 
 			// Probably won't be null but we may as well just reinitialise it instead of clearing it
 			this.recentSpells = EvictingQueue.create(MAX_RECENT_SPELLS);
-			this.recentSpells.addAll(NBTExtras.NBTToList(nbt.getTagList("recentSpells", NBT.TAG_INT),
-					(NBTTagInt tag) -> Spell.byMetadata(tag.getInt())));
+			// Deserialize recent spells with timestamps
+			NBTTagList recentSpellsList = nbt.getTagList("recentSpells", NBT.TAG_COMPOUND);
+			for(int i = 0; i < recentSpellsList.tagCount(); i++) {
+				NBTTagCompound spellTag = recentSpellsList.getCompoundTagAt(i);
+				Spell spell = Spell.byMetadata(spellTag.getInteger("spellId"));
+				long timestamp = spellTag.getLong("timestamp");
+				this.recentSpells.add(new SimpleEntry<>(spell, timestamp));
+			}
 
 			try{
 				storedVariables.forEach(k -> this.spellData.put(k, k.read(nbt)));

src/main/java/electroblob/wizardry/entity/construct/EntityDecay.java

@@ -35,8 +35,8 @@ public class EntityDecay extends EntityMagicConstruct {
 					0.6F + rand.nextFloat() * 0.15F);
 
 		if(!this.world.isRemote){
-			List<EntityLivingBase> targets = EntityUtils.getLivingWithinRadius(1.0d, this.posX, this.posY,
-					this.posZ, this.world);
+			List<EntityLivingBase> targets = EntityUtils.getLivingWithinCylinder(this.width/2f, this.posX, this.posY,
+					this.posZ, this.height, this.world);
 			for(EntityLivingBase target : targets){
 				if(target != this.getCaster()){
 					// If this check wasn't here the potion would be reapplied every tick and hence the entity would be

src/main/java/electroblob/wizardry/entity/construct/EntityFireRing.java

@@ -34,7 +34,7 @@ public class EntityFireRing extends EntityScaledConstruct {
 
 		if(this.ticksExisted % 5 == 0 && !this.world.isRemote){
 
-			List<EntityLivingBase> targets = EntityUtils.getLivingWithinRadius(width/2, this.posX, this.posY, this.posZ, this.world);
+			List<EntityLivingBase> targets = EntityUtils.getLivingWithinCylinder(this.width/2, this.posX, this.posY, this.posZ, this.height, this.world);
 
 			for(EntityLivingBase target : targets){
 

src/main/java/electroblob/wizardry/entity/construct/EntityFireSigil.java

@@ -34,7 +34,7 @@ public class EntityFireSigil extends EntityScaledConstruct {
 
 		if(!this.world.isRemote){
 
-			List<EntityLivingBase> targets = EntityUtils.getLivingWithinRadius(width/2, posX, posY, posZ, world);
+			List<EntityLivingBase> targets = EntityUtils.getLivingWithinCylinder(this.width/2, this.posX, this.posY, this.posZ, this.height, this.world);
 
 			for(EntityLivingBase target : targets){
 

src/main/java/electroblob/wizardry/entity/construct/EntityForcefield.java

@@ -146,23 +146,28 @@ public class EntityForcefield extends EntityMagicConstruct implements ICustomHit
 					if(EntityUtils.isLiving(target)) nudgeVelocity = 0.25;
 					Vec3d extraVelocity = targetRelativePos.normalize().scale(nudgeVelocity);
 
-					// ...make it bounce off!
-					target.motionX = target.motionX * -BOUNCINESS + extraVelocity.x;
-					target.motionY = target.motionY * -BOUNCINESS + extraVelocity.y;
-					target.motionZ = target.motionZ * -BOUNCINESS + extraVelocity.z;
-
-					// Prevents the forcefield bouncing things into the floor
-					if(target.onGround && target.motionY < 0) target.motionY = 0.1;
-
-					// How far the target needs to move towards the centre (negative means away from the centre)
-					double distanceTowardsCentre = -(targetRelativePos.length() - radius) - (radius - nextTickDistance);
-					Vec3d targetNewPos = target.getPositionVector().add(targetRelativePos.normalize().scale(distanceTowardsCentre));
-					target.setPosition(targetNewPos.x, targetNewPos.y, targetNewPos.z);
-
-					world.playSound(target.posX, target.posY, target.posZ, WizardrySounds.ENTITY_FORCEFIELD_DEFLECT,
-							WizardrySounds.SPELLS, 0.3f, 1.3f, false);
-
+					//Moved up the check by "19" so that way allied players aren't being moved out of the forcefield because
+					//allied players aren't synced to client like minions. Minions are only synced because it's saved to their
+					//entity data which is synced in their serialize/deserialize methods
 					if(!world.isRemote){
+						// ...make it bounce off!
+
+						target.motionX = target.motionX * -BOUNCINESS + extraVelocity.x;
+						target.motionY = target.motionY * -BOUNCINESS + extraVelocity.y;
+						target.motionZ = target.motionZ * -BOUNCINESS + extraVelocity.z;
+
+						// Prevents the forcefield bouncing things into the floor
+						if(target.onGround && target.motionY < 0) target.motionY = 0.1;
+
+						// How far the target needs to move towards the centre (negative means away from the centre)
+						double distanceTowardsCentre = -(targetRelativePos.length() - radius) - (radius - nextTickDistance);
+						Vec3d targetNewPos = target.getPositionVector().add(targetRelativePos.normalize().scale(distanceTowardsCentre));
+						target.setPosition(targetNewPos.x, targetNewPos.y, targetNewPos.z);
+
+						world.playSound(target.posX, target.posY, target.posZ, WizardrySounds.ENTITY_FORCEFIELD_DEFLECT,
+								WizardrySounds.SPELLS, 0.3f, 1.3f, false);
+
+
 						// Player motion is handled on that player's client so needs packets
 						if(target instanceof EntityPlayerMP){
 							((EntityPlayerMP)target).connection.sendPacket(new SPacketEntityVelocity(target));
@@ -174,6 +179,11 @@ public class EntityForcefield extends EntityMagicConstruct implements ICustomHit
 
 					}else{
 
+						//This is a super lazy way to make sure the visual isn't playing for players and probably won't display the visual
+						//for players if their velocity towards the forcefield is high. But it prevents the visual being spammed when ally player
+						//is in forcefield so it's fine #19
+						if(target instanceof EntityPlayer && target.getPositionVector().distanceTo(this.getPositionVector()) < this.getRadius()) return;
+
 						Vec3d relativeImpactPos = targetRelativePos.normalize().scale(radius);
 
 						float yaw = (float)Math.atan2(relativeImpactPos.x, -relativeImpactPos.z);

src/main/java/electroblob/wizardry/entity/construct/EntityFrostSigil.java

@@ -36,8 +36,8 @@ public class EntityFrostSigil extends EntityScaledConstruct {
 
 		if(!this.world.isRemote){
 
-			List<EntityLivingBase> targets = EntityUtils.getLivingWithinRadius(width/2, this.posX, this.posY,
-					this.posZ, this.world);
+			List<EntityLivingBase> targets = EntityUtils.getLivingWithinCylinder(width/2, this.posX, this.posY,
+					this.posZ, this.height, this.world);
 
 			for(EntityLivingBase target : targets){
 

src/main/java/electroblob/wizardry/entity/construct/EntityHealAura.java

@@ -33,30 +33,32 @@ public class EntityHealAura extends EntityScaledConstruct {
 
 		if(!this.world.isRemote){
 
-			List<EntityLivingBase> targets = EntityUtils.getLivingWithinRadius(width/2, posX, posY, posZ, world);
+			List<EntityLivingBase> targets = EntityUtils.getLivingWithinCylinder(width/2, posX, posY, posZ, this.height, world);
 
 			for(EntityLivingBase target : targets){
 
 				if(this.isValidTarget(target)){
 
-					if(target.isEntityUndead()){
+					if(target.isEntityUndead()) {
 
 						double velX = target.motionX;
 						double velY = target.motionY;
 						double velZ = target.motionZ;
 
-						if(this.getCaster() != null){
-							target.attackEntityFrom(
-									MagicDamage.causeIndirectMagicDamage(this, getCaster(), DamageType.RADIANT),
-									Spells.healing_aura.getProperty(Spell.DAMAGE).floatValue() * damageMultiplier);
-						}else{
-							target.attackEntityFrom(DamageSource.MAGIC, Spells.healing_aura.getProperty(Spell.DAMAGE).floatValue() * damageMultiplier);
-						}
+						if (this.ticksExisted % 10 == 1) {
+							if (this.getCaster() != null) {
+								target.attackEntityFrom(
+										MagicDamage.causeIndirectMagicDamage(this, getCaster(), DamageType.RADIANT),
+										Spells.healing_aura.getProperty(Spell.DAMAGE).floatValue() * damageMultiplier);
+							} else {
+								target.attackEntityFrom(DamageSource.MAGIC, Spells.healing_aura.getProperty(Spell.DAMAGE).floatValue() * damageMultiplier);
+							}
 
-						// Removes knockback
-						target.motionX = velX;
-						target.motionY = velY;
-						target.motionZ = velZ;
+							// Removes knockback
+							target.motionX = velX;
+							target.motionY = velY;
+							target.motionZ = velZ;
+						}
 					}
 
 				}else if(target.getHealth() < target.getMaxHealth() && target.ticksExisted % 5 == 0){

src/main/java/electroblob/wizardry/entity/construct/EntityLightningSigil.java

@@ -39,8 +39,8 @@ public class EntityLightningSigil extends EntityScaledConstruct {
 			this.setDead();
 		}
 
-		List<EntityLivingBase> targets = EntityUtils.getLivingWithinRadius(width/2, this.posX, this.posY,
-				this.posZ, this.world);
+		List<EntityLivingBase> targets = EntityUtils.getLivingWithinCylinder(this.width/2, this.posX, this.posY,
+				this.posZ, this.height, this.world);
 
 		for(EntityLivingBase target : targets){
 

src/main/java/electroblob/wizardry/entity/living/EntityWizard.java

@@ -68,7 +68,7 @@ public class EntityWizard extends EntityCreature implements INpc, IMerchant, ISp
 	protected Predicate<Entity> targetSelector;
 
 	/** The wizard's trades. */
-	private MerchantRecipeList trades;
+	public MerchantRecipeList trades;
     /** The wizard's current customer. */
     @Nullable
     private EntityPlayer customer;
@@ -130,8 +130,12 @@ public class EntityWizard extends EntityCreature implements INpc, IMerchant, ISp
 			if(entity != null && !entity.isInvisible()
 					&& AllyDesignationSystem.isValidTarget(EntityWizard.this, entity)){
 
-				// ... and is a mob, a summoned creature ...
-				if((entity instanceof IMob || entity instanceof ISummonedCreature
+				// ... and is a non summoned creature mob ...
+				if((entity instanceof IMob && !(entity instanceof ISummonedCreature)
+
+						// or is a summoned creature with a mob owner or an owner who has attacked the wizard ...
+						|| entity instanceof ISummonedCreature && (((ISummonedCreature)entity).getOwner() instanceof IMob || ((ISummonedCreature)entity).getOwner() == this.getRevengeTarget() || ((ISummonedCreature) entity).getOwner() == this.getAttackTarget())
+
 						// ... or in the whitelist ...
 						|| Arrays.asList(Wizardry.settings.summonedCreatureTargetsWhitelist)
 								.contains(EntityList.getKey(entity.getClass())))

src/main/java/electroblob/wizardry/event/ArtefactCheckEvent.java

@@ -8,7 +8,7 @@ import net.minecraftforge.fml.common.eventhandler.Cancelable;
 import net.minecraftforge.fml.common.eventhandler.Event;
 
 /**
- * SpellBindEvent is fired when a check happens for an ItemArtefact using {@link electroblob.wizardry.item.ItemArtefact#isArtefactActive(net.minecraft.entity.player.EntityPlayer, net.minecraft.item.Item)}
+ * ArtefactCheckEvent is fired when a check happens for an ItemArtefact using {@link electroblob.wizardry.item.ItemArtefact#isArtefactActive(net.minecraft.entity.player.EntityPlayer, net.minecraft.item.Item)}
  * <i>Fired on both sides.</i><br>
  * <br>
  * This event is {@link Cancelable}. <br>
@@ -42,4 +42,4 @@ public class ArtefactCheckEvent extends PlayerEvent {
 		return player;
 	}
 
-}
+}

src/main/java/electroblob/wizardry/integration/baubles/WizardryBaublesIntegration.java

@@ -49,7 +49,6 @@ public final class WizardryBaublesIntegration {
 		ARTEFACT_TYPE_MAP.put(ItemArtefact.Type.BELT, BaubleType.BELT);
 		ARTEFACT_TYPE_MAP.put(ItemArtefact.Type.BODY, BaubleType.BODY);
 		ARTEFACT_TYPE_MAP.put(ItemArtefact.Type.HEAD, BaubleType.HEAD);
-		ARTEFACT_TYPE_MAP.put(ItemArtefact.Type.TRINKET, BaubleType.TRINKET);
 	}
 
 	public static boolean enabled(){

src/main/java/electroblob/wizardry/inventory/ContainerArcaneWorkbench.java

@@ -452,6 +452,24 @@ public class ContainerArcaneWorkbench extends Container implements ISpellSortabl
 		}
 	}
 
+	/**
+	 * Called (via {@link electroblob.wizardry.packet.PacketControlInput PacketControlInput}) when the clear button in
+	 * the arcane workbench GUI is pressed.
+	 */
+	// As of 2.1, for the sake of events and neatness of code, this was moved here from TileEntityArcaneWorkbench.
+	// As of 4.2, the spell binding/charging/upgrading code was delegated (via IWorkbenchItem) to the items themselves.
+	public void onClearButtonPressed(EntityPlayer player){
+
+		Slot centre = this.getSlot(CENTRE_SLOT);
+
+		if(centre.getStack().getItem() instanceof IWorkbenchItem){ // Should always be true, but no harm in checking.
+
+			Slot[] spellBooks = this.inventorySlots.subList(0, 8).toArray(new Slot[8]);
+
+			((IWorkbenchItem) centre.getStack().getItem()).onClearButtonPressed(player, centre, this.getSlot(CRYSTAL_SLOT), this.getSlot(UPGRADE_SLOT), spellBooks);
+		}
+	}
+
 	/** Scrolls to the given row number. */
 	public void scrollTo(int row){
 		this.scroll = row;

src/main/java/electroblob/wizardry/item/IWorkbenchItem.java

@@ -55,6 +55,26 @@ public interface IWorkbenchItem {
 	 */
 	boolean onApplyButtonPressed(EntityPlayer player, Slot centre, Slot crystals, Slot upgrade, Slot[] spellBooks);
 
+	/**
+	 * Called when this item is in the central slot of an arcane workbench and the apply clear is pressed. Items must
+	 * implement this method to define what happens when the apply button is pressed.
+	 * @param player The player that pressed the apply button.
+	 * @param centre The central slot in the arcane workbench. This slot will always contain a stack of the implementing
+	 * item, or in other words, <i>it is guaranteed that</i> {@code this == centre.getStack().getItem()}.
+	 * @param crystals The magic crystal slot of the arcane workbench.
+	 * @param upgrade The upgrade slot of the arcane workbench.
+	 * @param spellBooks An array of the <i>active</i> (visible) spell book slots in the arcane workbench. The length of
+	 * the array will be equal to the value returned by {@link IWorkbenchItem#getSpellSlotCount(ItemStack)}.
+	 * */
+	default void onClearButtonPressed(EntityPlayer player, Slot centre, Slot crystals, Slot upgrade, Slot[] spellBooks){};
+
+	/**
+	 * Must be overridden in the item class to make the clear button in the Arcane Workbench clickable.
+	 * */
+	default boolean isClearable() {
+		return false;
+	}
+
 	/**
 	 * Returns whether the tooltip (dark grey box) should be drawn when this item is in an arcane workbench. Only
 	 * called client-side.

src/main/java/electroblob/wizardry/item/ItemArcaneTome.java

@@ -25,7 +25,7 @@ public class ItemArcaneTome extends Item {
 
 	@Override
 	public void getSubItems(CreativeTabs tab, NonNullList<ItemStack> list){
-		if(tab == WizardryTabs.WIZARDRY){ // Don't use isInCreativeTab here.
+		if(tab == WizardryTabs.WIZARDRY || tab == CreativeTabs.SEARCH){ // Don't use isInCreativeTab here.
 			for(int i = 1; i < Tier.values().length; i++){
 				list.add(new ItemStack(this, 1, i));
 			}

src/main/java/electroblob/wizardry/item/ItemArtefact.java

@@ -93,8 +93,7 @@ public class ItemArtefact extends Item {
 		/** An artefact that improves utility spells. One of these can be active at any one time. */ CHARM(1),
 		/** Added for add-on artefacts. */ BELT(1),
 		/** Added for add-on artefacts. */ BODY(1),
-		/** Added for add-on artefacts. */ HEAD(1),
-		/** Added for add-on artefacts. */ TRINKET(1);
+		/** Added for add-on artefacts. */ HEAD(1);
 
 		public final int maxAtOnce;
 

src/main/java/electroblob/wizardry/item/ItemCrystal.java

@@ -34,7 +34,7 @@ public class ItemCrystal extends Item implements IMultiTexturedItem {
 
     @Override
     public void getSubItems(CreativeTabs tab, NonNullList<ItemStack> items){
-        if(tab == WizardryTabs.WIZARDRY){
+        if(tab == WizardryTabs.WIZARDRY || tab == CreativeTabs.SEARCH){
         	for(Element element : Element.values()){
         		items.add(new ItemStack(this, 1, element.ordinal()));
         	}

src/main/java/electroblob/wizardry/item/ItemFlamecatcher.java

@@ -193,14 +193,6 @@ public class ItemFlamecatcher extends ItemBow implements IConjuredItem {
 			charge = net.minecraftforge.event.ForgeEventFactory.onArrowLoose(stack, world, (EntityPlayer)entity, charge, true);
 			if(charge < 0) return;
 
-			if(stack.getTagCompound() != null){
-				int shotsLeft = stack.getTagCompound().getInteger(Flamecatcher.SHOTS_REMAINING_NBT_KEY) - 1;
-				stack.getTagCompound().setInteger(Flamecatcher.SHOTS_REMAINING_NBT_KEY, shotsLeft);
-				if(shotsLeft == 0 && !world.isRemote){
-					stack.setItemDamage(getMaxDamage(stack) - getAnimationFrames());
-				}
-			}
-
 			float velocity = (float)charge / DRAW_TIME;
 			velocity = (velocity * velocity + velocity * 2) / 3;
 
@@ -208,6 +200,14 @@ public class ItemFlamecatcher extends ItemBow implements IConjuredItem {
 
 			if((double)velocity >= 0.1D){
 
+				if(stack.getTagCompound() != null){
+					int shotsLeft = stack.getTagCompound().getInteger(Flamecatcher.SHOTS_REMAINING_NBT_KEY) - 1;
+					stack.getTagCompound().setInteger(Flamecatcher.SHOTS_REMAINING_NBT_KEY, shotsLeft);
+					if(shotsLeft == 0 && !world.isRemote){
+						stack.setItemDamage(getMaxDamage(stack) - getAnimationFrames());
+					}
+				}
+
 				if(!world.isRemote){
 					EntityFlamecatcherArrow arrow = new EntityFlamecatcherArrow(world);
 					arrow.aim(player, EntityFlamecatcherArrow.SPEED * velocity);

src/main/java/electroblob/wizardry/item/ItemSpectralDust.java

@@ -29,7 +29,7 @@ public class ItemSpectralDust extends Item implements IMultiTexturedItem {
 
     @Override
     public void getSubItems(CreativeTabs tab, NonNullList<ItemStack> items){
-        if(tab == WizardryTabs.WIZARDRY){
+        if(tab == WizardryTabs.WIZARDRY || tab == CreativeTabs.SEARCH){
         	for(Element element : Arrays.copyOfRange(Element.values(), 1, Element.values().length)){
         		items.add(new ItemStack(this, 1, element.ordinal()));
         	}

src/main/java/electroblob/wizardry/item/ItemWand.java

@@ -28,6 +28,7 @@ import net.minecraft.inventory.Slot;
 import net.minecraft.item.EnumAction;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.*;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.RayTraceResult;
@@ -45,6 +46,7 @@ import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 
 import javax.annotation.Nullable;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Random;
 
@@ -68,7 +70,7 @@ import java.util.Random;
 public class ItemWand extends Item implements IWorkbenchItem, ISpellCastingItem, IManaStoringItem {
 	
 	/** The number of spell slots a wand has with no attunement upgrades applied. */
-	public static final int BASE_SPELL_SLOTS = 5;
+	public static int BASE_SPELL_SLOTS;
 
 	/** The number of ticks between each time a continuous spell is added to the player's recently-cast spells. */
 	private static final int CONTINUOUS_TRACKING_INTERVAL = 20;
@@ -239,7 +241,9 @@ public class ItemWand extends Item implements IWorkbenchItem, ISpellCastingItem,
 		// Decrements wand damage (increases mana) every 1.5 seconds if it has a condenser upgrade
 		if(!world.isRemote && !this.isManaFull(stack) && world.getTotalWorldTime() % Constants.CONDENSER_TICK_INTERVAL == 0){
 			// If the upgrade level is 0, this does nothing anyway.
-			this.rechargeMana(stack, WandHelper.getUpgradeLevel(stack, WizardryItems.condenser_upgrade));
+			int baseAmount = WandHelper.getUpgradeLevel(stack, WizardryItems.condenser_upgrade);
+			int amount = (int)(baseAmount * Wizardry.settings.condenserAmountMultiplier);
+			this.rechargeMana(stack, amount);
 		}
 	}
 
@@ -733,7 +737,7 @@ public class ItemWand extends Item implements IWorkbenchItem, ISpellCastingItem,
 			Item specialUpgrade = upgrade.getItem();
 
 			int maxUpgrades = this.tier.upgradeLimit;
-			if(this.element == Element.MAGIC) maxUpgrades += Constants.NON_ELEMENTAL_UPGRADE_BONUS;
+			if(this.element == null) maxUpgrades += Constants.NON_ELEMENTAL_UPGRADE_BONUS;
 
 			if(WandHelper.getTotalUpgrades(wand) < maxUpgrades
 					&& WandHelper.getUpgradeLevel(wand, specialUpgrade) < Constants.UPGRADE_STACK_LIMIT){
@@ -842,8 +846,19 @@ public class ItemWand extends Item implements IWorkbenchItem, ISpellCastingItem,
 				Spell spell = Spell.byMetadata(spellBooks[i].getStack().getItemDamage());
 				// If the wand is powerful enough for the spell, it's not already bound to that slot and it's enabled for wands
 				if(!(spell.getTier().level > this.tier.level) && spells[i] != spell && spell.isEnabled(SpellProperties.Context.WANDS)){
+
+					// Decide if we can bind this multiple times
+					if (Wizardry.settings.preventBindingSameSpellTwiceToWands && Arrays.stream(spells).anyMatch(s -> s == spell)) {
+						continue;
+					}
+
 					spells[i] = spell;
 					changed = true;
+
+					// setting to consume books upon use
+					if (Wizardry.settings.singleUseSpellBooks) {
+						spellBooks[i].getStack().shrink(1);
+					}
 				}
 			}
 		}
@@ -851,36 +866,35 @@ public class ItemWand extends Item implements IWorkbenchItem, ISpellCastingItem,
 		WandHelper.setSpells(centre.getStack(), spells);
 
 		// Charges wand by appropriate amount
-		if(crystals.getStack() != ItemStack.EMPTY && !this.isManaFull(centre.getStack())){
-			
-			int chargeDepleted = this.getManaCapacity(centre.getStack()) - this.getMana(centre.getStack());
-
-			// Not too pretty but allows addons implementing the IManaStoringItem interface to provide their mana amount for custom crystals,
-			// previously this was defaulted to the regular crystal's amount, allowing players to exploit it if a crystal was worth less mana than that.
-			int manaPerItem = crystals.getStack().getItem() instanceof IManaStoringItem ?
-					((IManaStoringItem) crystals.getStack().getItem()).getMana(crystals.getStack()) :
-					crystals.getStack().getItem() instanceof ItemCrystal ? Constants.MANA_PER_CRYSTAL : Constants.MANA_PER_SHARD;
-
-			if(crystals.getStack().getItem() == WizardryItems.crystal_shard) manaPerItem = Constants.MANA_PER_SHARD;
-			if(crystals.getStack().getItem() == WizardryItems.grand_crystal) manaPerItem = Constants.GRAND_CRYSTAL_MANA;
-			
-			if(crystals.getStack().getCount() * manaPerItem < chargeDepleted){
-				// If there aren't enough crystals to fully charge the wand
-				this.rechargeMana(centre.getStack(), crystals.getStack().getCount() * manaPerItem);
-				crystals.decrStackSize(crystals.getStack().getCount());
-
-			}else{
-				// If there are excess crystals (or just enough)
-				this.setMana(centre.getStack(), this.getManaCapacity(centre.getStack()));
-				crystals.decrStackSize((int)Math.ceil(((double)chargeDepleted) / manaPerItem));
-			}
-
+		if (WandHelper.rechargeManaOnApplyButtonPressed(centre, crystals)) {
 			changed = true;
 		}
-		
+
 		return changed;
 	}
 
+	@Override
+	public void onClearButtonPressed(EntityPlayer player, Slot centre, Slot crystals, Slot upgrade, Slot[] spellBooks){
+		ItemStack stack = centre.getStack();
+		if (stack.hasTagCompound() && stack.getTagCompound().hasKey(WandHelper.SPELL_ARRAY_KEY)) {
+			NBTTagCompound nbt = stack.getTagCompound();
+			int[] spells = nbt.getIntArray(WandHelper.SPELL_ARRAY_KEY);
+			int expectedSlotCount = BASE_SPELL_SLOTS + WandHelper.getUpgradeLevel(stack,
+					WizardryItems.attunement_upgrade);
+
+			// unbrick broken wands
+			if (spells.length < expectedSlotCount) {
+				spells = new int[expectedSlotCount];
+			}
+			Arrays.fill(spells, 0);
+			nbt.setIntArray(WandHelper.SPELL_ARRAY_KEY, spells);
+			stack.setTagCompound(nbt);
+		}
+	}
+
+	@Override
+	public boolean isClearable() { return true; }
+
 	// hitEntity is only called server-side, so we'll have to use events
 	@SubscribeEvent
 	public static void onAttackEntityEvent(AttackEntityEvent event){

src/main/java/electroblob/wizardry/misc/Forfeit.java

@@ -486,6 +486,8 @@ public abstract class Forfeit {
 			}
 		}));
 
+		add(Tier.MASTER, Element.SORCERY, create("teleport_self_large_distance", (w, p) -> ((Banish)Spells.banish).teleport(p, w, 8 + w.rand.nextDouble() * 700)));
+
 		add(Tier.NOVICE, Element.HEALING, create("damage_self", (w, p) -> p.attackEntityFrom(DamageSource.MAGIC, 4)));
 
 		add(Tier.NOVICE, Element.HEALING, create("spill_armour", (w, p) -> {

src/main/java/electroblob/wizardry/packet/PacketControlInput.java

@@ -51,6 +51,17 @@ public class PacketControlInput implements IMessageHandler<Message, IMessage> {
 
 					break;
 
+				case CLEAR_BUTTON:
+
+					if(!(player.openContainer instanceof ContainerArcaneWorkbench)){
+						Wizardry.logger.warn("Received a PacketControlInput, but the player that sent it was not " +
+								"currently using an arcane workbench. This should not happen!");
+					}else{
+						((ContainerArcaneWorkbench)player.openContainer).onClearButtonPressed(player);
+					}
+
+					break;
+
 				case NEXT_SPELL_KEY:
 
 					if(wand.getItem() instanceof ISpellCastingItem){
@@ -133,7 +144,7 @@ public class PacketControlInput implements IMessageHandler<Message, IMessage> {
 	}
 
 	public enum ControlType {
-		APPLY_BUTTON, NEXT_SPELL_KEY, PREVIOUS_SPELL_KEY, RESURRECT_BUTTON, CANCEL_RESURRECT, POSSESSION_PROJECTILE
+		APPLY_BUTTON, NEXT_SPELL_KEY, PREVIOUS_SPELL_KEY, RESURRECT_BUTTON, CANCEL_RESURRECT, POSSESSION_PROJECTILE, CLEAR_BUTTON
 	}
 
 	public static class Message implements IMessage {

src/main/java/electroblob/wizardry/packet/PacketPlayerSync.java

@@ -10,7 +10,11 @@ import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
 import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
 import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
 
-import java.util.*;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
 
 /**
  * <b>[Server -> Client]</b> This packet is sent to synchronise any fields that need synchronising in
@@ -54,9 +58,8 @@ public class PacketPlayerSync implements IMessageHandler<Message, IMessage> {
 
 			this.seed = buf.readLong();
 			this.selectedMinionID = buf.readInt();
-
 			this.spellData = new HashMap<>();
-			WizardData.getSyncedVariables().forEach(v -> spellData.put(v, v.read(buf)));
+			WizardData.getSyncedVariablesOrderedByKey().forEach(v -> spellData.put(v, v.read(buf)));
 			// Have to send empty tags to guarantee correct ByteBuf size/order, but no point keeping the resulting nulls
 			spellData.values().removeIf(Objects::isNull);
 
@@ -73,7 +76,7 @@ public class PacketPlayerSync implements IMessageHandler<Message, IMessage> {
 			buf.writeLong(seed);
 			buf.writeInt(selectedMinionID);
 
-			WizardData.getSyncedVariables().forEach(v -> v.write(buf, spellData.get(v)));
+			WizardData.getSyncedVariablesOrderedByKey().forEach(v -> v.write(buf, spellData.get(v)));
 
 			if(this.spellsDiscovered == null) return;
 			for(Spell spell : this.spellsDiscovered){

src/main/java/electroblob/wizardry/potion/PotionDiamondflesh.java

@@ -13,12 +13,15 @@ public class PotionDiamondflesh extends PotionMagicEffect {
 		super(isBadEffect, liquidColour, new ResourceLocation(Wizardry.MODID, "textures/gui/potion_icons/diamondflesh.png"));
 		// This needs to be here because registerPotionAttributeModifier doesn't like it if the potion has no name yet.
 		this.setPotionName("potion." + Wizardry.MODID + ":ironflesh");
-		this.registerPotionAttributeModifier(SharedMonsterAttributes.MOVEMENT_SPEED,
-				"158a8af2-6db0-4340-a01c-a7b60d10ddf4", -0.1f, EntityUtils.Operations.MULTIPLY_CUMULATIVE);
+		// Only apply slowness if the setting allows it
+		if(Wizardry.settings.fleshSpellsCauseSlowness) {
+			this.registerPotionAttributeModifier(SharedMonsterAttributes.MOVEMENT_SPEED,
+					"158a8af2-6db0-4340-a01c-a7b60d10ddf4", -0.1f, EntityUtils.Operations.MULTIPLY_CUMULATIVE);
+		}
 		this.registerPotionAttributeModifier(SharedMonsterAttributes.ARMOR_TOUGHNESS,
-				"a68d4532-5847-426c-9b03-d541b113cec2", 3.0f, EntityUtils.Operations.ADD);
+				"a68d4532-5847-426c-9b03-d541b113cec2", (float)Wizardry.settings.diamondFleshArmorToughnessBonus, EntityUtils.Operations.ADD);
 		this.registerPotionAttributeModifier(SharedMonsterAttributes.ARMOR,
-				"46a095be-82dd-43fd-8b67-13f51591eb8e", 4.0f, EntityUtils.Operations.ADD);
+				"46a095be-82dd-43fd-8b67-13f51591eb8e", (float)Wizardry.settings.diamondFleshArmorBonus, EntityUtils.Operations.ADD);
 	}
 
 	@Override

src/main/java/electroblob/wizardry/potion/PotionFireskin.java

@@ -0,0 +1,97 @@
+package electroblob.wizardry.potion;
+
+import electroblob.wizardry.registry.WizardrySounds;
+import net.minecraft.init.SoundEvents;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.EnumParticleTypes;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+public class PotionFireskin extends PotionMagicEffectParticles {
+
+	public PotionFireskin(boolean isBadEffect, int liquidColour, ResourceLocation texture) {
+		super(isBadEffect, liquidColour, texture);
+		this.setBeneficial();
+	}
+
+	@Override
+	public void spawnCustomParticle(World world, double x, double y, double z){
+		if(world.isRemote){
+			// Spawn ambient fire particles around the entity
+			world.spawnParticle(EnumParticleTypes.FLAME, x, y, z, 0, 0, 0);
+		}
+	}
+
+	@Override
+	public boolean isReady(int duration, int amplifier) {
+		return true;
+	}
+
+	@Override
+	public void performEffect(EntityLivingBase entitylivingbase, int strength){
+
+		// Original fireskin behavior: extinguish the entity to prevent fire damage from melee attacks
+		entitylivingbase.extinguish();
+
+		// Server-side cobweb burning logic
+		World world = entitylivingbase.world;
+		if(!world.isRemote){
+
+			AxisAlignedBB entityBox = entitylivingbase.getEntityBoundingBox();
+
+			// Expand the bounding box slightly to catch cobwebs the entity is touching
+			entityBox = entityBox.expand(0.1, 0.1, 0.1);
+
+			BlockPos minPos = new BlockPos(entityBox.minX, entityBox.minY, entityBox.minZ);
+			BlockPos maxPos = new BlockPos(entityBox.maxX, entityBox.maxY, entityBox.maxZ);
+
+			boolean burnedCobweb = false;
+
+			// Check all blocks in the entity's bounding box
+			for(int x = minPos.getX(); x <= maxPos.getX(); x++){
+				for(int y = minPos.getY(); y <= maxPos.getY(); y++){
+					for(int z = minPos.getZ(); z <= maxPos.getZ(); z++){
+
+						BlockPos pos = new BlockPos(x, y, z);
+
+						if(world.getBlockState(pos).getBlock() == Blocks.WEB){
+							// Burn the cobweb
+							world.setBlockToAir(pos);
+							burnedCobweb = true;
+
+							// Add visual effects - spawn particles on client side
+							if(world.rand.nextFloat() < 0.7f){ // 70% chance to spawn particles for better visibility
+								float offsetX = world.rand.nextFloat() * 0.1f - 0.05f;
+								float offsetY = world.rand.nextFloat() * 0.1f + 0.05f;
+								float offsetZ = world.rand.nextFloat() * 0.1f - 0.05f;
+
+								// Main flame particle rising up
+								world.spawnParticle(EnumParticleTypes.FLAME,
+									pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5,
+									0, 0.1, 0);
+
+								// Two additional flame particles with random movement
+								world.spawnParticle(EnumParticleTypes.FLAME,
+									pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5,
+									offsetX, offsetY, offsetZ);
+
+								world.spawnParticle(EnumParticleTypes.FLAME,
+									pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5,
+									offsetX * -0.5f, offsetY * 0.8f, offsetZ * -0.5f);
+							}
+						}
+					}
+				}
+			}
+
+			// Play the fire extinguish sound only when cobwebs were actually burned
+			if(burnedCobweb){
+				world.playSound(null, entitylivingbase.getPosition(), SoundEvents.BLOCK_FIRE_EXTINGUISH, SoundCategory.BLOCKS, 0.6f, 0.8f + world.rand.nextFloat() * 0.4f);
+			}
+		}
+	}
+}

src/main/java/electroblob/wizardry/potion/PotionIronflesh.java

@@ -13,12 +13,15 @@ public class PotionIronflesh extends PotionMagicEffect {
 		super(isBadEffect, liquidColour, new ResourceLocation(Wizardry.MODID, "textures/gui/potion_icons/ironflesh.png"));
 		// This needs to be here because registerPotionAttributeModifier doesn't like it if the potion has no name yet.
 		this.setPotionName("potion." + Wizardry.MODID + ":ironflesh");
-		this.registerPotionAttributeModifier(SharedMonsterAttributes.MOVEMENT_SPEED,
-				"fe607d55-50e3-4f4f-a959-6571503f92f4", -0.1f, EntityUtils.Operations.MULTIPLY_CUMULATIVE);
+		// Only apply slowness if the setting allows it
+		if(Wizardry.settings.fleshSpellsCauseSlowness) {
+			this.registerPotionAttributeModifier(SharedMonsterAttributes.MOVEMENT_SPEED,
+					"fe607d55-50e3-4f4f-a959-6571503f92f4", -0.1f, EntityUtils.Operations.MULTIPLY_CUMULATIVE);
+		}
 		this.registerPotionAttributeModifier(SharedMonsterAttributes.KNOCKBACK_RESISTANCE,
 				"6f78206e-8dd4-4d44-9792-d7a882111951", 0.3f, EntityUtils.Operations.ADD);
 		this.registerPotionAttributeModifier(SharedMonsterAttributes.ARMOR,
-				"e1adff1e-8510-4a09-96ed-ef677cad20c1", 4.0f, EntityUtils.Operations.ADD);
+				"e1adff1e-8510-4a09-96ed-ef677cad20c1", (float)Wizardry.settings.ironFleshArmorBonus, EntityUtils.Operations.ADD);
 	}
 
 	@Override

src/main/java/electroblob/wizardry/potion/PotionOakflesh.java

@@ -13,12 +13,15 @@ public class PotionOakflesh extends PotionMagicEffect {
 		super(isBadEffect, liquidColour, new ResourceLocation(Wizardry.MODID, "textures/gui/potion_icons/oakflesh.png"));
 		// This needs to be here because registerPotionAttributeModifier doesn't like it if the potion has no name yet.
 		this.setPotionName("potion." + Wizardry.MODID + ":ironflesh");
-		this.registerPotionAttributeModifier(SharedMonsterAttributes.MOVEMENT_SPEED,
-				"98b4ba66-7c50-4a4c-9f3f-40bcb37313b5", -0.1f, EntityUtils.Operations.MULTIPLY_CUMULATIVE);
+		// Only apply slowness if the setting allows it
+		if(Wizardry.settings.fleshSpellsCauseSlowness) {
+			this.registerPotionAttributeModifier(SharedMonsterAttributes.MOVEMENT_SPEED,
+					"98b4ba66-7c50-4a4c-9f3f-40bcb37313b5", -0.1f, EntityUtils.Operations.MULTIPLY_CUMULATIVE);
+		}
 		this.registerPotionAttributeModifier(SharedMonsterAttributes.MAX_HEALTH,
-				"ed9d0423-60f4-4998-bd8d-dc7c33bd45b8", 0.2f, EntityUtils.Operations.MULTIPLY_FLAT);
+				"ed9d0423-60f4-4998-bd8d-dc7c33bd45b8", (float)Wizardry.settings.oakFleshHealthBonus, EntityUtils.Operations.MULTIPLY_FLAT);
 		this.registerPotionAttributeModifier(SharedMonsterAttributes.ARMOR,
-				"0b607c3f-fb14-43d7-96b5-1c1b6f6da242", 3.0f, EntityUtils.Operations.ADD);
+				"0b607c3f-fb14-43d7-96b5-1c1b6f6da242", (float)Wizardry.settings.oakFleshArmorBonus, EntityUtils.Operations.ADD);
 	}
 
 	@Override

src/main/java/electroblob/wizardry/registry/WizardryPotions.java

@@ -2,6 +2,7 @@ package electroblob.wizardry.registry;
 
 import electroblob.wizardry.Wizardry;
 import electroblob.wizardry.potion.*;
+import electroblob.wizardry.potion.PotionFireskin;
 import electroblob.wizardry.util.ParticleBuilder;
 import electroblob.wizardry.util.ParticleBuilder.Type;
 import net.minecraft.entity.EntityLivingBase;
@@ -95,19 +96,8 @@ public final class WizardryPotions {
 			}
 		}.setBeneficial()); // 0xffe89b
 		
-		registerPotion(registry, "fireskin", new PotionMagicEffectParticles(false, 0,
-				new ResourceLocation(Wizardry.MODID, "textures/gui/potion_icons/fireskin.png")){
-			@Override
-			public void spawnCustomParticle(World world, double x, double y, double z){
-				world.spawnParticle(EnumParticleTypes.FLAME, x, y, z, 0, 0, 0);
-			}
-
-			@Override
-			public void performEffect(EntityLivingBase entitylivingbase, int strength){
-				entitylivingbase.extinguish(); // Stops melee mobs that are on fire from setting the player on fire,
-				// without allowing the player to actually stand in fire or swim in lava without taking damage.
-			}
-		}.setBeneficial()); // 0xff2f02
+		registerPotion(registry, "fireskin", new PotionFireskin(false, 0xff2f02,
+				new ResourceLocation(Wizardry.MODID, "textures/gui/potion_icons/fireskin.png")));
 		
 		registerPotion(registry, "ice_shroud", new PotionMagicEffectParticles(false, 0,
 				new ResourceLocation(Wizardry.MODID, "textures/gui/potion_icons/ice_shroud.png")){
@@ -130,17 +120,7 @@ public final class WizardryPotions {
 		registerPotion(registry, "decay", new PotionDecay(true, 0x3c006c));
 
 		registerPotion(registry, "sixth_sense", new PotionMagicEffect(false, 0xc6ff01,
-				new ResourceLocation(Wizardry.MODID, "textures/gui/potion_icons/sixth_sense.png")){
-			@Override
-			public void performEffect(EntityLivingBase target, int strength){
-				// Reset the shader (a bit dirty but both the potion expiry hooks are only fired server-side, and
-				// there's no point sending packets unnecessarily if we can just do this instead)
-				if(target.getActivePotionEffect(this).getDuration() <= 1 && target.world.isRemote
-						&& target == net.minecraft.client.Minecraft.getMinecraft().player){
-					net.minecraft.client.Minecraft.getMinecraft().entityRenderer.stopUseShader();
-				}
-			}
-		}.setBeneficial());
+				new ResourceLocation(Wizardry.MODID, "textures/gui/potion_icons/sixth_sense.png")).setBeneficial());
 
 		registerPotion(registry, "arcane_jammer", new PotionMagicEffect(true, 0xcf4aa2,
 				new ResourceLocation(Wizardry.MODID, "textures/gui/potion_icons/arcane_jammer.png")));

src/main/java/electroblob/wizardry/spell/ArcaneLock.java

@@ -13,14 +13,18 @@ import net.minecraft.tileentity.TileEntityDispenser;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.text.TextComponentTranslation;
 import net.minecraft.world.World;
 import net.minecraftforge.event.entity.living.LivingDestroyBlockEvent;
+
 import net.minecraftforge.event.entity.player.PlayerInteractEvent;
 import net.minecraftforge.event.world.BlockEvent;
 import net.minecraftforge.event.world.ExplosionEvent;
 import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 
+
+
 @Mod.EventBusSubscriber
 public class ArcaneLock extends SpellRay {
 
@@ -167,4 +171,8 @@ public class ArcaneLock extends SpellRay {
 				&& event.getWorld().getTileEntity(pos).getTileData().hasUniqueId(NBT_KEY));
 	}
 
+
+
+
+
 }

src/main/java/electroblob/wizardry/spell/Enrage.java

@@ -4,7 +4,7 @@ import electroblob.wizardry.item.SpellActions;
 import electroblob.wizardry.util.ParticleBuilder;
 import electroblob.wizardry.util.ParticleBuilder.Type;
 import electroblob.wizardry.util.SpellModifiers;
-import net.minecraft.entity.EntityCreature;
+import net.minecraft.entity.EntityLiving;
 import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.tileentity.TileEntityDispenser;
 import net.minecraft.util.math.Vec3d;
@@ -29,7 +29,7 @@ public class Enrage extends SpellAreaEffect {
 	@Override
 	protected boolean affectEntity(World world, Vec3d origin, @Nullable EntityLivingBase caster, EntityLivingBase target, int targetCount, int ticksInUse, SpellModifiers modifiers){
 
-		if(caster != null && target instanceof EntityCreature){
+		if(caster != null && target instanceof EntityLiving){
 			target.setRevengeTarget(caster); // Yours truly, angry mobs
 		}
 

src/main/java/electroblob/wizardry/spell/FireBreath.java

@@ -53,7 +53,7 @@ public class FireBreath extends SpellRay {
 						this.getNameForTranslationFormatted()), true);
 			// This now only damages in line with the maxHurtResistantTime. Some mods don't play nicely and fiddle
 			// with this mechanic for their own purposes, so this line makes sure that doesn't affect wizardry.
-			}else if(ticksInUse % ((EntityLivingBase)target).maxHurtResistantTime == 1){
+			}else if(ticksInUse % 10 == 0){
 				target.setFire((int)(getProperty(BURN_DURATION).floatValue() * modifiers.get(WizardryItems.duration_upgrade)));
 				EntityUtils.attackEntityWithoutKnockback(target,
 						MagicDamage.causeDirectMagicDamage(caster, DamageType.FIRE),

src/main/java/electroblob/wizardry/spell/FlameRay.java

@@ -56,7 +56,7 @@ public class FlameRay extends SpellRay {
 						this.getNameForTranslationFormatted()), true);
 			// This now only damages in line with the maxHurtResistantTime. Some mods don't play nicely and fiddle
 			// with this mechanic for their own purposes, so this line makes sure that doesn't affect wizardry.
-			}else if(ticksInUse % ((EntityLivingBase)target).maxHurtResistantTime == 1){
+			}else if(ticksInUse % 10 == 0){
 				target.setFire((int)(getProperty(BURN_DURATION).floatValue() * modifiers.get(WizardryItems.duration_upgrade)));
 				EntityUtils.attackEntityWithoutKnockback(target,
 						MagicDamage.causeDirectMagicDamage(caster, DamageType.FIRE),

src/main/java/electroblob/wizardry/spell/FrostRay.java

@@ -65,7 +65,7 @@ public class FrostRay extends SpellRay {
 						(int)(getProperty(EFFECT_DURATION).floatValue() * modifiers.get(WizardryItems.duration_upgrade)),
 						getProperty(EFFECT_STRENGTH).intValue()));
 
-				if(ticksInUse % ((EntityLivingBase)target).maxHurtResistantTime == 1){
+				if(ticksInUse % 10 == 0){
 					float damage = getProperty(DAMAGE).floatValue() * modifiers.get(SpellModifiers.POTENCY);
 					if(target instanceof EntityBlaze || target instanceof EntityMagmaCube) damage *= 2;
 

src/main/java/electroblob/wizardry/spell/Heal.java

@@ -38,7 +38,7 @@ public class Heal extends SpellBuff {
 		entity.heal(health);
 
 		// If the player is able to heal, they can't possibly have absorption hearts, so no need to check!
-		if(excessHealth > 0 && entity instanceof EntityPlayer
+		if(excessHealth > entity.getAbsorptionAmount() && entity instanceof EntityPlayer
 				&& ItemArtefact.isArtefactActive((EntityPlayer)entity, WizardryItems.amulet_absorption)){
 			entity.setAbsorptionAmount(excessHealth);
 		}

src/main/java/electroblob/wizardry/spell/LifeDrain.java

@@ -47,7 +47,7 @@ public class LifeDrain extends SpellRay {
 		
 		if(EntityUtils.isLiving(target)){
 
-			if(ticksInUse % 12 == 0){
+			if(ticksInUse % 10 == 0){
 				
 				float damage = getProperty(DAMAGE).floatValue() * modifiers.get(SpellModifiers.POTENCY);
 				

src/main/java/electroblob/wizardry/spell/LightningRay.java

@@ -51,7 +51,7 @@ public class LightningRay extends SpellRay {
 							this.getNameForTranslationFormatted()), true);
 			// This now only damages in line with the maxHurtResistantTime. Some mods don't play nicely and fiddle
 			// with this mechanic for their own purposes, so this line makes sure that doesn't affect wizardry.
-			}else if(ticksInUse % ((EntityLivingBase)target).maxHurtResistantTime == 1){
+			}else if(ticksInUse % 10 == 0){
 				EntityUtils.attackEntityWithoutKnockback(target,
 						MagicDamage.causeDirectMagicDamage(caster, DamageType.SHOCK),
 						getProperty(DAMAGE).floatValue() * modifiers.get(SpellModifiers.POTENCY));

src/main/java/electroblob/wizardry/spell/LightningWeb.java

@@ -53,7 +53,7 @@ public class LightningWeb extends SpellRay {
 	@Override
 	protected boolean onEntityHit(World world, Entity target, Vec3d hit, EntityLivingBase caster, Vec3d origin, int ticksInUse, SpellModifiers modifiers){
 
-		if(EntityUtils.isLiving(target)){
+		if(EntityUtils.isLiving(target) && ticksInUse % 10 == 0){
 
 			electrocute(world, caster, origin, target, getProperty(PRIMARY_DAMAGE).floatValue()
 					* modifiers.get(SpellModifiers.POTENCY), ticksInUse);

src/main/java/electroblob/wizardry/spell/RayOfPurification.java

@@ -58,7 +58,7 @@ public class RayOfPurification extends SpellRay {
 				if(!world.isRemote && ticksInUse == 1 && caster instanceof EntityPlayer) ((EntityPlayer)caster)
 				.sendStatusMessage(new TextComponentTranslation("spell.resist", target.getName(),
 						this.getNameForTranslationFormatted()), true);
-			}else{
+			}else if (ticksInUse % 10 == 0) {
 
 				float damage = getProperty(DAMAGE).floatValue() * modifiers.get(SpellModifiers.POTENCY);
 				// Fire

src/main/java/electroblob/wizardry/spell/Spell.java

@@ -922,6 +922,11 @@ public abstract class Spell extends IForgeRegistryEntry.Impl<Spell> implements C
 		return Arrays.asList(applicableItems).contains(item);
 	}
 
+	/** Returns the list of items this spell is applicable to. */
+	public List<Item> getApplicableItems() {
+		return Arrays.asList(applicableItems);
+	}
+
 	/**
 	 * Sets which items this spell can appear on (these default to the regular spell book and scroll).
 	 * @param applicableItems The items this spell should naturally appear on (or no items at all).

src/main/java/electroblob/wizardry/spell/SpellRay.java

@@ -47,7 +47,7 @@ import javax.annotation.Nullable;
 public abstract class SpellRay extends Spell {
 	
 	/** The distance below the caster's eyes that the bolt particles start from. */
-	protected static final double Y_OFFSET = 0.25;
+	public static final double Y_OFFSET = 0.25;
 
 	/** The distance between spawned particles. Defaults to 0.85. */
 	// 0.85 was chosen to keep it similar to the most common method used previously, which gave an effective spacing of

src/main/java/electroblob/wizardry/spell/Telekinesis.java

@@ -1,7 +1,9 @@
 package electroblob.wizardry.spell;
 
 import electroblob.wizardry.Wizardry;
+import electroblob.wizardry.item.ItemArtefact;
 import electroblob.wizardry.item.SpellActions;
+import electroblob.wizardry.registry.WizardryItems;
 import electroblob.wizardry.util.SpellModifiers;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.entity.Entity;
@@ -34,15 +36,15 @@ public class Telekinesis extends SpellRay {
 			target.motionZ = (origin.z - target.posZ) / 6;
 			return true;
 
-		}else if(target instanceof EntityPlayer && (Wizardry.settings.telekineticDisarmament || !(caster instanceof EntityPlayer))){
+		} else if (target instanceof EntityPlayer && (Wizardry.settings.telekineticDisarmament && !ItemArtefact.isArtefactActive((EntityPlayer) target, WizardryItems.amulet_anchoring))) {
+
+      EntityPlayer player = (EntityPlayer) target;
 
-			EntityPlayer player = (EntityPlayer)target;
-			
 			// IDEA: Disarm the offhand if the mainhand is empty or otherwise harmless?
 
-			if(!player.getHeldItemMainhand().isEmpty()){
+			if (!player.getHeldItemMainhand().isEmpty()) {
 
-				if(!world.isRemote){
+				if (!world.isRemote) {
 					EntityItem item = player.entityDropItem(player.getHeldItemMainhand(), 0);
 					// Makes the item move towards the caster
 					item.motionX = (origin.x - player.posX) / 20;
@@ -50,7 +52,7 @@ public class Telekinesis extends SpellRay {
 				}
 
 				player.setHeldItem(EnumHand.MAIN_HAND, ItemStack.EMPTY);
-				
+
 				return true;
 			}
 		}

src/main/java/electroblob/wizardry/tileentity/TileEntityArcaneWorkbench.java

@@ -67,7 +67,9 @@ public class TileEntityArcaneWorkbench extends TileEntity implements IInventory,
 		if(stack.getItem() instanceof IManaStoringItem && !this.world.isRemote && !((IManaStoringItem)stack.getItem()).isManaFull(stack)
 				&& this.world.getTotalWorldTime() % electroblob.wizardry.constants.Constants.CONDENSER_TICK_INTERVAL == 0){
 			// If the upgrade level is 0, this does nothing anyway.
-			((IManaStoringItem)stack.getItem()).rechargeMana(stack, WandHelper.getUpgradeLevel(stack, WizardryItems.condenser_upgrade));
+			int baseAmount = WandHelper.getUpgradeLevel(stack, WizardryItems.condenser_upgrade);
+			int amount = (int)(baseAmount * Wizardry.settings.condenserAmountMultiplier);
+			((IManaStoringItem)stack.getItem()).rechargeMana(stack, amount);
 		}
 
 		// The server doesn't care what these are, and there's no need for them to be synced or saved.

src/main/java/electroblob/wizardry/tileentity/TileEntityReceptacle.java

@@ -27,7 +27,7 @@ public class TileEntityReceptacle extends TileEntity {
 
 	public void setElement(@Nullable Element element){
 		this.element = element;
-		world.notifyNeighborsRespectDebug(pos, blockType, true); // Update altar if connected
+		world.notifyNeighborsRespectDebug(pos, getBlockType(), true); // Update altar if connected
 		world.checkLight(pos);
 	}
 

src/main/java/electroblob/wizardry/tileentity/TileEntityShrineCore.java

@@ -2,6 +2,7 @@ package electroblob.wizardry.tileentity;
 
 import electroblob.wizardry.Wizardry;
 import electroblob.wizardry.block.BlockPedestal;
+import electroblob.wizardry.constants.Element;
 import electroblob.wizardry.entity.living.EntityEvilWizard;
 import electroblob.wizardry.entity.living.EntityWizard;
 import electroblob.wizardry.packet.PacketConquerShrine;
@@ -13,87 +14,120 @@ import electroblob.wizardry.registry.WizardrySounds;
 import electroblob.wizardry.spell.ArcaneLock;
 import electroblob.wizardry.util.*;
 import electroblob.wizardry.util.ParticleBuilder.Type;
+import net.minecraft.block.state.IBlockState;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
 import net.minecraft.nbt.NBTBase;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.nbt.NBTTagList;
 import net.minecraft.nbt.NBTUtil;
 import net.minecraft.potion.PotionEffect;
 import net.minecraft.tileentity.TileEntity;
+import net.minecraft.tileentity.TileEntityChest;
 import net.minecraft.util.ITickable;
+import net.minecraft.util.ResourceLocation;
 import net.minecraft.util.SoundCategory;
 import net.minecraft.util.math.AxisAlignedBB;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.MathHelper;
+import net.minecraft.util.text.TextComponentTranslation;
 import net.minecraftforge.common.util.Constants;
 import net.minecraftforge.fml.common.network.NetworkRegistry;
 
-import java.util.Arrays;
-import java.util.List;
-import java.util.UUID;
+import java.util.*;
 
 public class TileEntityShrineCore extends TileEntity implements ITickable {
 
 	private static final double ACTIVATION_RADIUS = 5;
 
 	private boolean activated = false;
+	private boolean conquered = false;
+	private long regenerationTime = 0;
+	private long lastRegenerationTime = 0;
+	private Element shrineElement;
 	private AxisAlignedBB containmentField;
 	private final UUID[] linkedWizards = new UUID[3];
 	private TileEntity linkedContainer;
 	private BlockPos linkedContainerPos; // Temporary stores the container position read from NBT until the world is set
+	private final Set<UUID> lootedPlayers = new HashSet<>();
 
 	@Override
-	public void setPos(BlockPos pos){
+	public void setPos(BlockPos pos) {
 		super.setPos(pos);
 		initContainmentField(pos);
 	}
 
-	private void initContainmentField(BlockPos pos){
+	private void initContainmentField(BlockPos pos) {
 		float r = PotionContainment.getContainmentDistance(0);
 		this.containmentField = new AxisAlignedBB(-r, -r, -r, r, r, r).offset(GeometryUtils.getCentre(pos));
 	}
 
-	public void linkContainer(TileEntity container){
+	public void linkContainer(TileEntity container) {
 		this.linkedContainer = container;
 	}
 
-	@Override
-	public void update(){
+	public void setShrineElement(Element element) {
+		this.shrineElement = element;
+	}
 
-		if(this.linkedContainer == null && this.linkedContainerPos != null){
+	public boolean canPlayerLoot(EntityPlayer player) {
+		if (Wizardry.settings.shrineAllowMultipleLoot) {
+			return true; // Allow multiple looting if enabled
+		}
+		return !lootedPlayers.contains(player.getUniqueID());
+	}
+
+	public void recordPlayerLoot(EntityPlayer player) {
+		if (!Wizardry.settings.shrineAllowMultipleLoot) {
+			lootedPlayers.add(player.getUniqueID());
+			this.markDirty();
+		}
+	}
+
+	@Override
+	public void update() {
+
+		if (this.linkedContainer == null && this.linkedContainerPos != null) {
 			this.linkContainer(world.getTileEntity(this.linkedContainerPos));
 		}
 
+		// Handle shrine regeneration
+		if (conquered && Wizardry.settings.shrineRegenerationEnabled && regenerationTime > 0) {
+			if (world.getTotalWorldTime() >= regenerationTime) {
+				regenerate();
+				return; // Don't process other logic during regeneration
+			}
+		}
+
 		double x = this.pos.getX() + 0.5;
 		double y = this.pos.getY() + 0.5;
 		double z = this.pos.getZ() + 0.5;
 
-		if(!activated && world.getClosestPlayer(x, y, z, ACTIVATION_RADIUS, false) != null){
+		if (!activated && !conquered && world.getClosestPlayer(x, y, z, ACTIVATION_RADIUS, false) != null && (lastRegenerationTime == 0 || world.getTotalWorldTime() - lastRegenerationTime > 100)) { // 5 second delay after regeneration
 
 			this.activated = true;
 
-			if(world.isRemote){
+			if (world.isRemote) {
 				ParticleBuilder.create(Type.SPHERE).pos(x, y + 1, z).clr(0xf06495).scale(5).time(12).spawn(world);
 			}
 
-			world.playSound(x, y, z,
-					WizardrySounds.BLOCK_PEDESTAL_ACTIVATE, SoundCategory.BLOCKS, 1.5f, 1, false);
+			world.playSound(x, y, z, WizardrySounds.BLOCK_PEDESTAL_ACTIVATE, SoundCategory.BLOCKS, 1.5f, 1, false);
 
-			if(!world.isRemote){
+			if (!world.isRemote) {
 
 				EntityEvilWizard[] wizards = new EntityEvilWizard[linkedWizards.length];
 
-				for(int i = 0; i < linkedWizards.length; i++){
+				for (int i = 0; i < linkedWizards.length; i++) {
 
 					EntityEvilWizard wizard = new EntityEvilWizard(world);
 
-					float angle = world.rand.nextFloat() * 2 * (float)Math.PI;
+					float angle = world.rand.nextFloat() * 2 * (float) Math.PI;
 					double x1 = this.pos.getX() + 0.5 + 5 * MathHelper.sin(angle);
 					double z1 = this.pos.getZ() + 0.5 + 5 * MathHelper.cos(angle);
 					Integer y1 = BlockUtils.getNearestFloor(world, new BlockPos(x1, this.pos.getY(), z1), 8);
-					if(y1 == null){
+					if (y1 == null) {
 						// Fallback to the position of the shrine core if it failed to find a position (unlikely)
 						x1 = this.pos.getX() + 1; // Offset it so the wizard isn't inside the block
 						y1 = this.pos.getY();
@@ -110,110 +144,279 @@ public class TileEntityShrineCore extends TileEntity implements ITickable {
 					linkedWizards[i] = wizard.getUniqueID();
 				}
 
-				for(EntityEvilWizard wizard : wizards) wizard.groupUUIDs.addAll(Arrays.asList(linkedWizards));
+				for (EntityEvilWizard wizard : wizards) wizard.groupUUIDs.addAll(Arrays.asList(linkedWizards));
 			}
 
 			containNearbyTargets();
 		}
 
-		if(activated && world.getTotalWorldTime() % 20L == 0) containNearbyTargets();
+		if (!areWizardsDead() && activated && world.getTotalWorldTime() % 20L == 0) containNearbyTargets();
 
-		if(activated && areWizardsDead() && !world.isRemote){
+		if (activated && areWizardsDead() && !world.isRemote) {
 			conquer();
 		}
 	}
 
-	private boolean areWizardsDead(){
+	private boolean areWizardsDead() {
 
-		for(UUID uuid : linkedWizards){
+		for (UUID uuid : linkedWizards) {
 			Entity entity = EntityUtils.getEntityByUUID(world, uuid);
-			if(entity instanceof EntityEvilWizard && entity.isEntityAlive()) return false;
+			if (entity instanceof EntityEvilWizard && entity.isEntityAlive()) return false;
 		}
 
 		return true;
 	}
 
-	public void conquer(){
+	public void conquer() {
 
 		double x = this.pos.getX() + 0.5;
 		double y = this.pos.getY() + 0.5;
 		double z = this.pos.getZ() + 0.5;
 
-		if(!world.isRemote){
+		if (!world.isRemote) {
 
-			WizardryPacketHandler.net.sendToAllAround(new PacketConquerShrine.Message(this.pos),
-					new NetworkRegistry.TargetPoint(this.world.provider.getDimension(), x, y, z, 64));
+			WizardryPacketHandler.net.sendToAllAround(new PacketConquerShrine.Message(this.pos), new NetworkRegistry.TargetPoint(this.world.provider.getDimension(), x, y, z, 64));
 
-			if(world.getBlockState(pos).getBlock() == WizardryBlocks.runestone_pedestal){
-				world.setBlockState(pos, WizardryBlocks.runestone_pedestal.getDefaultState()
-						.withProperty(BlockPedestal.ELEMENT, world.getBlockState(pos).getValue(BlockPedestal.ELEMENT)));
-			}else{
-				Wizardry.logger.warn("What's going on?! A shrine core is being conquered but the block at its position is not a runestone pedestal!");
+			// Remove containment effects from nearby targets when shrine is conquered
+			removeContainmentFromNearbyTargets();
+
+			// If regeneration is enabled, schedule regeneration instead of removing the tile entity
+			if (Wizardry.settings.shrineRegenerationEnabled) {
+				this.conquered = true;
+				this.regenerationTime = world.getTotalWorldTime() + (Wizardry.settings.shrineRegenerationTime * 1200L); // Convert minutes to ticks (20 ticks per second * 60 seconds)
+				this.activated = false;
+				Arrays.fill(this.linkedWizards, null); // Clear wizard references
+				// Keep lootedPlayers list - it's permanent tracking for this shrine instance
+
+				// Handle chest breaking and loot dropping
+				handleChestLootDrop();
+
+				// Mark the tile entity for update
+				this.markDirty();
+
+				if (world.getBlockState(pos).getBlock() == WizardryBlocks.runestone_pedestal) {
+					// Keep the block state the same, just mark as conquered
+					this.shrineElement = world.getBlockState(pos).getValue(BlockPedestal.ELEMENT);
+				} else {
+					Wizardry.logger.warn("What's going on?! A shrine core is being conquered but the block at its position is not a runestone pedestal!");
+				}
+			} else {
+				// Original behavior: remove the tile entity
+				BlockPos chestPos = this.pos.up();
+				TileEntity chestTileEntity = world.getTileEntity(chestPos);
+				if (chestTileEntity instanceof TileEntityChest) {
+					TileEntityChest chest = (TileEntityChest) chestTileEntity;
+					NBTExtras.removeUniqueId(chest.getTileData(), ArcaneLock.NBT_KEY);
+					chest.markDirty();
+					world.markAndNotifyBlock(pos, null, world.getBlockState(pos), world.getBlockState(pos), 3);
+				}
+				if (world.getBlockState(pos).getBlock() == WizardryBlocks.runestone_pedestal) {
+					world.setBlockState(pos, WizardryBlocks.runestone_pedestal.getDefaultState().withProperty(BlockPedestal.ELEMENT, world.getBlockState(pos).getValue(BlockPedestal.ELEMENT)));
+				} else {
+					Wizardry.logger.warn("What's going on?! A shrine core is being conquered but the block at its position is not a runestone pedestal!");
+				}
+				world.markTileEntityForRemoval(this);
 			}
 		}
 
-		world.markTileEntityForRemoval(this);
-
-		if(!world.isRemote){
-			if(linkedContainer != null) NBTExtras.removeUniqueId(linkedContainer.getTileData(), ArcaneLock.NBT_KEY);
-		}else{
-			TileEntity tileEntity = world.getTileEntity(this.pos.up());
-			if(tileEntity != null){ // Bit of a dirty fix but it's only visual, so meh
-				NBTExtras.removeUniqueId(tileEntity.getTileData(), ArcaneLock.NBT_KEY);
-			}
+		if (linkedContainer == null) {
+			linkedContainer = world.getTileEntity(pos.up());
 		}
 
+		if (linkedContainer != null) {
+			NBTExtras.removeUniqueId(linkedContainer.getTileData(), ArcaneLock.NBT_KEY);
+			//linkedContainer.getTileData().removeTag("arcaneLockOwnerMost");
+			//linkedContainer.getTileData().removeTag("arcaneLockOwnerLeast");
+		}
 		world.playSound(x, y, z, WizardrySounds.BLOCK_PEDESTAL_CONQUER, SoundCategory.BLOCKS, 1, 1, false);
 
-		if(world.isRemote){
+		if (world.isRemote) {
 			ParticleBuilder.create(Type.SPHERE).scale(5).pos(x, y + 1, z).clr(0xf06495).time(12).spawn(world);
-			for(int i=0; i<5; i++){
+			for (int i = 0; i < 5; i++) {
 				float brightness = 0.8f + world.rand.nextFloat() * 0.2f;
-				ParticleBuilder.create(Type.SPARKLE, world.rand, x, y + 1, z, 1, true)
-				.clr(1, brightness, brightness).spawn(world);
+				ParticleBuilder.create(Type.SPARKLE, world.rand, x, y + 1, z, 1, true).clr(1, brightness, brightness).spawn(world);
 			}
 		}
 	}
 
-	private void containNearbyTargets(){
+	private void regenerate() {
 
-		List<EntityLivingBase> entities = world.getEntitiesWithinAABB(EntityLivingBase.class, containmentField,
-				e -> e instanceof EntityPlayer || e instanceof EntityWizard || e instanceof EntityEvilWizard);
+		if (world.isRemote) return;
 
-		for(EntityLivingBase entity : entities){
+		// Remove containment effects from nearby targets when shrine regenerates
+		removeContainmentFromNearbyTargets();
+
+		// Reset shrine state
+		this.conquered = false;
+		this.regenerationTime = 0;
+		this.activated = false;
+		Arrays.fill(this.linkedWizards, null);
+		// Keep lootedPlayers list - it's permanent for this shrine instance
+
+		// Force a short delay before allowing reactivation to prevent immediate re-activation
+		this.lastRegenerationTime = world.getTotalWorldTime();
+
+		// Forcibly replace whatever block is above the altar with a fresh chest
+		BlockPos chestPos = this.pos.up();
+
+		// Always replace the block above with a fresh chest during regeneration
+		world.setBlockState(chestPos, Blocks.CHEST.getDefaultState());
+
+		// Set up the loot table for the shrine chest
+		TileEntity chestTileEntity = world.getTileEntity(chestPos);
+		if (chestTileEntity instanceof TileEntityChest) {
+			TileEntityChest chest = (TileEntityChest) chestTileEntity;
+			chest.setLootTable(new ResourceLocation(Wizardry.MODID, "chests/shrine"), world.rand.nextLong());
+		}
+
+		// Link and apply arcane lock to the container
+		if (chestTileEntity != null) {
+			this.linkContainer(chestTileEntity);
+			chestTileEntity.getTileData().setUniqueId(ArcaneLock.NBT_KEY, new UUID(0, 0)); // Nil UUID for shrine lock
+			chestTileEntity.markDirty(); // Mark tile entity as dirty for client sync
+
+			// Trigger visual update for arcane lock effect
+			IBlockState blockState = world.getBlockState(chestPos);
+			world.markAndNotifyBlock(chestPos, null, blockState, blockState, 3);
+			world.notifyBlockUpdate(chestPos, blockState, blockState, 3); // Additional client sync
+		}
+
+		// Visual and audio effects for regeneration
+		double x = this.pos.getX() + 0.5;
+		double y = this.pos.getY() + 0.5;
+		double z = this.pos.getZ() + 0.5;
+
+		//	WizardryPacketHandler.net.sendToAllAround(new PacketConquerShrine.Message(this.pos), new NetworkRegistry.TargetPoint(this.world.provider.getDimension(), x, y, z, 64));
+
+		if (world.isRemote) {
+			ParticleBuilder.create(Type.SPHERE).pos(x, y + 1, z).clr(0xf06495).scale(5).time(12).spawn(world);
+		}
+
+		world.playSound(x, y, z, WizardrySounds.BLOCK_PEDESTAL_ACTIVATE, SoundCategory.BLOCKS, 1.5f, 1, false);
+
+		this.markDirty();
+	}
+
+	private void handleChestLootDrop() {
+		BlockPos chestPos = this.pos.up();
+
+		// Check if there's a chest at the expected position
+		if (world.getBlockState(chestPos).getBlock() == Blocks.CHEST) {
+			TileEntity chestTileEntity = world.getTileEntity(chestPos);
+
+			if (chestTileEntity instanceof TileEntityChest) {
+				TileEntityChest chest = (TileEntityChest) chestTileEntity;
+
+				// Find the player who conquered the shrine (closest player)
+				EntityPlayer conqueringPlayer = world.getClosestPlayer(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5, 20.0, false);
+
+				if (conqueringPlayer != null && !canPlayerLoot(conqueringPlayer)) {
+					// Send message to player that they've already looted this shrine
+					if (!world.isRemote) {
+						conqueringPlayer.sendMessage(new TextComponentTranslation("wizardry.shrine_already_looted"));
+					}
+					chest.setLootTable(null, world.rand.nextLong());
+					if (world.getBlockState(chestPos).getBlock() == Blocks.CHEST) {
+						world.setBlockToAir(chestPos);
+					}
+					return;
+				}
+
+				if (conqueringPlayer != null && canPlayerLoot(conqueringPlayer)) {
+					// Record that this player has looted the shrine
+					recordPlayerLoot(conqueringPlayer);
+				}
+				// If player has already looted, don't drop anything
+			}
+		}
+
+		// Break the chest regardless
+		if (world.getBlockState(chestPos).getBlock() == Blocks.CHEST) {
+			world.setBlockToAir(chestPos);
+		}
+	}
+
+	private void containNearbyTargets() {
+		List<EntityLivingBase> entities = world.getEntitiesWithinAABB(EntityLivingBase.class, containmentField, e -> e instanceof EntityPlayer || e instanceof EntityWizard || e instanceof EntityEvilWizard);
+
+		for (EntityLivingBase entity : entities) {
 			entity.addPotionEffect(new PotionEffect(WizardryPotions.containment, 219));
 			NBTExtras.storeTagSafely(entity.getEntityData(), PotionContainment.ENTITY_TAG, NBTUtil.createPosTag(this.pos));
 		}
 	}
 
+	private void removeContainmentFromNearbyTargets() {
+//		List<EntityLivingBase> entities = world.getEntitiesWithinAABB(EntityLivingBase.class, containmentField,
+//				e -> e instanceof EntityPlayer || e instanceof EntityWizard || e instanceof EntityEvilWizard);
+//
+//		for(EntityLivingBase entity : entities){
+//			// Remove the containment potion effect
+//			if(entity.isPotionActive(WizardryPotions.containment)){
+//				entity.removePotionEffect(WizardryPotions.containment);
+//			}
+//			// Also remove the containment position tag
+//			if(entity.getEntityData().hasKey(PotionContainment.ENTITY_TAG)){
+//				BlockPos containmentPos = NBTUtil.getPosFromTag(entity.getEntityData().getCompoundTag(PotionContainment.ENTITY_TAG));
+//				// Only remove if the containment position matches this shrine
+//				if(containmentPos.equals(this.pos)){
+//					entity.getEntityData().removeTag(PotionContainment.ENTITY_TAG);
+//				}
+//			}
+//		}
+	}
+
 	@Override
-	public NBTTagCompound writeToNBT(NBTTagCompound compound){
+	public NBTTagCompound writeToNBT(NBTTagCompound compound) {
 
 		compound.setBoolean("activated", this.activated);
-		if(linkedContainer != null) NBTExtras.storeTagSafely(compound, "linkedContainerPos", NBTUtil.createPosTag(linkedContainer.getPos()));
+		compound.setBoolean("conquered", this.conquered);
+		compound.setLong("regenerationTime", this.regenerationTime);
+		compound.setLong("lastRegenerationTime", this.lastRegenerationTime);
+		if (shrineElement != null) compound.setInteger("shrineElement", this.shrineElement.ordinal());
+		if (linkedContainer != null)
+			NBTExtras.storeTagSafely(compound, "linkedContainerPos", NBTUtil.createPosTag(linkedContainer.getPos()));
 
-		NBTTagList tagList = new NBTTagList();
-		for(UUID uuid : linkedWizards){
-			if(uuid != null) tagList.appendTag(NBTUtil.createUUIDTag(uuid));
+		NBTTagList wizardTagList = new NBTTagList();
+		for (UUID uuid : linkedWizards) {
+			if (uuid != null) wizardTagList.appendTag(NBTUtil.createUUIDTag(uuid));
 		}
-		NBTExtras.storeTagSafely(compound, "wizards", tagList);
+		NBTExtras.storeTagSafely(compound, "wizards", wizardTagList);
+
+		NBTTagList playerTagList = new NBTTagList();
+		for (UUID uuid : lootedPlayers) {
+			playerTagList.appendTag(NBTUtil.createUUIDTag(uuid));
+		}
+		NBTExtras.storeTagSafely(compound, "lootedPlayers", playerTagList);
 
 		return super.writeToNBT(compound);
 	}
 
 	@Override
-	public void readFromNBT(NBTTagCompound compound){
+	public void readFromNBT(NBTTagCompound compound) {
 
 		this.activated = compound.getBoolean("activated");
+		this.conquered = compound.getBoolean("conquered");
+		this.regenerationTime = compound.getLong("regenerationTime");
+		this.lastRegenerationTime = compound.getLong("lastRegenerationTime");
+		if (compound.hasKey("shrineElement"))
+			this.shrineElement = Element.values()[compound.getInteger("shrineElement")];
 		this.linkedContainerPos = NBTUtil.getPosFromTag(compound.getCompoundTag("linkedContainerPos"));
 
-		NBTTagList tagList = compound.getTagList("wizards", Constants.NBT.TAG_COMPOUND);
+		NBTTagList wizardTagList = compound.getTagList("wizards", Constants.NBT.TAG_COMPOUND);
 		int i = 0;
-		for(NBTBase tag : tagList){
-			if(tag instanceof NBTTagCompound) linkedWizards[i++] = NBTUtil.getUUIDFromTag((NBTTagCompound)tag);
+		for (NBTBase tag : wizardTagList) {
+			if (tag instanceof NBTTagCompound) linkedWizards[i++] = NBTUtil.getUUIDFromTag((NBTTagCompound) tag);
 			else Wizardry.logger.warn("Unexpected tag type in NBT tag list of compound tags!");
 		}
 
+		this.lootedPlayers.clear();
+		if (compound.hasKey("lootedPlayers")) {
+			NBTTagList playerTagList = compound.getTagList("lootedPlayers", Constants.NBT.TAG_COMPOUND);
+			for (NBTBase tag : playerTagList) {
+				if (tag instanceof NBTTagCompound) lootedPlayers.add(NBTUtil.getUUIDFromTag((NBTTagCompound) tag));
+			}
+		}
+
 		super.readFromNBT(compound);
 		// Must be after super
 		initContainmentField(this.pos);

src/main/java/electroblob/wizardry/util/AllyDesignationSystem.java

@@ -141,6 +141,11 @@ public final class AllyDesignationSystem {
 			return false;
 		}
 
+		// Tests whether the target is a creature that was summoned/tamed (or is otherwise owned) by the attacker
+		if(target instanceof IEntityOwnable && attacker instanceof EntityLiving && !(((EntityLiving)attacker).getRevengeTarget() == ((IEntityOwnable)target).getOwner() || ((EntityLiving)attacker).getAttackTarget() == ((IEntityOwnable)target).getOwner())){
+			return false;
+		}
+
 		// Tests whether the target is a creature that was mind controlled by the attacker
 		if(target instanceof EntityLiving && ((EntityLivingBase)target).isPotionActive(WizardryPotions.mind_control)){
 
@@ -201,7 +206,7 @@ public final class AllyDesignationSystem {
 		// Owned entities inherit their owner's allies
 		if(allyOf instanceof IEntityOwnable){
 			Entity owner = ((IEntityOwnable)allyOf).getOwner();
-			if(owner instanceof EntityLivingBase && isAllied((EntityLivingBase)owner, possibleAlly)) return true;
+			if(owner instanceof EntityLivingBase && (owner == possibleAlly || isAllied((EntityLivingBase)owner, possibleAlly))) return true;
 		}
 
 		if(allyOf instanceof EntityPlayer && possibleAlly instanceof EntityPlayer
@@ -215,6 +220,16 @@ public final class AllyDesignationSystem {
 			if(allyOf instanceof EntityPlayer && isOwnerAlly((EntityPlayer)allyOf, pet)) return true;
 		}
 
+		// Check if the possibleAlly is mind controlled by the allyOf entity
+		if(possibleAlly instanceof EntityLiving && possibleAlly.isPotionActive(WizardryPotions.mind_control)){
+			NBTTagCompound entityNBT = possibleAlly.getEntityData();
+
+			if(entityNBT != null && entityNBT.hasUniqueId(MindControl.NBT_KEY)){
+				Entity controller = EntityUtils.getEntityByUUID(possibleAlly.world, entityNBT.getUniqueId(MindControl.NBT_KEY));
+				return controller == allyOf;
+			}
+		}
+
 		return false;
 	}
 

src/main/java/electroblob/wizardry/util/EntityUtils.java

@@ -117,6 +117,45 @@ public final class EntityUtils {
 		return entityList;
 	}
 
+	/**
+	 * Returns all EntityLivingBase within the cylinder radius of the given coordinates. This should
+	 * used by circle effects.
+	 *
+	 * @param radius The search radius
+	 * @param x The x coordinate to search around
+	 * @param y The y coordinate to search around
+	 * @param z The z coordinate to search around
+	 * @param height The height of the cylinder
+	 * @param world The world to search in
+	 */
+	public static List<EntityLivingBase> getLivingWithinCylinder(double radius, double x, double y, double z, double height, World world) {
+		return getEntitiesWithinCylinder(radius, x, y, z, height, world, EntityLivingBase.class);
+	}
+
+	/**
+	 * Returns all entities of the specified type within the cylinder radius of the given coordinates. This should
+	 * used by circle effects.
+	 *
+	 * @param radius The search radius
+	 * @param x The x coordinate to search around
+	 * @param y The y coordinate to search around
+	 * @param z The z coordinate to search around
+	 * @param height The height of the cylinder
+	 * @param world The world to search in
+	 * @param entityType The class of entity to search for; pass in Entity.class for all entities
+	 */
+	public static <T extends Entity> List<T> getEntitiesWithinCylinder(double radius, double x, double y, double z, double height, World world, Class<T> entityType) {
+		AxisAlignedBB aabb = new AxisAlignedBB(x - radius, y, z - radius, x + radius, y + height, z + radius);
+		List<T> entityList = world.getEntitiesWithinAABB(entityType, aabb);
+		for(T entity : entityList) {
+			if (entity.getDistance(x, entity.posY, z) > radius) {
+				entityList.remove(entity);
+				break;
+			}
+		}
+		return entityList;
+	}
+
 	/**
 	 * Gets an entity from its UUID. If the UUID is known to belong to an {@code EntityPlayer}, use the more efficient
 	 * {@link World#getPlayerEntityByUUID(UUID)} instead.

src/main/java/electroblob/wizardry/util/ISpellSortable.java

@@ -20,8 +20,7 @@ public interface ISpellSortable {
 
 		TIER("tier", Comparator.naturalOrder()),
 		ELEMENT("element", Comparator.comparing(Spell::getElement).thenComparing(Spell::getTier)),
-		ALPHABETICAL("alphabetical", Comparator.comparing(Spell::getUnlocalisedName));
-
+		ALPHABETICAL("alphabetical", Comparator.comparing(s -> s.getRegistryName().getPath().toString()));
 		public String name;
 		public Comparator<? super Spell> comparator;
 

src/main/java/electroblob/wizardry/util/MagicDamage.java

@@ -1,5 +1,7 @@
 package electroblob.wizardry.util;
 
+import electroblob.wizardry.Settings;
+import electroblob.wizardry.Wizardry;
 import electroblob.wizardry.entity.living.*;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.boss.EntityDragon;
@@ -195,7 +197,7 @@ public class MagicDamage extends EntityDamageSource implements IElementalDamage
 	 * @return A damagesource object of type EntityDamageSource
 	 */
 	public static DamageSource causeDirectMagicDamage(Entity caster, DamageType type, boolean isRetaliatory){
-		return new MagicDamage(DIRECT_MAGIC_DAMAGE, caster, type, isRetaliatory);
+		return new MagicDamage(getDirectDamageNameForType(type), caster, type, isRetaliatory);
 	}
 
 	/**
@@ -241,7 +243,15 @@ public class MagicDamage extends EntityDamageSource implements IElementalDamage
 	 */
 	public static DamageSource causeIndirectMagicDamage(Entity magic, Entity caster, DamageType type,
 			boolean isRetaliatory){
-		return new IndirectMagicDamage(INDIRECT_MAGIC_DAMAGE, magic, caster, type, isRetaliatory);
+		return new IndirectMagicDamage(getIndirectDamageNameForType(type), magic, caster, type, isRetaliatory);
+	}
+
+	public static String getIndirectDamageNameForType(DamageType type) {
+		return Wizardry.settings.damageTypePerElement ? type.name().toLowerCase() + "_" + INDIRECT_MAGIC_DAMAGE : INDIRECT_MAGIC_DAMAGE;
+	}
+
+	public static String getDirectDamageNameForType(DamageType type) {
+		return Wizardry.settings.damageTypePerElement ? type.name().toLowerCase() + "_" + DIRECT_MAGIC_DAMAGE : DIRECT_MAGIC_DAMAGE;
 	}
 
 	@Override

src/main/java/electroblob/wizardry/util/WandHelper.java

@@ -1,9 +1,14 @@
 package electroblob.wizardry.util;
 
+import electroblob.wizardry.constants.Constants;
+import electroblob.wizardry.item.IManaStoringItem;
+import electroblob.wizardry.item.IWorkbenchItem;
+import electroblob.wizardry.item.ItemCrystal;
 import electroblob.wizardry.item.ItemWand;
 import electroblob.wizardry.registry.Spells;
 import electroblob.wizardry.registry.WizardryItems;
 import electroblob.wizardry.spell.Spell;
+import net.minecraft.inventory.Slot;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
@@ -494,4 +499,49 @@ public final class WandHelper {
 		setProgression(wand, getProgression(wand) + progression);
 	}
 
+	/**
+	 * Recharges the mana of an item when the apply button is pressed in the arcane workbench GUI.
+	 * This method requires the central item to implement both the {@link IWorkbenchItem} and {@link IManaStoringItem} interfaces.
+	 *
+	 * @param centre The slot representing the central item to be recharged.
+	 * @param crystals The slot containing mana crystals for recharging.
+	 * @return {@code true} if the mana of the central item was successfully recharged, {@code false} otherwise.
+	 */
+	public static boolean rechargeManaOnApplyButtonPressed(Slot centre, Slot crystals) {
+		boolean changed = false;
+		if (!(centre.getStack().getItem() instanceof IWorkbenchItem) || !(centre.getStack().getItem() instanceof IManaStoringItem)) {
+			return false;
+		}
+		IManaStoringItem iManaStoringItem = (IManaStoringItem) centre.getStack().getItem();
+
+		// Charges the item by appropriate amount
+		if (crystals.getStack() != ItemStack.EMPTY && !iManaStoringItem.isManaFull(centre.getStack())) {
+
+			int chargeDepleted = iManaStoringItem.getManaCapacity(centre.getStack()) - iManaStoringItem.getMana(centre.getStack());
+
+			// Not too pretty but allows addons implementing the IManaStoringItem interface to provide their mana amount for custom crystals,
+			// previously this was defaulted to the regular crystal's amount, allowing players to exploit it if a crystal was worth less mana than that.
+			int manaPerItem = crystals.getStack().getItem() instanceof IManaStoringItem ?
+					((IManaStoringItem) crystals.getStack().getItem()).getMana(crystals.getStack()) :
+					crystals.getStack().getItem() instanceof ItemCrystal ? Constants.MANA_PER_CRYSTAL : Constants.MANA_PER_SHARD;
+
+			if (crystals.getStack().getItem() == WizardryItems.crystal_shard) {manaPerItem = Constants.MANA_PER_SHARD;}
+			if (crystals.getStack().getItem() == WizardryItems.grand_crystal) {manaPerItem = Constants.GRAND_CRYSTAL_MANA;}
+
+			if (crystals.getStack().getCount() * manaPerItem < chargeDepleted) {
+				// If there aren't enough crystals to fully charge the item
+				iManaStoringItem.rechargeMana(centre.getStack(), crystals.getStack().getCount() * manaPerItem);
+				crystals.decrStackSize(crystals.getStack().getCount());
+
+			} else {
+				// If there are excess crystals (or just enough)
+				iManaStoringItem.setMana(centre.getStack(), iManaStoringItem.getManaCapacity(centre.getStack()));
+				crystals.decrStackSize((int) Math.ceil(((double) chargeDepleted) / manaPerItem));
+			}
+
+			changed = true;
+		}
+
+		return changed;
+	}
 }

src/main/java/electroblob/wizardry/worldgen/WorldGenShrine.java

@@ -74,13 +74,27 @@ public class WorldGenShrine extends WorldGenSurfaceStructure {
 				if(container != null){
 
 					container.getTileData().setUniqueId(ArcaneLock.NBT_KEY, new UUID(0, 0)); // Nil UUID
+					container.markDirty(); // Mark tile entity as dirty for client sync
 
-					if(core instanceof TileEntityShrineCore){
-						((TileEntityShrineCore)core).linkContainer(container);
-					}else{
-						Wizardry.logger.info("What?!");
+					// Trigger visual update for arcane lock effect
+					BlockPos chestPos = entry.getKey().up();
+					net.minecraft.block.state.IBlockState blockState = world.getBlockState(chestPos);
+					world.markAndNotifyBlock(chestPos, null, blockState, blockState, 3);
+					world.notifyBlockUpdate(chestPos, blockState, blockState, 3); // Additional client sync
+
+					// Set up the loot table for the shrine chest
+					if(container instanceof net.minecraft.tileentity.TileEntityChest){
+						net.minecraft.tileentity.TileEntityChest chest = (net.minecraft.tileentity.TileEntityChest) container;
+						chest.setLootTable(new net.minecraft.util.ResourceLocation(Wizardry.MODID, "chests/shrine"), world.rand.nextLong());
 					}
 
+									if(core instanceof TileEntityShrineCore){
+					((TileEntityShrineCore)core).linkContainer(container);
+					((TileEntityShrineCore)core).setShrineElement(element);
+				}else{
+					Wizardry.logger.info("What?!");
+				}
+
 				}else{
 					Wizardry.logger.info("Expected chest or other container at {} in structure {}, found no tile entity", entry.getKey(), structureFile);
 				}

src/main/resources/assets/ebwizardry/lang/en_gb.lang

@@ -1731,6 +1731,8 @@ config.ebwizardry.mobs_immune_to_ice=Mobs Immune To Ice
 config.ebwizardry.mobs_immune_to_ice.tooltip=List of names of entities that are immune to ice, in addition to the defaults. Add mod creatures to this list if you want them to be immune to ice magic and they aren't already. Entity names are not case sensitive. For mod entities, prefix with the mod ID (e.g. ebwizardry\:wizard).
 config.ebwizardry.mobs_immune_to_lightning=Mobs Immune To Lightning
 config.ebwizardry.mobs_immune_to_lightning.tooltip=List of names of entities that are immune to lightning, in addition to the defaults. Add mod creatures to this list if you want them to be immune to lightning magic and they aren't already. Entity names are not case sensitive. For mod entities, prefix with the mod ID (e.g. ebwizardry\:wizard).
+config.ebwizardry.mobs_immune_to_magic=Mobs Immune To Magic
+config.ebwizardry.mobs_immune_to_magic.tooltip=List of names of entities that are immune to magic, in addition to the defaults. Add mod creatures to this list if you want them to be immune to magic damage and they aren't already. Entity names are not case sensitive. For mod entities, prefix with the mod ID (e.g. ebwizardry\:wizard).
 config.ebwizardry.mobs_immune_to_wither=Mobs Immune To Wither
 config.ebwizardry.mobs_immune_to_wither.tooltip=List of names of entities that are immune to wither effects, in addition to the defaults. Add mod creatures to this list if you want them to be immune to withering magic and they aren't already. Entity names are not case sensitive. For mod entities, prefix with the mod ID (e.g. ebwizardry\:wizard).
 config.ebwizardry.mobs_immune_to_poison=Mobs Immune To Poison

src/main/resources/assets/ebwizardry/lang/en_us.lang

@@ -882,6 +882,7 @@ container.ebwizardry\:arcane_workbench.sort_tier=Sort by Tier
 container.ebwizardry\:arcane_workbench.sort_element=Sort by Element
 container.ebwizardry\:arcane_workbench.sort_alphabetical=Sort Alphabetically
 container.ebwizardry\:arcane_workbench.search_tooltip=%1$sSearch Tips\n\ntier=%2$s, %1$st=%2$s: match tiers\n%1$selement=%2$s, %1$se=%2$s: match elements\n%1$stype=%2$s, %1$sp=%2$s: match spell types\n%1$sdiscovered=true/false%2$s, %1$sd=t/f%2$s: include only (un)discovered\n%1$smodid=%2$s, %1$sm=%2$s: match mod IDs\n\nSeparate multiple values with %1$s,%2$s\nSeparate multiple criteria with %1$s;
+container.ebwizardry\:arcane_workbench.clear=Clear Spell Slots
 
 container.ebwizardry\:bookshelf=Bookshelf
 
@@ -1370,6 +1371,7 @@ forfeit.ebwizardry\:bury_self=The ground collapses beneath you!
 
 forfeit.ebwizardry\:spill_inventory=Your items spill themselves everywhere!
 forfeit.ebwizardry\:teleport_self=You are instantly teleported somewhere!
+forfeit.ebwizardry\:teleport_self_large_distance=You are instantly teleported somewhere far away!
 forfeit.ebwizardry\:levitate_self=You begin to float upwards helplessly!
 forfeit.ebwizardry\:vex_horde=A horde of vexes materializes around you!
 forfeit.ebwizardry\:black_hole=A swirling vortex appears in front of you!
@@ -1446,6 +1448,25 @@ key.ebwizardry.spell_8=Spell Slot 8
 
 death.attack.wizardry_magic=%1$s was killed by %2$s using magic
 death.attack.indirect_wizardry_magic=%1$s was killed by %2$s using magic
+death.attack.magic_wizardry_magic=%1$s was killed by %2$s using magic
+death.attack.magic_indirect_wizardry_magic=%1$s was killed by %2$s using magic
+
+death.attack.fire_wizardry_magic=%1$s was killed by %2$s using fire magic
+death.attack.fire_indirect_wizardry_magic=%1$s was killed by %2$s using fire magic
+death.attack.frost_wizardry_magic=%1$s was killed by %2$s using frost magic
+death.attack.frost_indirect_wizardry_magic=%1$s was killed by %2$s using frost magic
+death.attack.shock_wizardry_magic=%1$s was killed by %2$s using a shock magic
+death.attack.shock_indirect_wizardry_magic=%1$s was killed by %2$s using shock magic
+death.attack.wither_wizardry_magic=%1$s was killed by %2$s using withering magic
+death.attack.wither_indirect_wizardry_magic=%1$s was killed by %2$s withering magic
+death.attack.poison_wizardry_magic=%1$s was killed by %2$s using poison magic
+death.attack.poison_indirect_wizardry_magic=%1$s was killed by %2$s poison magic
+death.attack.force_wizardry_magic=%1$s was killed by %2$s using a magical force
+death.attack.force_indirect_wizardry_magic=%1$s was killed by %2$s using magical force
+death.attack.blast_wizardry_magic=%1$s was killed by %2$s using a magical blast
+death.attack.blast_indirect_wizardry_magic=%1$s was killed by %2$s using magical blast
+death.attack.radiant_wizardry_magic=%1$s was killed by %2$s using radiant magic
+death.attack.radiant_indirect_wizardry_magic=%1$s was killed by %2$s using radiant magic
 
 soundCategory.ebwizardry_spells=Spells
 
@@ -1514,6 +1535,28 @@ config.ebwizardry.player_block_damage.true=Yes - kaboom!
 config.ebwizardry.player_block_damage.false=No - activate anti-grief (TM)
 config.ebwizardry.dispenser_block_damage=Dispenser Block Damage
 config.ebwizardry.dispenser_block_damage.tooltip=Whether spells cast by dispensers can destroy blocks in the world. Wizardry makes every attempt to respect protection mods and plugins, but cannot guarantee it will work in all cases for every mod. If you need absolutely watertight anti-grief, disable this setting.
+config.ebwizardry.damage_type_per_element=Damage Type Per Element
+config.ebwizardry.damage_type_per_element.tooltip=Whether damage should be registered with the old system (wizardry_magic/indirect_wizardry_magic) prefixed damage with the elements like necromancy_indirect_wizardry_magic, necromancy_wizardry_magic. This is disabled by default to not break existing modpacks. The intention of this setting is to allow differentiating various damage types for e.g. the Distinct Damage Descriptions mod
+config.ebwizardry.single_use_spell_books=Spell Books Are Consumed By Wands
+config.ebwizardry.single_use_spell_books.tooltip=Whether spell books are consumed when they are bound to a wand.
+config.ebwizardry.prevent_binding_same_spell_twice_to_wands=Prevent Binding The Same Spell To A Wand Multiple Times
+config.ebwizardry.prevent_binding_same_spell_twice_to_wands.tooltip=Whether to prevent binding the same spell to a wand multiple times
+config.ebwizardry.mana_per_shard=Mana Per Crystal Shard
+config.ebwizardry.mana_per_shard.tooltip=The amount of mana a crystal shard is worth.
+config.ebwizardry.mana_per_crystal=Mana Per Crystal
+config.ebwizardry.mana_per_crystal.tooltip=The amount of mana each magic crystal is worth.
+config.ebwizardry.grand_crystal_mana=Grand Crystal Mana
+config.ebwizardry.grand_crystal_mana.tooltip=The amount of mana a grand magic crystal is worth.
+config.ebwizardry.upgrade_stack_limit=Upgrade Stack Limit
+config.ebwizardry.upgrade_stack_limit.tooltip=The maximum number of one type of wand upgrade which can be applied to a wand.
+config.ebwizardry.non_elemental_upgrade_bonus=Non-Elemental Upgrade Bonus
+config.ebwizardry.non_elemental_upgrade_bonus.tooltip=The bonus amount of wand upgrades that can be applied to a non-elemental wand.
+config.ebwizardry.siphon_mana_per_level=Siphon Mana Per Level
+config.ebwizardry.siphon_mana_per_level.tooltip=The amount of mana given for a kill for each level of siphon upgrade.
+config.ebwizardry.condenser_tick_interval=Condenser Tick Interval
+config.ebwizardry.condenser_tick_interval.tooltip=The number of ticks between each mana increase for wands with the condenser upgrade.
+config.ebwizardry.base_spell_slots=Base Spell Slots
+config.ebwizardry.base_spell_slots.tooltip=The number of spell slots a wand has with no attunement upgrades applied.
 config.ebwizardry.telekinetic_disarmament=Telekinetic Disarmament
 config.ebwizardry.telekinetic_disarmament.tooltip=Whether to allow players to disarm other players using the telekinesis spell. Disable to prevent stealing of items.
 config.ebwizardry.telekinetic_disarmament.true=Yes - let people steal things
@@ -1548,12 +1591,15 @@ config.ebwizardry.blast_increase_per_level=Blast Increase Per Level
 config.ebwizardry.blast_increase_per_level.tooltip=The fraction by which spell blast is increased for each level of blast upgrade. May cause extreme lag with high values!
 config.ebwizardry.frost_slowness_increase_per_level=Frost Slowness Increase Per Level
 config.ebwizardry.frost_slowness_increase_per_level.tooltip=The fraction by which movement speed is reduced per level of frost effect.
+config.ebwizardry.storage_increase_per_level=Storage Increase Per Level
+config.ebwizardry.storage_increase_per_level.tooltip=The fraction by which maximum charge is increased for each level of storage upgrade.
 
 config.ebwizardry.category.difficulty=Difficulty Settings
 config.ebwizardry.category.difficulty.tooltip=Configure wizardry's difficulty
 config.ebwizardry.title.difficulty=Difficulty Settings
 config.ebwizardry.subtitle.difficulty=Settings that affect the mod's difficulty.
 
+config.ebwizardry.unfocused_search_bars=Whether to autofocus search bar in Arcane Workbench and lectern
 config.ebwizardry.discovery_mode=Discovery Mode
 config.ebwizardry.discovery_mode.tooltip=For those who like a sense of mystery! When enabled, spells you haven't cast yet will be unreadable until you cast them (on a per-world basis). Has no effect when in creative mode. Spells of identification will be unobtainable in survival mode if this is disabled.
 config.ebwizardry.legacy_wand_levelling=Legacy Wand Levelling
@@ -1574,6 +1620,54 @@ config.ebwizardry.forfeit_chance=Forfeit Chance
 config.ebwizardry.forfeit_chance.tooltip=The chance to 'misread' an undiscovered spell and trigger a forfeit instead. Setting this to 0 effectively disables the forfeit mechanic. Has no effect if discovery mode is disabled.
 config.ebwizardry.progression_requirements=Progression Requirements
 config.ebwizardry.progression_requirements.tooltip=The progression required to upgrade a wand to each tier (apprentice, advanced and master respectively).
+
+config.ebwizardry.tier_max_charges=Tier Maximum Charges
+config.ebwizardry.tier_max_charges.tooltip=Maximum mana each tier can store (novice, apprentice, advanced, master respectively).
+
+config.ebwizardry.tier_upgrade_limits=Tier Upgrade Limits
+config.ebwizardry.tier_upgrade_limits.tooltip=Maximum number of upgrades each tier can have (novice, apprentice, advanced, master respectively).
+
+config.ebwizardry.novice_max_charge=Novice Maximum Charge
+config.ebwizardry.novice_max_charge.tooltip=Maximum mana a novice wand can store.
+
+config.ebwizardry.apprentice_max_charge=Apprentice Maximum Charge
+config.ebwizardry.apprentice_max_charge.tooltip=Maximum mana an apprentice wand can store.
+
+config.ebwizardry.advanced_max_charge=Advanced Maximum Charge
+config.ebwizardry.advanced_max_charge.tooltip=Maximum mana an advanced wand can store.
+
+config.ebwizardry.master_max_charge=Master Maximum Charge
+config.ebwizardry.master_max_charge.tooltip=Maximum mana a master wand can store.
+
+config.ebwizardry.novice_upgrade_limit=Novice Upgrade Limit
+config.ebwizardry.novice_upgrade_limit.tooltip=Maximum number of upgrades a novice wand can have.
+
+config.ebwizardry.apprentice_upgrade_limit=Apprentice Upgrade Limit
+config.ebwizardry.apprentice_upgrade_limit.tooltip=Maximum number of upgrades an apprentice wand can have.
+
+config.ebwizardry.advanced_upgrade_limit=Advanced Upgrade Limit
+config.ebwizardry.advanced_upgrade_limit.tooltip=Maximum number of upgrades an advanced wand can have.
+
+config.ebwizardry.master_upgrade_limit=Master Upgrade Limit
+config.ebwizardry.master_upgrade_limit.tooltip=Maximum number of upgrades a master wand can have.
+
+config.ebwizardry.condenser_amount_multiplier=Condenser Amount Multiplier
+config.ebwizardry.condenser_amount_multiplier.tooltip=Multiplier for condenser upgrade mana regeneration amount. Higher values make condensers more effective.
+
+config.ebwizardry.flesh_spells_cause_slowness=Flesh Spells Cause Slowness
+config.ebwizardry.flesh_spells_cause_slowness.tooltip=Whether flesh spells (DiamondFlesh, IronFlesh, OakFlesh) apply slowness. When disabled, these spells only provide their defensive benefits without movement penalty.
+config.ebwizardry.flesh_spells_cause_slowness.true=Yes - flesh spells slow you down
+config.ebwizardry.flesh_spells_cause_slowness.false=No - flesh spells don't slow you down
+config.ebwizardry.diamond_flesh_armor_bonus=DiamondFlesh Armor Bonus
+config.ebwizardry.diamond_flesh_armor_bonus.tooltip=Armor bonus provided by the DiamondFlesh spell.
+config.ebwizardry.diamond_flesh_armor_toughness_bonus=DiamondFlesh Armor Toughness Bonus
+config.ebwizardry.diamond_flesh_armor_toughness_bonus.tooltip=Armor toughness bonus provided by the DiamondFlesh spell.
+config.ebwizardry.iron_flesh_armor_bonus=IronFlesh Armor Bonus
+config.ebwizardry.iron_flesh_armor_bonus.tooltip=Armor bonus provided by the IronFlesh spell.
+config.ebwizardry.oak_flesh_armor_bonus=OakFlesh Armor Bonus
+config.ebwizardry.oak_flesh_armor_bonus.tooltip=Armor bonus provided by the OakFlesh spell.
+config.ebwizardry.oak_flesh_health_bonus=OakFlesh Health Bonus
+config.ebwizardry.oak_flesh_health_bonus.tooltip=Health bonus provided by the OakFlesh spell (as a multiplier, e.g., 0.2 = 20% increase).
 config.ebwizardry.player_damage_scaling=Player Damage Scaling Factor
 config.ebwizardry.player_damage_scaling.tooltip=Global damage scaling factor for the damage dealt by players casting spells, relative to 1.
 config.ebwizardry.npc_damage_scaling=NPC Damage Scaling Factor
@@ -1757,6 +1851,8 @@ config.ebwizardry.mobs_immune_to_ice=Mobs Immune To Ice
 config.ebwizardry.mobs_immune_to_ice.tooltip=List of names of entities that are immune to ice, in addition to the defaults. Add mod creatures to this list if you want them to be immune to ice magic and they aren't already. Entity names are not case sensitive. For mod entities, prefix with the mod ID (e.g. ebwizardry\:wizard).
 config.ebwizardry.mobs_immune_to_lightning=Mobs Immune To Lightning
 config.ebwizardry.mobs_immune_to_lightning.tooltip=List of names of entities that are immune to lightning, in addition to the defaults. Add mod creatures to this list if you want them to be immune to lightning magic and they aren't already. Entity names are not case sensitive. For mod entities, prefix with the mod ID (e.g. ebwizardry\:wizard).
+config.ebwizardry.mobs_immune_to_magic=Mobs Immune To Magic
+config.ebwizardry.mobs_immune_to_magic.tooltip=List of names of entities that are immune to magic, in addition to the defaults. Add mod creatures to this list if you want them to be immune to magic damage and they aren't already. Entity names are not case sensitive. For mod entities, prefix with the mod ID (e.g. ebwizardry\:wizard).
 config.ebwizardry.mobs_immune_to_wither=Mobs Immune To Wither
 config.ebwizardry.mobs_immune_to_wither.tooltip=List of names of entities that are immune to wither effects, in addition to the defaults. Add mod creatures to this list if you want them to be immune to withering magic and they aren't already. Entity names are not case sensitive. For mod entities, prefix with the mod ID (e.g. ebwizardry\:wizard).
 config.ebwizardry.mobs_immune_to_poison=Mobs Immune To Poison
@@ -1802,3 +1898,5 @@ spell.ebwizardry\:invigorating_presence_festive=Invigorating Presents
 spell.ebwizardry\:empowering_presence_festive=Empowering Presents
 
 wizard.debug=%1$s, %2$s, %3$s
+
+wizardry.shrine_already_looted=You have already looted this shrine!

src/main/resources/assets/ebwizardry/texts/handbook_ru_ru.json

@@ -12,7 +12,7 @@
 	"images": {
 		"workbench": {
 			"location": "ebwizardry:textures/gui/handbook/pictures/arcane_workbench.png",
-			"caption": "Мистический верстак",
+			"caption": "Верстак для тайноведения",
 			"u": 0,
 			"v": 0,
 			"width": 110,
@@ -28,7 +28,7 @@
 		},
 		"magic_crystal": {
 			"location": "ebwizardry:textures/items/crystal_magic.png",
-			"caption": "Волшебный кристалл",
+			"caption": "Магический кристалл",
 			"u": 6,
 			"v": 6,
 			"width": 36,
@@ -39,7 +39,7 @@
 		},
 		"magic_wand": {
 			"location": "ebwizardry:textures/items/wand_novice.png",
-			"caption": "Волшебный жезл",
+			"caption": "Магический жезл",
 			"u": 0,
 			"v": 0,
 			"width": 64,
@@ -48,7 +48,7 @@
 		},
 		"crystal_flower": {
 			"location": "ebwizardry:textures/gui/handbook/pictures/crystal_flower.png",
-			"caption": "Кристальный цветок",
+			"caption": "Хрустальный цветок",
 			"u": 0,
 			"v": 0,
 			"width": 48,
@@ -56,7 +56,7 @@
 		},
 		"wizard_tower": {
 			"location": "ebwizardry:textures/gui/handbook/pictures/wizard_tower.png",
-			"caption": "Башня волшебника",
+			"caption": "Башня колдуна",
 			"u": 0,
 			"v": 0,
 			"width": 110,
@@ -64,7 +64,7 @@
 		},
 		"wizard_armour": {
 			"location": "ebwizardry:textures/gui/handbook/pictures/wizard_armour.png",
-			"caption": "Набор брони Волшебника",
+			"caption": "Комплект брони колдуна",
 			"u": 0,
 			"v": 0,
 			"width": 90,
@@ -72,7 +72,7 @@
 		},
 		"classes": {
 			"location": "ebwizardry:textures/gui/handbook/pictures/classes.png",
-			"caption": "3 Класса",
+			"caption": "3 класса",
 			"u": 0,
 			"v": 0,
 			"width": 96,
@@ -89,7 +89,7 @@
 		},
 		"shrine": {
 			"location": "ebwizardry:textures/gui/handbook/pictures/shrine.png",
-			"caption": "Святилище земли",
+			"caption": "Храм земли",
 			"u": 0,
 			"v": 0,
 			"width": 110,
@@ -97,7 +97,7 @@
 		},
 		"library_ruins": {
 			"location": "ebwizardry:textures/gui/handbook/pictures/library_ruins.png",
-			"caption": "Разрушенные библиотеки",
+			"caption": "Руины библиотеки",
 			"u": 0,
 			"v": 0,
 			"width": 110,
@@ -122,7 +122,7 @@
 		},
 		"elements": {
 			"location": "ebwizardry:textures/gui/handbook/pictures/elements.png",
-			"caption": "7 мистических аспектов",
+			"caption": "7 мистических стихий",
 			"u": 0,
 			"v": 0,
 			"width": 106,
@@ -294,9 +294,9 @@
 			},
 			"text": [
 
-				"Руководство волшебника",
+				"Руководство колдуна",
 
-				"от Electroblob"
+				"автор: Electroblob"
 			]
 		},
 
@@ -304,11 +304,11 @@
 			"title": "Введение",
 			"text": [
 
-				"Приветствую тебя, Волшебник! Эта книга объясняет множество путей мистики и как их использовать. Эта не обычная книга, тем не менее - её страницы будут осуществляться перед Вами, когда Вы узнаете больше о Волшебном мире.",
+				"Приветствую, колдун! Эта книга описывает множество порядков тайноведения и как их применять. Это не простая книга, правда — её страницы будут материализоваться перед тем, как вы будете больше узнавать о магическом мире.",
 
-				"Используйте кнопки Стрелок, чтобы переключаться между страницами, и кнопки с двойными стрелками, чтобы быстро перелистываться между разделами. Используйте центральную кнопку Меню, чтобы вернуться на основную страницу содержимого.",
+				"Используйте кнопки со стрелками для переворота страницы, а кнопки с двойными стрелками для быстрого переключения между разделами. Используйте центральную кнопку меню для возврата на главную страницу.",
 
-				"Нажмите на любую фиолетовую текстовую ссылку, чтобы перейти сразу на соответствующую страницу. Нажмите Пкм по закладке, чтобы сдвинуть её на текущую страницу, и нажмите лкм, чтобы вернуться к странице с закладкой."
+				"Нажмите на пурпурный текст ссылки, чтобы сразу перейти на соответствующую страницу. Нажмите ПКМ на закладке, чтобы перейти на текущую страницу, а ЛКМ для возврата на страницу, отмеченную закладкой."
 			]
 		},
 
@@ -323,25 +323,25 @@
 		},
 
 		"setting_up": {
-			"title": "Создание",
+			"title": "Подготовка",
 			"include_in_contents": "main_contents",
 			"text": [
 
-				"Чтобы начать осваиваться в моём моде Wizardry, Вам понадобится:",
+				"Чтобы начать wizardry, вам понадобится:",
 
-				"- Волшебный жезл, создаётся как это показано:",
+				"— Магический жезл, создаваемый, как показано на рисунке:",
 
 				"#recipe magic_wand",
 
-				"- @arcane_workbench Мистический верстак@, создаётся как это показано:",
+				"— @arcane_workbench Верстак для тайноведения@, создаваемый таким образом: ",
 
 				"#recipe arcane_workbench",
 
-				"- @spells Книга заклинаний@. Их можно найти в сундуках, выпавшие как добыча, купленные у Волшебников, или Вы можете сделать Заклинание новичка: Волшебный метательный снаряд, как это показано:",
+				"— @spells Колдовская@ книга. Они могут быть найдены в сундуках, выпадаемые как добыча, купленные у колдунов или вы можете сделать заклинание новичка «Магический снаряд», как показано на рисунке:",
 
 				"#recipe magic_missile_spell_book",
 
-				"Вам также нужно куча других Волшебных кристаллов, чтобы снабдить свой Жезл @mana маной@."
+				"Вам ещё понадобится куча магических кристаллов, чтобы снабжать свой жезл @mana маной@."
 			]
 		},
 
@@ -353,13 +353,13 @@
 			],
 			"text": [
 
-				"Мана - мистическая энергия, которая даёт Волшебникам их силы. Сама по себе она не физическая форма; скорее всего, она всегда присутствует в Ауре, которая проникает во всё в мире. В частности, она проявляется в Кристаллах, встречающихся в природе, которые могут быть найдены вложенными в камнях под землёй. @wands Жезлы@ могут хранить в себе Ману, и эта мана направляется в @spells Заклинания@, которых Вы можете бросить. Некоторые заклинания требуют некое количество маны, в зависимости от того, насколько они сильны и как долго они длятся.",
+				"Мана — эзотерическая энергия, дарующая колдунам их силы. Мана сама по себе не материальное вещество, скорее вездесущая аура, пронизывающая вообще всё. По сути она проявляется в самих кристаллах, что появляются естественным образом и которых можно найти под землёй, погружённых в камни. @wands Жезлы@ могут хранить в себе ману, а эта мана направляется в используемые вами @spells заклинания@. Различные заклинания требуют различное количество маны в зависимости от того, насколько они мощные и как долго они держатся.",
 
 				"#image crystal_ore",
 
 				"#image magic_crystal",
 
-				"Общепризнано, что Ману нельзя создать или уничтожить, и когда Заклинание брошено, ману, которую оно направляет, просто рассеивает в окрестностях. Безусловно, именно таким образом и существует большая часть маны - рассеянной по всему миру. Однако, чтобы мана была полезной, она может быть сконцентрирована, либо естественным путём на протяжении тысячелетий; как в случае с кристаллами под землёй, или искусственно - продвинутая тема, которая не предусмотрена в этой книге. Кроме того, существуют различные способы создания более эффективных Заклинаний и восстановить часть маны, рассеянную во время наложения Заклинаний."
+				"Общепризнанный факт, что ману невозможно создать или уничтожить, и что, когда используется заклинание, направленная мана буквально рассеивается в окружающий мир. Безусловно, вот как существует большая часть маны, понемногу усеяна по всему миру. Однако, чтобы мана была полезной, она должна быть концентрированной либо естественным образом на протяжении тысячелетий, аналогично кристаллам под землёй, или искусственно — продвинутая тема, не описывающаяся в этой книге. Кроме того, существуют различные пути, чтобы сделать заклинания более мана-экономичными и восстановить немного усеянной маны во время прочтения заклинания."
 			]
 		},
 
@@ -371,17 +371,17 @@
 			],
 			"text": [
 
-				"Жезл, это орудие выбора Волшебника. С ним Вы можете бросить любое @spells Заклинание@, если Жезл может сдерживать его силу (смотрите: @tiers Уровни@). Жезлы бывают разных видов, но Вы скорее всего приступите с простого Волшебного жезла.",
+				"Жезлы — выбор каждого колдуна. С его помощью вы сможете использовать любые @spells заклинания@, при условии, что жезл может удерживать его силу (см. @tiers Уровни@). Жезлы существуют во множество различных вариаций, но вы почти наверняка начнёте с базового жезла.",
 
 				"#image magic_wand",
 
-				"Большинство жезлов начинают свою жизнь как простое устройство своего рода Волшебного кристалла, прилагаемый к деревянной палке, с золотым самородком прикреплённый на другом конце. Кристалл это, разумеется, источник силы Жезла, поскольку он обеспечивает фокусировку, необходимая для направления @spells Заклинаний@. Оставшаяся часть Жезла тоже очень важна, поскольку она обеспечивает не только средства, с которыми держится Жезл, но также траектория, через которую @mana Ману@ можно направить и ориентировать.",
+				"Большинство жезлов начинают свою жизнь устройством из нечто вроде магического кристалла, прикреплённого к деревянной палке с кусочком золота, закреплённым на другом конце. Разумеется, кристалл — источник силы жезла, он обеспечивает необходимую фокусировку для направления @spells заклинаний@. Всё же, оставшаяся часть жезла тоже важна — она не только снабжает средствами, с помощью которых держится жезл, но также путь, с помощью которого можно направлять и управлять @mana маной@.",
 
-				"Чем больше заклинаний брошено Жезлом, тем больше он становится эффективным в направлении @spells Заклинаний@, и следовательно, может бросить заклинания большей силы. Этот эффект может быть различим по едва различимым изменениям, которые возникают в форме и внешнем виде самого Жезла: поскольку Жезл становится всё более мощным, его кристалл будет становиться всё более ярким, его цвет может изменяться в зависимости от его @elements Аспекта@, и спустя определённое время, дерево из которого он сделан, начнёт расти и меняться в более сложные формы.",
+				"Чем больше жезл использует заклинаний, тем более эффективным он становится при направлении @spells заклинаний@, и тем самым сможет использовать заклинания большей силы. Этот эффект можно различить по едва заметным изменениям, проявляющимся по форме и внешнему виду самого жезла: по мере того как жезл становится более мощным, кристалл становится более выразительным, а цвет может меняться в зависимости от его @elements стихии@, и спустя какое-то время древесина, из которой он сделан, начнёт расти и превращаться в более сложные формы.",
 
-				"Когда держите Жезл, будет показан небольшой предупреждающий дисплей в углу экрана. Это показывает Заклинание, которое в данный момент выбрано совместно с графическим изображением, и, если Заклинание было брошено, панель отката укажет время до того, когда Заклинание снова можно бросить. Он также показывает название следующих и предыдущих Заклинаний связанных с Жезлом. Чтобы переключаться между Заклинаниями, используйте клавиши #next_spell_key и #previous_spell_key (их можно поменять в Настройках -> Управление). Также Вы можете переключать Заклинания за счёт прокручивания колёсика мыши при крадении.",
+				"При удерживании жезла в углу экрана появится небольшой индикатор. Этот индикатор отображает выбранное текущее заклинание вместе с рисунком заклинания, и всякий раз, когда используется заклинание, полоска перезарядки отсчитывает время, после которого можно повторно использовать заклинание. Кроме того, он отображает названия следующих и предыдущих заклинаний, связанных с жезлом. Чтобы переключать заклинания, используйте клавишу #next_spell_key и #previous_spell_key (их можно изменить в настройки —> управление). Кроме того, вы можете переключать заклинания с помощью колёсика мыши во время крадения.",
 
-				"При просмотре инвентаря, наведя курсор на Жезл отобразит, сколько хранится в нём @mana Маны@, вместе с его текущим выбранным @spells Заклинанием@ и любыми особенными способностями, с которыми он может обладать. Больше детальной информации о Жезле можно посмотреть, положив его в @arcane_workbench Мистический верстак@."
+				"При просмотре инвентаря, наведение курсора на жезл покажет, сколько в нём хранится маны вместе с его текущим выбранным @spells заклинанием@ и какими-либо определёнными способностями, что есть у него в наличии. Больше подробной информации касательно жезла можно просмотреть, поместив жезл в @arcane_workbench верстак для тайноведения@."
 			]
 		},
 
@@ -393,20 +393,20 @@
 			],
 			"text": [
 
-				"@wands Жезл@ бесполезен без Заклинаний, чтобы бросать с его помощью. Заклинания записаны в двух формах: в книгах, которые являются постоянными, и в свитках, которые являются временными.",
+				"@wands Жезл@ без заклинаний бесполезен. Заклинания записываются двумя формами: в книги, которые постоянные, и в свитки, которые временные.",
 
-				"Книги с заклинаниями сами по себе малополезные; вместо этого они используются  для привязывания Заклинания, которые они содержатся в @wands Жезле@. Книги с заклинаниями можно найти во всём мире и Вам не потребуется на это много времени. Если Вы нашли одну, то Вы можете навести мышкой на Книгу с заклинанием, чтобы сразу посмотреть основную информацию о Заклинании. Вы также можете нажать Пкм, пока держите Книгу с заклинанием, чтобы узнать о ней подробнее.",
+				"Колдовские книги в одиночку малопригодны, на самом деле они используются для привязки заклинания и содержатся в @wands жезле@. Колдовские книги можно найти по всему миру, это не займёт много времени. Когда вы её нашли, наведите курсором на колдовскую книгу, чтобы сразу посмотреть основную информацию о заклинании. Кроме того, нажмите правую кнопку мыши во время удерживания колдовской книги, чтобы прочесть её описание",
 
-				"Свитки, со другой стороны, служат для другой цели: Щёлкнув пкм, пока держите Свиток, бросит Заклинание которое связано с ним, уничтожая Свиток в процессе. Подобно книгам с заклинаниями, Свитки можно найти во всём мире, но Вы также можете делать их сами (смотрите: @enchanting_scrolls Зачаровывание свитков@)",
+				"Свитки же служат другой цели: нажатие ПКМ во время удерживания прочтёт связанное заклинание, уничтожив свиток в процессе. Подобно колдовским книгам, свитки можно найти по всему миру, но вы можете сделать их самому (см. @enchanting_scrolls Зачарование свитков@).",
 
-				"Свитки весьма полезны, если Вам нужно использовать Заклинание один раз или дважды по конкретному заданию, чтобы не занимать место в слоте в своём @wands Жезле@. У них также имеется преимущество, мгновенно бросать Заклинания, которые обычно требуют период зарядки. Следует подчеркнуть, они являются неэффективным методом бросания Заклинаний по сравнению с использованием Жезла.",
+				"Свитки очень полезны, если вам нужно использовать заклинание несколько раз в рамках индивидуального задания, и им не нужно занимать слот на вашем @wands жезле@. Кроме того, у них есть преимущество — возможность мгновенно использовать заклинания, что обычно не требует период зарядки. Следует отметить, что они не являются эффективным способом использования заклинания по сравнению с использованием жезла.",
 
-				"На первый взгляд, волшебные руны с помощью которых написаны Заклинания, нечитаемы. Для определения Заклинания, Вы можете, несомненно, бросить Заклинание и посмотреть, что произойдёт - хотя, это может вызвать нежеланные побочные последствия, и большинство Заклинаний нуждаются в определённых условиях для работы. Более того, всегда есть вероятность недооценить неизвестное Заклинание когда бросаете, с потенциально опасными последствиями в зависимости от того, насколько мощное Заклинание. Более безопасный и более надёжный вариант - использовать Свиток идентификации, который можно найти в сундуках или купить у Волшебника. Щёлкните Пкм, пока держите, Свиток идентифицирует первую неизвестную Книгу с заклинанием или Свиток в панели быстрого доступа, потребляя Свиток идентификации в процессе."
+				"Для необученного глаза магические руны, на которых написаны заклинания, неразборчивые. Для того чтобы опознать заклинание, вы непременно можете использовать заклинание и посмотреть, что произойдёт, правда, такая практика может вызвать нежелательные побочные эффекты, и большинство заклинаний требуют определённых условий, чтобы работать. Кроме того, при прочтении всегда есть шанс неправильно прочесть неизвестное заклинание с потенциально опасными последствиями независимо от того, насколько мощное заклинание. Безопасный и надёжный возможный вариант — использовать свиток опознания, найденный в сундуках или купленный у колдуна. Нажатие ПКМ во время удерживания опознаёт первую неизвестную колдовскую книгу или заклинание в горячей панели, между делом расходуя свиток опознания."
 			]
 		},
 
 		"arcane_workbench": {
-			"title": "Мистический верстак",
+			"title": "Верстак для тайноведения",
 			"include_in_contents": "main_contents",
 			"contents": {
 				"id": "arcane_workbench_subsections",
@@ -419,11 +419,11 @@
 			],
 			"text": [
 
-				"Мистический верстак - блок, похожий по внешнему виду на Стол зачарования, где Вы можете зарядить, улучшить и привязать @spells Заклинания@ в свой @wands Жезл@. Его можно создать следующим образом:",
+				"Верстак для тайноведения — блок, схожий внешним видом на чародейский стол, где можно заряжать, улучшать и привязывать @spells заклинания@ к своему @wands жезлу@. Его можно создать как следует ниже:",
 
 				"#recipe arcane_workbench",
 
-				"Следующие страницы объясняют различные действия, которые могут быть выполнены в Мистическом верстаке.",
+				"Следующие страницы объясняют разные действия, которые могут осуществляться в «Верстаке для тайноведения».",
 
 				"#image workbench"
 			],
@@ -436,7 +436,7 @@
 					],
 					"text": [
 
-						"Чтобы привязать @spells Заклинание@ к своему @wands Жезлу@, просто поместите свой Жезл в центральный слот верстака, затем поместите Книгу с заклинанием в одно из окружающих слотов и нажмите Применить. Обратите внимание, что Книга с заклинанием остаётся нетронутой во время этого процесса - это потому, что акт привязки Заклинания не 'берёт' Заклинание из Книги с заклинанием; напротив, она поднастраивает Жезл к Заклинанию. По существу, Вы можете изменять Заклинания привязанные к Жезлу, столько, сколько пожелаете, просто повторив процесс привязывания Заклинания. Вы можете привязать до 5 Заклинаний к Жезлу за раз, хотя, это число может быть увеличено с Улучшением: Сонастройка."
+						"Для привязки @spells заклинания@ к @wands жезлу@, поместите жезл в центральный слот верстака, затем поместите колдовскую книгу в один из окружающих слотов и нажмите «Применить». Вы заметите, что колдовская книга останется нетронутой во время этого процесса. Это обусловлено тем, что акт привязки заклинания не 'забирает' заклинание из колдовской книги, вернее, она настраивает жезл на заклинание. По сути, вы можете заменить заклинания, что связаны с вашим жезлом, по желанию, буквально повторив процесс привязки заклинания. Вы можете связать до пяти заклинаний одновременно, тем не менее это число может быть увеличено «Улучшениями для жезла: Настройка»."
 					]
 				},
 				"charging_wands": {
@@ -447,7 +447,7 @@
 					],
 					"text": [
 
-						"Чтобы зарядить свой @wands Жезл@, поместите Жезл в центральный слот Мистического верстака и поместите несколько волшебных кристаллов в нижний левый слот, и затем нажмите Применить. Каждый кристалл стоит #mana_per_crystal @mana Маны@, и Жезл возьмёт столько, сколько ему необходимо, поэтому, Вы можете сохранить запасы кристаллов в Верстаке, когда они Вам понадобятся. Однако, имейте ввиду, что Жезл может взять только целое количество кристаллов, так что, если Жезлу необходимо, например, 30 и более маны, #example_charging_loss маны будет потеряно при зарядки."
+						"Чтобы зарядить @wands жезл@, поместите его в центральный слот верстака для тайноведения и немного магических кристаллов в левый нижний слот, а затем нажмите «Применить». Сумма каждого кристалла — #mana_per_crystal @mana маны@, но жезл заберёт столько, сколько он потребует, а значит, вы можете сохранить запас кристаллов в верстаке на случай, когда они вам потребуются. Впрочем, зарубите себе на носу: жезл забирает только целое число кристаллов. Если жезлу потребуется, напр.: более 30 маны, то при зарядке жезла израсходуется #example_charging_loss маны."
 					]
 				},
 				"upgrading_wands": {
@@ -458,42 +458,42 @@
 					],
 					"text": [
 
-						"Чтобы улучшить свой @wands Жезл@, Вам нужен Фолиант арканы подходящего @tiers Уровня@ или специальное улучшение Жезла. Обе, могут быть найдены как трофей или куплены у Волшебника. Чтобы улучшить свой Жезл, поместите его в центральный слот для Улучшения в правом верхнем слоте, затем нажмите Применить.",
+						"Чтобы улучшить @wands жезл@, вам потребуется фолиант чар соответствующего @tiers уровня@ или специальное улучшение для жезла. Оба из них можно найти в качестве добычи или куплены у колдуна. Чтобы улучшить жезл, поместите его в центральный слот для улучшения в правом верхнем слоте, затем нажмите «Применить».",
 
-						"Специальные улучшения Жезла, повышают конкретный аспект Жезла. Каждый тип Улучшения можно складывать до 3х раз, и общее число улучшений, которых Жезл может принимать, зависит от его уровня. Улучшения нельзя удалить."
+						"Специальные улучшения улучшают особый аспект жезла. Каждый тип улучшения можно суммировать до 3-х раз, а общее количество улучшений, что может взять на себя жезл, зависит от его уровня. Улучшения невозможно убрать."
 					]
 				},
 				"enchanting_scrolls": {
-					"title": "Зачаровывание свитков",
+					"title": "Зачарование свитков",
 					"include_in_contents": "arcane_workbench_subsections",
 					"triggers": [
 						"ebwizardry:handbook/scrolls"
 					],
 					"text": [
 
-						"Мистический верстак также может быть использован для Зачаровывания @spells заклинаний@ и Свитков. Для этого, Вам понадобится Пустой свиток, созданный из кусочка бумаги и несколько ниток, Книга с заклинанием выбранная для Заклинания, и достаточно волшебных кристаллов, чтобы предоставить @mana Ману@, для наложения.",
+						"Для зачаровывания @spells заклинаний@ и свитков используйте «Верстак для тайноведения». Вам потребуется: чистый свиток, созданный из кусочка бумаги, нить, колдовская книга с выбранным заклинанием и достаточно количество магических кристаллов для обеспечения @mana маны@, чтобы наложить заклинание или свиток.",
 
 						"#recipe blank_scroll",
 
-						"Поместите кристаллы в нижний левый слот, Пустой свиток в центральный слот, а Книгу с заклинанием в отдельный слот над ним, затем нажмите Подтвердить, чтобы зачаровать Свиток."
+						"Поместите кристаллы в левый нижний слот, чистый свиток в центральный слот, а колдовскую книгу в отдельный слот над ним, затем нажмите «Подтвердить», чтобы зачаровать свиток."
 					]
 				}
 			}
 		},
 
 		"wizard_armour": {
-			"title": "Броня волшебника",
+			"title": "Броня колдуна",
 			"include_in_contents": "main_contents",
 			"triggers": [
 				"ebwizardry:arcane_initiate"
 			],
 			"text": [
 
-				"Как волшебник, Вам нужно что-то, чтобы защитить Вас от существ, с которыми Вы сражаетесь. Впрочем, простая броня не подойдёт. Чтобы наиболее эффективно использовать свои Заклинания, Вам потребуется Броня волшебника: Шляпа, роба, поножи и ботинки. В отличие от простой брони, эти не ломаются. Вместо этого, они используют мистическую энергию для защиты Носителя. Это, безусловно, означает, что они могут быть заряжены Волшебными кристаллами, точно также как Жезлы. К счастью, эта одежда не потребляет много @mana Маны@. Зарядите их, как Жезл в @arcane_workbench Мистическом верстаке@ или @mana_flasks Фляжками с маной@, но будьте осторожны - если у них кончится мана, то Вы окажетесь беззащитным.",
+				"Будучи колдуном, для сражения с существами, вам потребуется что-то, что защитит вас от них. Всё же обычная броня не сгодится. Чтобы создавать большую часть заклинаний, вам потребуется «Броня колдуна»: шляпа, мантия, поножи и сапоги. В отличие от обычной брони, эти не разрушаются. Напротив, они используют сакральную энергию, чтобы оберегать носителя. Разумеется, это означает, что их нужно заряжать магическими кристаллами, как и жезлы. К счастью, это одеяние не тратит много @mana маны@. Заряжайте их, как бы вы это делали с жезлом, в @arcane_workbench верстаке для тайноведения@ или при помощи @mana_flasks колб маны@, но будьте осмотрительны, если у них закончится мана, вы будете уязвимы.",
 
 				"#image wizard_armour",
 
-				"Вы можете получить броню Волшебника создав её из Волшебного шёлка:",
+				"Вы можете получить «Броню колдуна», создав её из натурального магического шёлка:",
 
 				"#recipe magic_silk",
 				"#recipe wizard_hat",
@@ -501,30 +501,30 @@
 				"#recipe wizard_leggings",
 				"#recipe wizard_boots",
 
-				"Можно зачаровать Броню волшебника используя обычный Стол зачаровывания, а из-за собственных свойств волшебного шёлка, он довольно эффективен в сдерживании чар. Особенно полезны для Волшебников зачарования защиты - Волшебная, Морозная и Шоковая, которая может оказаться полезной защитой против других обладателей магии.",
+				"Можно зачаровать Броню колдуна с использованием обычного чародейского стола, а благодаря врождённым свойствам натурального магического шёлка, он обладает свойством эффективно сдерживать чары. Чары: защита от магии, мороза и шока представляют особую пользу колдуну, которые могут пригодиться для защиты от других обладателей магии.",
 
-				"Те волшебники, кто посвящают себя практике одной стихии, иногда носят специальную одежду, которая даёт бонусы для этой стихии. Полный набор такой одежды очень востребованный среди Волшебников и её не так просто найти.",
+				"Колдуны, посвятившие себя практике одной из стихии, иногда носят особое одеяние, которое предоставляет бонусы за счёт стихии. Полный комплект такого одеяния очень популярен среди колдунов, и найти его непросто.",
 
-				"Как только они овладеют Основами магии, большинство Волшебников выберут следующий особый путь, либо класс, чтобы продолжить своё обучение. Есть 3 основных класса, к которым Волшебник может присоединиться: Мудрец, Боевой маг и Чародей. Членов каждого класса можно легко отличить по их мантиям, которые модифицируются - обычно с помощью Редких и Экзотических материалов - чтобы лучше удовлетворять свои потребности.",
+				"Освоив основы магии, большинство колдунов предпочитают следовать особым путём или классу, чтобы продолжить своё обучение. Существует 3 основных класса, к которым колдун может присоединиться: мудрец, боевой маг и чернокнижник. Члены каждого класса могут легко быть различимы по их мантиям, которые обычно модифицируются при помощи редких и экзотических материалов, чтобы лучше соответствовать своими потребностями.",
 
 				"#image classes",
 
 				"Мудрец",
 
-				"Посвятив свою жизнь стремлению к знаниям, Мудрец усовершенствовал искусство эффективного бросания заклинания, позволив ему бросать заклинания используя наименьшее возможное количество маны. Их наряд из шёлковой мантии, опровергает значительную защиту, которую они обеспечивают, поскольку Мудрец также является искусным Волшебником - хотя они по-прежнему не могут сравниться с твёрдым металлическим покрытием. Однако, столь длительное проведение периодов времени в безопасной библиотеки делает их весьма вялыми в бою.",
+				"Посвятив свою жизнь поиску знаний, мудрец достиг совершенства в искусстве эффективного прочтения заклинаний, что позволяет ему читать заклинания, используя наименьшее количество маны из допустимого. Пышный наряд из шёлковых мантий скрывает обеспечиваемую ему прочную защиту. Кроме того, мудрец искусный колдун, правда, наряд по-прежнему и близко не стоит прочной металлической обшивке. Провождение столь длительного периода в безопасной библиотеке в то же время делает его довольно вялым в бою.",
 
 				"Боевой маг",
 
-				"Боевой маг является приспособленным для боя, одетого в комбинацию из упрочнённой ткани и кристально-серебряного покрытия добываемые на самых квалифицированных плавильных заводах. Через дисциплину и тренировку, боевой маг также улучшил свою скорость и реакции, позволяя ему более часто бросать заклинания. Однако, дёшево это не обходится, причём Боевой маг должен быть осторожен, чтобы слишком быстро не прожигать ману.",
+				"Боевой маг приспособлен для боя, облачённый в сочетание прочной ткани и хрустальной серебряной обшивки, получаемой из наиболее квалифицированных литейн. Благодаря дисциплине и подготовке, боевой маг усовершенствовал свою скорость и реакцию, что позволяет ему чаще читать заклинания. Это удовольствие не из дешёвых, тем не менее боевой маг должен стараться не прожигать ману слишком быстро.",
 
-				"Чародей",
+				"Чернокнижник",
 
-				"Чародей живёт ради исследований, выталкивая границы того, что возможно, чтобы откапывать мистические тайны. Это, совместно со стремлением экспериментировать с тем, что другие могут счесть с запретным, позволили им преодолеть ограничения привычного обучения и бросать заклинания с невероятной скоростью, а также уменьшить использование маны. Их легковесные мантии, хотя и пригодны для разведки, обеспечивают меньшую защиту в бою, чем их представители. "
+				"Чернокнижник живёт ради исследований, открывая новые горизонты возможного и извлекая затерянные сакральные тайны. Наряду со склонностью экспериментировать с тем, что другие могут счесть запретным, это позволило ему разрушать путы традиционного обучения и использовать заклинания с огромной скоростью, в том числе снизив себе расход маны. Его лёгкая мантия полезна для исследования, и всё же она оказывает меньшую защиту в бою, чем её аналоги."
 			]
 		},
 
 		"magical_world": {
-			"title": "Магия в Мире",
+			"title": "Магия в мире",
 			"include_in_contents": "main_contents",
 			"contents": {
 				"id": "magical_world_subsections",
@@ -537,42 +537,42 @@
 			],
 			"text": [
 
-				"Никто не может овладеть мистикой просто сидя в доме - есть целый мир, который полон магии и которую нужно исследовать. Древние руины, реликвии и таинственные особи, хорошие и плохие ждут своего открытия - если знаете, где искать. Величайшие волшебники также самые любопытные, и получают большую часть своих знаний и силы, путём исследования окружающей среды вокруг них и экспериментируя с тем, что они находят.",
+				"Нельзя овладеть тайнами, просто сидя дома. Откройте для себя мир, полный магией! Древние руины, реликвии и мистические существа добра и зла ждут своего открытия, если знать, где их искать. Величайшие колдуны — самые любопытные, и большую часть своих знаний и силы они получают, исследуя окружающий мир и экспериментируя с тем, что находят.",
 
-				"Пока большую часть времени Волшебник неминуемо проводит в одиночестве, обмен знаниями также жизненно важен для изучения мистических искусств. Ищите  практикующих специалистов магии, и узнайте от них как можно больше, насколько Вы сможете: общение - пожалуй величайшая сила из всех."
+				"Несмотря на то, что значительную часть времени колдуны неизбежно проводят в одиночестве, важно обмениваться знаниями для изучения тайноведческих искусств. Ищите практик магии и изучайте столько знаний, сколько сможете себе позволить, — общение, пожалуй, абсолютно величайшая сила."
 			],
 			"sections": {
 				"crystal_flowers": {
-					"title": "Кристальные цветы",
+					"title": "Хрустальный цветки",
 					"include_in_contents": "magical_world_subsections",
 					"triggers": [
 						"ebwizardry:handbook/crystal_flowers"
 					],
 					"text": [
 
-						"В ходе Ваших путешествий, Вы, вероятно, встретите любопытные светящиеся цветки, растущие в дикой природе время от времени. Эти отличительные цветы известны как Кристальные цветы, и они удивительно эффективны в концентрации @mana Маны@ - по сей день, никто не знает почему. Однако, мы точно знаем, что они могут быть собраны и созданы, чтобы извлечь ману как кристаллы, делая их весьма полезным надземным источником маны. Количество маны, получаемое таким способом, ограничено, хотя, за счёт маленьких размеров цветов и благодаря им, растут только в небольших участков.",
+						"За время ваших путешествий, возможно, вы случайно встретите необычные светящиеся цветы в природе. Эти специфические цветы известны как хрустальные цветки, и они на удивление способны концентрировать @mana ману@. По сей день никто не знает наверняка. По крайней мере, нам известно, что их можно добывать и собирать, чтобы извлекать ману в виде кристаллов, что делает их довольно ценным живым источником маны. Количество маны, получаемое таким образом, ограничено. И всё же, за счёт их малого размера, цветки растут только на небольших участках земли.",
 
 						"#image crystal_flower",
 						"#recipe crystal_flower_to_crystals"
 					]
 				},
 				"wizard_towers": {
-					"title": "Башни волшебника",
+					"title": "Башни колдуна",
 					"include_in_contents": "magical_world_subsections",
 					"triggers": [
 						"ebwizardry:wizard_tower"
 					],
 					"text": [
 
-						"Не страшитесь - Вы не единственный практикующий магии в этом мире. В Ваших путешествиях, Вы вполне можете встретить Высокую башню или 2 с отличительной крышей. Это место проживания товарища Волшебника. Жизнь в уединении иногда может сделать Волшебников немного раздражительными, но они обычно дружелюбные люди, кто желает поделиться своими знаниями с Вами - пусть даже за вознаграждение. Ожидайте, что заплатите ценные металлы и драгоценные камни, а взамен, Вы получите очень много мистического чуда.",
+						"Вряд ли вы не единственный практик магии в этом мире. В течение своих путешествий вы вполне можете встретить высокую башню или две с отличительной остроконечной крышей. Это обитель колдуна. Порою жизнь в глуши может сделать колдунов малость раздражительными, но в основном они дружелюбный народ и готовы поделиться своими знаниями, хотя и за вознаграждение. Надейтесь расплатиться драгоценными металлами и самоцветами, а в знак благодарности вы получите множество восхитительных эзотерических диковин.",
 
-						"С другой стороны, если Вы ищете Заклинание уровня @tiers Мастер@, Вам нужно будет поговорить со специалистом.",
+						"Если вы искали заклинание @tiers магистра@, вам придётся поговорить с мастером.",
 
 						"#image wizard_tower",
 
-						"К несчастью, существует всего несколько Волшебников, которые не рады гостям. Эти волшебники чаще всего изгои, и враждебны к любому, кто пересекает их путь. Подходите к этим лицам с предосторожностью, и будьте подготовлены защитить себя против могучей магии. Впрочем, одолейте их, и их знания ждут Вас.",
+						"К сожалению, в мире существует несколько колдунов, не приветствующие посетителей. Обычно эти колдуны отщепенцы, враждебно настроенные к любому, кто встретится у него на пути. Осторожно приближайтесь к таким индивидам и будьте готовы защитить себя от их мощной магии. Одержите над ними победу, и их знания вам обеспечены.",
 
-						"Следует также упомянуть, что ни один Волшебник не потерпит нападению или кражи - и они с готовностью возьмут правосудие в свои руки."
+						"Кроме того, следует отметить, что ни один колдун не потерпит нападения или воровства, он без промедления учинит самосуд."
 					]
 				},
 				"obelisks": {
@@ -583,76 +583,76 @@
 					],
 					"text": [
 
-						"Остатки древней магии разбросаны по всему миру, самые примечательные из них - Резные каменные структуры, которые покрыты множеством символов и рун. Эти руины это всё, что по-прежнему осталось от древней цивилизацией. Кто бы, или что бы их ни построило, они очевидно имели значительный объём знаний магии, и использовали её, для размещения защитных чар на таких местах, которые до сих пор существуют по сей день.",
+						"По миру усеяны остатки древней магии, самые достопримечательные из них — высеченные из камня структуры, выдерживающие множество символов и рун. Эти развалины — всё, что осталось от своего рода древней цивилизации. Кто бы ни или что-либо построило их, у них явно было широкое знание магии, и оно применялось для наложения защитных чар на такие места, что существуют по сей день.",
 
-						"Эти структуры в целом относятся к двум типам. Первые и более частые из них - Обелиски: высокие шипы резного камня, известный как Рунный камень, с открытой структурой внизу, содержащий мелкие мистические реликвии из забытого прошлого.",
+						"Структуры, не вдаваясь в детали, относятся к двум типам. Первый и более распространённый среди них — обелиски, высокие шипы из высеченного камня, известные как Рунический камень, с решётчатой конструкцией у основания, содержит незначительное количество эзотерических реликвий из забытого прошлого.",
 
 						"#image obelisk",
 
-						"Эти структуры, как правило, защищены за счёт чар, которые призывают враждебных @creatures Волшебных существ@, если какой-нибудь человек случайно окажется поблизости. Отгоните этих существ и уничтожьте их источник, и реликвии будут Вашими."
+						"Структуры, как правило, защищены чарами, призывающими враждебных @creatures магических существ@, если вдруг человек окажется слишком близко. Прогоните этих существ и уничтожьте их источник, и тогда реликвии в ваших руках."
 					]
 				},
 				"shrines": {
-					"title": "Святилища",
+					"title": "Храмы",
 					"include_in_contents": "magical_world_subsections",
 					"triggers": [
 						"ebwizardry:visit_shrine"
 					],
 					"text": [
 
-						"Второй, и более редкий тип структуры, известный как Святилище. Эти структуры состоят из круга рунно-каменных столбов, окружающих центральный пьедестал, над которого расположен сундук наполненный древними @artefacts Артефактами@. Этот сундук, как правило, защищён за счёт заклинания Мистическая блокировка, не допуская никого, за исключением Владельца от открытия. Целая структура также защищена за счёт Сдерживающего поля, которое ни кому не допустит уйти, кто случайно окажется слишком близко.",
+						"Вторая и более редкая, как бы структура, известная как храм. Структуры состоят из круга столбов из рунических камней, окружающих центральный пьедестал, на основании чего расположен сундук, полный древними @artefacts артефактами@. Чаще всего этот сундук защищён чаром «Мистический замок», не позволяя кому-либо открывать его, кроме владельца. Целая структура тоже защищена сдерживающим полем, которое никому не даст сбежать, кто окажется слишком близко.",
 
 						"#image shrine",
 
-						"Из-за их великой мистической силы и значимости, не говоря уже об сокровища внутри, эти структуры особо привлекательны, для любого начинающего Волшебника - но будьте осторожны. Поступают многочисленные сообщения о Волшебниках попадающих в западню в Сдерживающем поле и постепенно сходящие с ума, возможно, при клаустрофобии. Однако, всё большее число полагают, что такие случаи бывают преднамеренной частью защитной магии Святилища, и что Волшебники попавшие в ловушку внутри Святилища, фактически контролируются для защиты структуры. Крайне негативная возможность, непременно, для любого, кто осмелится рискнуть..."
+						"Благодаря их великой эзотерической силе и значимости, не говоря уже о богатствах внутри, эти структуры крайне привлекательны для амбициозного колдуна: но проявите осторожность. Существует множество сообщений от колдунов, попавшие в ловушку сдерживающего поля и медленно сходившие с ума, вероятно, из-за клаустрофобии. Хотя всё большее число верят, что такого рода происшествия были умышленной частью защитной магии храма, а колдуны, оказавшиеся в пределах поля, фактически завладеваются для того, чтобы защитить структуру. Пугающая перспектива непременно для любого, кто отважится приблизиться..."
 					]
 				},
 				"library_ruins": {
-					"title": "Разрушенные библиотеки",
+					"title": "Руины библиотеки",
 					"include_in_contents": "magical_world_subsections",
 					"triggers": [
 						"ebwizardry:find_library_ruins"
 					],
 					"text": [
 
-						"Волшебники склонны накапливать довольно много Книг с заклинаниями на протяжении всей своей жизни, и обычно по этой причине, Волшебник строит Библиотеку для хранения своей коллекции. Некоторые особо скрытные Волшебники, были даже известны тем, что хранили свои мистические знания даже под землёй, подальше от любопытных глаз. Тем не менее, библиотека требует ухода, и если его владелец умрёт без своего Подмастерья, который унаследует книги, структура быстро придёт в негодность. Тысячи лет использования магии видели всё больше и больше библиотек, оставленными заброшенными таким путём, и во время исследования, Вы, возможно, наткнётесь на одну из них. Они имеют нередко смысл для поиска любых Книг с заклинаниями или других предметов, которые могли пережить тяжёлые последствия времени.",
+						"Колдуны чаще всего склонны скапливать довольно много колдовских книг за всю свою жизнь, и в таком случае колдун, как правило, строит себе библиотеку для хранения коллекции. Некоторые весьма таинственные колдуны, как известно, хранят свои тайные знания под землёй, подальше от любопытных глаз. Тем не менее библиотеке нужен уход, но в случае если хозяин умирает в отсутствие подмастерья, книги не перейдут в наследство и вскоре структура придёт в негодность. Тысячелетнее применение магии приводило к тому, что всё больше и больше библиотек забрасывалось таким образом, но, возможно, при исследовании вы могли случайно её встретить. Как правило, они являются ценным источником поиска колдовских книг или других предметов, что смогли пережить разрушительное воздействие времени.",
 
 						"#image library_ruins",
 
-						"Библиотеки не только используются для хранения книг. Волшебники прошлого, использовали силу Алтаря наполнения, который используется для осуществления наполнения волшебными аспектами на волшебные материалы. Расположение алтаря является точным и сложным исскуством, поскольку, он должен быть соответствовать с учётом небесными движениями и местными колебаниями маны. Их практика строительства стала гораздо более редкой в новейшей истории, в основном, потому, что когда то построенный, твёрдый каменный алтарь держится веками, так что, нет особой обходимости в новых. Вместо этого, большинство Волшебников находят и восстанавливают существующий алтарь на случай того, чтобы необходимо было выполнять ритуалы для наполнения и, - Разрушенные библиотеки идеальное место для поиска.",
+						"Библиотеки не только используются для хранения книг. В былые времена колдунам доводилось использовать силу алтаря наполнения для выполнения ритуалов, наделяющих стихией магические предметы. Местоположение алтаря — точное и сложное искусство, которое должно налаживаться в соответствии с особыми небесными движениями и местными изменениями маны. В современной истории практика их строительства осталась в прошлом, в основном потому что они были построены из твёрдой породы, которая хранится веками, а значит существует малая потребность в новых. На самом деле большинство колдунов находят и чинят тогдашние алтари, если им нужно выполнить ритуалы наполнения, а руины библиотеки — идеальное место для поиска.",
 
-						"Вы, тоже, можете в определённый момент сочтить это полезным, и построить свою собственную библиотеку, которая, разумеется, потребует несколько Книжных полок:",
+						"Однажды вы тоже можете посчитать полезным построить собственную библиотеку, которая непременно потребует несколько книжных полок:",
 
 						"#recipe bookshelves",
 
 						"#recipe gilded_wood",
 
-						"Однако, эти книжные полки не просто мебель. Наполняя самые мощные волшебные кристаллы в своих Книжных полках, позволит беспрепятственно передавать знания между ними и близлежащим @arcane_workbench Мистическим верстаком@ - очень удобно, когда коллекция расширяется. В равной степени полезна - Кафедра:",
+						"Тем не менее эти книжные полки — не просто мебель. Наполнение максимально мощного магического кристалла в книжные полки обеспечивает пассивную передачу знаний между ними и близлежащим @arcane_workbench верстаком для тайноведения@, весьма кстати по мере того, как расширяется коллекция. Не менее полезна и кафедра:",
 
 						"#recipe lecterns",
 
-						"Фолиант, который парит над кафедрой, собирает знания из ближайших Книг с заклинаниями, позволив каждому просматривать их в свободное время, не помня их точного местоположения."
+						"Книга, парящая над кафедрой, получает знания из близлежащих колдовских книг, что позволяет читать каждое заклинание в свободное время, не запоминая её точного местоположения."
 					]
 				},
 				"creatures": {
-					"title": "Волшебные существа",
+					"title": "Магические существа",
 					"include_in_contents": "magical_world_subsections",
 					"triggers": [
 						"ebwizardry:handbook/magical_creatures"
 					],
 					"text": [
 
-						"Помимо волшебников, множество других существ также используют магию. Многие из этих существ загадочны по своему происхождению, и большую часть можно призвать используя конкретные волшебные @spells Заклинания@. Этих существ можно встретить охраняющих @obelisks Обелиск@, а может и мощного Призывателя. Менее загадочные существа периодически встречаются в глуши.",
+						"Не считая колдунов, огромное количество разных существ тоже применяют магию. Многие из этих существ имеют эзотерическое происхождение и большую часть можно призвать при помощи определённых магических @spells заклинаний@. Вы можете встретить этих существ, охраняющие @obelisks обелиск@ или, возможно, сильного заклинателя. Второсортные существа редко встречаются в дикой местности.",
 
-						"Наглядным примером является Пережиток, наподобие духа, сущность, которая формируется естественным образом из вещества, которое остаётся за счёт мощной магии, и чаще всего, принимает 1 из 7 мистических @elements Аспектов@. По отдельности, они не более чем помеха, но толпа, может быстро ошеломить неподготовленного Искателя приключений, а их присущая устойчивость к магии, требует принятия разумного ношения с собой Лука, или другого оружия дальнего боя.",
+						"Яркий пример — пережиток по образу и подобию духа, формирующийся естественным образом из следов оставшейся после себя мощной магии. Они, как правило, приобретают один из семи мистических @elements стихий@. Сами по себе они не более чем неприятность, однако рой сможет быстро сокрушить неподкованного авантюриста, а их врождённая устойчивость к магии повод задуматься о ношении лука или другого стрелкового оружия.",
 
 						"#image remnant",
 
-						"Как только побеждён, с них может быть собрана Спектральная пыль, которая, помимо излучения яркого свечения, имеет ряд полезных свойств. Вместилище, создаётся как показано ниже, оно же, обеспечивает удобное средство её сдерживания.",
+						"При убийстве с него можно собрать спектральный прах, который, помимо излучения яркого света, обладает рядом полезных свойств. Хранилище (создаётся как показано на рисунке), обеспечивает удобный способ содержания в себе праха.",
 
 						"#recipe receptacle",
 
-						"Вместилища могут быть размещены на поверхности или прикреплёнными к стене и щёлкнув Пкм спектральной пылью, чтобы заполнить Вместилище. Вместилище действует как мягкий источника света. Нажмите Пкм по заполненному Вместилищу, чтобы опустошить и вернуть пыль."
+						"Хранилища размещаются на поверхность или крепятся на стену. Нажатие ПКМ спектральным прахом наполняет его, действуя как мягкий источник света. Нажатие ПКМ по заполненному хранилищу опустошает и возвращает прах."
 					]
 				},
 				"artefacts": {
@@ -663,7 +663,7 @@
 					],
 					"text": [
 
-						"Изучая @shrines Святилища@, возможно, Вам посчастливится обнаружить какой-нибудь древний волшебный артефакт - объект, способный предоставить своему Носителю уникальные и мощные баффы и особые силы. Известны 3 типа, которые были обнаружены: кольца, которые дают бонусы и эффекты к Заклинаниям, амулеты, которые увеличивают защитные свойства, и талисманы, которые дают полезные эффекты. Эти артефакты функционируют только в том случае, если надеть их правильным образом; просто имея их на одном человеке - недостаточно."
+						"При исследовании @shrines храма@, возможно, вам посчастливилось обнаружить своего рода древние магические артефакты. Предмет способен наделить своего владельца уникальными и мощными усилениями с особыми силами. Было обнаружено 3 типа: кольца, предоставляющие бонусы и эффекты для заклинаний; амулеты, улучшающие способности защиты, а также талисманы, дающие вспомогательные эффекты. Эти артефакты кажется, работают только в том случае, когда надеты должным образом. Носить их при себе недостаточно."
 					]
 				}
 			}
@@ -677,58 +677,58 @@
 			],
 			"text":[
 
-				"@wands Жезлы@ и @spells Заклинания@ переходят в 4 уровня: #colour_noviceНовичок#colour_reset, #colour_apprenticeподмастерье#colour_reset, #colour_advancedпродвинутый#colour_reset, и #colour_masterмастерский#colour_reset. Каждый уровень намного мощнее, чем предыдущий.",
+				"@wands Жезлы@ и @spells заклинания @ встречаются четырёх уровнях: #colour_noviceновичок#colour_reset, #colour_apprenticeподмастерье#colour_reset, #colour_advancedпродвинутый#colour_resetand и #colour_masterмагистр#colour_reset. Каждый уровень могущественнее последнего.",
 
 				"#image tiers",
 
-				"#colour_noviceЖезлы#colour_reset уровня новичок являются теми, кого можно создать. Они хранят до #novice_max_charge маны, и можно наложить только Заклинания уровня новичка. Заклинания новичка достаточно просты, чтобы их мог бросить любой и они обычно не расходуют много маны. Однако, это не обязательно означает, что они бесполезны на высоких уровнях; их низкий расход маны, делает некоторые Заклинания новичка полезными, даже когда у Вас есть доступ к Заклинаниям уровня Мастер.",
+				"#colour_noviceЖезлы #colour_reset новичка те, что можно создать. Они вмещают до #novice_max_charge ед. маны и могут использовать только заклинания новичка. Заклинания новичка настолько просты, что используются кем-угодно, и они, как правило, не тратят много маны. Однако это не всегда означает, что они бесполезны на следующих уровнях. Их малозатратность делает некоторые начинающие заклинания полезными даже в том случае, когда у вас есть доступ к заклинаниям магистра.",
 
-				"#colour_apprenticeЖезлы#colour_reset уровня подмастерья - следующий уровень от Жезлов уровня новичка. Они хранят до #apprentice_max_charge маны и могут бросать Заклинания уровня новичка и подмастерья. Заклинания подмастерья намного сложнее чем Заклинания новичка, но обычно расходуют больше маны.",
+				"#colour_apprenticeЖезлы #colour_reset подмастерья — следующий уровень по сравнению с жезлами новичка. Они вмещают до #apprentice_max_charge ед. маны и могут использовать заклинания уровня новичок и подмастерье. Заклинания подмастерья несколько поразительнее, чем заклинания новичка, но, как правило, тратят гораздо больше.",
 
-				"#colour_advancedПродвинутые#colour_reset жезлы - достаточно редки и гораздо сильнее. Они могут бросать все Заклинания помимо Заклинаний уровня Мастер, и хранят до #advanced_max_charge маны. Продвинутые заклинания могут давать супер-человеческие силы такие как: Невидимость и сеять хаос на врагов.",
+				"#colour_advancedПродвинутые #colour_reset жезлы — та ещё редкость, но в разы мощнее. Они могут использовать всякие заклинания, кроме уровня магистра, и вмещают #advanced_max_charge ед. маны. Продвинутые заклинания наделяют сверхчеловеческими силами, такими как невидимость, и погружают врагов в хаос.",
 
-				"#colour_masterМастерские#colour_reset жезлы - более мощные Жезлы в существовании. Они хранят до #master_max_charge маны, и могут бросать любые Заклинания. Книги с заклинаниями уровня Мастер - очень редки и Заклинания могут причинять полные разрушения не только на врагов, но и даже на сам мир. Используйте с большой осторожностью.",
+				"#colour_masterЖезлы #colour_reset магистра крайне мощные жезлы, существующие в природе. Они вмещают до #master_max_charge ед. маны и могут использовать любое заклинание. Колдовские книги магистра — весьма редкие, причём заклинания могут вызвать полное уничтожение не только врагов, но и самого мира. Используйте с осторожностью.",
 
-				"Чтобы улучшить на высокий уровень, Жезл сначала должен стать достаточно мощным, чтобы направлять Заклинания этого уровня. Жезлы получают энергию когда бросают свои Заклинания. Разновидность заклинаний, сила заклинаний, стихийные эффекты и другие внешние факторы могут оказать эффект на то, насколько быстро палочка созревает.",
+				"Чтобы перейти на следующий уровень, сперва жезл должен стать довольно мощным, чтобы направлять заклинания нового уровня. Жезлы получают силу по мере использования заклинаний. Разновидность заклинания, сила, эффекты стихии и другие внешние факторы могут повлиять на то, как быстро созревает жезл.",
 
-				"Как только Жезл достаточно мощный, Фолиант арканы обеспечивает конечный катализатор, необходимый для повышения Жезла на следующий уровень (смотрите @upgrading_wands Улучшение жезлов@), и как только это уже произошло, процесс созревания может начаться заново на следующем уровне."
+				"Когда жезл достаточно мощный, фолиант чар выполняет роль финального катализатора, необходимого для повышение уровня жезла (см. @upgrading_wands Улучшение жезлов@). Как только это уже произошло, возобновится процесс созревания до следующего уровня."
 			]
 		},
 
 		"elements": {
-			"title": "Аспекты/стихии",
+			"title": "Стихии",
 			"include_in_contents": "main_contents",
 			"triggers": [
 				"ebwizardry:handbook/elements"
 			],
 			"text": [
 
-				"@spells Заклинания@ относятся к разным стихиям, которые определяют природу Заклинания, а также дают преимущества, когда используются с разными @wands Жезлами@.",
+				"@spells Заклинания@ относятся к определённым стихиям, которые определяют природу заклинания, и кроме того, предоставляют преимущество при использовании определённого @wands жезла@.",
 
 				"#image elements",
 
-				"#colour_fireОгонь#colour_reset \nНаверное, самая разрушительный аспект, огонь относится к горениям, лавам, и взрывам. Могучий пиромант обрушит ад над своих врагов, и возможно, сожжёт мир в процессе. Большинство огненных нападений Заклинанием, поджигают свои цели, постепенно причиняя постоянный урон. Впрочем, будьте осторожны, огненные Заклинания не оказывают воздействий на Незеровских мобов.",
+				"#colour_fireОгонь#colour_reset \nОчевидно, самая разрушительная стихия — огонь. Она относится к горению, лаве и взрывам. Могущественный пиромант разразит гнев на своих врагов и, вероятно, зажжёт мир по ходу дела. Большая часть огненных заклинаний поджигают свою цель, причиняя ей постоянный урон в течение долгого времени. Тем не менее, будьте бдительны: огненные заклинания не могут действовать на существ Незера.",
 
-				"#colour_iceЛёд#colour_reset \nАспект льда, который сделан из всего холодного. Морозные заклинания часто замедляют врагов или замораживают их полностью, и особенно эффективны на огненных существ. Морозная магия может оказаться такой же полезной вне боя, а именно: заморозка воды, чтобы пересечь реку.",
+				"#colour_iceЛёд#colour_reset \nСтихия льда относится ко всему холодному. Морозные заклинания чаще всего замедляют врагов или полностью их замораживают, а главным образом эффективны по отношению к огненным существам. Магия мороза может оказаться не менее полезной вне боя, напр.: заморозка воды, чтобы пересечь реку.",
 
-				"#colour_lightningМолния#colour_reset \nЭтот аспект относится к Молниям, грозам и погодам. Могучий грозовой маг это сила, с которой нужно считаться, а некоторые обладают способностью навлекать молнию по своему желанию. Молниевые заклинания часто повреждают множество врагов сразу, и обычно ищут свою цель, делая их эффективной атакой против любых мобов... но опасайтесь криперов.",
+				"#colour_lightningГроза#colour_reset \nЭта стихия относится к грозе, штормам и погоде. Могущественный маг грозы — сила, с которой нужно считаться, причём некоторые обладают способностью вызывать грозу, когда они того пожелают. Грозовые заклинания чаще всего наносят вред нескольким врагам одновременно и, как правило, преследуют свою цель, что делает их эффективной атакой против любого существа... Впрочем, остерегайтесь криперов.",
 
-				"#colour_necromancyНекроматия#colour_reset \nНекромантия является аспектом тьмы, хаоса и нежити. Некроманты мистические и чаще всего считаются как злыми, хотя обычно это не так. Некромантийные заклинания широко используются для призыва @creatures Существ@, бьющимися за Вас, или даже подчиняют волю своих врагов.",
+				"#colour_necromancyНекромантия#colour_reset \nНекромантия — элемент тьмы, хаоса и нежити. Некроманты — мистические и чаще всего расцениваются как зло, хотя, как правило, это не совсем так. Заклинания некромантии широко применяются для призыва @creatures существ@, чтобы они защищали вас или даже покоряли волю ваших врагов.",
 
-				"#colour_earthЗемля#colour_reset \nАспект земли направлен на естественный мир: Животные, растения, ветер, и подобное. Магия земли разнообразная и принимает целый ряд форм, от отравления врагов до высвобождения ярости погоды. Заклинания земли - сочетание атаки, защиты и практичности.",
+				"#colour_earthЗемля#colour_reset \nСтихия земли основана на естественном существовании: животные, растения, ветер и подобного рода. Магия земли разнородна и принимает самые разнообразные формы, начиная с отравления врагов и заканчивая с высвобождением ярости погоды. Заклинания земли — сочетание атаки, защиты и пользы.",
 
-				"#colour_sorceryВолшебство#colour_reset \nВолшебство является аспектом силы и разнообразия. Чародеи манипулируют светом, гравитацией и даже самой реальностью, для удовлетворения своих потребностей. Чародейские заклинания можно использовать, среди прочего, чтобы предоставить своему Заклинателю волшебные силы или двигать объекты по своей воле.",
+				"#colour_sorceryКолдовство#colour_reset \nКолдовство — элемент силы и перемены. Чародеи манипулируют светом, гравитацией, а ещё самой реальностью для удовлетворения своих потребностей. Заклинания колдовства могут использоваться, среди прочего, для наделения колдуна магическими силами или перемещения объектов, когда он того пожелает.",
 
-				"#colour_healingЛечение#colour_reset \nАспект лечения соответствует защите и регенерации. Целители стараются защитить себя и своих союзников насколько это возможно, и связи с этим, могут быть весьма сложными соперниками. Хотя в целом, не используется как атака, очищающий свет некоторых исцеляющих Заклинаний, нанесёт немалый урон нежити. Лечебные заклинания незаменимы, когда в бою.",
+				"#colour_healingИсцеление#colour_reset \nЭлемент исцеления связан с защитой и регенерацией. Знахари стараются защитить себя самих и своих союзников по мере возможности и насколько могут быть опасны соперники. Правда, элемент как правило не используется в качестве атаки. Луч очищения из числа исцеляющих заклинаний нанесёт значительный ущерб нежити. Исцеляющие заклинания незаменимы в бою.",
 
-				"Границы между различными стихиями не всегда различаются, а некоторые Заклинания имеют схожие черты аспектов помимо их собственными.",
+				"Рамки между различными стихиями не всегда чётко выражены, но некоторые заклинания носят черты стихий, не связанные с их собственными.",
 
-				"Если Вам повезёт, Вы можете случайно встретить Стихийный кристалл. Стихийные кристаллы - волшебные кристаллы, которые поглощают стихийные свойства по мере своего роста - хотя точные необходимые условия и механизм, с помощью которых это происходит, остаётся загадкой. Нам известно, наверное, что подобные кристаллы можно использовать для создания стихийных Жезлов, которые позволяют бросать Заклинания с нужной стихией с большей мощью, чем обычно."
+				"В лучшем случае вы можете натолкнуться на стихийный кристалл. Стихийные кристаллы — магические кристаллы, которые поглотили стихийные свойства по мере своего роста. Точные условия и методы обработки, при которых это происходит, остаются «тайной за семью печатями». Однако нам известно, что такие кристаллы могут использоваться для создания стихийных жезлов, которые позволяют применять заклинания соответствующей стихии с большей силой, чем обычно."
 			]
 		},
 
 		"miscellaneous": {
-			"title": "Прочее",
+			"title": "Разное",
 			"include_in_contents": "main_contents",
 			"contents": {
 				"id": "miscellaneous_subsections",
@@ -741,25 +741,25 @@
 			],
 			"sections": {
 				"mana_flasks": {
-					"title": "Фляжки с маной",
+					"title": "Колба маны",
 					"include_in_contents": "miscellaneous_subsections",
 					"triggers": [
 						"ebwizardry:handbook/mana_flasks"
 					],
 					"text": [
 
-						"Arkendur's Arcane Supplies Co. - волшебные предметы для всех Ваших нужд!",
+						"Arkendur's Arcane Supplies Co. — магические предметы для всяких нужд!",
 
-						"Нужно перезарядить свой @wands Жезл@ на ходу? Нет проблем! @mana Ману@ теперь можно разливать в бутылки. Просто изготовьте Фляжку с маной с помощью Колбы и 8 волшебными кристаллами и заберите её с собой. Когда Вам нужно использовать её, просто  изготовьте её своим Жезлом и она восстановит немного заряда.*",
+						"Хотите перезарядить свой @wands жезл@, постоянно находясь в движении? Не проблема! @mana Ману@ теперь можно хранить в бутылках. Создайте колбу маны при наличии бутылочки и восьми магических кристаллов и заберите её с собой. Когда она вам понадобится, внесите её в сетку создания с жезлом, и она восстановит некоторое количество заряда. *",
 
 						"#recipe medium_mana_flask",
 
-						"НОВОЕ! Внедрение совершенно новых Малых и Больших фляжек с маной, а теперь - Вы можете выбрать размер Фляжки с маной, чтобы удовлетворять свои потребности!",
+						"НОВИНКА! Представляем совершенно новые колбы маны (малые и большие). Теперь вы можете выбирать размер колбы маны, дабы удовлетворить свои потребности!",
 
 						"#recipe small_mana_flask",
 						"#recipe large_mana_flask",
 
-						"* Этот процесс, уничтожит колбу. Определённое количество маны потеряется во время разлива."
+						"* Действие уничтожит бутылку. При разливе израсходуется некоторое количество маны."
 					]
 				},
 				"throwable_items": {
@@ -770,7 +770,7 @@
 					],
 					"text": [
 
-						"Различные @spells Заклинания@ наколдовывают физические предметы, некоторых из них также можно создать напрямую. Огненные шары, отравляющие бомбы, искровые бомбы и дымовые бомбы, все из них можно создать:",
+						"Различные @spells заклинания@ наколдовывают физические предметы, кроме того, некоторые из которых можно создать вручную. Из числа которых: огненные бомбы, ядовитые бомбы, бомбы искр и дымовые бомбы:",
 
 						"#recipe firebomb",
 						"#recipe poison_bomb",
@@ -779,21 +779,21 @@
 					]
 				},
 				"automated_casting": {
-					"title": "Автоматизированное бросание",
+					"title": "Автоматическое использование",
 					"include_in_contents": "miscellaneous_subsections",
 					"triggers": [
 						"ebwizardry:enchant_scroll"
 					],
 					"text": [
 
-						"Последние эксперименты выявили, что возможно автоматизировать бросания @spells Заклинаний@, в какой-то степени, используя исключительно обычный Раздатчик. Никто точно не уверен, почему, но складывается впечатление, что странные свойства Красного камня, даже распространяются на активацию активацию Свитков с заклинаниями. Поместите несколько в Раздатчик и запитайте его, должно сработать ..."
+						"Недавний эксперимент показал, что возможно автоматизировать использование @spells заклинаний@ при использовании всего лишь простого раздатчика. Никто действительно не знает почему, однако создается впечатление, что странные свойства редстоуна распространяются на активацию свитков. Помещение несколько свитков в раздатчик и запитав его, должно произвести желаемый эффект..."
 					]
 				}
 			}
 		},
 
 		"crafting_recipes": {
-			"title": "Изготовление рецептов",
+			"title": "Рецепты создания",
 			"include_in_contents": "main_contents",
 			"text": [
 
@@ -829,37 +829,36 @@
 		},
 
 		"credits": {
-			"title": "Титры",
+			"title": "Благодарности",
 			"include_in_contents": "main_contents",
 			"text": [
 
 				"Electroblob's Wizardry \nВерсия #version \nДля Minecraft #mcversion",
 
-				"Разработано, закодировано и затекстурировано: Electroblob",
+				"Спроектировано, запрограммировано и текстурировано автором: Electroblob.",
 
-				"Спасибо Minecraft Forge и MCP, без которого этот мод был бы невозможным.",
+				"Спасибо Minecraft Forge и MCP, без которого этот мод не был бы осуществим.",
 
-				"Спасибо также сообществу Minecraft modding, который всегда имеет решение с моими проблемами в моддинге!",
+				"Кроме того, спасибо сообществу Minecraft modding, у которого всегда есть решения моих проблем с созданием мода!",
 
-				"В дополнении, Я хотел бы поблагодарить следующие лица за их вклад в мод:",
+				"При этом хотелось бы поблагодарить следующие лица за их вклад в мод:",
 
 				"Код:",
 
-				"- Corail31 \n- 12foo \n- Shadows-of-Fire \n- HellFirePvP \n- Tora-B \n- Avatair \n- Aeronica \n- UltraHex \n- Azim-Palmer \n- raoulvdberge \n- rafasoares \n- xinyuan-liu \n- SettingDust",
+				"— Corail31; \n- 12foo; \n- Shadows-of-Fire; \n- HellFirePvP; \n- Tora-B; \n- Avatair; \n- Aeronica; \n- UltraHex; \n- Azim-Palmer; \n- raoulvdberge; \n- rafasoares; \n- xinyuan-liu; \n- SettingDust.",
 
 				"Переводчики:",
 
-				"- Испанский: MadWrist, Alsentar \n- Мексиканский испанский: MadWrist \n- Русский: VilagVil, kellixon, bigenergy, MugGod2, DrHesperus \n- Французский: Hahdrim \n- Бразильский португальский: lorrampi \n- Китайский (Упрощённый): ZHENGLOC, dragon-evol, Hokorizero, TUsama, Determancer \n- Корейский: shejery, rewi_wire, 방통, red1854th \n- Польский: Trozuu, Olej \n- Немецкий: BirdyDragon, Lemopav \n- Китайский (Традиционный): chesterccj305 \n- Венгерский: Bombadil",
+				"— Испанский язык: MadWrist, Alsentar; \n- Мексиканский вариант испанского языка: MadWrist; \n- Русский язык: VilagVil, kellixon, bigenergy, MugGod2, DrHesperus & Heimdallr-1; \n- Французский язык: Hahdrim; \n- Бразильский вариант португальского языка: lorrampi; \n- Китайский язык (упрощённый): ZHENGLOC, dragon-evol, Hokorizero, TUsama, Determancer; \n- Корейский язык: shejery, rewi_wire, 방통, red1854th; \n- Польский язык: Trozuu, Olej; \n- Немецкий язык: BirdyDragon, Lemopav; \n- Китайский язык (традиционный): chesterccj305; \n- Венгерский язык: Bombadil.",
 
-				"Звуковые эффекты",
+				"Звуковые спецэффекты:",
 
-				"- OhhWowProductions\n- fredzed\n- deleted_user_3277771\n- DiscoveryME\n- OGSoundFX\n- leosalom\n- juskiddink",
+				"— OhhWowProductions; \n- fredzed; \n- deleted_user_3277771; \n- DiscoveryME; \n- OGSoundFX; \n- leosalom; \n- juskiddink.",
 
-				"Для большей информации, проверьте нашу @https://github.com/Electroblob77/Wizardry/wiki википедию@.",
+				"За подробностями, посетите @https://github.com/Electroblob77/Wizardry/wiki википедию@.",
 
-				"Не хватает wizardry? Присоединяйтесь к @https://discord.gg/hs8yJP2 Дискорд серверу@ для последних новостей, обсуждений и дополнений!"
+				"В восторге от Wizardry? Присоединяйтесь к @https://discord.gg/hs8yJP2 Discord-серверу@ ради самых свежих новостей, обсуждений и дополнений!"
 			]
 		}
-		
 	}
-}
+}

src/main/resources/mcmod.info

@@ -2,10 +2,10 @@
 {
   "modid" : "ebwizardry",
   "name" : "Electroblob's Wizardry",
-  "version" : "4.3.7",
+  "version" : "4.3.15",
   "mcversion" : "1.12.2",
   "url" : "https://minecraft.curseforge.com/projects/electroblobs-wizardry",
-  "credits" : "\nDesigned, coded and textured by Electroblob.\nDiscord Moderators: FavouriteDragon, WinDanesz\nCode contributed by: Corail31, 12foo, Shadows-of-Fire, Tora-B, Avatair, Aeronica, UltraHex, Azim-Palmer, raoulvdberge, rafasoares, xinyuan-liu, SettingDust, Aralu115.\nTranslators: Alsentar (Spanish), MadWrist (Mexican Spanish), VilagVil, kellixon, bigenergy, MugGod2 & DrHesperus (Russian), Hahdrim & Crowller (French), lorrampi (Brazilian Portuguese), ZHENGLOC, dragon-evol, Hokorizero, TUsama & Determancer (Chinese - Simplified), shejery, rewi_wire, 방통 & red1854th (Korean), Trozuu & Olej (Polish), BirdyDragon & Lemopav (German), chesterccj305 (Chinese - Traditional), Bombadil (Hungarian).\nSound Effects: OhhWowProductions, fredzed, deleted_user_3277771, DiscoveryME, OGSoundFX, leosalom, juskiddink",
+  "credits" : "\nDesigned, coded and textured by Electroblob.\nDiscord Moderators: FavouriteDragon, WinDanesz\nCode contributed by: Corail31, 12foo, Shadows-of-Fire, Tora-B, Avatair, Aeronica, UltraHex, Azim-Palmer, raoulvdberge, rafasoares, xinyuan-liu, SettingDust, Aralu115, WinDanesz, ZettaSword.\nTranslators: Alsentar (Spanish), MadWrist (Mexican Spanish), VilagVil, kellixon, bigenergy, MugGod2 & DrHesperus (Russian), Hahdrim & Crowller (French), lorrampi (Brazilian Portuguese), ZHENGLOC, dragon-evol, Hokorizero, TUsama & Determancer (Chinese - Simplified), shejery, rewi_wire, 방통 & red1854th (Korean), Trozuu & Olej (Polish), BirdyDragon & Lemopav (German), chesterccj305 (Chinese - Traditional), Bombadil (Hungarian).\nSound Effects: OhhWowProductions, fredzed, deleted_user_3277771, DiscoveryME, OGSoundFX, leosalom, juskiddink",
   "authorList" : [
     "Electroblob"
   ],