Add REGENERATE_ENERGY_EFFICIENCY_FOOD and REGENERATE_ENERGY_EFFICIENCY_SATURATION

src/data/kotlin/ru/dbotthepony/mc/otm/datagen/DataGen.kt

@@ -23,7 +23,7 @@ import net.neoforged.neoforge.common.data.DatapackBuiltinEntriesProvider
 import net.neoforged.neoforge.data.event.GatherDataEvent
 import net.neoforged.neoforge.registries.NeoForgeRegistries
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
-import ru.dbotthepony.mc.otm.android.AndroidResearchDataProvider
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchDataProvider
 import ru.dbotthepony.mc.otm.core.ResourceLocation
 import ru.dbotthepony.mc.otm.core.math.yRotationBlockstateNorth
 import ru.dbotthepony.mc.otm.core.util.WriteOnce

src/data/kotlin/ru/dbotthepony/mc/otm/datagen/ResearchData.kt

@@ -4,9 +4,9 @@ import net.minecraft.tags.ItemTags
 import net.minecraft.world.item.Items
 import net.neoforged.neoforge.common.Tags
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
-import ru.dbotthepony.mc.otm.android.AndroidResearchDescriptions
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchDescriptions
-import ru.dbotthepony.mc.otm.android.AndroidResearchResults
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchResults
-import ru.dbotthepony.mc.otm.android.AndroidResearchType
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchType
 import ru.dbotthepony.mc.otm.client.render.ResearchIcons
 import ru.dbotthepony.mc.otm.core.TextComponent
 import ru.dbotthepony.mc.otm.core.TranslatableComponent

src/data/kotlin/ru/dbotthepony/mc/otm/datagen/lang/MatteryLanguageProvider.kt

@@ -15,8 +15,8 @@ import net.minecraft.world.item.ItemStack
 import net.minecraft.world.level.block.Block
 import net.neoforged.neoforge.common.data.LanguageProvider
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
-import ru.dbotthepony.mc.otm.android.AndroidFeatureType
+import ru.dbotthepony.mc.otm.player.android.AndroidFeatureType
-import ru.dbotthepony.mc.otm.android.AndroidResearchType
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchType
 import ru.dbotthepony.mc.otm.core.TranslatableComponent
 import ru.dbotthepony.mc.otm.datagen.DataGen
 import ru.dbotthepony.mc.otm.registry.objects.ColoredDecorativeBlock

src/main/java/ru/dbotthepony/mc/otm/mixin/FoodDataMixin.java

@@ -1,50 +0,0 @@
-package ru.dbotthepony.mc.otm.mixin;
-
-import net.minecraft.world.Difficulty;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.food.FoodData;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import ru.dbotthepony.mc.otm.player.IMatteryPlayer;
-
-@Mixin(FoodData.class)
-public class FoodDataMixin {
-	@Shadow(remap = false)
-	private int lastFoodLevel;
-	@Shadow(remap = false)
-	private int tickTimer;
-	@Shadow(remap = false)
-	private int foodLevel;
-	@Shadow(remap = false)
-	private float exhaustionLevel;
-
-	@Inject(
-		method = "tick(Lnet/minecraft/world/entity/player/Player;)V",
-		at = @At("HEAD"),
-		remap = false,
-		cancellable = true
-	)
-	private void tick(Player player, CallbackInfo info) {
-		var it = ((IMatteryPlayer) player).getOtmPlayer();
-
-		if (it.isAndroid()) {
-			info.cancel();
-
-			// полностью подменяем логику если андроид
-			lastFoodLevel = foodLevel;
-
-			if (player.level().getDifficulty() == Difficulty.PEACEFUL) {
-				exhaustionLevel = 0f;
-			} else {
-				tickTimer = 0;
-			}
-
-			// не обновляем уровень истощения ибо он обнуляется логикой внутри MatteryPlayerCapability
-			// а так же не регенерируем
-			// ну и не получаем урон от "голодания"
-		}
-	}
-}

src/main/java/ru/dbotthepony/mc/otm/mixin/MixinPlayer.java

@@ -4,21 +4,25 @@ import com.mojang.authlib.GameProfile;
 import net.minecraft.core.BlockPos;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.food.FoodData;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.Level;
 import org.jetbrains.annotations.NotNull;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 import ru.dbotthepony.mc.otm.player.IMatteryPlayer;
+import ru.dbotthepony.mc.otm.player.MatteryFoodData;
 import ru.dbotthepony.mc.otm.player.MatteryPlayer;
 
 import java.util.Objects;
 
 @Mixin(Player.class)
