Partial revert of #37 and Crafting Dupe Glitch Fix

src/main/java/com/darkona/adventurebackpack/block/BlockSleepingBag.java

@@ -73,15 +73,6 @@ private static boolean isBlockHeadOfBed(int meta) {
         return (meta & 8) != 0;
     }
 
-    private static ChunkCoordinates getHeadCoordinates(int x, int y, int z, int meta) {
-        if (!isBlockHeadOfBed(meta)) {
-            int dir = getDirection(meta);
-            x += footBlockToHeadBlockMap[dir][0];
-            z += footBlockToHeadBlockMap[dir][1];
-        }
-        return new ChunkCoordinates(x, y, z);
-    }
-
     public static boolean isSleepingInPortableBag(EntityPlayer player) {
         return Wearing.isWearingBackpack(player)
                 && Wearing.getWearingBackpackInv(player).getExtendedProperties().hasKey(Constants.TAG_SLEEPING_IN_BAG);
@@ -95,29 +86,39 @@ public static void packPortableSleepingBag(EntityPlayer player) {
         }
     }
 
+    public static void storeOriginalSpawn(EntityPlayer player) {
+        ChunkCoordinates spawn = player.getBedLocation(player.worldObj.provider.dimensionId);
+        final BackpackProperty props = BackpackProperty.get(player);
+
+        if (spawn != null && props != null) {
+            props.setStoredSpawn(spawn);
+            LogHelper.info(
+                    "Stored spawn data for " + player
+                            .getDisplayName() + ": " + spawn + " dimID: " + player.worldObj.provider.dimensionId);
+        } else {
+            LogHelper.warn("Cannot store spawn data for " + player.getDisplayName() + ", because it is non-existent");
+        }
+    }
+
     public static void restoreOriginalSpawn(EntityPlayer player) {
         final BackpackProperty props = BackpackProperty.get(player);
 
         if (props != null) {
             final ChunkCoordinates oldSpawn = props.getStoredSpawn();
             if (oldSpawn != null) {
-                player.setSpawnChunk(oldSpawn, false, props.getStoredSpawnDimension());
+                player.setSpawnChunk(oldSpawn, false, player.worldObj.provider.dimensionId);
+                LogHelper.info(
+                        "Restored spawn data for " + player.getDisplayName()
+                                + ": "
+                                + oldSpawn
+                                + " dimID: "
+                                + player.worldObj.provider.dimensionId);
             }
+        } else {
+            LogHelper.warn("No spawn data to restore for " + player.getDisplayName());
         }
     }
 
-    public static boolean shouldRestoreStoredSpawnOnDeath(EntityPlayer player) {
-        BackpackProperty prop = BackpackProperty.get(player);
-        if (prop == null) return false;
-
-        ChunkCoordinates sleepingBagSpawn = prop.getSleepingBagSpawn();
-        if (sleepingBagSpawn == null) return false;
-        if (prop.getSleepingBagSpawnDimension() != player.dimension) return false;
-
-        return player.worldObj.getBlock(sleepingBagSpawn.posX, sleepingBagSpawn.posY, sleepingBagSpawn.posZ)
-                != ModBlocks.blockSleepingBag;
-    }
-
     public void onPortableBlockActivated(World world, EntityPlayer player, int cX, int cY, int cZ) {
         if (world.isRemote) return;
         if (!isSleepingInPortableBag(player)) return;
@@ -170,24 +171,16 @@ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer p
                     setBedOccupied(world, x, y, z, false);
                 }
 
