6.2.0

6.2.0

well it runs..

porting..

moved db errors to lib

spawned mobs > mob lists

moving classes

map finish rar refactor

Author: RobertSkalko

CHANGELOG.txt

@@ -1,6 +1,32 @@
-Changelog of recent updates: https://github.com/RobertSkalko/Mine-And-Slash-Rework/blob/1.20-Forge/changelogs/v.6.1.txt
+Changelog of recent updates: https://github.com/RobertSkalko/Mine-And-Slash-Rework/blob/1.20-Forge/changelogs/v.6.2.txt
 
-v.6.1.15
+v.6.2.0
 
-- fixed a crafting output exploit
-- any curio should now work and apply stats
+- orbs of crafting was moved to library of exile mod so it's not needed anymore
+- the harvest now a separate required dependency (I tried to make it an optional dependency but was a bit too difficult, I might try to jarjar it again later)
+- adventure maps are now a separate required dependency called: dungeon realm
+- old dimension will stay as an empty dimension so future saves aren't borked by its removal
+- return to old map item system meaning: maps drop again, no more upgrading, but i made map boss always drop 1 map
+- uber maps changed slightly, now maps can become uber maps with an orb item, crafted with 4 uber frags, but the map must be mythic for the orb to be used
+- map mobs now drop vanilla loot again, this was removed due to item clutter, but will clash with the dungeon mod features now possibly
+- builder note: map boss arenas now need the 'map_teleporter' block
+- builder note2: harvest maps now use harvest_spawner blocks placed around the map instead of the league processor;32 something block
+- the map dimension no longer puts you in adventure mode, now uses events to make sure you can't place/break etc, report any bugs please!
+- new feature, command blocks should no longer show in maps
+- other dimension mod addons for dungeon realm now connect the maps, um. That means if you enter a harvest/obelisk etc through a map, it counts as your map too
+- changed dungeon datapack json, now require all types of rooms and no more fallback rooms
+- changed rarity json, map finish rarity is now a separate datapack under library mod
+- removed spawned mobs, now use mob lists from library mod
+- datapack checker now works for any of library's datapacks, not just mns
+- ailment procs now show damage chat messages when applied
+- buffed gathering profession dropchances at early levels by reducing the effect of exp to loot multiplier by half
+Now all gathers count as if they have an extra 50 experience. So if say you're mining a block that gives 10 exp, you'd before have 0.1x loot multi,
+now you'd have 0.6x loot multi. For a block that gives 200 exp, loot multi was 2x before, now it's 2.5x
+- as maps are now drops again, added a currency that allows you to upgrade map rarity
+- removed map lives system, possibly temporary
+
+New Feature: Relics!
+- the map device can now be equipped with relics
+- relics boost your maps with stats like mob pack size, chance to contain additional harvest etc
+- relics currently drop once per map boss and 3 per uber boss
+Enjoy customizing your maps and playing content you like or want to focus on!

build.gradle

@@ -28,11 +28,13 @@ apply plugin: 'org.spongepowered.mixin'
 
 apply from: 'https://raw.githubusercontent.com/RobertSkalko/ModResources/refs/heads/main/1.20.1/common.gradle'
 apply from: 'https://raw.githubusercontent.com/RobertSkalko/ModResources/refs/heads/main/1.20.1/exile_lib_dep.gradle'
-apply from: 'https://raw.githubusercontent.com/RobertSkalko/ModResources/refs/heads/main/1.20.1/orbs_dep.gradle'
 apply from: 'https://raw.githubusercontent.com/RobertSkalko/ModResources/refs/heads/main/1.20.1/ide_runs.gradle'
 apply from: 'https://raw.githubusercontent.com/RobertSkalko/ModResources/refs/heads/main/1.20.1/meta.gradle'
 apply from: 'https://raw.githubusercontent.com/RobertSkalko/ModResources/refs/heads/main/1.20.1/publishing.gradle'
 apply from: 'https://raw.githubusercontent.com/RobertSkalko/ModResources/refs/heads/main/1.20.1/mixin.gradle'
