private void findBestEquipment() {

    int bestScore = -1;
    ItemStack bestWeapon = null;
    int bestLocation = 0;
    ItemStack currentCheck;
    int currentScore;
    for (int i = 0; i < this.inventory.mainInventory.length; i++) {
      currentCheck = this.inventory.mainInventory[i];
      if (currentCheck == null) continue;
      Multimap map = currentCheck.getAttributeModifiers();
      Collection Attributes =
          (Collection) map.get(SharedMonsterAttributes.attackDamage.getAttributeUnlocalizedName());

      if (Attributes.size() == 0) currentScore = 0;
      else currentScore = (int) ((AttributeModifier) Attributes.toArray()[0]).getAmount();
      NBTTagList enchList = currentCheck.getEnchantmentTagList();
      if (enchList == null) currentScore += 0;
      else {
        for (int j = 0; j < enchList.tagCount(); j++) {
          NBTTagCompound comp = (NBTTagCompound) enchList.getCompoundTagAt(j);
          int enchId = comp.getShort("id");
          int enchLvl = comp.getShort("lvl");
          switch (enchId) {
            case 16:
              currentScore += (1 * enchLvl);
              break;
            case 19:
              currentScore += (1 * enchLvl);
              break;
            case 20:
              currentScore += (2 * enchLvl);
              break;
            default:
              currentScore += 1;
          }
        }
      }
      UnDeath.logging.info(
          String.format("Item %s got score %d", currentCheck.toString(), currentScore));
      if (currentScore > bestScore) {
        bestWeapon = currentCheck;
        bestLocation = i;
        bestScore = currentScore;
      }
    }
    if (bestScore == -1) {
      UnDeath.logging.info("No weapons found");
      this.inventory.currentItem = -1;
      return;
    }
    UnDeath.logging.info(
        String.format("Best Weapon is %s with score %d", bestWeapon.toString(), bestScore));
    this.inventory.currentItem = bestLocation;
  }
  private static void doPlayer(EntityPlayerMP player, VoteEvent vote) {
    if (!ConfigServerVote.msgAll.equals("")) {
      player.playerNetServerHandler.sendPacket(
          new S02PacketChat(
              new ChatComponentText(
                  ChatOutputHandler.formatColors(
                      ConfigServerVote.msgAll
                          .replaceAll("%service", vote.serviceName)
                          .replaceAll("%player", vote.player)))));
    }

    if (!ConfigServerVote.msgVoter.equals("")) {
      ChatOutputHandler.sendMessage(
          player,
          ChatOutputHandler.formatColors(
              ConfigServerVote.msgAll
                  .replaceAll("%service", vote.serviceName)
                  .replaceAll("%player", vote.player)));
    }

    if (!ConfigServerVote.freeStuff.isEmpty()) {
      for (ItemStack stack : ConfigServerVote.freeStuff) {
        LoggingHandler.felog.debug(stack.toString());
        player.inventory.addItemStackToInventory(stack.copy());
      }
    }
  }
Example #3
0
 private void ExtractItem() {
   TileEntity tile = LazUtils.XYZCoords.FromTile(this).Next(currentfacing).ToTile();
   if (tile instanceof IInventory) {
     if (LazUtils.InventoryCore.ExtractOneFromInventory((IInventory) tile, false) != null) {
       ItemStack stack = LazUtils.InventoryCore.ExtractOneFromInventory((IInventory) tile, true);
       if (YATS.IS_DEBUG)
         LazUtils.logNormal(
             "Heartbreak! Extracting item at "
                 + xCoord
                 + ","
                 + yCoord
                 + ","
                 + zCoord
                 + ": ("
                 + stack.toString()
                 + ")");
       TileEntity tile2 =
           LazUtils.XYZCoords.FromTile(this).Next(currentfacing.getOpposite()).ToTile();
       if (tile2 instanceof ITubeConnectible
           && ((ITubeConnectible) tile2).IsConnectedOnSide(currentfacing))
         ((ITubeConnectible) tile2)
             .AcceptCapsule(new ItemCapsule(stack, Colours.NONE, currentfacing.getOpposite()));
       else if (tile2 instanceof IInventory
           && LazUtils.InventoryCore.CanAddToInventory((IInventory) tile2, stack))
         LazUtils.InventoryCore.AddToInventory((IInventory) tile2, stack);
       else {
         LazUtils.XYZCoords coords =
             LazUtils.XYZCoords.FromTile(this).Next(currentfacing.getOpposite());
         EntityItem item = new EntityItem(worldObj, coords.x, coords.y, coords.z, stack);
         worldObj.spawnEntityInWorld(item);
       }
     }
   }
 }
