Esempio n. 1
0
  /**
   * Fire a FMLMissingMappingsEvent to let mods determine how blocks/items defined in the world
   * save, but missing from the runtime, are to be handled.
   *
   * @param missing Map containing missing names with their associated id, blocks need to come
   *     before items for remapping.
   * @param isLocalWorld Whether this is executing for a world load (local/server) or a client.
   * @param gameData GameData instance where the new map's config is to be loaded into.
   * @return List with the mapping results.
   */
  public List<String> fireMissingMappingEvent(
      LinkedHashMap<String, Integer> missingBlocks,
      LinkedHashMap<String, Integer> missingItems,
      boolean isLocalWorld,
      GameData gameData,
      Map<String, Integer[]> remapBlocks,
      Map<String, Integer[]> remapItems) {
    if (missingBlocks.isEmpty() && missingItems.isEmpty()) // nothing to do
    {
      return ImmutableList.of();
    }

    FMLLog.fine(
        "There are %d mappings missing - attempting a mod remap",
        missingBlocks.size() + missingItems.size());
    ArrayListMultimap<String, MissingMapping> missingMappings = ArrayListMultimap.create();

    for (Map.Entry<String, Integer> mapping : missingBlocks.entrySet()) {
      MissingMapping m =
          new MissingMapping(GameRegistry.Type.BLOCK, mapping.getKey(), mapping.getValue());
      missingMappings.put(m.name.substring(0, m.name.indexOf(':')), m);
    }
    for (Map.Entry<String, Integer> mapping : missingItems.entrySet()) {
      MissingMapping m =
          new MissingMapping(GameRegistry.Type.ITEM, mapping.getKey(), mapping.getValue());
      missingMappings.put(m.name.substring(0, m.name.indexOf(':')), m);
    }

    FMLMissingMappingsEvent missingEvent = new FMLMissingMappingsEvent(missingMappings);
    modController.propogateStateMessage(missingEvent);

    if (isLocalWorld) // local world, warn about entries still being set to the default action
    {
      boolean didWarn = false;

      for (MissingMapping mapping : missingMappings.values()) {
        if (mapping.getAction() == FMLMissingMappingsEvent.Action.DEFAULT) {
          if (!didWarn) {
            FMLLog.severe(
                "There are unidentified mappings in this world - we are going to attempt to process anyway");
            didWarn = true;
          }

          FMLLog.severe(
              "Unidentified %s: %s, id %d",
              mapping.type == Type.BLOCK ? "block" : "item", mapping.name, mapping.id);
        }
      }
    } else // remote world, fail on entries with the default action
    {
      List<String> missedMapping = new ArrayList<String>();

      for (MissingMapping mapping : missingMappings.values()) {
        if (mapping.getAction() == FMLMissingMappingsEvent.Action.DEFAULT) {
          missedMapping.add(mapping.name);
        }
      }

      if (!missedMapping.isEmpty()) {
        return ImmutableList.copyOf(missedMapping);
      }
    }

    return GameData.processIdRematches(
        missingMappings.values(), isLocalWorld, gameData, remapBlocks, remapItems);
  }