+apply from: 'https://raw.githubusercontent.com/RobertSkalko/ModResources/refs/heads/main/1.20.1/dungeon_dep.gradle'
+apply from: 'https://raw.githubusercontent.com/RobertSkalko/ModResources/refs/heads/main/1.20.1/mns_other_deps.gradle'
+
 
 // --- COMMON BUILD SCRIPT END ---
 
@@ -75,13 +77,15 @@ publishMods {
         requires { slug = "library-of-exile" }
         requires { slug = "curios" }
         requires { slug = "playeranimator" }
-        requires { slug = "orbs-of-crafting" }
+        requires { slug = "dungeon-realm" }
+        requires { slug = "the-harvest" }
     }
     modrinth {
         requires { slug = "library-of-exile" }
         requires { slug = "curios" }
         requires { slug = "playeranimator" }
-        requires { slug = "orbs-of-crafting" }
+        requires { slug = "dungeon-realm" }
+        requires { slug = "the-harvest" }
     }
 }
 

gradle.properties

@@ -2,7 +2,7 @@
 org.gradle.jvmargs=-Xmx2G
 # --- COMMON GRADLE START ---
 # Mod Properties
-mod_version=6.1.15
+mod_version=6.2.0
 # Minecraft Versions
 minecraft_version=1.20.1
 forgeversion=47.1.43
@@ -20,13 +20,14 @@ modrinth_id=oifKCkhG
 release_type=release
 maven_group=com.robertx22
 # Dependencies
-exile_library_version=1.6.9
+exile_library_version=2.0.1
 curios_version=5.2.0-beta.3+1.20.1
 jei_version=15.2.0.27
 wiki_toolkit_version=0.2.4
 publish_plugin_version=0.8.3
 # --- COMMON GRADLE END ---
 # -- Mod Specific --
 player_animator_version=1.0.2-rc1+1.20
-orbs_of_crafting_version=1.0.2
-
+orbs_of_crafting_version=1.0.3
+dungeon_realm_version=1.0.0
+the_harvest_version=1.0.0

src/main/java/com/robertx22/addons/dungeon_realm/DungeonAddonEvents.java