Example #4
0
 /** Called upon block activation (right click on the block.) */
 @Override
 public boolean onBlockActivated(
     World world,
     int x,
     int y,
     int z,
     EntityPlayer player,
     int side,
     float hitX,
     float hitY,
     float hitZ) {
   if (!world.isRemote) {
     if (player.isSneaking()) {
       player.openGui(FullPower.instance, GuiHandler.GuiIDs.CAMO_MINE.ordinal(), world, x, y, z);
     }
     TileEntityCamoMine te = (TileEntityCamoMine) world.getTileEntity(x, y, z);
     if (te.getCamouflage(side) != null) {
       ItemStack camoStack = te.getCamouflage(side);
       te.setCamouflage(null, side);
       EntityItem itemEntity = new EntityItem(world, x, y, z, camoStack);
       LogHelper.info("StackSize=" + camoStack.stackSize);
       // Tell world this item needs to be spawned
       world.spawnEntityInWorld(itemEntity);
     } else {
       ItemStack playerItem = player.getCurrentEquippedItem();
       if (playerItem != null) {
         ItemStack camoStack = playerItem.splitStack(1); // Remove 1 from stack
         ChatHelper.send(camoStack.toString());
         te.setCamouflage(camoStack, side);
       }
     }
   }
   return true;
 }
Example #5
0
 public void setRepresentativeItem(ItemStack representativeItem) {
   if (representativeItem == null) {
     this.representativeItem = null;
   } else if (matches(representativeItem) != null) {
     this.representativeItem = representativeItem;
   } else {
     TinkerRegistry.log.warn(
         "Itemstack {} cannot represent material {} since it is not associated with the material!",
         representativeItem.toString(),
         identifier);
   }
 }
Example #6
0
 public void setShard(ItemStack stack) {
   if (stack == null) {
     this.shardItem = null;
   } else {
     RecipeMatch.Match match = matches(stack);
     if (match != null) {
       if (match.amount == VALUE_Shard) {
         this.shardItem = stack;
       } else {
         TinkerRegistry.log.warn(
             "Itemstack {} cannot be shard of material {} since it does not have the correct value! (is {}, has to be {})",
             representativeItem.toString(),
             identifier,
             match.amount,
             VALUE_Shard);
       }
     } else {
       TinkerRegistry.log.warn(
           "Itemstack {} cannot be shard of material {} since it is not associated with the material!",
           stack.toString(),
           identifier);
     }
   }
 }
Example #7
0
  private static void loadTransformer() {
    for (TransformData data : ConfigRegistry.transformData) {
      ItemStack output = RecipeTransformer.dataToItemStack(data.output, true).get(0);
      Object input = RecipeTransformer.dataToObject(data.input);

      System.out.println("---------------- INPUT -----------------");
      System.out.println("INPUT: " + data.input);
      System.out.println("---------------- OUTPUT -----------------");
      System.out.println(
          "OUTPUT: " + data.output + " -> " + (output == null ? "NULL" : output.toString()));
      System.out.println("CODE: " + data.code);

      transformationContainer.add(new TransformerContainer(input, output, data.code));
    }

    for (TransformerContainer con : transformationContainer) {
      CristalRegistry.register(new WeakCristalTransformation(con));
    }
  }
  @Override
  public void writeToWorld(IBuilderContext context) {
    if (mode == Mode.ClearIfInvalid) {
      if (!getSchematic().isAlreadyBuilt(context, x, y, z)) {
        if (BuildCraftBuilders.dropBrokenBlocks) {
          BlockUtils.breakBlock((WorldServer) context.world(), x, y, z);
        } else {
          context.world().setBlockToAir(x, y, z);
        }
      }
    } else {
      try {
        getSchematic().placeInWorld(context, x, y, z, stackConsumed);

        // This is slightly hackish, but it's a very important way to verify
        // the stored requirements.

        if (!context.world().isAirBlock(x, y, z)
            && getSchematic().getBuildingPermission() == BuildingPermission.ALL
            && getSchematic() instanceof SchematicBlock) {
          SchematicBlock sb = (SchematicBlock) getSchematic();
          // Copy the old array of stored requirements.
          ItemStack[] oldRequirementsArray = sb.storedRequirements;
          List<ItemStack> oldRequirements = Arrays.asList(oldRequirementsArray);
          sb.storedRequirements = new ItemStack[0];
          sb.storeRequirements(context, x, y, z);
          for (ItemStack s : sb.storedRequirements) {
            boolean contains = false;
            for (ItemStack ss : oldRequirements) {
              if (StackHelper.isMatchingItem(s, ss)) {
                contains = true;
                break;
              }
            }
            if (!contains) {
              BCLog.logger.warn(
                  "Blueprint has MISMATCHING REQUIREMENTS! Potential corrupted/hacked blueprint! Removed mismatched block.");
              BCLog.logger.warn(
                  "Location: " + x + ", " + y + ", " + z + " - ItemStack: " + s.toString());
              context.world().removeTileEntity(x, y, z);
              context.world().setBlockToAir(x, y, z);
              return;
            }
          }
          // Restore the stored requirements.
          sb.storedRequirements = oldRequirementsArray;
        }

        // Once the schematic has been written, we're going to issue
        // calls
        // to various functions, in particular updating the tile entity.
        // If these calls issue problems, in order to avoid corrupting
        // the world, we're logging the problem and setting the block to
        // air.

        TileEntity e = context.world().getTileEntity(x, y, z);

        if (e != null) {
          e.updateEntity();
        }
      } catch (Throwable t) {
        t.printStackTrace();
        context.world().setBlockToAir(x, y, z);
      }
    }
  }