Esempio n. 2
0
  public static List<String> processIdRematches(
      Iterable<MissingMapping> missedMappings,
      boolean isLocalWorld,
      GameData gameData,
      Map<String, Integer[]> remapBlocks,
      Map<String, Integer[]> remapItems) {
    List<String> failed = Lists.newArrayList();
    List<String> ignored = Lists.newArrayList();
    List<String> warned = Lists.newArrayList();
    List<String> defaulted = Lists.newArrayList();

    for (MissingMapping remap : missedMappings) {
      FMLMissingMappingsEvent.Action action = remap.getAction();

      if (action == FMLMissingMappingsEvent.Action.REMAP) {
        // block/item re-mapped, finish the registration with the new name/object, but the old id
        int currId, newId;
        String newName;

        if (remap.type == Type.BLOCK) {
          currId = getMain().iBlockRegistry.getId((Block) remap.getTarget());
          newName = getMain().iBlockRegistry.getNameForObject(remap.getTarget()).toString();
          FMLLog.fine("The Block %s is being remapped to %s.", remap.name, newName);

          newId = gameData.registerBlock((Block) remap.getTarget(), newName, remap.id);
          gameData.iBlockRegistry.addAlias(remap.name, newName);
        } else {
          currId = getMain().iItemRegistry.getId((Item) remap.getTarget());
          newName = getMain().iItemRegistry.getNameForObject(remap.getTarget()).toString();
          FMLLog.fine("The Item %s is being remapped to %s.", remap.name, newName);

          newId = gameData.registerItem((Item) remap.getTarget(), newName, remap.id);
          gameData.iItemRegistry.addAlias(remap.name, newName);
        }

        if (newId != remap.id) throw new IllegalStateException();

        if (currId != newId) {
          FMLLog.info(
              "Fixed %s id mismatch %s: %d (init) -> %d (map).",
              remap.type == Type.BLOCK ? "block" : "item", newName, currId, newId);
          (remap.type == Type.BLOCK ? remapBlocks : remapItems)
              .put(newName, new Integer[] {currId, newId});
        }
      } else if (action == FMLMissingMappingsEvent.Action.BLOCKONLY) {
        // Pulled out specifically so the block doesn't get reassigned a new ID just because it's
        // Item block has gone away
        FMLLog.fine(
            "The ItemBlock %s is no longer present in the game. The residual block will remain",
            remap.name);
      } else {
        // block item missing, warn as requested and block the id
        if (action == FMLMissingMappingsEvent.Action.DEFAULT) {
          defaulted.add(remap.name);
        } else if (action == FMLMissingMappingsEvent.Action.IGNORE) {
          ignored.add(remap.name);
        } else if (action == FMLMissingMappingsEvent.Action.FAIL) {
          failed.add(remap.name);
        } else if (action == FMLMissingMappingsEvent.Action.WARN) {
          warned.add(remap.name);
        }

        gameData.block(remap.id); // prevent the id from being reused later
      }
    }

    if (!defaulted.isEmpty()) {
      String text =
          "Forge Mod Loader detected missing blocks/items.\n\n"
              + "There are "
              + defaulted.size()
              + " missing blocks and items in this save.\n"
              + "If you continue the missing blocks/items will get removed.\n"
              + "A world backup will be automatically created in your saves directory.\n\n"
              + "Missing Blocks/Items:\n";

      for (String s : defaulted) text += s + "\n";

      boolean confirmed = StartupQuery.confirm(text);
      if (!confirmed) StartupQuery.abort();

      try {
        String skip = System.getProperty("fml.doNotBackup");
        if (skip == null || !"true".equals(skip)) {
          ZipperUtil.backupWorld();
        } else {
          for (int x = 0; x < 10; x++)
            FMLLog.severe("!!!!!!!!!! UPDATING WORLD WITHOUT DOING BACKUP !!!!!!!!!!!!!!!!");
        }
      } catch (IOException e) {
        StartupQuery.notify("The world backup couldn't be created.\n\n" + e);
        StartupQuery.abort();
      }

      warned.addAll(defaulted);
    }
    if (!failed.isEmpty()) {
      FMLLog.severe(
          "This world contains blocks and items that refuse to be remapped. The world will not be loaded");
      return failed;
    }
    if (!warned.isEmpty()) {
      FMLLog.severe("This world contains block and item mappings that may cause world breakage");
      return failed;
    } else if (!ignored.isEmpty()) {
      FMLLog.fine("There were %d missing mappings that have been ignored", ignored.size());
    }
    return failed;
  }