-                BackpackProperty props = BackpackProperty.get(player);
-                ChunkCoordinates previousSpawn = player.getBedLocation(player.dimension);
-                int previousSpawnDimension = player.dimension;
                 EntityPlayer.EnumStatus enumstatus = player.sleepInBedAt(x, y, z);
 
                 if (enumstatus == EntityPlayer.EnumStatus.OK) {
                     setBedOccupied(world, x, y, z, true);
-                    ChunkCoordinates sleepingBagSpawn = new ChunkCoordinates(x, y, z);
-                    if (props != null) {
-                        props.setSleepingBagSpawn(sleepingBagSpawn, player.dimension);
-                        if (previousSpawn != null) {
-                            props.setStoredSpawn(previousSpawn, previousSpawnDimension);
-                        }
-                    }
                     // This is so the wake-up event can detect it. It fires before the player wakes up.
                     // and the bed location isn't set until then, normally.
 
-                    if (!isSleepingInPortableBag(player)) {
+                    if (isSleepingInPortableBag(player)) {
+                        storeOriginalSpawn(player);
+                    } else {
                         LogHelper.info("Looking for a campfire nearby...");
                         ChunkCoordinates campfire = CoordsUtils
                                 .findBlock3D(world, x, y, z, ModBlocks.blockCampFire, 8, 2);
@@ -196,10 +189,12 @@ public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer p
                             BackpackProperty.get(player).setCampFire(campfire);
                         } else {
                             LogHelper.info("No campfire found. Keeping spawnpoint at previous location");
+                            storeOriginalSpawn(player);
                             BackpackProperty.get(player).setCampFire(null);
                         }
                     }
-                    player.setSpawnChunk(sleepingBagSpawn, true, player.dimension);
+                    player.setSpawnChunk(new ChunkCoordinates(x, y, z), true, player.dimension);
+
                     return true;
                 } else {
                     if (enumstatus == EntityPlayer.EnumStatus.NOT_POSSIBLE_NOW) {
@@ -302,36 +297,33 @@ public void onBlockDestroyedByExplosion(World world, int x, int y, int z, Explos
 
     @Override
     public void onBlockDestroyedByPlayer(World world, int x, int y, int z, int meta) {
-        ChunkCoordinates head = getHeadCoordinates(x, y, z, meta);
+        // TODO make it work if player destroyed head block of sleeping bag (so backpack 1 more tile away)
+        // LogHelper.info("onBlockDestroyedByPlayer() : BlockSleepingBag");
         int direction = getDirection(meta);
         int tileZ = z;
         int tileX = x;
-        if (isBlockHeadOfBed(meta)) {
-            tileX -= footBlockToHeadBlockMap[direction][0];
-            tileZ -= footBlockToHeadBlockMap[direction][1];
-        } else {
-            tileX += footBlockToHeadBlockMap[direction][0];
-            tileZ += footBlockToHeadBlockMap[direction][1];
+        switch (meta) {
+            case 0:
+                tileZ--;
+                break;
+            case 1:
+                tileX++;
+                break;
+            case 2:
+                tileZ++;
+                break;
+            case 3:
+                tileX--;
+                break;
         }
+        // LogHelper.info("onBlockDestroyedByPlayer() Looking for tile entity in x=" +tileX+" y="+y+" z="+tileZ+" while
+        // breaking the block in x= "+x+" y="+y+" z="+z);
         if (world.getTileEntity(tileX, y, tileZ) != null
                 && world.getTileEntity(tileX, y, tileZ) instanceof TileAdventureBackpack) {
+            // LogHelper.info("onBlockDestroyedByPlayer() Found the tile entity in x=" +tileX+" y="+y+" z="+z+" while
+            // breaking the block in x= "+x+" y="+y+" z="+z+" ...removing.");
             ((TileAdventureBackpack) world.getTileEntity(tileX, y, tileZ)).setSleepingBagDeployed(false);
         }
-
-        if (!world.isRemote) {
-            for (Object object : world.playerEntities) {
-                EntityPlayer player = (EntityPlayer) object;
-                BackpackProperty props = BackpackProperty.get(player);
-                if (props != null && props.getSleepingBagSpawn() != null
-                        && props.getSleepingBagSpawnDimension() == world.provider.dimensionId
-                        && props.getSleepingBagSpawn().posX == head.posX
-                        && props.getSleepingBagSpawn().posY == head.posY
-                        && props.getSleepingBagSpawn().posZ == head.posZ) {
-                    restoreOriginalSpawn(player);
-                    props.clearSleepingBagSpawn();
-                }
-            }
-        }
     }
 
     @Override

src/main/java/com/darkona/adventurebackpack/handlers/PlayerEventHandler.java

@@ -1,7 +1,6 @@
 package com.darkona.adventurebackpack.handlers;
 
 import java.util.HashSet;
-import java.util.Objects;
 
 import net.minecraft.entity.EntityCreature;
 import net.minecraft.entity.SharedMonsterAttributes;
@@ -166,23 +165,18 @@ public void playerDies(LivingDeathEvent event) {
                     // point if there's no campfire.
                 }
 
-                if (BlockSleepingBag.shouldRestoreStoredSpawnOnDeath(player)) {
-                    BlockSleepingBag.restoreOriginalSpawn(player);
-                    props.clearSleepingBagSpawn();
-                }
-
                 if (Wearing.isWearingWearable(player)) {
                     if (Wearing.isWearingTheRightBackpack(player, BackpackTypes.CREEPER)) {
                         player.worldObj.createExplosion(player, player.posX, player.posY, player.posZ, 4.0F, false);
                     }
 
                     if (player.getEntityWorld().getGameRules().getGameRuleBooleanValue("keepInventory")
                             || PotionAndEnchantUtils.hasStickyItems(player)) {
-                        ((IBackWearableItem) Objects.requireNonNull(props.getWearable().getItem()))
+                        ((IBackWearableItem) props.getWearable().getItem())
                                 .onPlayerDeath(player.worldObj, player, props.getWearable());
+                        ServerProxy.storePlayerProps(player);
                     }
                 }
-                ServerProxy.storePlayerProps(player);
             }
         }
         event.setResult(Event.Result.ALLOW);
@@ -289,6 +283,7 @@ public void playerWokeUp(PlayerWakeUpEvent event) {
             } else {
                 BackpackProperty props = BackpackProperty.get(player);
                 if (props != null) {
+                    BackpackProperty.get(player).setWakingUpInDeployedBag(true);
                     if (props.getCampFire() != null) {
                         props.setForceCampFire(true);
                         LogHelper.info(
@@ -300,9 +295,7 @@ public void playerWokeUp(PlayerWakeUpEvent event) {
             }
         } else {
             // If it's a regular bed or whatever
-            BackpackProperty props = BackpackProperty.get(player);
-            props.setForceCampFire(false);
-            props.clearSleepingBagSpawn();
+            BackpackProperty.get(player).setForceCampFire(false);
         }
     }
 
@@ -323,6 +316,11 @@ public void tickPlayer(TickEvent.PlayerTickEvent event) {
                         }
                     }
                 }
+            } else if (event.phase == TickEvent.Phase.END && !player.worldObj.isRemote) {
+                if (BackpackProperty.get(player).isWakingUpInDeployedBag()) {
+                    BlockSleepingBag.restoreOriginalSpawn(player);
+                    BackpackProperty.get(player).setWakingUpInDeployedBag(false);
+                }
             }
         }
         if (player != null && !player.isDead && player instanceof EntityPlayer) {

src/main/java/com/darkona/adventurebackpack/inventory/InventoryAdventure.java

@@ -80,7 +80,9 @@ public int getInventoryStackLimit() {
     }
 
     @Override
-    public void markDirty() {}
+    public void markDirty() {
+        dirtyInventory();
+    }
 
     @Override
     public boolean isUseableByPlayer(EntityPlayer player) {

src/main/java/com/darkona/adventurebackpack/playerProperties/BackpackProperty.java

@@ -17,19 +17,16 @@ public class BackpackProperty implements IExtendedEntityProperties {
 
     private static final String PROPERTY_NAME = "abp.property";
     private static final String TAG_STORED_SPAWN = "storedSpawn";
-    private static final String TAG_SLEEPING_BAG_SPAWN = "sleepingBagSpawn";
 
     private EntityPlayer player;
     private ItemStack wearable = null;
     private ChunkCoordinates storedSpawn = null;
-    private int storedSpawnDimension = 0;
-    private ChunkCoordinates sleepingBagSpawn = null;
-    private int sleepingBagSpawnDimension = 0;
     private ChunkCoordinates campFire = null;
     private boolean forceCampFire = false;
     private int dimension = 0;
 
     private boolean isWakingUpInPortableBag = false;
+    private boolean isWakingUpInDeployedBag = false;
 
     public void setWakingUpInPortableBag(boolean b) {
         this.isWakingUpInPortableBag = b;
@@ -39,6 +36,14 @@ public boolean isWakingUpInPortableBag() {
         return this.isWakingUpInPortableBag;
     }
 
+    public void setWakingUpInDeployedBag(boolean b) {
+        this.isWakingUpInDeployedBag = b;
+    }
+
+    public boolean isWakingUpInDeployedBag() {
+        return this.isWakingUpInDeployedBag;
+    }
+
     public static void sync(EntityPlayer player) {
         if (player instanceof EntityPlayerMP) {
             syncToNear((EntityPlayerMP) player);
@@ -83,17 +88,8 @@ public void saveNBTData(NBTTagCompound compound) {
             spawn.setInteger("posX", storedSpawn.posX);
             spawn.setInteger("posY", storedSpawn.posY);
             spawn.setInteger("posZ", storedSpawn.posZ);
-            spawn.setInteger("dim", storedSpawnDimension);
             compound.setTag(TAG_STORED_SPAWN, spawn);
         }
-        if (sleepingBagSpawn != null) {
-            NBTTagCompound spawn = new NBTTagCompound();
-            spawn.setInteger("posX", sleepingBagSpawn.posX);
-            spawn.setInteger("posY", sleepingBagSpawn.posY);
-            spawn.setInteger("posZ", sleepingBagSpawn.posZ);
-            spawn.setInteger("dim", sleepingBagSpawnDimension);
-            compound.setTag(TAG_SLEEPING_BAG_SPAWN, spawn);
-        }
         if (campFire != null) {
             compound.setInteger("campFireX", campFire.posX);
             compound.setInteger("campFireY", campFire.posY);
@@ -115,17 +111,7 @@ public void loadNBTData(NBTTagCompound compound) {
                         new ChunkCoordinates(
                                 spawn.getInteger("posX"),
                                 spawn.getInteger("posY"),
-                                spawn.getInteger("posZ")),
-                        spawn.getInteger("dim"));
-            }
-            if (compound.hasKey(TAG_SLEEPING_BAG_SPAWN)) {
-                NBTTagCompound spawn = compound.getCompoundTag(TAG_SLEEPING_BAG_SPAWN);
-                setSleepingBagSpawn(
-                        new ChunkCoordinates(
-                                spawn.getInteger("posX"),
-                                spawn.getInteger("posY"),
-                                spawn.getInteger("posZ")),
-                        spawn.getInteger("dim"));
+                                spawn.getInteger("posZ")));
             }
             setCampFire(
                     new ChunkCoordinates(
@@ -151,40 +137,13 @@ public ItemStack getWearable() {
     }
 
     public void setStoredSpawn(ChunkCoordinates coords) {
-        setStoredSpawn(coords, player.worldObj.provider.dimensionId);
-    }
-
-    public void setStoredSpawn(ChunkCoordinates coords, int dim) {
         storedSpawn = coords;
-        storedSpawnDimension = dim;
     }
 
     public ChunkCoordinates getStoredSpawn() {
         return storedSpawn;
     }
 
-    public int getStoredSpawnDimension() {
-        return storedSpawnDimension;
-    }
-
-    public void setSleepingBagSpawn(ChunkCoordinates coords, int dim) {
-        sleepingBagSpawn = coords;
-        sleepingBagSpawnDimension = dim;
-    }
-
-    public ChunkCoordinates getSleepingBagSpawn() {
-        return sleepingBagSpawn;
-    }
-
-    public int getSleepingBagSpawnDimension() {
-        return sleepingBagSpawnDimension;
-    }
-
-    public void clearSleepingBagSpawn() {
-        sleepingBagSpawn = null;
-        sleepingBagSpawnDimension = 0;
-    }
-
     public void setCampFire(ChunkCoordinates cf) {
         campFire = cf;
     }