@@ -0,0 +1,190 @@
+package com.robertx22.addons.dungeon_realm;
+
+import com.robertx22.dungeon_realm.api.*;
+import com.robertx22.dungeon_realm.database.holders.DungeonMapBlocks;
+import com.robertx22.dungeon_realm.main.DungeonMain;
+import com.robertx22.library_of_exile.events.base.EventConsumer;
+import com.robertx22.mine_and_slash.capability.world.WorldData;
+import com.robertx22.mine_and_slash.config.forge.ServerContainer;
+import com.robertx22.mine_and_slash.database.registry.ExileDB;
+import com.robertx22.mine_and_slash.loot.LootInfo;
+import com.robertx22.mine_and_slash.loot.blueprints.MapBlueprint;
+import com.robertx22.mine_and_slash.maps.MapData;
+import com.robertx22.mine_and_slash.maps.MapItemData;
+import com.robertx22.mine_and_slash.uncommon.ExplainedResultUtil;
+import com.robertx22.mine_and_slash.uncommon.datasaving.Load;
+import com.robertx22.mine_and_slash.uncommon.datasaving.StackSaving;
+import com.robertx22.mine_and_slash.uncommon.interfaces.data_items.IRarity;
+import com.robertx22.mine_and_slash.uncommon.localization.Chats;
+import com.robertx22.mine_and_slash.uncommon.localization.Words;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+
+import java.util.List;
+
+public class DungeonAddonEvents {
+
+    public static void init() {
+
+        DungeonExileEvents.ON_GENERATE_NEW_MAP_ITEM.register(new EventConsumer<OnGenerateNewMapItemEvent>() {
+            @Override
+            public void accept(OnGenerateNewMapItemEvent event) {
+                MapBlueprint b = new MapBlueprint(LootInfo.ofLevel(1));
+                StackSaving.MAP.saveTo(event.mapStack, b.createData());
+            }
+        });
+
+        DungeonExileEvents.ON_START_NEW_MAP.register(new EventConsumer<OnStartMapEvent>() {
+            @Override
+            public void accept(OnStartMapEvent event) {
+
+                if (event.mapInfo.dimensionId.equals(DungeonMain.DIMENSION_KEY)) {
+
+                    var map = StackSaving.MAP.loadFrom(event.stack);
+
+                    if (map != null) {
+
+                        map.lvl = Load.Unit(event.p).getLevel();
+
+                        var mapdata = MapData.newMap(event.p, map);
+
+                        WorldData.get(event.p.level()).map.setData(event.p, mapdata, event.mapInfo.structure, event.startChunkPos.getMiddleBlockPosition(5));
+
+                        Load.Unit(event.p).getCooldowns().setOnCooldown("start_map", 20 * 60 * 2);
+                    }
+                }
+            }
+        });
+
+        DungeonExileEvents.ON_SPAWN_UBER_BOSS.register(new EventConsumer<SpawnUberEvent>() {
+            @Override
+            public void accept(SpawnUberEvent event) {
+                LivingEntity en = event.uberBoss;
+                Load.Unit(en).setRarity(IRarity.UBER);
+                Load.Unit(en).recalcStats_DONT_CALL();
+            }
+        });
+
+        DungeonExileEvents.PREPARE_DUNGEON_MOB_SPAWN.register(new EventConsumer<PrepareDungeonMobEditsEvent>() {
+            @Override
+            public void accept(PrepareDungeonMobEditsEvent event) {
+                event.dataBlock.ifPresent(x -> {
+
+                    if (DungeonMapBlocks.INSTANCE.ELITE_MOB.GUID().equals(x.GUID()) || DungeonMapBlocks.INSTANCE.ELITE_MOB_HORDE.GUID().equals(x.GUID())) {
+                        var rar = ExileDB.MobRarities().getFilterWrapped(e -> e.is_elite).random();
+                        event.edits.add(DungeonAddonUtil.createMobRarityEdit(rar));
+                    }
+                    if (DungeonMapBlocks.INSTANCE.MAP_BOSS.GUID().equals(x.GUID())) {
+                        var rar = ExileDB.MobRarities().get(IRarity.BOSS);
+                        event.edits.add(DungeonAddonUtil.createMobRarityEdit(rar));
+                    }
+                    if (DungeonMapBlocks.INSTANCE.BOSS.GUID().equals(x.GUID())) {
+                        var rar = ExileDB.MobRarities().get(IRarity.MYTHIC_ID);
+                        event.edits.add(DungeonAddonUtil.createMobRarityEdit(rar));
+                    }
+
+                });
+            }
+        });
+
+        DungeonExileEvents.CAN_START_MAP.register(new EventConsumer<CanStartMapEvent>() {
+            @Override
+            public void accept(CanStartMapEvent event) {
+
+                Player p = event.p;
+
+                if (Load.Unit(p).getLevel() < ServerContainer.get().MIN_LEVEL_MAP_DROPS.get()) {
+                    p.sendSystemMessage(ExplainedResultUtil.createErrorAndReason(Chats.MAP_DEVICE_USE_ERROR.locName(), Chats.TOO_LOW_LEVEL.locName(ServerContainer.get().MIN_LEVEL_MAP_DROPS.get())));
+                    event.canEnter = false;
+                    return;
+                }
+                MapItemData data = StackSaving.MAP.loadFrom(event.stack);
+
+                if (data == null) {
+                    p.sendSystemMessage(ExplainedResultUtil.createErrorAndReason(Chats.MAP_DEVICE_USE_ERROR, Chats.INVALID_MAP_ITEM));
+                    event.canEnter = false;
+                    return;
+                }
+                if (!checkCooldown(p)) {
+                    event.canEnter = false;
+                    return;
+                }
+                if (!meetsResists(p, data)) {
+                    event.canEnter = false;
+                    return;
+                }
+
+            }
+        });
+        DungeonExileEvents.CAN_ENTER_MAP.register(new EventConsumer<CanEnterMapEvent>() {
+            @Override
+            public void accept(CanEnterMapEvent event) {
+
+                try {
+                    // we use this getter here because we don't want to check dimension ids now
+                    var map = WorldData.get(event.p.level()).map.getData(DungeonMain.MAIN_DUNGEON_STRUCTURE, event.mapDevice.pos);
+
+                    if (map == null) {
+                        event.canEnter = false;
+                        return;
+                    }
+                    if (!canJoinMap(event.p, map)) {
+                        event.canEnter = false;
+                        return;
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+
+            }
+        });
+
+    }
+
+    static boolean checkCooldown(Player p) {
+
+        var cds = Load.Unit(p).getCooldowns();
+
+        if (!p.isCreative()) {
+            if (cds.isOnCooldown("start_map")) {
+                int sec = cds.getCooldownTicks("start_map") / 20;
+                p.sendSystemMessage(ExplainedResultUtil.createErrorAndReason(Chats.MAP_DEVICE_USE_ERROR.locName(), Words.MAP_START_COOLDOWN.locName(sec)));
+                return false;
+            }
+        }
+        return true;
+    }
+
+    static boolean meetsResists(Player p, MapItemData data) {
+        if (!data.getStatReq().meetsReq(Load.Unit(p).getLevel(), Load.Unit(p))) {
+            ExplainedResultUtil.sendErrorMessage(p, Chats.MAP_DEVICE_USE_ERROR, Chats.RESISTS_TOO_LOW_FOR_MAP);
+
+            List<Component> reqDifference = data.getStatReq().getReqDifference(data.lvl, Load.Unit(p));
+            if (!reqDifference.isEmpty()) {
+                ExplainedResultUtil.sendErrorMessage(p, Chats.MAP_DEVICE_USE_ERROR, Chats.NOT_MEET_MAP_REQ_FIRST_LINE);
+                reqDifference.forEach(p::sendSystemMessage);
+            }
+            return false;
+        }
+        return true;
+    }
+
+
+    static boolean canJoinMap(Player p, MapData mapData) {
+
+
+        if (!meetsResists(p, mapData.map)) {
+            return false;
+        }
+
+        MapItemData map1 = mapData.map;
+
+        if (Load.Unit(p).getLevel() < (map1.lvl - 5)) {
+            p.sendSystemMessage(ExplainedResultUtil.createErrorAndReason(Chats.MAP_DEVICE_USE_ERROR, Chats.TOO_LOW_LEVEL));
+            return false;
+        }
+
+        return true;
+    }
+}

src/main/java/com/robertx22/addons/dungeon_realm/DungeonAddonUtil.java

@@ -0,0 +1,23 @@
+package com.robertx22.addons.dungeon_realm;
+
+import com.robertx22.mine_and_slash.database.data.rarities.MobRarity;
+import com.robertx22.mine_and_slash.event_hooks.entity.OnMobSpawn;
+import com.robertx22.mine_and_slash.uncommon.datasaving.Load;
+import net.minecraft.world.entity.LivingEntity;
+
+import java.util.function.Consumer;
+
+public class DungeonAddonUtil {
+
+    public static Consumer<LivingEntity> createMobRarityEdit(MobRarity rarity) {
+        return mob -> {
+            if (rarity != null) {
+                Load.Unit(mob).setRarity(rarity.GUID());
+            }
+            OnMobSpawn.setupNewMobOnSpawn(mob);
+            if (rarity != null) {
+                Load.Unit(mob).setRarity(rarity.GUID());
+            }
+        };
+    }
+}

src/main/java/com/robertx22/addons/dungeon_realm/MnsDungeonOrbEdits.java

@@ -0,0 +1,30 @@
+package com.robertx22.addons.dungeon_realm;
+
+import com.robertx22.addons.orbs_of_crafting.currency.reworked.item_req.ItemReqs;
+import com.robertx22.dungeon_realm.database.holders.DungeonOrbs;
+import com.robertx22.library_of_exile.registry.helpers.ExileKey;
+import com.robertx22.library_of_exile.registry.helpers.ExileKeyHolder;
+import com.robertx22.library_of_exile.registry.helpers.KeyInfo;
+import com.robertx22.library_of_exile.registry.register_info.ModRequiredRegisterInfo;
+import com.robertx22.mine_and_slash.mmorpg.MMORPG;
+import com.robertx22.orbs_of_crafting.register.orb_edit.OrbEdit;
+
+public class MnsDungeonOrbEdits extends ExileKeyHolder<OrbEdit> {
+
+    public static MnsDungeonOrbEdits INSTANCE = new MnsDungeonOrbEdits(MMORPG.REGISTER_INFO);
+
+    public MnsDungeonOrbEdits(ModRequiredRegisterInfo modRegisterInfo) {
+        super(modRegisterInfo);
+    }
+
+    public ExileKey<OrbEdit, KeyInfo> UBER_UPGRADE = ExileKey.ofId(this, "uber_upgrade", x -> {
+        var e = OrbEdit.of(x.GUID(), DungeonOrbs.INSTANCE.UBER_UPGRADE.GUID());
+        e.req.add(ItemReqs.INSTANCE.MAP_IS_MYTHIC.GUID());
+        return e;
+    });
+
+    @Override
+    public void loadClass() {
+
+    }
+}

src/main/java/com/robertx22/addons/dungeon_realm/MnsLeagues.java

@@ -0,0 +1,24 @@
+package com.robertx22.addons.dungeon_realm;
+
+import com.robertx22.library_of_exile.database.league.League;
+import com.robertx22.library_of_exile.registry.helpers.ExileKey;
+import com.robertx22.library_of_exile.registry.helpers.ExileKeyHolder;
+import com.robertx22.library_of_exile.registry.helpers.KeyInfo;
+import com.robertx22.library_of_exile.registry.register_info.ModRequiredRegisterInfo;
+import com.robertx22.mine_and_slash.mmorpg.MMORPG;
+
+public class MnsLeagues extends ExileKeyHolder<League> {
+
+    public static MnsLeagues INSTANCE = new MnsLeagues(MMORPG.REGISTER_INFO);
+
+    public MnsLeagues(ModRequiredRegisterInfo modRegisterInfo) {
+        super(modRegisterInfo);
+    }
+
+    public ExileKey<League, KeyInfo> PROPHECY = ExileKey.ofId(this, "prophecy", x -> new ProphecyLeague(x.GUID()));
+
+    @Override
+    public void loadClass() {
+
+    }
+}

src/main/java/com/robertx22/addons/dungeon_realm/MnsMapContents.java

@@ -0,0 +1,26 @@
+package com.robertx22.addons.dungeon_realm;
+
+import com.robertx22.library_of_exile.database.extra_map_content.MapContent;
+import com.robertx22.library_of_exile.registry.helpers.ExileKey;
+import com.robertx22.library_of_exile.registry.helpers.ExileKeyHolder;
+import com.robertx22.library_of_exile.registry.helpers.KeyInfo;
+import com.robertx22.library_of_exile.registry.register_info.ModRequiredRegisterInfo;
+import com.robertx22.mine_and_slash.mmorpg.MMORPG;
+import com.robertx22.mine_and_slash.mmorpg.registers.common.SlashBlocks;
+
+public class MnsMapContents extends ExileKeyHolder<MapContent> {
+
+    public static MnsMapContents INSTANCE = new MnsMapContents(MMORPG.REGISTER_INFO);
+
+    public MnsMapContents(ModRequiredRegisterInfo info) {
+        super(info);
+    }
+
+    public ExileKey<MapContent, KeyInfo> PROPHECY = ExileKey.ofId(this, "prophecy", x -> MapContent.of(x.GUID(), 1000, SlashBlocks.PROPHECY_ALTAR.getRegistryObject().getKey().location().toString(), 3, 5));
+
+
+    @Override
+    public void loadClass() {
+
+    }
+}