Esempio n. 3
0
  @EventHandler
  public void onMapping(FMLMissingMappingsEvent event) {
    if (!TragicConfig.getBoolean("allowNonMobBlocks")
        || !TragicConfig.getBoolean("allowNonMobItems")) return;

    List<MissingMapping> list = event.get();

    for (MissingMapping mm : list) {
      if (mm.name.equals("TragicMC:darkStoneBlocks")) {
        if (mm.type == Type.BLOCK) {
          mm.remap(TragicBlocks.DarkStone);
        } else {
          mm.remap(Item.getItemFromBlock(TragicBlocks.DarkStone));
        }
      } else if (mm.name.equals("TragicMC:obsidianVariants")) {
        if (mm.type == Type.BLOCK) {
          mm.remap(TragicBlocks.ObsidianVariant);
        } else {
          mm.remap(Item.getItemFromBlock(TragicBlocks.ObsidianVariant));
        }
      } else if (mm.name.equals("TragicMC:darkCobbleBlocks")) {
        if (mm.type == Type.BLOCK) {
          mm.remap(TragicBlocks.DarkCobblestone);
        } else {
          mm.remap(Item.getItemFromBlock(TragicBlocks.DarkCobblestone));
        }
      } else if (mm.name.equals("TragicMC:rubyOreBlock")) {
        if (mm.type == Type.BLOCK) {
          mm.remap(TragicBlocks.RubyOre);
        } else {
          mm.remap(Item.getItemFromBlock(TragicBlocks.RubyOre));
        }
      } else if (mm.name.equals("TragicMC:sapphireOreBlock")) {
        if (mm.type == Type.BLOCK) {
          mm.remap(TragicBlocks.SapphireOre);
        } else {
          mm.remap(Item.getItemFromBlock(TragicBlocks.SapphireOre));
        }
      } else if (mm.name.equals("TragicMC:mercuryOreBlock")) {
        if (mm.type == Type.BLOCK) {
          mm.remap(TragicBlocks.MercuryOre);
        } else {
          mm.remap(Item.getItemFromBlock(TragicBlocks.MercuryOre));
        }
      } else if (mm.name.equals("TragicMC:tungstenOreBlock")) {
        if (mm.type == Type.BLOCK) {
          mm.remap(TragicBlocks.TungstenOre);
        } else {
          mm.remap(Item.getItemFromBlock(TragicBlocks.TungstenOre));
        }
      } else if (mm.name.equals("TragicMC:summonBlocks")) {
        if (mm.type == Type.BLOCK) {
          mm.remap(TragicBlocks.SummonBlock);
        } else {
          mm.remap(Item.getItemFromBlock(TragicBlocks.SummonBlock));
        }
      } else if (mm.name.equals("TragicMC:quicksandBlocks")) {
        if (mm.type == Type.BLOCK) {
          mm.remap(TragicBlocks.Quicksand);
        } else {
          mm.remap(Item.getItemFromBlock(TragicBlocks.Quicksand));
        }
      } else if (mm.name.equals("TragicMC:foxBlock")) {
        if (mm.type == Type.BLOCK) {
          mm.remap(TragicBlocks.SmoothNetherrack);
        } else {
          mm.remap(Item.getItemFromBlock(TragicBlocks.SmoothNetherrack));
        }
      } else if (mm.name.equals("TragicMC:storageBlocks")) {
        if (mm.type == Type.BLOCK) {
          mm.remap(TragicBlocks.CompactOre);
        } else {
          mm.remap(Item.getItemFromBlock(TragicBlocks.CompactOre));
        }
      } else if (mm.name.equals("TragicMC:structureSeeds")) {
        if (mm.type == Type.BLOCK) {
          mm.remap(TragicBlocks.StructureSeed);
        } else {
          mm.remap(Item.getItemFromBlock(TragicBlocks.StructureSeed));
        }
      } else if (mm.name.equals("TragicMC:lightCobble")) {
        if (mm.type == Type.BLOCK) {
          mm.remap(TragicBlocks.LightCobblestone);
        } else {
          mm.remap(Item.getItemFromBlock(TragicBlocks.LightCobblestone));
        }
      } else if (mm.name.equals("TragicMC:fragileLightInvis")) {
        if (mm.type == Type.BLOCK) {
          mm.remap(TragicBlocks.FragileLight);
        } else {
          mm.remap(Item.getItemFromBlock(TragicBlocks.FragileLight));
        }
      } else if (mm.name.equals("TragicMC:geyserSteaming")) {
        if (mm.type == Type.BLOCK) {
          mm.remap(TragicBlocks.Geyser);
        } else {
          mm.remap(Item.getItemFromBlock(TragicBlocks.Geyser));
        }
      } else if (mm.name.contains("TragicMC:")) {
        mm.ignore();
      }
    }
  }