-public class MixinPlayer implements IMatteryPlayer {
+public abstract class MixinPlayer implements IMatteryPlayer {
 	private Player otmSelf() {
 		return (Player) (Object) this;
 	}
@@ -85,4 +89,15 @@ public class MixinPlayer implements IMatteryPlayer {
 	private void readAdditionalSaveData(CompoundTag data, CallbackInfo ci) {
 		otmPlayer.deserializeNBT(data.getCompound("overdrive_that_matters_player"), otmSelf().registryAccess());
 	}
+
+	@Shadow
+	protected FoodData foodData;
+
+	@Inject(
+		method = "<init>",
+		at = @At("TAIL")
+	)
+	private void ctorMix(Level level, BlockPos pos, float yRot, GameProfile gameProfile, CallbackInfo info) {
+		foodData = new MatteryFoodData(otmSelf());
+	}
 }

src/main/kotlin/ru/dbotthepony/mc/otm/OverdriveThatMatters.kt

@@ -6,12 +6,12 @@ import net.neoforged.bus.api.EventPriority
 import net.neoforged.fml.common.Mod
 import net.neoforged.fml.event.lifecycle.FMLClientSetupEvent
 import net.neoforged.fml.event.lifecycle.FMLCommonSetupEvent
-import ru.dbotthepony.mc.otm.android.AndroidResearchDescription
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchDescription
-import ru.dbotthepony.mc.otm.android.AndroidResearchDescriptions
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchDescriptions
-import ru.dbotthepony.mc.otm.android.AndroidResearchManager
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchManager
-import ru.dbotthepony.mc.otm.android.AndroidResearchResult
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchResult
-import ru.dbotthepony.mc.otm.android.AndroidResearchResults
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchResults
-import ru.dbotthepony.mc.otm.android.feature.EnderTeleporterFeature
+import ru.dbotthepony.mc.otm.player.android.feature.EnderTeleporterFeature
 import ru.dbotthepony.mc.otm.block.entity.MatteryBlockEntity
 import ru.dbotthepony.mc.otm.block.entity.decorative.DevChestBlockEntity
 import ru.dbotthepony.mc.otm.player.MatteryPlayer
@@ -43,7 +43,7 @@ import ru.dbotthepony.mc.otm.client.render.blockentity.MatterBatteryBankRenderer
 import ru.dbotthepony.mc.otm.compat.curios.isCuriosLoaded
 import ru.dbotthepony.mc.otm.compat.curios.onCuriosSlotModifiersUpdated
 import ru.dbotthepony.mc.otm.compat.vanilla.MatteryChestMenu
-import ru.dbotthepony.mc.otm.config.AndroidConfig
+import ru.dbotthepony.mc.otm.config.PlayerConfig
 import ru.dbotthepony.mc.otm.config.CablesConfig
 import ru.dbotthepony.mc.otm.config.ClientConfig
 import ru.dbotthepony.mc.otm.config.ExopackConfig
@@ -170,7 +170,7 @@ object OverdriveThatMatters {
 		ClientConfig.register(container)
 		ServerConfig.register(container)
 		CablesConfig.register(container)
-		AndroidConfig.register(container)
+		PlayerConfig.register(container)
 		ExopackConfig.register(container)
 		ItemsConfig.register(container)
 		MachinesConfig.register(container)

src/main/kotlin/ru/dbotthepony/mc/otm/client/AndroidAbilityKeyMapping.kt

@@ -8,7 +8,7 @@ import net.neoforged.neoforge.client.event.RenderLevelStageEvent
 import net.neoforged.neoforge.client.settings.KeyConflictContext
 import net.neoforged.neoforge.network.PacketDistributor
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
-import ru.dbotthepony.mc.otm.android.AndroidActiveFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidActiveFeature
 import ru.dbotthepony.mc.otm.player.matteryPlayer
 import ru.dbotthepony.mc.otm.client.render.MGUIGraphics
 import ru.dbotthepony.mc.otm.client.render.Widgets18

src/main/kotlin/ru/dbotthepony/mc/otm/client/AndroidMenuKeyMapping.kt

@@ -11,8 +11,8 @@ import net.neoforged.neoforge.client.event.RenderGuiEvent
 import net.neoforged.neoforge.client.settings.KeyConflictContext
 import net.neoforged.neoforge.network.PacketDistributor
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
-import ru.dbotthepony.mc.otm.android.AndroidFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidFeature
-import ru.dbotthepony.mc.otm.android.AndroidSwitchableFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidSwitchableFeature
 import ru.dbotthepony.mc.otm.player.matteryPlayer
 import ru.dbotthepony.mc.otm.client.render.MGUIGraphics
 import ru.dbotthepony.mc.otm.client.render.RenderGravity

src/main/kotlin/ru/dbotthepony/mc/otm/client/ClientEventHandler.kt

@@ -18,7 +18,7 @@ import net.neoforged.neoforge.client.event.ScreenEvent
 import net.neoforged.neoforge.event.entity.player.ItemTooltipEvent
 import net.neoforged.neoforge.network.PacketDistributor
 import ru.dbotthepony.mc.otm.config.ClientConfig
-import ru.dbotthepony.mc.otm.android.feature.JumpBoostFeature
+import ru.dbotthepony.mc.otm.player.android.feature.JumpBoostFeature
 import ru.dbotthepony.mc.otm.player.MatteryPlayer
 import ru.dbotthepony.mc.otm.player.matteryPlayer
 import ru.dbotthepony.mc.otm.client.render.UVWindingOrder

src/main/kotlin/ru/dbotthepony/mc/otm/client/MatteryGUI.kt

@@ -23,7 +23,7 @@ import net.neoforged.neoforge.client.event.RenderGuiLayerEvent
 import net.neoforged.neoforge.client.event.ScreenEvent
 import net.neoforged.neoforge.client.gui.VanillaGuiLayers
 import net.neoforged.neoforge.common.ItemAbilities
-import ru.dbotthepony.mc.otm.android.feature.NanobotsArmorFeature
+import ru.dbotthepony.mc.otm.player.android.feature.NanobotsArmorFeature
 import ru.dbotthepony.mc.otm.core.TranslatableComponent
 import ru.dbotthepony.mc.otm.player.MatteryPlayer
 import ru.dbotthepony.mc.otm.player.matteryPlayer

src/main/kotlin/ru/dbotthepony/mc/otm/client/render/ShockwaveRenderer.kt

@@ -7,7 +7,7 @@ import com.mojang.blaze3d.vertex.VertexFormat
 import net.minecraft.client.renderer.GameRenderer
 import net.neoforged.neoforge.client.event.RenderLevelStageEvent
 import org.lwjgl.opengl.GL11.GL_LESS
-import ru.dbotthepony.mc.otm.config.AndroidConfig
+import ru.dbotthepony.mc.otm.config.PlayerConfig
 import ru.dbotthepony.mc.otm.core.math.Vector
 import ru.dbotthepony.mc.otm.core.math.component1
 import ru.dbotthepony.mc.otm.core.math.component2
@@ -74,6 +74,6 @@ object ShockwaveRenderer {
 	}
 
 	fun handle(packet: ShockwaveEffectPacket) {
-		State(packet.pos, AndroidConfig.Shockwave.RADIUS_HORIZONTAL.toFloat())
+		State(packet.pos, PlayerConfig.Shockwave.RADIUS_HORIZONTAL.toFloat())
 	}
 }

src/main/kotlin/ru/dbotthepony/mc/otm/client/screen/tech/AndroidStationScreen.kt

@@ -11,9 +11,9 @@ import net.minecraft.world.entity.player.Inventory
 import net.minecraft.world.item.ItemStack
 import net.neoforged.neoforge.network.PacketDistributor
 import ru.dbotthepony.mc.otm.core.TranslatableComponent
-import ru.dbotthepony.mc.otm.android.AndroidResearch
+import ru.dbotthepony.mc.otm.player.android.AndroidResearch
-import ru.dbotthepony.mc.otm.android.AndroidResearchManager
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchManager
-import ru.dbotthepony.mc.otm.android.AndroidResearchType
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchType
 import ru.dbotthepony.mc.otm.player.MatteryPlayer
 import ru.dbotthepony.mc.otm.client.CursorType
 import ru.dbotthepony.mc.otm.client.render.MGUIGraphics

src/main/kotlin/ru/dbotthepony/mc/otm/config/IFoodRegenerationValues.kt

@@ -0,0 +1,9 @@
+package ru.dbotthepony.mc.otm.config
+
+interface IFoodRegenerationValues {
+	val foodLimit: Int
+	val requiresSaturation: Boolean
+	val ticks: Int
+	val regenerationSlowdown: Boolean
+	val upperSlowdownBound: Double
+}

src/main/kotlin/ru/dbotthepony/mc/otm/config/PlayerConfig.kt

@@ -4,16 +4,31 @@ import ru.dbotthepony.kommons.util.getValue
 import ru.dbotthepony.mc.otm.core.math.Decimal
 import ru.dbotthepony.mc.otm.core.math.defineDecimal
 
-object AndroidConfig : AbstractConfig("androids") {
+object PlayerConfig : AbstractConfig("player") {
+	init {
+		builder.push("Android")
+	}
+
 	val REGENERATE_ENERGY: Boolean by builder
-		.comment("If (technically) hunger is above threshold, it turns into energy")
 		.comment("This setting controls whenever to regenerate small amount of energy while eating as Android")
 		.comment("And also whenever to regenerate energy while in peaceful")
-		.comment("If this is disabled, any (technically) excess hunger will be nullified, unless playing on peaceful difficulty.")
 		.define("REGENERATE_ENERGY", true)
 
+	val REGENERATE_ENERGY_EFFICIENCY_FOOD: Double by builder
+		.comment("How much % of food points to convert to energy")
+		.defineInRange("REGENERATE_ENERGY_EFFICIENCY_FOOD", 0.75, 0.0)
+
+	val REGENERATE_ENERGY_EFFICIENCY_SATURATION: Double by builder
+		.comment("How much % of food saturation points to convert to energy")
+		.defineInRange("REGENERATE_ENERGY_EFFICIENCY_SATURATION", 0.4, 0.0)
+
+	val REGENERATE_ENERGY_IN_PEACEFUL: Boolean by builder
+		.comment("Regenerate energy while in peaceful")
+		.comment("This is disabled by default because this is easily exploitable")
+		.define("REGENERATE_ENERGY_IN_PEACEFUL", false)
+
 	val TIME_BETWEEN_NATURAL_REGENERATION: Int by builder
-		.comment("Time in ticks between natural health regeneration ticks")
+		.comment("Time in ticks between natural health regeneration ticks for Android")
 		.comment("Default value is meant to be one of downsides of being an android,")
 		.comment("so please, don't blindly buff it, players have ability to research into Nanobots Regeneration,")
 		.comment("which provide superior regeneration on average than human players.")
@@ -24,6 +39,10 @@ object AndroidConfig : AbstractConfig("androids") {
 		.comment("for android players, since 'hunger' (for compatibility) is managed by mod in such case")
 		.defineInRange("TIME_BETWEEN_NATURAL_REGENERATION", 120, 0, Int.MAX_VALUE)
 
+	init {
+		builder.pop()
+	}
+
 	object NanobotsRegeneration {
 		init {
 			builder.push("NanobotsRegeneration")
@@ -148,4 +167,103 @@ object AndroidConfig : AbstractConfig("androids") {
 		Magnet
 		Shockwave
 	}
+
+	object Food {
+		init {
+			builder
+				.comment("Food related tweaks")
+				.comment("Since OTM overrides FoodData logic (to make room for Android logic)")
+				.comment("these settings are provided for tweaking FoodData behavior")
+				.push("Food")
+		}
+
+		val SOFT_FOOD_LIMIT: Int by builder
+			.comment("Soft food points limit, which dictate upper bound where player is considered 'hungry',")
+			.comment("e.g. they can eat food which is not marked as 'can always eat'")
+			.defineInRange("SOFT_FOOD_LIMIT", 20, 0)
+
+		val HARD_FOOD_LIMIT: Int by builder
+			.comment("Hard food points limit, which dictate upper bound of food points,")
+			.comment("e.g. hunger can not go above this value")
+			.comment("This is extremely buffed in OTM by default to remove annoyance regarding consuming foodstuffs")
+			.comment("when you are running low on food, so you can eat high-quality food without fear")
+			.comment("that food points will go to waste (especially when you need to regenerate lots of HP)")
+			.defineInRange("HARD_FOOD_LIMIT", 40, 1)
+
+		val OVERSATURATION_LIMIT: Double by builder
+			.comment("Controls how much 'saturation' can be stored above hunger level.")
+			.comment("Negative values will decrease maximum saturation achievable.")
+			.defineInRange("OVERSATURATION_LIMIT", 0.0, -Float.MAX_VALUE.toDouble() + 1.0, Float.MAX_VALUE.toDouble() - 1.0)
+
+		val EXHAUSTION_LIMIT: Double by builder
+			.comment("Controls technical aspect how much 'exhaustion' player can accumulate")
+			.comment("This should not be confused with how much 'exhaustion' is considered as 1 hunger point")
+			.comment("Usually, this should not be changed, since it is a very technical detail;")
+			.comment("but if you have a mod installed which easily hits this limit (and somehow hunger system can't keep up,)")
+			.comment("e.g. it pushes exhaustion over its limit in one call), you can increase this value")
+			.defineInRange("EXHAUSTION_LIMIT", 40.0, 4.0, Float.MAX_VALUE.toDouble() - 1.0)
+
+		private fun defineRegeneration(
+			threshold: Int,
+			requiresSaturation: Boolean,
+			ticks: Int,
+		): IFoodRegenerationValues {
+			return object : IFoodRegenerationValues {
+				override val foodLimit: Int by builder
+					.defineInRange("FOOD_THRESHOLD", threshold, 1)
+
+				override val requiresSaturation: Boolean by builder
+					.define("REQUIRES_SATURATION", requiresSaturation)
+
+				override val ticks: Int by builder
+					.defineInRange("TICKS", ticks, 0)
+
+				override val regenerationSlowdown: Boolean by builder
+					.comment("Slowdown regeneration based on remaining saturation (given REQUIRES_SATURATION is true)")
+					.comment("This replicates vanilla behavior where fast regeneration speed linearly slowdowns the moment")
+					.comment("saturation falls below 6 hunger points (configurable through SATURATION_SLOWDOWN_BOUND)")
+					.comment("This is disabled in OTM by default to buff humans compared to androids when it comes to regeneration")
+					.define("SATURATION_SLOWDOWN", false)
+
+				override val upperSlowdownBound: Double by builder
+					.defineInRange("SATURATION_SLOWDOWN_BOUND", 6.0, 1.0, Float.MAX_VALUE - 1.0)
+			}
+		}
+
+		val FAST_REGEN: IFoodRegenerationValues
+		val SLOW_REGEN: IFoodRegenerationValues
+
+		init {
+			builder.push("FAST_REGENERATION")
+			FAST_REGEN = defineRegeneration(20, true, 10)
+			builder.pop()
+
+			builder.push("SLOW_REGENERATION")
+			SLOW_REGEN = defineRegeneration(18, false, 80)
+			builder.pop()
+		}
+
+		val ENABLE_STARVATION: Boolean by builder
+			.define("ENABLE_STARVATION", true)
+
+		val STARVATION_TICKS: Int by builder
+			.defineInRange("STARVATION_TICKS", 80, 1)
+
+		val STARVATION_HEALTH_LIMIT_EASY: Double by builder
+			.defineInRange("STARVATION_HEALTH_LIMIT_EASY", 10.0, 0.0)
+
+		val STARVATION_HEALTH_LIMIT_NORMAL: Double by builder
+			.defineInRange("STARVATION_HEALTH_LIMIT_NORMAL", 1.0, 0.0)
+
+		val STARVATION_HEALTH_LIMIT_HARD: Double by builder
+			.defineInRange("STARVATION_HEALTH_LIMIT_HARD", 0.0, 0.0)
+
+		init {
+			builder.pop()
+		}
+	}
+
+	init {
+		Food
+	}
 }

src/main/kotlin/ru/dbotthepony/mc/otm/network/AndroidPackets.kt

@@ -10,17 +10,17 @@ import net.minecraft.server.level.ServerPlayer
 import net.minecraft.sounds.SoundSource
 import net.neoforged.neoforge.network.handling.IPayloadContext
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
-import ru.dbotthepony.mc.otm.android.AndroidActiveFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidActiveFeature
-import ru.dbotthepony.mc.otm.android.AndroidFeatureType
+import ru.dbotthepony.mc.otm.player.android.AndroidFeatureType
-import ru.dbotthepony.mc.otm.android.AndroidResearchManager
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchManager
-import ru.dbotthepony.mc.otm.android.AndroidResearchType
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchType
-import ru.dbotthepony.mc.otm.android.AndroidSwitchableFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidSwitchableFeature
 import ru.dbotthepony.mc.otm.capability.energy.extractEnergyExact
 import ru.dbotthepony.mc.otm.player.matteryPlayer
 import ru.dbotthepony.mc.otm.client.MatteryGUI
 import ru.dbotthepony.mc.otm.client.minecraft
 import ru.dbotthepony.mc.otm.client.render.GlitchRenderer
-import ru.dbotthepony.mc.otm.config.AndroidConfig
+import ru.dbotthepony.mc.otm.config.PlayerConfig
 import ru.dbotthepony.mc.otm.core.ResourceLocation
 import ru.dbotthepony.mc.otm.core.readComponent
 import ru.dbotthepony.mc.otm.core.writeComponent
@@ -366,7 +366,7 @@ object TriggerJumpBoostPacket : CustomPacketPayload {
 
 		val feature = mattery.getFeature(AndroidFeatures.JUMP_BOOST) ?: return
 
-		if (feature.isActive && feature.cooldown <= 4 && mattery.androidEnergy.extractEnergyExact(AndroidConfig.JumpBoost.ENERGY_COST, false)) {
+		if (feature.isActive && feature.cooldown <= 4 && mattery.androidEnergy.extractEnergyExact(PlayerConfig.JumpBoost.ENERGY_COST, false)) {
 			feature.putOnCooldown()
 
 			context.player().level().playSound(

src/main/kotlin/ru/dbotthepony/mc/otm/network/NetworkPackets.kt

@@ -2,8 +2,8 @@ package ru.dbotthepony.mc.otm.network
 
 import net.neoforged.neoforge.network.event.RegisterPayloadHandlersEvent
 import net.neoforged.neoforge.network.registration.HandlerThread
-import ru.dbotthepony.mc.otm.android.AndroidResearchManager
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchManager
-import ru.dbotthepony.mc.otm.android.feature.ItemEntityDataPacket
+import ru.dbotthepony.mc.otm.player.android.feature.ItemEntityDataPacket
 import ru.dbotthepony.mc.otm.compat.vanilla.InventoryScrollPacket
 import ru.dbotthepony.mc.otm.data.FlywheelMaterials
 import ru.dbotthepony.mc.otm.item.QuantumBatteryItem

src/main/kotlin/ru/dbotthepony/mc/otm/player/MatteryFoodData.kt

@@ -0,0 +1,202 @@
+package ru.dbotthepony.mc.otm.player
+
+import net.minecraft.nbt.CompoundTag
+import net.minecraft.world.Difficulty
+import net.minecraft.world.damagesource.DamageSource
+import net.minecraft.world.effect.MobEffectInstance
+import net.minecraft.world.effect.MobEffects
+import net.minecraft.world.entity.player.Player
+import net.minecraft.world.food.FoodConstants
+import net.minecraft.world.food.FoodData
+import net.minecraft.world.food.FoodProperties
+import net.minecraft.world.level.GameRules
+import ru.dbotthepony.mc.otm.config.IFoodRegenerationValues
+import ru.dbotthepony.mc.otm.config.PlayerConfig
+import ru.dbotthepony.mc.otm.core.damageType
+import ru.dbotthepony.mc.otm.core.math.Decimal
+import ru.dbotthepony.mc.otm.core.math.getDecimal
+import ru.dbotthepony.mc.otm.core.math.set
+import ru.dbotthepony.mc.otm.core.nbt.set
+import ru.dbotthepony.mc.otm.registry.MDamageTypes
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.roundToInt
+
+class MatteryFoodData(private var player: Player) : FoodData() {
+	private fun add(foodLevel: Int, saturation: Float) {
+		if (player.matteryPlayer.isAndroid && PlayerConfig.REGENERATE_ENERGY) {
+			energyToDrain -= PlayerConfig.ANDROID_ENERGY_PER_HUNGER_POINT * foodLevel * PlayerConfig.REGENERATE_ENERGY_EFFICIENCY_FOOD
+			energyToDrain -= PlayerConfig.ANDROID_ENERGY_PER_HUNGER_POINT * saturation.coerceAtMost(PlayerConfig.Food.SOFT_FOOD_LIMIT.toFloat()) * PlayerConfig.REGENERATE_ENERGY_EFFICIENCY_SATURATION
+		} else if (!player.matteryPlayer.isAndroid) {
+			this.foodLevel = min(this.foodLevel + foodLevel, PlayerConfig.Food.HARD_FOOD_LIMIT)
+			this.saturationLevel = min(this.saturationLevel + saturation, this.foodLevel + PlayerConfig.Food.OVERSATURATION_LIMIT.toFloat()).coerceAtLeast(0f)
+		}
+	}
+
+	override fun eat(foodLevelModifier: Int, saturationLevelModifier: Float) {
+		add(foodLevelModifier, FoodConstants.saturationByModifier(foodLevelModifier, saturationLevelModifier))
+	}
+
+	override fun eat(foodProperties: FoodProperties) {
+		add(foodProperties.nutrition(), foodProperties.saturation())
+	}
+
+	override fun needsFood(): Boolean {
+		return player.matteryPlayer.isAndroid || foodLevel < PlayerConfig.Food.SOFT_FOOD_LIMIT
+	}
+
+	override fun addExhaustion(exhaustion: Float) {
+		// store exhaustion as usual, and handle its reduction in tick for both humans and androids
+		this.exhaustionLevel = min(this.exhaustionLevel + exhaustion, PlayerConfig.Food.EXHAUSTION_LIMIT.toFloat()).coerceAtLeast(0f)
+	}
+
+	override fun readAdditionalSaveData(compoundTag: CompoundTag) {
+		super.readAdditionalSaveData(compoundTag)
+
+		if ("lastFoodLevel" in compoundTag)
+			lastFoodLevel = compoundTag.getInt("lastFoodLevel")
+
+		if ("foodAndroidEnergyToDrain" in compoundTag)
+			energyToDrain = compoundTag.getDecimal("foodAndroidEnergyToDrain")
+	}
+
+	override fun addAdditionalSaveData(compoundTag: CompoundTag) {
+		super.addAdditionalSaveData(compoundTag)
+		compoundTag["lastFoodLevel"] = lastFoodLevel
+		compoundTag["foodAndroidEnergyToDrain"] = energyToDrain
+	}
+
+	private var energyToDrain = Decimal.ZERO
+
+	private fun tickExhaustion() {
+		if (exhaustionLevel >= EXHAUSTION_PER_HUNGER_POINT) {
+			var points = (exhaustionLevel / EXHAUSTION_PER_HUNGER_POINT).toInt()
+			exhaustionLevel %= EXHAUSTION_PER_HUNGER_POINT
+
+			if (player.matteryPlayer.isAndroid) {
+				energyToDrain += PlayerConfig.ANDROID_ENERGY_PER_HUNGER_POINT * points
+			} else {
+				if (saturationLevel > 0f) {
+					val satisfied = min(saturationLevel.roundToInt(), points)
+					points -= satisfied
+					saturationLevel -= satisfied
+				}
+
+				foodLevel = max(0, foodLevel - points)
+			}
+		}
+	}
+
+	private fun tickRegeneration(values: IFoodRegenerationValues): Boolean {
+		if (!player.isHurt || foodLevel < values.foodLimit || values.requiresSaturation && saturationLevel <= 0f)
+			return false
+
+		while (player.isHurt && foodLevel >= values.foodLimit && (!values.requiresSaturation || saturationLevel > 0f) && ++tickTimer >= values.ticks) {
+			tickTimer = 0
+
+			val healAmount = if (values.requiresSaturation && values.regenerationSlowdown) min(saturationLevel, values.upperSlowdownBound.toFloat()) / values.upperSlowdownBound.toFloat() else 1f
+			player.heal(healAmount)
+			addExhaustion(healAmount * 6f)
+			tickExhaustion()
+		}
+
+		return tickTimer != 0
+	}
+
+	override fun tick(player: Player) {
+		this.player = player
+
+		tickExhaustion()
+
+		if (player.matteryPlayer.isAndroid) {
+			if (energyToDrain > Decimal.ZERO)
+				energyToDrain -= player.matteryPlayer.androidEnergy.extractEnergy(energyToDrain, false)
+			else if (energyToDrain < Decimal.ZERO)
+				energyToDrain += player.matteryPlayer.androidEnergy.receiveEnergy(-energyToDrain, false)
+
+			if (player.level().difficulty == Difficulty.PEACEFUL && PlayerConfig.REGENERATE_ENERGY_IN_PEACEFUL)
+				player.matteryPlayer.androidEnergy.receiveEnergy(PlayerConfig.ANDROID_ENERGY_PER_HUNGER_POINT, false)
+
+			if (!player.matteryPlayer.androidHasEnergy) {
+				if (++tickTimer >= 20 && player.hurt(DamageSource(player.level().registryAccess().damageType(MDamageTypes.ANDROID_DISCHARGE)), 1f)) {
+					tickTimer = 0
+				}
+
+				val effect = player.activeEffectsMap[MobEffects.MOVEMENT_SLOWDOWN]
+
+				if (effect == null || effect.duration < 40 || effect.amplifier < 2) {
+					player.addEffect(MobEffectInstance(MobEffects.MOVEMENT_SLOWDOWN, effect?.duration?.coerceAtLeast(60) ?: 60, effect?.amplifier?.coerceAtLeast(2) ?: 2, false, false))
+				}
+			} else {
+				if (player.isHurt && player.level().gameRules.getBoolean(GameRules.RULE_NATURAL_REGENERATION)) {
+					if (++tickTimer >= PlayerConfig.TIME_BETWEEN_NATURAL_REGENERATION) {
+						player.heal(1f)
+						addExhaustion(6f)
+						tickTimer = 0
+					}
+				} else {
+					tickTimer = 0
+				}
+			}
+		} else {
+			lastFoodLevel = foodLevel
+			energyToDrain = Decimal.ZERO
+
+			if (
+				player.level().gameRules.getBoolean(GameRules.RULE_NATURAL_REGENERATION) &&
+				(tickRegeneration(PlayerConfig.Food.FAST_REGEN) || tickRegeneration(PlayerConfig.Food.SLOW_REGEN))
+			) {
+				// do nothing
+			} else if (PlayerConfig.Food.ENABLE_STARVATION && foodLevel <= 0) {
+				if (++tickTimer >= PlayerConfig.Food.STARVATION_TICKS) {
+					tickTimer = 0
+
+					val threshold = when (player.level().difficulty) {
+						Difficulty.PEACEFUL -> Float.POSITIVE_INFINITY
+						Difficulty.EASY -> PlayerConfig.Food.STARVATION_HEALTH_LIMIT_EASY.toFloat()
+						Difficulty.NORMAL -> PlayerConfig.Food.STARVATION_HEALTH_LIMIT_NORMAL.toFloat()
+						Difficulty.HARD -> PlayerConfig.Food.STARVATION_HEALTH_LIMIT_HARD.toFloat()
+					}
+
+					if (player.health > threshold) {
+						player.hurt(player.damageSources().starve(), 1.0f)
+					}
+				}
+			} else {
+				tickTimer = 0
+			}
+		}
+	}
+
+	override fun getFoodLevel(): Int {
+		if (player.matteryPlayer.isAndroid)
+			return if (player.matteryPlayer.androidHasEnergy) PlayerConfig.Food.SOFT_FOOD_LIMIT else 0
+
+		return super.getFoodLevel()
+	}
+
+	override fun getLastFoodLevel(): Int {
+		if (player.matteryPlayer.isAndroid)
+			return getFoodLevel()
+
+		return super.getLastFoodLevel()
+	}
+
+	override fun getExhaustionLevel(): Float {
+		if (player.matteryPlayer.isAndroid && player.matteryPlayer.androidHasEnergy)
+			return 0f
+
+		return super.getExhaustionLevel()
+	}
+
+	override fun getSaturationLevel(): Float {
+		if (player.matteryPlayer.isAndroid)
+			return if (player.matteryPlayer.androidHasEnergy) player.matteryPlayer.androidEnergy.batteryLevel.percentage(player.matteryPlayer.androidEnergy.maxBatteryLevel) * PlayerConfig.Food.SOFT_FOOD_LIMIT else 0f
+
+		return super.getSaturationLevel()
+	}
+
+	companion object {
+		const val EXHAUSTION_PER_HUNGER_POINT = 4f
+	}
+}

src/main/kotlin/ru/dbotthepony/mc/otm/player/MatteryPlayer.kt

@@ -20,22 +20,19 @@ import net.minecraft.server.level.ServerLevel
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.tags.TagKey
 import net.minecraft.world.Container
-import net.minecraft.world.Difficulty
-import net.minecraft.world.damagesource.DamageSource
 import net.minecraft.world.effect.MobEffect
-import net.minecraft.world.effect.MobEffectInstance
 import net.minecraft.world.effect.MobEffects
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.boss.wither.WitherBoss
 import net.minecraft.world.entity.player.Inventory
 import net.minecraft.world.entity.player.Player
+import net.minecraft.world.food.FoodProperties
 import net.minecraft.world.item.Item
 import net.minecraft.world.item.ItemStack
 import net.minecraft.world.item.ProjectileWeaponItem
 import net.minecraft.world.item.crafting.RecipeManager
 import net.minecraft.world.item.crafting.RecipeType
 import net.minecraft.world.item.crafting.SingleRecipeInput
-import net.minecraft.world.level.GameRules
 import net.minecraft.world.level.Level
 import net.minecraft.world.phys.Vec3
 import net.neoforged.bus.api.Event
@@ -59,11 +56,11 @@ import ru.dbotthepony.kommons.util.getValue
 import ru.dbotthepony.kommons.util.setValue
 import ru.dbotthepony.kommons.util.value
 import ru.dbotthepony.mc.otm.*
-import ru.dbotthepony.mc.otm.android.AndroidFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidFeature
-import ru.dbotthepony.mc.otm.android.AndroidFeatureType
+import ru.dbotthepony.mc.otm.player.android.AndroidFeatureType
-import ru.dbotthepony.mc.otm.android.AndroidResearch
+import ru.dbotthepony.mc.otm.player.android.AndroidResearch
-import ru.dbotthepony.mc.otm.android.AndroidResearchManager
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchManager
-import ru.dbotthepony.mc.otm.android.AndroidResearchType
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchType
 import ru.dbotthepony.mc.otm.block.entity.ItemJob
 import ru.dbotthepony.mc.otm.block.entity.JobContainer
 import ru.dbotthepony.mc.otm.block.entity.JobStatus
@@ -73,11 +70,9 @@ import ru.dbotthepony.mc.otm.capability.energy
 import ru.dbotthepony.mc.otm.capability.energy.BatteryBackedEnergyStorage
 import ru.dbotthepony.mc.otm.capability.energy.IMatteryEnergyStorage
 import ru.dbotthepony.mc.otm.capability.energy.ProfiledEnergyStorage
-import ru.dbotthepony.mc.otm.capability.energy.extractEnergyExact
-import ru.dbotthepony.mc.otm.capability.energy.receiveEnergyExact
 import ru.dbotthepony.mc.otm.capability.receiveEnergy
 import ru.dbotthepony.mc.otm.client.minecraft
-import ru.dbotthepony.mc.otm.config.AndroidConfig
+import ru.dbotthepony.mc.otm.config.PlayerConfig
 import ru.dbotthepony.mc.otm.config.ExopackConfig
 import ru.dbotthepony.mc.otm.container.CombinedContainer
 import ru.dbotthepony.mc.otm.container.DynamicallyProxiedContainer
@@ -435,8 +430,6 @@ class MatteryPlayer(val ply: Player) {
 
 	private var shouldPlaySound = false
 	private val research = IdentityHashMap<AndroidResearchType, AndroidResearch>()
-	private var nextDischargeHurt = 20
-	private var nextHealTick = 0
 
 	/**
 	 * This returns if player is an Android or will become one on death/sleep/etc
@@ -560,7 +553,10 @@ class MatteryPlayer(val ply: Player) {
 	/**
 	 * [IMatteryEnergyStorage] instance, representing Android' battery charge
 	 */
-	val androidEnergy = BatteryBackedEnergyStorage(ply, syncher, AndroidConfig.ANDROID_MAX_ENERGY, AndroidConfig.ANDROID_MAX_ENERGY, true)
+	val androidEnergy = BatteryBackedEnergyStorage(ply, syncher, PlayerConfig.ANDROID_MAX_ENERGY, PlayerConfig.ANDROID_MAX_ENERGY, true)
+
+	val androidHasEnergy: Boolean
+		get() = androidEnergy.batteryLevel > Decimal.TEN
 
 	/**
 	 * [IMatteryEnergyStorage] instance, representing Exopack battery charge
@@ -583,8 +579,6 @@ class MatteryPlayer(val ply: Player) {
 		savetables.bool(::isExopackCraftingUpgraded, "isExoSuitCraftingUpgraded")
 		savetables.bool(::isExopackEnderAccessInstalled, "isExopackEnderAccessUpgraded")
 		savetables.bool(::acceptExopackChargeFromWirelessCharger)
-		savetables.int(::nextDischargeHurt)
-		savetables.int(::nextHealTick)
 
 		savetables.vector(::lastLiquidPosition)
 		savetables.codec(::lastDimension, ResourceLocation.CODEC)
@@ -658,8 +652,8 @@ class MatteryPlayer(val ply: Player) {
 		shouldPlaySound = false
 		iteration = 0
 		deathLog.clear()
-		androidEnergy.batteryLevel = AndroidConfig.ANDROID_MAX_ENERGY
+		androidEnergy.batteryLevel = PlayerConfig.ANDROID_MAX_ENERGY
-		androidEnergy.maxBatteryLevel = AndroidConfig.ANDROID_MAX_ENERGY
+		androidEnergy.maxBatteryLevel = PlayerConfig.ANDROID_MAX_ENERGY
 
 		lastLiquidPosition = ply.position()
 		wasInLiquid = false
@@ -713,7 +707,7 @@ class MatteryPlayer(val ply: Player) {
 		iteration = 0
 		deathLog.clear()
 		androidEnergy.batteryLevel = Decimal.ZERO
-		androidEnergy.maxBatteryLevel = AndroidConfig.ANDROID_MAX_ENERGY
+		androidEnergy.maxBatteryLevel = PlayerConfig.ANDROID_MAX_ENERGY
 		dropBattery()
 
 		lastLiquidPosition = ply.position()
@@ -1212,81 +1206,6 @@ class MatteryPlayer(val ply: Player) {
 
 					lastLiquidPosition = ply.position
 				}
-
-				val stats = ply.foodData
-				val fourTimesTheHunger = AndroidConfig.ANDROID_ENERGY_PER_HUNGER_POINT * 4
-
-				// истощение
-				if (stats.exhaustionLevel > 0f) {
-					val extracted = androidEnergy.extractEnergy(AndroidConfig.ANDROID_ENERGY_PER_HUNGER_POINT * (stats.exhaustionLevel / 4f), false)
-					stats.setExhaustion(stats.exhaustionLevel - (extracted / AndroidConfig.ANDROID_ENERGY_PER_HUNGER_POINT).toFloat() * 4f)
-				}
-
-				// Обычный голод
-				while (
-					stats.foodLevel < 18 &&
-					androidEnergy.batteryLevel >= fourTimesTheHunger &&
-					androidEnergy.extractEnergyExact(AndroidConfig.ANDROID_ENERGY_PER_HUNGER_POINT, false)
-				) {
-					stats.foodLevel++
-				}
-
-				// "поглощение" излишек голода, как при мирном режиме, так и при поедании обычной еды
-				if (AndroidConfig.REGENERATE_ENERGY) {
-					while (stats.foodLevel > 18 && androidEnergy.receiveEnergyExact(AndroidConfig.ANDROID_ENERGY_PER_HUNGER_POINT / 2, false)) {
-						stats.foodLevel--
-					}
-				} else if (ply.level().difficulty != Difficulty.PEACEFUL) {
-					stats.foodLevel = stats.foodLevel.coerceAtMost(18)
-				}
-
-				val foodLevel = stats.foodLevel.toFloat()
-
-				// насыщение
-				if (stats.saturationLevel < foodLevel && androidEnergy.batteryLevel >= fourTimesTheHunger) {
-					val extracted = androidEnergy.extractEnergy(AndroidConfig.ANDROID_ENERGY_PER_HUNGER_POINT * (foodLevel - stats.saturationLevel), false)
-					stats.setSaturation(stats.saturationLevel + (extracted / AndroidConfig.ANDROID_ENERGY_PER_HUNGER_POINT).toFloat())
-				}
-
-				if (androidEnergy.batteryLevel <= Decimal.TEN && !ply.isCreative && ply.level().difficulty != Difficulty.PEACEFUL) {
-					if (stats.saturationLevel > 1f) {
-						if (androidEnergy.receiveEnergyExact(AndroidConfig.ANDROID_ENERGY_PER_HUNGER_POINT, false)) {
-							stats.setSaturation(stats.saturationLevel - 1f)
-						}
-					} else if (stats.saturationLevel > 0f) {
-						val received = androidEnergy.receiveEnergy(AndroidConfig.ANDROID_ENERGY_PER_HUNGER_POINT * stats.saturationLevel, false)
-						stats.setSaturation(stats.saturationLevel - (received / AndroidConfig.ANDROID_ENERGY_PER_HUNGER_POINT).toFloat())
-					} else if (stats.foodLevel > 0) {
-						// так как голод не тикает для андроидов, "умереть с голоду" мы не можем
-						// но со стороны будет выглядеть как будто мы умираем с голода
-						if (androidEnergy.receiveEnergyExact(AndroidConfig.ANDROID_ENERGY_PER_HUNGER_POINT, false)) {
-							stats.foodLevel--
-						}
-					}
-
-					if (androidEnergy.batteryLevel <= Decimal.TEN) {
-						if (--nextDischargeHurt <= 0 && ply.hurt(DamageSource(ply.level().registryAccess().damageType(MDamageTypes.ANDROID_DISCHARGE)), 1f)) {
-							nextDischargeHurt = 20
-						}
-
-						val effect = ply.activeEffectsMap[MobEffects.MOVEMENT_SLOWDOWN]
-
-						if (effect == null || effect.duration < 40 || effect.amplifier < 2) {
-							ply.addEffect(MobEffectInstance(MobEffects.MOVEMENT_SLOWDOWN, effect?.duration?.coerceAtLeast(60) ?: 60, effect?.amplifier?.coerceAtLeast(2) ?: 2, false, false))
-						}
-					}
-				} else {
-					nextDischargeHurt = 20
-
-					if (ply.isHurt && ply.level().gameRules.getBoolean(GameRules.RULE_NATURAL_REGENERATION)) {
-						if (--nextHealTick <= 0) {
-							nextHealTick = if (ply.level().difficulty == Difficulty.PEACEFUL) 10 else AndroidConfig.TIME_BETWEEN_NATURAL_REGENERATION
-							ply.heal(1f)
-						}
-					} else {
-						nextHealTick = if (ply.level().difficulty == Difficulty.PEACEFUL) 10 else AndroidConfig.TIME_BETWEEN_NATURAL_REGENERATION
-					}
-				}
 			}
 
 			for (feature in featureMap.values) {
@@ -1475,8 +1394,8 @@ class MatteryPlayer(val ply: Player) {
 			ply.matteryPlayer.shouldSendIteration = true
 			ply.matteryPlayer.deathLog.addLast(ply.tickCount to ply.combatTracker.deathMessage)
 
-			if (ply.matteryPlayer.androidEnergy.batteryLevel < AndroidConfig.ANDROID_MAX_ENERGY * Decimal("0.2"))
+			if (ply.matteryPlayer.androidEnergy.batteryLevel < PlayerConfig.ANDROID_MAX_ENERGY * Decimal("0.2"))
-				ply.matteryPlayer.androidEnergy.batteryLevel = AndroidConfig.ANDROID_MAX_ENERGY * Decimal("0.2") // если смерть была от разряда батареи, то предотвращаем софтлок
+				ply.matteryPlayer.androidEnergy.batteryLevel = PlayerConfig.ANDROID_MAX_ENERGY * Decimal("0.2") // если смерть была от разряда батареи, то предотвращаем софтлок
 
 			while (ply.matteryPlayer.deathLog.size > 6) {
 				ply.matteryPlayer.deathLog.removeFirst()
@@ -1521,14 +1440,14 @@ class MatteryPlayer(val ply: Player) {
 		 * hooked into LivingEntity through coremod script
 		 */
 		@JvmStatic
-		fun addEatEffectHook(iterator: Iterator<com.mojang.datafixers.util.Pair<MobEffectInstance, Float>>, entity: LivingEntity): Iterator<com.mojang.datafixers.util.Pair<MobEffectInstance, Float>> {
+		fun addEatEffectHook(iterator: Iterator<FoodProperties.PossibleEffect>, entity: LivingEntity): Iterator<FoodProperties.PossibleEffect> {
 			if (entity !is Player) {
 				return iterator
 			}
 
 			if (entity.matteryPlayer.isAndroid) {
 				return iterator.filter {
-					it.first.effect != MobEffects.HUNGER
+					it.effect().effect != MobEffects.HUNGER
 				}
 			}
 

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/AndroidActiveFeature.kt

@@ -1,4 +1,4 @@
-package ru.dbotthepony.mc.otm.android
+package ru.dbotthepony.mc.otm.player.android
 
 import com.mojang.blaze3d.vertex.PoseStack
 import net.minecraft.client.Camera

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/AndroidFeature.kt

@@ -1,4 +1,4 @@
-package ru.dbotthepony.mc.otm.android
+package ru.dbotthepony.mc.otm.player.android
 
 import net.minecraft.core.HolderLookup
 import net.minecraft.nbt.CompoundTag

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/AndroidFeatureType.kt

@@ -1,4 +1,4 @@
-package ru.dbotthepony.mc.otm.android
+package ru.dbotthepony.mc.otm.player.android
 
 import net.minecraft.network.chat.Component
 import net.minecraft.network.chat.ComponentContents

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/AndroidResearch.kt

@@ -1,4 +1,4 @@
-package ru.dbotthepony.mc.otm.android
+package ru.dbotthepony.mc.otm.player.android
 
 import net.minecraft.ChatFormatting
 import net.minecraft.core.HolderLookup

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/AndroidResearchDataProvider.kt

@@ -1,4 +1,4 @@
-package ru.dbotthepony.mc.otm.android
+package ru.dbotthepony.mc.otm.player.android
 
 import com.google.gson.JsonObject
 import it.unimi.dsi.fastutil.objects.ObjectArraySet

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/AndroidResearchDescription.kt

@@ -1,4 +1,4 @@
-package ru.dbotthepony.mc.otm.android
+package ru.dbotthepony.mc.otm.player.android
 
 import com.mojang.serialization.Codec
 import com.mojang.serialization.MapCodec
@@ -9,7 +9,7 @@ import net.minecraft.network.chat.ComponentSerialization
 import net.neoforged.bus.api.IEventBus
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
 import ru.dbotthepony.mc.otm.client.ShiftPressedCond
-import ru.dbotthepony.mc.otm.config.AndroidConfig
+import ru.dbotthepony.mc.otm.config.PlayerConfig
 import ru.dbotthepony.mc.otm.core.TextComponent
 import ru.dbotthepony.mc.otm.core.TranslatableComponent
 import ru.dbotthepony.mc.otm.core.util.formatPower
@@ -29,35 +29,76 @@ object AndroidResearchDescriptions {
 
 	val ENDER_TELEPORTER: AndroidResearchDescription.Singleton by registrar.register("ender_teleporter") {
 		AndroidResearchDescription.singleton {
-			TranslatableComponent("otm.gui.power_cost_per_use", AndroidConfig.EnderTeleporter.ENERGY_COST.formatPower(formatAsReadable = ShiftPressedCond).copy().withStyle(ChatFormatting.YELLOW)) }
+			TranslatableComponent(
+				"otm.gui.power_cost_per_use",
+				PlayerConfig.EnderTeleporter.ENERGY_COST.formatPower(formatAsReadable = ShiftPressedCond).copy()
+					.withStyle(ChatFormatting.YELLOW)
+			)
+		}
 	}
 
 	val FALL_DAMPENERS: AndroidResearchDescription.Leveled by registrar.register("fall_dampeners") {
 		AndroidResearchDescription.Leveled { _, list, level ->
-			list.add(TranslatableComponent("otm.fall_dampeners.description",
+			list.add(
-				TextComponent("%.1f".format((AndroidConfig.FALL_DAMAGE_REDUCTION_PER_LEVEL_P * level).toFloat().coerceIn(0f, 1f) * 100f)).withStyle(ChatFormatting.YELLOW),
+				TranslatableComponent(
-				TextComponent("%.1f".format((AndroidConfig.FALL_DAMAGE_REDUCTION_PER_LEVEL_F * level).toFloat())).withStyle(ChatFormatting.YELLOW),
+					"otm.fall_dampeners.description",
-			)) }
+					TextComponent(
+						"%.1f".format(
+							(PlayerConfig.FALL_DAMAGE_REDUCTION_PER_LEVEL_P * level).toFloat().coerceIn(0f, 1f) * 100f
+						)
+					).withStyle(ChatFormatting.YELLOW),
+					TextComponent("%.1f".format((PlayerConfig.FALL_DAMAGE_REDUCTION_PER_LEVEL_F * level).toFloat())).withStyle(
+						ChatFormatting.YELLOW
+					),
+				)
+			)
+		}
 	}
 
 	val SWIM_BOOSTERS: AndroidResearchDescription.Leveled by registrar.register("swim_boosters") {
 		AndroidResearchDescription.Leveled { _, list, level ->
-			list.add(TranslatableComponent(
+			list.add(
-				"android_research.overdrive_that_matters.swim_boosters.description",
+				TranslatableComponent(
-				TextComponent("%.1f".format(AndroidConfig.SWIM_BOOSTERS * (1 + level) * 100.0)).withStyle(ChatFormatting.YELLOW)
+					"android_research.overdrive_that_matters.swim_boosters.description",
-			)) }
+					TextComponent("%.1f".format(PlayerConfig.SWIM_BOOSTERS * (1 + level) * 100.0)).withStyle(
+						ChatFormatting.YELLOW
+					)
+				)
+			)
+		}
 	}
 
 	val ITEM_MAGNET: AndroidResearchDescription.Singleton by registrar.register("item_magnet") {
-		AndroidResearchDescription.singleton { TranslatableComponent("otm.gui.power_cost_per_tick", AndroidConfig.Magnet.POWER_DRAW.formatPower(formatAsReadable = ShiftPressedCond).copy().withStyle(ChatFormatting.YELLOW)) }
+		AndroidResearchDescription.singleton {
+			TranslatableComponent(
+				"otm.gui.power_cost_per_tick",
+				PlayerConfig.Magnet.POWER_DRAW.formatPower(
+					formatAsReadable = ShiftPressedCond
+				).copy().withStyle(ChatFormatting.YELLOW)
+			)
+		}
 	}
 
 	val JUMP_BOOST: AndroidResearchDescription.Singleton by registrar.register("jump_boost") {
-		AndroidResearchDescription.singleton { TranslatableComponent("otm.gui.power_cost_per_use", AndroidConfig.JumpBoost.ENERGY_COST.formatPower(formatAsReadable = ShiftPressedCond).copy().withStyle(ChatFormatting.YELLOW)) }
+		AndroidResearchDescription.singleton {
+			TranslatableComponent(
+				"otm.gui.power_cost_per_use",
+				PlayerConfig.JumpBoost.ENERGY_COST.formatPower(
+					formatAsReadable = ShiftPressedCond
+				).copy().withStyle(ChatFormatting.YELLOW)
+			)
+		}
 	}
 
 	val SHOCKWAVE: AndroidResearchDescription.Singleton by registrar.register("shockwave") {
-		AndroidResearchDescription.singleton { TranslatableComponent("otm.gui.power_cost_per_use", AndroidConfig.Shockwave.ENERGY_COST.formatPower(formatAsReadable = ShiftPressedCond).copy().withStyle(ChatFormatting.YELLOW)) }
+		AndroidResearchDescription.singleton {
+			TranslatableComponent(
+				"otm.gui.power_cost_per_use",
+				PlayerConfig.Shockwave.ENERGY_COST.formatPower(
+					formatAsReadable = ShiftPressedCond
+				).copy().withStyle(ChatFormatting.YELLOW)
+			)
+		}
 	}
 }
 
@@ -138,7 +179,7 @@ object PlainAndroidResearchDescription : AndroidResearchDescription.Type<PlainAn
 		RecordCodecBuilder.mapCodec {
 			it.group(
 				ComponentSerialization.CODEC.fieldOf("line").forGetter { it.line }
-			).apply(it, ::Instance)
+			).apply(it, PlainAndroidResearchDescription::Instance)
 		}
 	}
 }

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/AndroidResearchManager.kt

@@ -1,4 +1,4 @@
-package ru.dbotthepony.mc.otm.android
+package ru.dbotthepony.mc.otm.player.android
 
 import com.google.common.collect.ImmutableMap
 import com.google.gson.GsonBuilder
@@ -108,7 +108,10 @@ object AndroidResearchManager : SimpleJsonResourceReloadListener(GsonBuilder().s
 	}
 
 	val SYNC_TYPE = CustomPacketPayload.Type<SyncPacket>(ResourceLocation(OverdriveThatMatters.MOD_ID, "research_sync"))
-	val SYNC_CODEC: StreamCodec<FriendlyByteBuf, SyncPacket> = StreamCodec.ofMember(SyncPacket::write, ::readSyncPacket)
+	val SYNC_CODEC: StreamCodec<FriendlyByteBuf, SyncPacket> = StreamCodec.ofMember(
+		SyncPacket::write,
+		AndroidResearchManager::readSyncPacket
+	)
 
 	class SyncPacket(val collection: Collection<AndroidResearchType>) : CustomPacketPayload {
 		fun write(buff: FriendlyByteBuf) {

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/AndroidResearchResult.kt

@@ -1,4 +1,4 @@
-package ru.dbotthepony.mc.otm.android
+package ru.dbotthepony.mc.otm.player.android
 
 import com.mojang.serialization.Codec
 import com.mojang.serialization.MapCodec
@@ -16,8 +16,8 @@ object AndroidResearchResults {
 	private val registrar = MDeferredRegister(AndroidResearchResult.registryKey, OverdriveThatMatters.MOD_ID)
 
 	init {
-		registrar.register("feature") { AndroidResearchResult.Feature.Companion }
+		registrar.register("feature") { AndroidResearchResult.Feature }
-		registrar.register("feature_level") { AndroidResearchResult.FeatureLevel.Companion }
+		registrar.register("feature_level") { AndroidResearchResult.FeatureLevel }
 	}
 
 	private object NanobotsArmorStrength : AndroidResearchResult.Singleton<NanobotsArmorStrength> {
@@ -90,7 +90,7 @@ interface AndroidResearchResult {
 					it.group(
 						ResourceLocation.CODEC.fieldOf("id").forGetter(Feature::id),
 						Codec.BOOL.optionalFieldOf("optional", false).forGetter(Feature::optional)
-					).apply(it, ::Feature)
+					).apply(it, AndroidResearchResult::Feature)
 				}
 			}
 		}
@@ -99,7 +99,8 @@ interface AndroidResearchResult {
 	/**
 	 * Increases level of specific android feature [id] by specified amount [levels]
 	 */
-	class FeatureLevel(val id: ResourceLocation, val optional: Boolean = false, val levels: Int = 1) : AndroidResearchResult {
+	class FeatureLevel(val id: ResourceLocation, val optional: Boolean = false, val levels: Int = 1) :
+		AndroidResearchResult {
 		val feature = MRegistry.ANDROID_FEATURES.get(id) ?: if (optional) null else throw NoSuchElementException("Unknown android feature $id")
 
 		override val type: Type<*>
@@ -132,7 +133,7 @@ interface AndroidResearchResult {
 						ResourceLocation.CODEC.fieldOf("id").forGetter(FeatureLevel::id),
 						Codec.BOOL.optionalFieldOf("optional", false).forGetter(FeatureLevel::optional),
 						Codec.INT.optionalFieldOf("levels", 1).forGetter(FeatureLevel::levels),
-					).apply(it, ::FeatureLevel)
+					).apply(it, AndroidResearchResult::FeatureLevel)
 				}
 			}
 		}

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/AndroidResearchType.kt

@@ -1,4 +1,4 @@
-package ru.dbotthepony.mc.otm.android
+package ru.dbotthepony.mc.otm.player.android
 
 import com.google.common.collect.ImmutableList
 import com.google.gson.JsonObject
@@ -131,10 +131,10 @@ class AndroidResearchType(
 						it.group(
 							ResourceLocation.CODEC.fieldOf("id").forGetter(Reference::id),
 							Codec.BOOL.optionalFieldOf("optional", false).forGetter(Reference::optional)
-						).apply(it, ::Reference)
+						).apply(it, AndroidResearchType::Reference)
 					})
 					.xmap(
-						{ c -> c.map(::Reference, Function.identity()) },
+						{ c -> c.map(AndroidResearchType::Reference, Function.identity()) },
 						{ c -> if (c.optional) Either.right(c) else Either.left(c.id) }
 					)
 			}

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/AndroidSwitchableFeature.kt

@@ -1,4 +1,4 @@
-package ru.dbotthepony.mc.otm.android
+package ru.dbotthepony.mc.otm.player.android
 
 import net.minecraft.client.multiplayer.ClientLevel
 import net.minecraft.core.HolderLookup

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/feature/AttackBoostFeature.kt

@@ -1,9 +1,9 @@
-package ru.dbotthepony.mc.otm.android.feature
+package ru.dbotthepony.mc.otm.player.android.feature
 
 import net.minecraft.world.entity.ai.attributes.AttributeModifier
 import net.minecraft.world.entity.ai.attributes.Attributes
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
-import ru.dbotthepony.mc.otm.android.AndroidFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidFeature
 import ru.dbotthepony.mc.otm.player.MatteryPlayer
 import ru.dbotthepony.mc.otm.core.ResourceLocation
 import ru.dbotthepony.mc.otm.registry.game.AndroidFeatures

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/feature/EnderTeleporterFeature.kt

@@ -1,4 +1,4 @@
-package ru.dbotthepony.mc.otm.android.feature
+package ru.dbotthepony.mc.otm.player.android.feature
 
 import com.mojang.blaze3d.systems.RenderSystem
 import com.mojang.blaze3d.vertex.PoseStack
@@ -25,7 +25,7 @@ import net.neoforged.neoforge.event.entity.living.LivingDeathEvent
 import ru.dbotthepony.kommons.math.RGBAColor
 import ru.dbotthepony.mc.otm.NULLABLE_MINECRAFT_SERVER
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
-import ru.dbotthepony.mc.otm.android.AndroidActiveFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidActiveFeature
 import ru.dbotthepony.mc.otm.player.MatteryPlayer
 import ru.dbotthepony.mc.otm.capability.energy.extractEnergyExact
 import ru.dbotthepony.mc.otm.player.matteryPlayer
@@ -34,7 +34,7 @@ import ru.dbotthepony.mc.otm.client.render.MGUIGraphics
 import ru.dbotthepony.mc.otm.client.render.ResearchIcons
 import ru.dbotthepony.mc.otm.client.render.linesIgnoreZRenderType
 import ru.dbotthepony.mc.otm.client.render.sprites.sprite
-import ru.dbotthepony.mc.otm.config.AndroidConfig
+import ru.dbotthepony.mc.otm.config.PlayerConfig
 import ru.dbotthepony.mc.otm.core.ResourceLocation
 import ru.dbotthepony.mc.otm.core.genericPositions
 import ru.dbotthepony.mc.otm.core.holder
@@ -60,10 +60,10 @@ class EnderTeleporterFeature(capability: MatteryPlayer) : AndroidActiveFeature(A
 		private set
 
 	override val maxCooldown: Int
-		get() = AndroidConfig.EnderTeleporter.COOLDOWN
+		get() = PlayerConfig.EnderTeleporter.COOLDOWN
 
 	private fun canUse(): Boolean {
-		return !isOnCooldown && android.androidEnergy.extractEnergyExact(AndroidConfig.EnderTeleporter.ENERGY_COST, true)
+		return !isOnCooldown && android.androidEnergy.extractEnergyExact(PlayerConfig.EnderTeleporter.ENERGY_COST, true)
 	}
 
 	private fun isValidGround(blockPos: BlockPos): Boolean {
@@ -112,14 +112,14 @@ class EnderTeleporterFeature(capability: MatteryPlayer) : AndroidActiveFeature(A
 	}
 
 	private fun tryToPhaseThroughWall(blockPos: BlockPos, normal: Vec3i): TraceResult? {
-		val phasedBlocks = ArrayList<BlockPos>(AndroidConfig.EnderTeleporter.MAX_PHASE_DISTANCE)
+		val phasedBlocks = ArrayList<BlockPos>(PlayerConfig.EnderTeleporter.MAX_PHASE_DISTANCE)
 		phasedBlocks.add(blockPos)
 
-		for (extend in 1 .. AndroidConfig.EnderTeleporter.MAX_PHASE_DISTANCE) {
+		for (extend in 1 .. PlayerConfig.EnderTeleporter.MAX_PHASE_DISTANCE) {
 			val pos = blockPos + normal * extend
 
 			if (isAirGap(pos)) {
-				for (y in 0 .. AndroidConfig.EnderTeleporter.MAX_PHASE_DISTANCE - extend) {
+				for (y in 0 .. PlayerConfig.EnderTeleporter.MAX_PHASE_DISTANCE - extend) {
 					val newPos = BlockPos(pos.x, pos.y - y, pos.z)
 
 					if (isValidPosition(newPos)) {
@@ -142,7 +142,7 @@ class EnderTeleporterFeature(capability: MatteryPlayer) : AndroidActiveFeature(A
 
 		val result = ply.level().clip(ClipContext(
 			headPosition,
-			headPosition + aimVector * (AndroidConfig.EnderTeleporter.MAX_DISTANCE * 2.0),
+			headPosition + aimVector * (PlayerConfig.EnderTeleporter.MAX_DISTANCE * 2.0),
 			ClipContext.Block.COLLIDER,
 			ClipContext.Fluid.NONE,
 			ply
@@ -158,7 +158,7 @@ class EnderTeleporterFeature(capability: MatteryPlayer) : AndroidActiveFeature(A
 			!ply.isShiftKeyDown &&
 			result.direction == Direction.UP &&
 			isValidPosition(result.blockPos.above()) &&
-			shortestDistanceBetween(testPositions, result.blockPos.above().asVector()) <= AndroidConfig.EnderTeleporter.MAX_DISTANCE
+			shortestDistanceBetween(testPositions, result.blockPos.above().asVector()) <= PlayerConfig.EnderTeleporter.MAX_DISTANCE
 		) {
 			return TraceResult(result.blockPos.above())
 		}
@@ -216,14 +216,14 @@ class EnderTeleporterFeature(capability: MatteryPlayer) : AndroidActiveFeature(A
 			if (!isAirGap(pos)) {
 				phasedBlocks++
 
-				if (phasedBlocks >= AndroidConfig.EnderTeleporter.MAX_PHASE_DISTANCE) {
+				if (phasedBlocks >= PlayerConfig.EnderTeleporter.MAX_PHASE_DISTANCE) {
 					break
 				}
 
 				phasedBlocksList.add(pos)
 			}
 
-			if (shortestDistanceBetween(testPositions, pos.asVector()) > AndroidConfig.EnderTeleporter.MAX_DISTANCE) {
+			if (shortestDistanceBetween(testPositions, pos.asVector()) > PlayerConfig.EnderTeleporter.MAX_DISTANCE) {
 				break
 			}
 
@@ -270,14 +270,14 @@ class EnderTeleporterFeature(capability: MatteryPlayer) : AndroidActiveFeature(A
 				if (!isAirGap(pos)) {
 					phasedBlocks++
 
-					if (phasedBlocks >= AndroidConfig.EnderTeleporter.MAX_PHASE_DISTANCE) {
+					if (phasedBlocks >= PlayerConfig.EnderTeleporter.MAX_PHASE_DISTANCE) {
 						break
 					}
 
 					phasedBlocksList.add(pos)
 				}
 
-				if (shortestDistanceBetween(testPositions, pos.asVector()) > AndroidConfig.EnderTeleporter.MAX_DISTANCE) {
+				if (shortestDistanceBetween(testPositions, pos.asVector()) > PlayerConfig.EnderTeleporter.MAX_DISTANCE) {
 					break
 				}
 
@@ -308,7 +308,7 @@ class EnderTeleporterFeature(capability: MatteryPlayer) : AndroidActiveFeature(A
 
 		putOnCooldown()
 		lastTeleport = ply.server!!.tickCount
-		android.androidEnergy.extractEnergy(AndroidConfig.EnderTeleporter.ENERGY_COST, false)
+		android.androidEnergy.extractEnergy(PlayerConfig.EnderTeleporter.ENERGY_COST, false)
 
 		ply.level().playSound(null, ply, SoundEvents.ENDERMAN_TELEPORT, SoundSource.PLAYERS, 0.3f, 0.8f + ply.level().random.nextFloat() * 0.4f)
 		ply.teleportTo(event.targetX, event.targetY, event.targetZ)

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/feature/ExtendedReachFeature.kt

@@ -1,9 +1,9 @@
-package ru.dbotthepony.mc.otm.android.feature
+package ru.dbotthepony.mc.otm.player.android.feature
 
 import net.minecraft.world.entity.ai.attributes.AttributeModifier
 import net.minecraft.world.entity.ai.attributes.Attributes
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
-import ru.dbotthepony.mc.otm.android.AndroidFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidFeature
 import ru.dbotthepony.mc.otm.player.MatteryPlayer
 import ru.dbotthepony.mc.otm.core.ResourceLocation
 import ru.dbotthepony.mc.otm.registry.game.AndroidFeatures

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/feature/FallDampenersFeature.kt

@@ -1,10 +1,10 @@
-package ru.dbotthepony.mc.otm.android.feature
+package ru.dbotthepony.mc.otm.player.android.feature
 
 import net.minecraft.server.level.ServerPlayer
 import net.neoforged.neoforge.event.entity.living.LivingIncomingDamageEvent
-import ru.dbotthepony.mc.otm.android.AndroidFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidFeature
 import ru.dbotthepony.mc.otm.player.MatteryPlayer
-import ru.dbotthepony.mc.otm.config.AndroidConfig
+import ru.dbotthepony.mc.otm.config.PlayerConfig
 import ru.dbotthepony.mc.otm.core.isFall
 import ru.dbotthepony.mc.otm.registry.game.AndroidFeatures
 import ru.dbotthepony.mc.otm.triggers.FallDampenersSaveTrigger
@@ -12,8 +12,8 @@ import ru.dbotthepony.mc.otm.triggers.FallDampenersSaveTrigger
 class FallDampenersFeature(capability: MatteryPlayer) : AndroidFeature(AndroidFeatures.FALL_DAMPENERS, capability) {
 	override fun onHurt(event: LivingIncomingDamageEvent) {
 		if (event.source.isFall) {
-			val reduction = (AndroidConfig.FALL_DAMAGE_REDUCTION_PER_LEVEL_P * (level + 1)).toFloat().coerceIn(0f, 1f)
+			val reduction = (PlayerConfig.FALL_DAMAGE_REDUCTION_PER_LEVEL_P * (level + 1)).toFloat().coerceIn(0f, 1f)
-			val flat = (AndroidConfig.FALL_DAMAGE_REDUCTION_PER_LEVEL_F * (level + 1)).toFloat().coerceIn(0f, Float.MAX_VALUE)
+			val flat = (PlayerConfig.FALL_DAMAGE_REDUCTION_PER_LEVEL_F * (level + 1)).toFloat().coerceIn(0f, Float.MAX_VALUE)
 
 			val old = event.amount
 			event.amount = ((event.amount - flat) * (1f - reduction)).coerceAtLeast(0f)

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/feature/ItemMagnetFeature.kt

@@ -1,4 +1,4 @@
-package ru.dbotthepony.mc.otm.android.feature
+package ru.dbotthepony.mc.otm.player.android.feature
 
 import net.minecraft.client.multiplayer.ClientLevel
 import net.minecraft.network.FriendlyByteBuf
@@ -11,8 +11,8 @@ import net.neoforged.neoforge.network.PacketDistributor
 import net.neoforged.neoforge.network.handling.IPayloadContext
 import ru.dbotthepony.kommons.math.RGBAColor
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
-import ru.dbotthepony.mc.otm.config.AndroidConfig
+import ru.dbotthepony.mc.otm.config.PlayerConfig
-import ru.dbotthepony.mc.otm.android.AndroidSwitchableFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidSwitchableFeature
 import ru.dbotthepony.mc.otm.player.MatteryPlayer
 import ru.dbotthepony.mc.otm.capability.energy.extractEnergyExact
 import ru.dbotthepony.mc.otm.client.render.MGUIGraphics
@@ -60,7 +60,10 @@ class ItemEntityDataPacket(val itemUUID: Int, val owner: UUID? = null, val age:
 
 	companion object {
 		val TYPE = CustomPacketPayload.Type<ItemEntityDataPacket>(ResourceLocation(OverdriveThatMatters.MOD_ID, "item_entity_data"))
-		val CODEC: StreamCodec<FriendlyByteBuf, ItemEntityDataPacket> = StreamCodec.ofMember(ItemEntityDataPacket::write, ::read)
+		val CODEC: StreamCodec<FriendlyByteBuf, ItemEntityDataPacket> = StreamCodec.ofMember(
+			ItemEntityDataPacket::write,
+			Companion::read
+		)
 
 		fun read(buff: FriendlyByteBuf): ItemEntityDataPacket {
 			return ItemEntityDataPacket(buff.readVarInt(), if (buff.readBoolean()) buff.readUUID() else null, buff.readVarInt(), buff.readVarInt(), buff.readBoolean())
@@ -76,13 +79,13 @@ class ItemMagnetFeature(capability: MatteryPlayer) : AndroidSwitchableFeature(An
 	private val clientPredicate = Predicate<Entity> { it is ItemEntity && (datatable[it] ?: SharedItemEntityData.EMPTY).let { !it.hasPickupDelay && (it.owner == null || it.owner != ply.uuid || it.lifespan - it.age <= 200) } }
 
 	private fun doTick(server: Boolean) {
-		if (ply.isSpectator || server && !android.androidEnergy.extractEnergyExact(AndroidConfig.Magnet.POWER_DRAW, true)) {
+		if (ply.isSpectator || server && !android.androidEnergy.extractEnergyExact(PlayerConfig.Magnet.POWER_DRAW, true)) {
 			return
 		}
 
 		val entities = ply.level().getEntitiesInEllipsoid(
 			ply.position,
-			Vector(AndroidConfig.Magnet.RADIUS_HORIZONTAL, AndroidConfig.Magnet.RADIUS_VERTICAL, AndroidConfig.Magnet.RADIUS_HORIZONTAL),
+			Vector(PlayerConfig.Magnet.RADIUS_HORIZONTAL, PlayerConfig.Magnet.RADIUS_VERTICAL, PlayerConfig.Magnet.RADIUS_HORIZONTAL),
 			if (server) Predicate<Entity> { it is ItemEntity } else clientPredicate
 		)
 
@@ -101,7 +104,7 @@ class ItemMagnetFeature(capability: MatteryPlayer) : AndroidSwitchableFeature(An
 				if (data.position.distanceToSqr(ent.position) < 1.0) {
 					data.ticksSinceActivity++
 				} else {
-					if (!android.androidEnergy.extractEnergyExact(AndroidConfig.Magnet.POWER_DRAW, false)) {
+					if (!android.androidEnergy.extractEnergyExact(PlayerConfig.Magnet.POWER_DRAW, false)) {
 						return
 					}
 
@@ -117,7 +120,7 @@ class ItemMagnetFeature(capability: MatteryPlayer) : AndroidSwitchableFeature(An
 	override fun tickClient() {
 		super.tickClient()
 
-		if (!ply.isSpectator && isActive && android.androidEnergy.extractEnergyExact(AndroidConfig.Magnet.POWER_DRAW, true)) {
+		if (!ply.isSpectator && isActive && android.androidEnergy.extractEnergyExact(PlayerConfig.Magnet.POWER_DRAW, true)) {
 			doTick(false)
 		}
 	}

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/feature/JumpBoostFeature.kt

@@ -1,4 +1,4 @@
-package ru.dbotthepony.mc.otm.android.feature
+package ru.dbotthepony.mc.otm.player.android.feature
 
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.sounds.SoundSource
@@ -6,12 +6,12 @@ import net.neoforged.neoforge.network.PacketDistributor
 import ru.dbotthepony.kommons.math.RGBAColor
 import ru.dbotthepony.kommons.util.getValue
 import ru.dbotthepony.kommons.util.setValue
-import ru.dbotthepony.mc.otm.android.AndroidSwitchableFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidSwitchableFeature
 import ru.dbotthepony.mc.otm.player.MatteryPlayer
 import ru.dbotthepony.mc.otm.capability.energy.extractEnergyExact
 import ru.dbotthepony.mc.otm.client.render.MGUIGraphics
 import ru.dbotthepony.mc.otm.client.render.ResearchIcons
-import ru.dbotthepony.mc.otm.config.AndroidConfig
+import ru.dbotthepony.mc.otm.config.PlayerConfig
 import ru.dbotthepony.mc.otm.config.ClientConfig
 import ru.dbotthepony.mc.otm.core.math.Vector
 import ru.dbotthepony.mc.otm.core.math.plus
@@ -24,7 +24,7 @@ class JumpBoostFeature(capability: MatteryPlayer) : AndroidSwitchableFeature(And
 	private var tickCooldownClient = false
 
 	override val maxCooldown: Int
-		get() = (AndroidConfig.JumpBoost.BASE_COOLDOWN - AndroidConfig.JumpBoost.COOLDOWN_REDUCTION * level).coerceAtLeast(0)
+		get() = (PlayerConfig.JumpBoost.BASE_COOLDOWN - PlayerConfig.JumpBoost.COOLDOWN_REDUCTION * level).coerceAtLeast(0)
 
 	override var cooldown by syncher.int(setter = setter@{ access, value ->
 		access.accept(value)
@@ -46,8 +46,8 @@ class JumpBoostFeature(capability: MatteryPlayer) : AndroidSwitchableFeature(And
 		val old = lastGround
 		lastGround = ply.onGround()
 
-		if (isActive && cooldown <= 0 && old != lastGround && !lastGround && isJumping && isShifting && ply.xRot <= ClientConfig.JUMP_BOOST_LOOK_ANGLE && android.androidEnergy.extractEnergyExact(AndroidConfig.JumpBoost.ENERGY_COST, true)) {
+		if (isActive && cooldown <= 0 && old != lastGround && !lastGround && isJumping && isShifting && ply.xRot <= ClientConfig.JUMP_BOOST_LOOK_ANGLE && android.androidEnergy.extractEnergyExact(PlayerConfig.JumpBoost.ENERGY_COST, true)) {
-			ply.deltaMovement += Vector(0.0, AndroidConfig.JumpBoost.POWER * (level + 1) / 20.0, 0.0)
+			ply.deltaMovement += Vector(0.0, PlayerConfig.JumpBoost.POWER * (level + 1) / 20.0, 0.0)
 			putOnCooldown()
 			PacketDistributor.sendToServer(TriggerJumpBoostPacket)
 

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/feature/LimbOverclockingFeature.kt

@@ -1,11 +1,11 @@
-package ru.dbotthepony.mc.otm.android.feature
+package ru.dbotthepony.mc.otm.player.android.feature
 
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.attributes.AttributeModifier
 import net.minecraft.world.entity.ai.attributes.Attributes
 import net.minecraft.world.entity.player.Player
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
-import ru.dbotthepony.mc.otm.android.AndroidFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidFeature
 import ru.dbotthepony.mc.otm.player.MatteryPlayer
 import ru.dbotthepony.mc.otm.player.matteryPlayer
 import ru.dbotthepony.mc.otm.core.ResourceLocation
@@ -17,7 +17,7 @@ class LimbOverclockingFeature(android: MatteryPlayer) : AndroidFeature(AndroidFe
 
 		if (speed != null) {
 			speed.removeModifier(MODIFIER_ID)
-			speed.addPermanentModifier(AttributeModifier(MODIFIER_ID,(level + 1) * 0.08, AttributeModifier.Operation.ADD_MULTIPLIED_TOTAL))
+			speed.addPermanentModifier(AttributeModifier(MODIFIER_ID, (level + 1) * 0.08, AttributeModifier.Operation.ADD_MULTIPLIED_TOTAL))
 		}
 
 		val attackSpeed = ply.getAttribute(Attributes.ATTACK_SPEED)

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/feature/NanobotsArmorFeature.kt

@@ -1,4 +1,4 @@
-package ru.dbotthepony.mc.otm.android.feature
+package ru.dbotthepony.mc.otm.player.android.feature
 
 import net.minecraft.core.HolderLookup
 import net.minecraft.nbt.CompoundTag
@@ -7,7 +7,7 @@ import net.minecraft.tags.DamageTypeTags
 import net.neoforged.neoforge.event.entity.living.LivingIncomingDamageEvent
 import ru.dbotthepony.kommons.util.getValue
 import ru.dbotthepony.kommons.util.setValue
-import ru.dbotthepony.mc.otm.android.AndroidFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidFeature
 import ru.dbotthepony.mc.otm.player.MatteryPlayer
 import ru.dbotthepony.mc.otm.capability.energy.extractEnergyExact
 import ru.dbotthepony.mc.otm.core.isBypassArmor

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/feature/NanobotsRegenerationFeature.kt

@@ -1,12 +1,12 @@
-package ru.dbotthepony.mc.otm.android.feature
+package ru.dbotthepony.mc.otm.player.android.feature
 
 import net.minecraft.core.HolderLookup
 import net.minecraft.nbt.CompoundTag
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.level.GameRules
 import net.neoforged.neoforge.event.entity.living.LivingIncomingDamageEvent
-import ru.dbotthepony.mc.otm.config.AndroidConfig
+import ru.dbotthepony.mc.otm.config.PlayerConfig
-import ru.dbotthepony.mc.otm.android.AndroidFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidFeature
 import ru.dbotthepony.mc.otm.player.MatteryPlayer
 import ru.dbotthepony.mc.otm.registry.game.AndroidFeatures
 import ru.dbotthepony.mc.otm.registry.StatNames
@@ -21,16 +21,16 @@ class NanobotsRegenerationFeature(android: MatteryPlayer) : AndroidFeature(Andro
 		if (ply.isHurt && ply.level().gameRules.getBoolean(GameRules.RULE_NATURAL_REGENERATION)) {
 			ticksPassed++
 
-			val waitTime = AndroidConfig.NanobotsRegeneration.COOLDOWN.getOrElse(healTicks) { AndroidConfig.NanobotsRegeneration.COOLDOWN.last() }
+			val waitTime = PlayerConfig.NanobotsRegeneration.COOLDOWN.getOrElse(healTicks) { PlayerConfig.NanobotsRegeneration.COOLDOWN.last() }
 
 			if (ticksPassed > waitTime) {
 				val missingHealth = (ply.maxHealth - ply.health).coerceAtMost(2f)
-				val power = AndroidConfig.NanobotsRegeneration.ENERGY_PER_HITPOINT * missingHealth
+				val power = PlayerConfig.NanobotsRegeneration.ENERGY_PER_HITPOINT * missingHealth
 				val extracted = android.androidEnergy.extractEnergy(power, false)
 
 				if (extracted.isPositive) {
 					healTicks = (healTicks + 1).coerceAtMost(level)
-					val healed = (extracted / AndroidConfig.NanobotsRegeneration.ENERGY_PER_HITPOINT).toFloat()
+					val healed = (extracted / PlayerConfig.NanobotsRegeneration.ENERGY_PER_HITPOINT).toFloat()
 					ply.heal(healed)
 					(ply as ServerPlayer?)?.awardStat(StatNames.HEALTH_REGENERATED, (healed * 10f).roundToInt())
 					ticksPassed = 0

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/feature/NightVisionFeature.kt

@@ -1,14 +1,14 @@
-package ru.dbotthepony.mc.otm.android.feature
+package ru.dbotthepony.mc.otm.player.android.feature
 
 import net.minecraft.world.effect.MobEffectInstance
 import net.minecraft.world.effect.MobEffects
 import ru.dbotthepony.kommons.math.RGBAColor
-import ru.dbotthepony.mc.otm.android.AndroidSwitchableFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidSwitchableFeature
 import ru.dbotthepony.mc.otm.player.MatteryPlayer
 import ru.dbotthepony.mc.otm.capability.energy.extractEnergyExact
 import ru.dbotthepony.mc.otm.client.render.MGUIGraphics
 import ru.dbotthepony.mc.otm.client.render.ResearchIcons
-import ru.dbotthepony.mc.otm.config.AndroidConfig
+import ru.dbotthepony.mc.otm.config.PlayerConfig
 import ru.dbotthepony.mc.otm.registry.game.AndroidFeatures
 
 class NightVisionFeature(android: MatteryPlayer) : AndroidSwitchableFeature(AndroidFeatures.NIGHT_VISION, android) {
@@ -19,7 +19,7 @@ class NightVisionFeature(android: MatteryPlayer) : AndroidSwitchableFeature(Andr
 		if (isActive) {
 			val effect = android.ply.activeEffectsMap[MobEffects.NIGHT_VISION]
 
-			if ((effect == null || effect.duration < 220) && (ply.isSpectator || android.androidEnergy.extractEnergyExact(AndroidConfig.NIGHT_VISION_POWER_DRAW, false))) {
+			if ((effect == null || effect.duration < 220) && (ply.isSpectator || android.androidEnergy.extractEnergyExact(PlayerConfig.NIGHT_VISION_POWER_DRAW, false))) {
 				android.ply.addEffect(MobEffectInstance(MobEffects.NIGHT_VISION, 220, 0, false, false))
 			}
 		}

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/feature/ShockwaveFeature.kt

@@ -1,4 +1,4 @@
-package ru.dbotthepony.mc.otm.android.feature
+package ru.dbotthepony.mc.otm.player.android.feature
 
 import it.unimi.dsi.fastutil.objects.ReferenceArraySet
 import net.minecraft.server.level.ServerPlayer
@@ -7,12 +7,12 @@ import net.minecraft.world.entity.Entity
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.monster.warden.Warden
 import net.neoforged.neoforge.network.PacketDistributor
-import ru.dbotthepony.mc.otm.android.AndroidSwitchableFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidSwitchableFeature
 import ru.dbotthepony.mc.otm.player.MatteryPlayer
 import ru.dbotthepony.mc.otm.capability.energy.extractEnergyExact
 import ru.dbotthepony.mc.otm.client.render.MGUIGraphics
 import ru.dbotthepony.mc.otm.client.render.ResearchIcons
-import ru.dbotthepony.mc.otm.config.AndroidConfig
+import ru.dbotthepony.mc.otm.config.PlayerConfig
 import ru.dbotthepony.mc.otm.core.damageType
 import ru.dbotthepony.mc.otm.core.getEntitiesInEllipsoid
 import ru.dbotthepony.mc.otm.core.getExplosionResistance
@@ -37,7 +37,7 @@ import kotlin.math.roundToInt
 
 class ShockwaveFeature(capability: MatteryPlayer) : AndroidSwitchableFeature(AndroidFeatures.SHOCKWAVE, capability) {
 	override val maxCooldown: Int
-		get() = AndroidConfig.Shockwave.COOLDOWN
+		get() = PlayerConfig.Shockwave.COOLDOWN
 
 	private var wasMidair = false
 	private var highestSpeed = 0.0
@@ -52,18 +52,18 @@ class ShockwaveFeature(capability: MatteryPlayer) : AndroidSwitchableFeature(And
 			isActive &&
 			ply.isShiftKeyDown &&
 			!isOnCooldown &&
-			android.androidEnergy.extractEnergyExact(AndroidConfig.Shockwave.ENERGY_COST, true) &&
+			android.androidEnergy.extractEnergyExact(PlayerConfig.Shockwave.ENERGY_COST, true) &&
 			ply.deltaMovement.y < -0.01 &&
 			creativeFlightTicks == 0
 		) {
-			ply.deltaMovement += Vector(0.0, -AndroidConfig.Shockwave.ACCELERATION / 20.0, 0.0)
+			ply.deltaMovement += Vector(0.0, -PlayerConfig.Shockwave.ACCELERATION / 20.0, 0.0)
 		}
 
 		ticker(true)
 	}
 
 	fun shockwave() {
-		if (ply.isSpectator || isOnCooldown || !android.androidEnergy.extractEnergyExact(AndroidConfig.Shockwave.ENERGY_COST, false)) {
+		if (ply.isSpectator || isOnCooldown || !android.androidEnergy.extractEnergyExact(PlayerConfig.Shockwave.ENERGY_COST, false)) {
 			return
 		}
 
@@ -86,14 +86,14 @@ class ShockwaveFeature(capability: MatteryPlayer) : AndroidSwitchableFeature(And
 		// TODO: raycasting
 		val entities = ply.level().getEntitiesInEllipsoid(
 			ply.position,
-			Vector(AndroidConfig.Shockwave.RADIUS_HORIZONTAL, AndroidConfig.Shockwave.RADIUS_VERTICAL, AndroidConfig.Shockwave.RADIUS_HORIZONTAL),
+			Vector(PlayerConfig.Shockwave.RADIUS_HORIZONTAL, PlayerConfig.Shockwave.RADIUS_VERTICAL, PlayerConfig.Shockwave.RADIUS_HORIZONTAL),
 			except = ply,
 		) { (it !is LivingEntity || !it.isSpectator && it.isAlive) }
 
 		val wardens = ply.level().getEntitiesInEllipsoid(
 			Warden::class.java,
 			ply.position,
-			Vector(AndroidConfig.Shockwave.RADIUS_HORIZONTAL_WARDEN, AndroidConfig.Shockwave.RADIUS_VERTICAL_WARDEN, AndroidConfig.Shockwave.RADIUS_HORIZONTAL_WARDEN),
+			Vector(PlayerConfig.Shockwave.RADIUS_HORIZONTAL_WARDEN, PlayerConfig.Shockwave.RADIUS_VERTICAL_WARDEN, PlayerConfig.Shockwave.RADIUS_HORIZONTAL_WARDEN),
 		) { true }
 
 		val seen = ReferenceArraySet<Entity>()
@@ -103,7 +103,7 @@ class ShockwaveFeature(capability: MatteryPlayer) : AndroidSwitchableFeature(And
 			val multiplier = (1.0 - distanceMultiplier).pow(0.5)
 
 			val source = MatteryDamageSource(ply.level().registryAccess().damageType(MDamageTypes.SHOCKWAVE), ply)
-			val damage = multiplier.toFloat() * AndroidConfig.Shockwave.DAMAGE.toFloat() * AndroidConfig.Shockwave.WARDEN_DAMAGE_MULT.toFloat()
+			val damage = multiplier.toFloat() * PlayerConfig.Shockwave.DAMAGE.toFloat() * PlayerConfig.Shockwave.WARDEN_DAMAGE_MULT.toFloat()
 			entity.hurt(source, damage)
 			entity.deltaMovement += (entity.position - ply.position).normalize() * (multiplier * 3.0)
 
@@ -119,7 +119,7 @@ class ShockwaveFeature(capability: MatteryPlayer) : AndroidSwitchableFeature(And
 				// don't hurt items, arrows, etc etc
 				if (entity is LivingEntity) {
 					val source = MatteryDamageSource(ply.level().registryAccess().damageType(MDamageTypes.SHOCKWAVE), ply)
-					val damage = multiplier.toFloat() * AndroidConfig.Shockwave.DAMAGE.toFloat()
+					val damage = multiplier.toFloat() * PlayerConfig.Shockwave.DAMAGE.toFloat()
 					entity.hurt(source, damage)
 					entity.deltaMovement += (entity.position - ply.position).normalize() * (multiplier * 3.0)
 
@@ -132,10 +132,10 @@ class ShockwaveFeature(capability: MatteryPlayer) : AndroidSwitchableFeature(And
 			}
 		}
 
-		if (AndroidConfig.Shockwave.BREAK_BLOCKS) {
+		if (PlayerConfig.Shockwave.BREAK_BLOCKS) {
 			val rounded = ply.position.roundToIntVector()
 
-			for (blockPos in getEllipsoidBlockPositions(AndroidConfig.Shockwave.RADIUS_HORIZONTAL.roundToInt(), AndroidConfig.Shockwave.RADIUS_VERTICAL.roundToInt(), AndroidConfig.Shockwave.RADIUS_HORIZONTAL.roundToInt())) {
+			for (blockPos in getEllipsoidBlockPositions(PlayerConfig.Shockwave.RADIUS_HORIZONTAL.roundToInt(), PlayerConfig.Shockwave.RADIUS_VERTICAL.roundToInt(), PlayerConfig.Shockwave.RADIUS_HORIZONTAL.roundToInt())) {
 				val newBlockPos = blockPos + rounded
 
 				val blockState = ply.level().getBlockState(newBlockPos)
@@ -168,7 +168,7 @@ class ShockwaveFeature(capability: MatteryPlayer) : AndroidSwitchableFeature(And
 			!ply.isSpectator &&
 			isActive &&
 			!isOnCooldown &&
-			android.androidEnergy.extractEnergyExact(AndroidConfig.Shockwave.ENERGY_COST, true) &&
+			android.androidEnergy.extractEnergyExact(PlayerConfig.Shockwave.ENERGY_COST, true) &&
 			creativeFlightTicks == 0
 		) {
 			val old = wasMidair
@@ -178,7 +178,7 @@ class ShockwaveFeature(capability: MatteryPlayer) : AndroidSwitchableFeature(And
 				highestSpeed = (-ply.deltaMovement.y).coerceAtLeast(highestSpeed)
 			}
 
-			if (old != wasMidair && !wasMidair && AndroidConfig.Shockwave.TERMINAL_VELOCITY <= (highestSpeed * 20.0) && ply.isShiftKeyDown) {
+			if (old != wasMidair && !wasMidair && PlayerConfig.Shockwave.TERMINAL_VELOCITY <= (highestSpeed * 20.0) && ply.isShiftKeyDown) {
 				if (isClient) {
 					// I HATE SELF-UPDATING PLAYERS
 					// I HATE SELF-UPDATING PLAYERS

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/feature/StepAssistFeature.kt

@@ -1,8 +1,8 @@
-package ru.dbotthepony.mc.otm.android.feature
+package ru.dbotthepony.mc.otm.player.android.feature
 
 import net.minecraft.world.entity.ai.attributes.AttributeModifier
 import net.minecraft.world.entity.ai.attributes.Attributes
-import ru.dbotthepony.mc.otm.android.AndroidSwitchableFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidSwitchableFeature
 import ru.dbotthepony.mc.otm.player.MatteryPlayer
 import ru.dbotthepony.mc.otm.client.render.MGUIGraphics
 import ru.dbotthepony.mc.otm.client.render.ResearchIcons

src/main/kotlin/ru/dbotthepony/mc/otm/player/android/feature/SwimBoostersFeature.kt

@@ -1,12 +1,12 @@
-package ru.dbotthepony.mc.otm.android.feature
+package ru.dbotthepony.mc.otm.player.android.feature
 
 import net.minecraft.world.entity.ai.attributes.AttributeModifier
 import net.neoforged.neoforge.common.NeoForgeMod
-import ru.dbotthepony.mc.otm.android.AndroidSwitchableFeature
+import ru.dbotthepony.mc.otm.player.android.AndroidSwitchableFeature
 import ru.dbotthepony.mc.otm.player.MatteryPlayer
 import ru.dbotthepony.mc.otm.client.render.MGUIGraphics
 import ru.dbotthepony.mc.otm.client.render.ResearchIcons
-import ru.dbotthepony.mc.otm.config.AndroidConfig
+import ru.dbotthepony.mc.otm.config.PlayerConfig
 import ru.dbotthepony.kommons.math.RGBAColor
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
 import ru.dbotthepony.mc.otm.core.ResourceLocation
@@ -20,7 +20,7 @@ class SwimBoostersFeature(android: MatteryPlayer) : AndroidSwitchableFeature(And
 		val attr = ply.getAttribute(NeoForgeMod.SWIM_SPEED) ?: return
 
 		attr.removeModifier(MODIFIER_ID)
-		attr.addPermanentModifier(AttributeModifier(MODIFIER_ID, (level + 1) * AndroidConfig.SWIM_BOOSTERS, AttributeModifier.Operation.ADD_VALUE))
+		attr.addPermanentModifier(AttributeModifier(MODIFIER_ID, (level + 1) * PlayerConfig.SWIM_BOOSTERS, AttributeModifier.Operation.ADD_VALUE))
 	}
 
 	override fun removeModifiers() {

src/main/kotlin/ru/dbotthepony/mc/otm/registry/MRegistry.kt

@@ -29,9 +29,9 @@ import net.neoforged.neoforge.event.ModifyDefaultComponentsEvent
 import net.neoforged.neoforge.registries.RegisterEvent
 import ru.dbotthepony.kommons.math.RGBAColor
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
-import ru.dbotthepony.mc.otm.android.AndroidFeatureType
+import ru.dbotthepony.mc.otm.player.android.AndroidFeatureType
-import ru.dbotthepony.mc.otm.android.feature.EnderTeleporterFeature
+import ru.dbotthepony.mc.otm.player.android.feature.EnderTeleporterFeature
-import ru.dbotthepony.mc.otm.android.feature.NanobotsArmorFeature
+import ru.dbotthepony.mc.otm.player.android.feature.NanobotsArmorFeature
 import ru.dbotthepony.mc.otm.block.decorative.CargoCrateBlock
 import ru.dbotthepony.mc.otm.block.decorative.ComputerTerminalBlock
 import ru.dbotthepony.mc.otm.block.decorative.StarChairBlock

src/main/kotlin/ru/dbotthepony/mc/otm/registry/game/AndroidFeatures.kt

@@ -1,9 +1,21 @@
 package ru.dbotthepony.mc.otm.registry.game
 
 import net.neoforged.bus.api.IEventBus
-import ru.dbotthepony.mc.otm.android.AndroidFeatureType
+import ru.dbotthepony.mc.otm.player.android.AndroidFeatureType
-import ru.dbotthepony.mc.otm.android.DummyAndroidFeature
+import ru.dbotthepony.mc.otm.player.android.DummyAndroidFeature
-import ru.dbotthepony.mc.otm.android.feature.*
+import ru.dbotthepony.mc.otm.player.android.feature.AttackBoostFeature
+import ru.dbotthepony.mc.otm.player.android.feature.EnderTeleporterFeature
+import ru.dbotthepony.mc.otm.player.android.feature.ExtendedReachFeature
+import ru.dbotthepony.mc.otm.player.android.feature.FallDampenersFeature
+import ru.dbotthepony.mc.otm.player.android.feature.ItemMagnetFeature
+import ru.dbotthepony.mc.otm.player.android.feature.JumpBoostFeature
+import ru.dbotthepony.mc.otm.player.android.feature.LimbOverclockingFeature
+import ru.dbotthepony.mc.otm.player.android.feature.NanobotsArmorFeature
+import ru.dbotthepony.mc.otm.player.android.feature.NanobotsRegenerationFeature
+import ru.dbotthepony.mc.otm.player.android.feature.NightVisionFeature
+import ru.dbotthepony.mc.otm.player.android.feature.ShockwaveFeature
+import ru.dbotthepony.mc.otm.player.android.feature.StepAssistFeature
+import ru.dbotthepony.mc.otm.player.android.feature.SwimBoostersFeature
 import ru.dbotthepony.mc.otm.registry.MDeferredRegister
 import ru.dbotthepony.mc.otm.registry.MNames
 import ru.dbotthepony.mc.otm.registry.MRegistry

src/main/kotlin/ru/dbotthepony/mc/otm/server/command/AndroidCommand.kt

@@ -4,8 +4,8 @@ import net.minecraft.commands.Commands
 import net.minecraft.commands.arguments.EntityArgument
 import net.minecraft.world.entity.player.Player
 import net.neoforged.neoforge.event.RegisterCommandsEvent
-import ru.dbotthepony.mc.otm.android.AndroidResearchManager
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchManager
-import ru.dbotthepony.mc.otm.android.AndroidResearchType
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchType
 import ru.dbotthepony.mc.otm.player.matteryPlayer
 
 object AndroidCommand {

src/main/kotlin/ru/dbotthepony/mc/otm/server/command/AndroidResearchArgument.kt

@@ -8,8 +8,8 @@ import com.mojang.brigadier.suggestion.SuggestionsBuilder
 import net.minecraft.commands.CommandSourceStack
 import net.minecraft.commands.SharedSuggestionProvider
 import net.minecraft.resources.ResourceLocation
-import ru.dbotthepony.mc.otm.android.AndroidResearchManager
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchManager
-import ru.dbotthepony.mc.otm.android.AndroidResearchType
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchType
 import java.util.concurrent.CompletableFuture
 
 class AndroidResearchArgument : ArgumentType<AndroidResearchType> {

src/main/kotlin/ru/dbotthepony/mc/otm/triggers/AndroidResearchTrigger.kt

@@ -6,7 +6,7 @@ import net.minecraft.advancements.critereon.ContextAwarePredicate
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
-import ru.dbotthepony.mc.otm.android.AndroidResearchType
+import ru.dbotthepony.mc.otm.player.android.AndroidResearchType
 import ru.dbotthepony.mc.otm.core.ResourceLocation
 import java.util.*
 import java.util.function.Predicate

src/main/resources/META-INF/accesstransformer.cfg

@@ -176,3 +176,9 @@ public net.minecraft.advancements.critereon.InventoryChangeTrigger$TriggerInstan
 #public-f net.minecraft.advancements.critereon.SimpleCriterionTrigger removePlayerListeners(Lnet/minecraft/server/PlayerAdvancements;)V
 
 public net.minecraft.world.entity.npc.VillagerTrades$TreasureMapForEmeralds
+
+protected net.minecraft.world.food.FoodData foodLevel
+protected net.minecraft.world.food.FoodData saturationLevel
+protected net.minecraft.world.food.FoodData exhaustionLevel
+protected net.minecraft.world.food.FoodData tickTimer
+protected net.minecraft.world.food.FoodData lastFoodLevel

src/main/resources/coremods/code_injector.js

@@ -576,7 +576,7 @@ function backtrack(instructions, from, opcode, skipAmount) {
 
 function initializeCoreMod() {
 	return {
-		'LivingEntity#addEatEffect patch for androids': method('net.minecraft.world.entity.LivingEntity.m_21063_(Lnet/minecraft/world/item/ItemStack;Lnet/minecraft/world/level/Level;Lnet/minecraft/world/entity/LivingEntity;)V', function(node) {
+		'LivingEntity#addEatEffect patch for androids': method('net.minecraft.world.entity.LivingEntity.addEatEffect(Lnet/minecraft/world/food/FoodProperties;)V', function(node) {
 			for (var i = 0; i < node.instructions.size(); i++) {
 				var instr = node.instructions.get(i)
 
@@ -585,7 +585,7 @@ function initializeCoreMod() {
 						new VarInsnNode(opcodesRemapped.aload, 0),
 						new MethodInsnNode(
 							opcodesRemapped.invokestatic,
-							'ru/dbotthepony/mc/otm/capability/MatteryPlayerCapability',
+							'ru/dbotthepony/mc/otm/player/MatteryPlayer',
 							'addEatEffectHook',
 							'(Ljava/util/Iterator;Lnet/minecraft/world/entity/LivingEntity;)Ljava/util/Iterator;'
 						),

src/main/resources/overdrive_that_matters.mixins.json

@@ -7,7 +7,6 @@
   "refmap": "overdrive_that_matters.refmap.json",
   "mixins": [
     "BlockEntityMixin",
-    "FoodDataMixin",
     "MixinLivingEntity",
     "MixinAnvilBlock",
     "MixinInventory",