API tools faq
paste
Advertisement
robin4002

Untitled

robin4002
Jun 30th, 2013
228
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 34.90 KB | None | 0 0
raw download clone embed print report
  1. package com.eloraam.redpower.core;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Arrays;
  5. import java.util.HashMap;
  6. import java.util.Iterator;
  7.  
  8. import net.minecraft.block.Block;
  9. import net.minecraft.entity.Entity;
  10. import net.minecraft.item.ItemStack;
  11. import net.minecraft.util.MovingObjectPosition;
  12. import net.minecraft.world.World;
  13.  
  14. public class CoverLib
  15. {
  16.     public static final float selectBoxWidth = 0.25F;
  17.     public static Block blockCoverPlate = null;
  18.     private static ItemStack[] materials = new ItemStack[256];
  19.     private static String[] names = new String[256];
  20.     private static String[] descs = new String[256];
  21.     private static int[] hardness = new int[256];
  22.     private static ArrayList materialHandlers = new ArrayList();
  23.     private static boolean[] transparency = new boolean[256];
  24.     public static int[][] coverTextures = new int[256][];
  25.     public static String[] coverTextureFiles = new String[256];
  26.     private static float[] miningHardness = new float[256];
  27.     private static HashMap coverIndex = new HashMap();
  28.  
  29.     public static void addMaterialHandler(CoverLib$IMaterialHandler var0)
  30.     {
  31.         for (int var1 = 0; var1 < 256; ++var1)
  32.         {
  33.             if (materials[var1] != null)
  34.             {
  35.                 var0.addMaterial(var1);
  36.             }
  37.         }
  38.  
  39.         materialHandlers.add(var0);
  40.     }
  41.  
  42.     public static Integer getMaterial(ItemStack var0)
  43.     {
  44.         return (Integer)coverIndex.get(Arrays.asList(new Integer[] {Integer.valueOf(var0.itemID), Integer.valueOf(var0.getItemDamage())}));
  45.     }
  46.  
  47.     public static void addMaterial(int var0, int var1, Block var2, String var3, String var4)
  48.     {
  49.         addMaterial(var0, var1, false, var2, 0, var3, var4);
  50.     }
  51.  
  52.     public static void addMaterial(int var0, int var1, Block var2, int var3, String var4, String var5)
  53.     {
  54.         addMaterial(var0, var1, false, var2, var3, var4, var5);
  55.     }
  56.  
  57.     public static void addMaterial(int var0, int var1, boolean var2, Block var3, String var4, String var5)
  58.     {
  59.         addMaterial(var0, var1, var2, var3, 0, var4, var5);
  60.     }
  61.  
  62.     public static void addMaterial(int var0, int var1, boolean var2, Block var3, int var4, String var5, String var6)
  63.     {
  64.         ItemStack var8 = new ItemStack(var3, 1, var4);
  65.         coverTextures[var0] = new int[6];
  66.  
  67.         for (int var7 = 0; var7 < 6; ++var7)
  68.         {
  69.             coverTextures[var0][var7] = var3.getBlockTextureFromSideAndMetadata(var7, var4);
  70.         }
  71.  
  72.         if (!var3.isDefaultTexture)
  73.         {
  74.             coverTextureFiles[var0] = var3.getTextureFile();
  75.         }
  76.  
  77.         if (var3 instanceof IBlockHardness)
  78.         {
  79.             miningHardness[var0] = ((IBlockHardness)var3).getPrototypicalHardness(var4);
  80.         }
  81.         else
  82.         {
  83.             miningHardness[var0] = var3.getBlockHardness((World)null, 0, 0, 0);
  84.         }
  85.  
  86.         materials[var0] = var8;
  87.         names[var0] = var5;
  88.         descs[var0] = var6;
  89.         hardness[var0] = var1;
  90.         transparency[var0] = var2;
  91.         coverIndex.put(Arrays.asList(new Integer[] {Integer.valueOf(var3.blockID), Integer.valueOf(var4)}), Integer.valueOf(var0));
  92.         Iterator var9 = materialHandlers.iterator();
  93.  
  94.         while (var9.hasNext())
  95.         {
  96.             CoverLib$IMaterialHandler var10 = (CoverLib$IMaterialHandler)var9.next();
  97.             var10.addMaterial(var0);
  98.         }
  99.  
  100.         Config.addName("tile.rpcover." + var5 + ".name", var6 + " Cover");
  101.         Config.addName("tile.rppanel." + var5 + ".name", var6 + " Panel");
  102.         Config.addName("tile.rpslab." + var5 + ".name", var6 + " Slab");
  103.         Config.addName("tile.rphcover." + var5 + ".name", "Hollow " + var6 + " Cover");
  104.         Config.addName("tile.rphpanel." + var5 + ".name", "Hollow " + var6 + " Panel");
  105.         Config.addName("tile.rphslab." + var5 + ".name", "Hollow " + var6 + " Slab");
  106.         Config.addName("tile.rpcovc." + var5 + ".name", var6 + " Cover Corner");
  107.         Config.addName("tile.rppanc." + var5 + ".name", var6 + " Panel Corner");
  108.         Config.addName("tile.rpslabc." + var5 + ".name", var6 + " Slab Corner");
  109.         Config.addName("tile.rpcovs." + var5 + ".name", var6 + " Cover Strip");
  110.         Config.addName("tile.rppans." + var5 + ".name", var6 + " Panel Strip");
  111.         Config.addName("tile.rpslabs." + var5 + ".name", var6 + " Slab Strip");
  112.         Config.addName("tile.rpcov3." + var5 + ".name", var6 + " Triple Cover");
  113.         Config.addName("tile.rpcov5." + var5 + ".name", var6 + " Cover Slab");
  114.         Config.addName("tile.rpcov6." + var5 + ".name", var6 + " Triple Panel");
  115.         Config.addName("tile.rpcov7." + var5 + ".name", var6 + " Anticover");
  116.         Config.addName("tile.rphcov3." + var5 + ".name", var6 + " Hollow Triple Cover");
  117.         Config.addName("tile.rphcov5." + var5 + ".name", var6 + " Hollow Cover Slab");
  118.         Config.addName("tile.rphcov6." + var5 + ".name", var6 + " Hollow Triple Panel");
  119.         Config.addName("tile.rphcov7." + var5 + ".name", var6 + " Hollow Anticover");
  120.         Config.addName("tile.rpcov3c." + var5 + ".name", var6 + " Triple Cover Corner");
  121.         Config.addName("tile.rpcov5c." + var5 + ".name", var6 + " Cover Slab Corner");
  122.         Config.addName("tile.rpcov6c." + var5 + ".name", var6 + " Triple Panel Corner");
  123.         Config.addName("tile.rpcov7c." + var5 + ".name", var6 + " Anticover Corner");
  124.         Config.addName("tile.rpcov3s." + var5 + ".name", var6 + " Triple Cover Strip");
  125.         Config.addName("tile.rpcov5s." + var5 + ".name", var6 + " Cover Slab Strip");
  126.         Config.addName("tile.rpcov6s." + var5 + ".name", var6 + " Triple Panel Strip");
  127.         Config.addName("tile.rpcov7s." + var5 + ".name", var6 + " Anticover Strip");
  128.         Config.addName("tile.rppole1." + var5 + ".name", var6 + " Post");
  129.         Config.addName("tile.rppole2." + var5 + ".name", var6 + " Pillar");
  130.         Config.addName("tile.rppole3." + var5 + ".name", var6 + " Column");
  131.     }
  132.  
  133.     public static int damageToCoverData(int var0)
  134.     {
  135.         int var1 = var0 >> 8;
  136.         int var2 = var0 & 255;
  137.  
  138.         switch (var1)
  139.         {
  140.             case 0:
  141.                 var2 |= 65536;
  142.  
  143.             case 1:
  144.             case 2:
  145.             case 3:
  146.             case 4:
  147.             case 5:
  148.             case 6:
  149.             case 7:
  150.             case 8:
  151.             case 9:
  152.             case 10:
  153.             case 11:
  154.             case 12:
  155.             case 13:
  156.             case 14:
  157.             case 15:
  158.             default:
  159.                 break;
  160.  
  161.             case 16:
  162.                 var2 |= 131328;
  163.                 break;
  164.  
  165.             case 17:
  166.                 var2 |= 262656;
  167.                 break;
  168.  
  169.             case 18:
  170.                 var2 |= 33619968;
  171.                 break;
  172.  
  173.             case 19:
  174.                 var2 |= 33685760;
  175.                 break;
  176.  
  177.             case 20:
  178.                 var2 |= 33817088;
  179.                 break;
  180.  
  181.             case 21:
  182.                 var2 |= 16842752;
  183.                 break;
  184.  
  185.             case 22:
  186.                 var2 |= 16908544;
  187.                 break;
  188.  
  189.             case 23:
  190.                 var2 |= 17039872;
  191.                 break;
  192.  
  193.             case 24:
  194.                 var2 |= 1114880;
  195.                 break;
  196.  
  197.             case 25:
  198.                 var2 |= 1180672;
  199.                 break;
  200.  
  201.             case 26:
  202.                 var2 |= 1312000;
  203.                 break;
  204.  
  205.             case 27:
  206.                 var2 |= 198144;
  207.                 break;
  208.  
  209.             case 28:
  210.                 var2 |= 329472;
  211.                 break;
  212.  
  213.             case 29:
  214.                 var2 |= 395264;
  215.                 break;
  216.  
  217.             case 30:
  218.                 var2 |= 461056;
  219.                 break;
  220.  
  221.             case 31:
  222.                 var2 |= 1247744;
  223.                 break;
  224.  
  225.             case 32:
  226.                 var2 |= 1379072;
  227.                 break;
  228.  
  229.             case 33:
  230.                 var2 |= 1444864;
  231.                 break;
  232.  
  233.             case 34:
  234.                 var2 |= 1510656;
  235.                 break;
  236.  
  237.             case 35:
  238.                 var2 |= 33751808;
  239.                 break;
  240.  
  241.             case 36:
  242.                 var2 |= 33883136;
  243.                 break;
  244.  
  245.             case 37:
  246.                 var2 |= 33948928;
  247.                 break;
  248.  
  249.             case 38:
  250.                 var2 |= 34014720;
  251.                 break;
  252.  
  253.             case 39:
  254.                 var2 |= 16974592;
  255.                 break;
  256.  
  257.             case 40:
  258.                 var2 |= 17105920;
  259.                 break;
  260.  
  261.             case 41:
  262.                 var2 |= 17171712;
  263.                 break;
  264.  
  265.             case 42:
  266.                 var2 |= 17237504;
  267.                 break;
  268.  
  269.             case 43:
  270.                 var2 |= 50462720;
  271.                 break;
  272.  
  273.             case 44:
  274.                 var2 |= 50594048;
  275.                 break;
  276.  
  277.             case 45:
  278.                 var2 |= 50725376;
  279.         }
  280.  
  281.         return var2;
  282.     }
  283.  
  284.     public static int damageToCoverValue(int var0)
  285.     {
  286.         return damageToCoverData(var0) & 65535;
  287.     }
  288.  
  289.     public static int coverValueToDamage(int var0, int var1)
  290.     {
  291.         int var2 = var1 >> 8;
  292.         int var3 = var1 & 255;
  293.  
  294.         if (var0 < 6)
  295.         {
  296.             switch (var2)
  297.             {
  298.                 case 1:
  299.                     var3 |= 4096;
  300.                     break;
  301.  
  302.                 case 2:
  303.                     var3 |= 4352;
  304.                     break;
  305.  
  306.                 case 3:
  307.                     var3 |= 6144;
  308.                     break;
  309.  
  310.                 case 4:
  311.                     var3 |= 6400;
  312.                     break;
  313.  
  314.                 case 5:
  315.                     var3 |= 6656;
  316.                     break;
  317.  
  318.                 case 6:
  319.                     var3 |= 6912;
  320.                     break;
  321.  
  322.                 case 7:
  323.                     var3 |= 7168;
  324.                     break;
  325.  
  326.                 case 8:
  327.                     var3 |= 7424;
  328.                     break;
  329.  
  330.                 case 9:
  331.                     var3 |= 7680;
  332.                     break;
  333.  
  334.                 case 10:
  335.                     var3 |= 7936;
  336.                     break;
  337.  
  338.                 case 11:
  339.                     var3 |= 8192;
  340.                     break;
  341.  
  342.                 case 12:
  343.                     var3 |= 8448;
  344.                     break;
  345.  
  346.                 case 13:
  347.                     var3 |= 8704;
  348.             }
  349.         }
  350.         else if (var0 < 14)
  351.         {
  352.             switch (var2)
  353.             {
  354.                 case 0:
  355.                     var3 |= 4608;
  356.                     break;
  357.  
  358.                 case 1:
  359.                     var3 |= 4864;
  360.                     break;
  361.  
  362.                 case 2:
  363.                     var3 |= 5120;
  364.                     break;
  365.  
  366.                 case 3:
  367.                     var3 |= 8960;
  368.                     break;
  369.  
  370.                 case 4:
  371.                     var3 |= 9216;
  372.                     break;
  373.  
  374.                 case 5:
  375.                     var3 |= 9472;
  376.                     break;
  377.  
  378.                 case 6:
  379.                     var3 |= 9728;
  380.             }
  381.         }
  382.         else if (var0 < 26)
  383.         {
  384.             switch (var2)
  385.             {
  386.                 case 0:
  387.                     var3 |= 5376;
  388.                     break;
  389.  
  390.                 case 1:
  391.                     var3 |= 5632;
  392.                     break;
  393.  
  394.                 case 2:
  395.                     var3 |= 5888;
  396.                     break;
  397.  
  398.                 case 3:
  399.                     var3 |= 9984;
  400.                     break;
  401.  
  402.                 case 4:
  403.                     var3 |= 10240;
  404.                     break;
  405.  
  406.                 case 5:
  407.                     var3 |= 10496;
  408.                     break;
  409.  
  410.                 case 6:
  411.                     var3 |= 10752;
  412.             }
  413.         }
  414.         else if (var0 < 29)
  415.         {
  416.             switch (var2)
  417.             {
  418.                 case 0:
  419.                     var3 |= 11008;
  420.                     break;
  421.  
  422.                 case 1:
  423.                     var3 |= 11264;
  424.                     break;
  425.  
  426.                 case 2:
  427.                     var3 |= 11520;
  428.             }
  429.         }
  430.  
  431.         return var3;
  432.     }
  433.  
  434.     public static ItemStack convertCoverPlate(int var0, int var1)
  435.     {
  436.         return blockCoverPlate == null ? null : new ItemStack(blockCoverPlate, 1, coverValueToDamage(var0, var1));
  437.     }
  438.  
  439.     public static int cornerToCoverMask(int var0)
  440.     {
  441.         switch (var0)
  442.         {
  443.             case 0:
  444.                 return 21;
  445.  
  446.             case 1:
  447.                 return 25;
  448.  
  449.             case 2:
  450.                 return 37;
  451.  
  452.             case 3:
  453.                 return 41;
  454.  
  455.             case 4:
  456.                 return 22;
  457.  
  458.             case 5:
  459.                 return 26;
  460.  
  461.             case 6:
  462.                 return 38;
  463.  
  464.             default:
  465.                 return 42;
  466.         }
  467.     }
  468.  
  469.     public static int coverToCornerMask(int var0)
  470.     {
  471.         switch (var0)
  472.         {
  473.             case 0:
  474.                 return 15;
  475.  
  476.             case 1:
  477.                 return 240;
  478.  
  479.             case 2:
  480.                 return 85;
  481.  
  482.             case 3:
  483.                 return 170;
  484.  
  485.             case 4:
  486.                 return 51;
  487.  
  488.             default:
  489.                 return 204;
  490.         }
  491.     }
  492.  
  493.     public static int coverToStripMask(int var0)
  494.     {
  495.         switch (var0)
  496.         {
  497.             case 0:
  498.                 return 15;
  499.  
  500.             case 1:
  501.                 return 3840;
  502.  
  503.             case 2:
  504.                 return 337;
  505.  
  506.             case 3:
  507.                 return 674;
  508.  
  509.             case 4:
  510.                 return 1076;
  511.  
  512.             default:
  513.                 return 2248;
  514.         }
  515.     }
  516.  
  517.     public static int stripToCornerMask(int var0)
  518.     {
  519.         switch (var0)
  520.         {
  521.             case 0:
  522.                 return 5;
  523.  
  524.             case 1:
  525.                 return 10;
  526.  
  527.             case 2:
  528.                 return 3;
  529.  
  530.             case 3:
  531.                 return 12;
  532.  
  533.             case 4:
  534.                 return 17;
  535.  
  536.             case 5:
  537.                 return 34;
  538.  
  539.             case 6:
  540.                 return 68;
  541.  
  542.             case 7:
  543.                 return 136;
  544.  
  545.             case 8:
  546.                 return 80;
  547.  
  548.             case 9:
  549.                 return 160;
  550.  
  551.             case 10:
  552.                 return 48;
  553.  
  554.             default:
  555.                 return 192;
  556.         }
  557.     }
  558.  
  559.     public static int stripToCoverMask(int var0)
  560.     {
  561.         switch (var0)
  562.         {
  563.             case 0:
  564.                 return 5;
  565.  
  566.             case 1:
  567.                 return 9;
  568.  
  569.             case 2:
  570.                 return 17;
  571.  
  572.             case 3:
  573.                 return 33;
  574.  
  575.             case 4:
  576.                 return 20;
  577.  
  578.             case 5:
  579.                 return 24;
  580.  
  581.             case 6:
  582.                 return 36;
  583.  
  584.             case 7:
  585.                 return 40;
  586.  
  587.             case 8:
  588.                 return 6;
  589.  
  590.             case 9:
  591.                 return 10;
  592.  
  593.             case 10:
  594.                 return 18;
  595.  
  596.             default:
  597.                 return 34;
  598.         }
  599.     }
  600.  
  601.     public static float getThickness(int var0, int var1)
  602.     {
  603.         if (var0 < 6)
  604.         {
  605.             switch (var1 >> 8)
  606.             {
  607.                 case 0:
  608.                     return 0.125F;
  609.  
  610.                 case 1:
  611.                     return 0.25F;
  612.  
  613.                 case 2:
  614.                     return 0.5F;
  615.  
  616.                 case 3:
  617.                     return 0.125F;
  618.  
  619.                 case 4:
  620.                     return 0.25F;
  621.  
  622.                 case 5:
  623.                     return 0.5F;
  624.  
  625.                 case 6:
  626.                     return 0.375F;
  627.  
  628.                 case 7:
  629.                     return 0.625F;
  630.  
  631.                 case 8:
  632.                     return 0.75F;
  633.  
  634.                 case 9:
  635.                     return 0.875F;
  636.  
  637.                 case 10:
  638.                     return 0.375F;
  639.  
  640.                 case 11:
  641.                     return 0.625F;
  642.  
  643.                 case 12:
  644.                     return 0.75F;
  645.  
  646.                 case 13:
  647.                     return 0.875F;
  648.  
  649.                 default:
  650.                     return 1.0F;
  651.             }
  652.         }
  653.         else
  654.         {
  655.             if (var0 >= 26 && var0 < 29)
  656.             {
  657.                 switch (var1 >> 8)
  658.                 {
  659.                     case 0:
  660.                         return 0.125F;
  661.  
  662.                     case 1:
  663.                         return 0.25F;
  664.  
  665.                     case 2:
  666.                         return 0.375F;
  667.                 }
  668.             }
  669.  
  670.             switch (var1 >> 8)
  671.             {
  672.                 case 0:
  673.                     return 0.125F;
  674.  
  675.                 case 1:
  676.                     return 0.25F;
  677.  
  678.                 case 2:
  679.                     return 0.5F;
  680.  
  681.                 case 3:
  682.                     return 0.375F;
  683.  
  684.                 case 4:
  685.                     return 0.625F;
  686.  
  687.                 case 5:
  688.                     return 0.75F;
  689.  
  690.                 case 6:
  691.                     return 0.875F;
  692.  
  693.                 default:
  694.                     return 1.0F;
  695.             }
  696.         }
  697.     }
  698.  
  699.     public static int getThicknessQuanta(int var0, int var1)
  700.     {
  701.         if (var0 < 6)
  702.         {
  703.             switch (var1 >> 8)
  704.             {
  705.                 case 0:
  706.                     return 1;
  707.  
  708.                 case 1:
  709.                     return 2;
  710.  
  711.                 case 2:
  712.                     return 4;
  713.  
  714.                 case 3:
  715.                     return 1;
  716.  
  717.                 case 4:
  718.                     return 2;
  719.  
  720.                 case 5:
  721.                     return 4;
  722.  
  723.                 case 6:
  724.                     return 3;
  725.  
  726.                 case 7:
  727.                     return 5;
  728.  
  729.                 case 8:
  730.                     return 6;
  731.  
  732.                 case 9:
  733.                     return 7;
  734.  
  735.                 case 10:
  736.                     return 3;
  737.  
  738.                 case 11:
  739.                     return 5;
  740.  
  741.                 case 12:
  742.                     return 6;
  743.  
  744.                 case 13:
  745.                     return 7;
  746.  
  747.                 default:
  748.                     return 0;
  749.             }
  750.         }
  751.         else
  752.         {
  753.             if (var0 >= 26 && var0 < 29)
  754.             {
  755.                 switch (var1 >> 8)
  756.                 {
  757.                     case 0:
  758.                         return 1;
  759.  
  760.                     case 1:
  761.                         return 2;
  762.  
  763.                     case 2:
  764.                         return 3;
  765.                 }
  766.             }
  767.  
  768.             switch (var1 >> 8)
  769.             {
  770.                 case 0:
  771.                     return 1;
  772.  
  773.                 case 1:
  774.                     return 2;
  775.  
  776.                 case 2:
  777.                     return 4;
  778.  
  779.                 case 3:
  780.                     return 3;
  781.  
  782.                 case 4:
  783.                     return 5;
  784.  
  785.                 case 5:
  786.                     return 6;
  787.  
  788.                 case 6:
  789.                     return 7;
  790.  
  791.                 default:
  792.                     return 0;
  793.             }
  794.         }
  795.     }
  796.  
  797.     public static boolean checkPlacement(int var0, short[] var1, int var2, boolean var3)
  798.     {
  799.         boolean var7 = false;
  800.         boolean var8 = false;
  801.         CoverLib$PlacementValidator var9 = new CoverLib$PlacementValidator(var0, var1);
  802.         return var9.checkPlacement(var2, var3);
  803.     }
  804.  
  805.     private static boolean canAddCover(World var0, MovingObjectPosition var1, int var2)
  806.     {
  807.         if (var0.canPlaceEntityOnSide(blockCoverPlate.blockID, var1.blockX, var1.blockY, var1.blockZ, false, var1.sideHit, (Entity)null))
  808.         {
  809.             return true;
  810.         }
  811.         else
  812.         {
  813.             ICoverable var3 = (ICoverable)CoreLib.getTileEntity(var0, var1.blockX, var1.blockY, var1.blockZ, ICoverable.class);
  814.             return var3 == null ? false : var3.canAddCover(var1.subHit, var2);
  815.         }
  816.     }
  817.  
  818.     private static int extractCoverSide(MovingObjectPosition var0)
  819.     {
  820.         byte var1 = 0;
  821.         double var2 = var0.hitVec.xCoord - (double)var0.blockX - 0.5D;
  822.         double var4 = var0.hitVec.yCoord - (double)var0.blockY - 0.5D;
  823.         double var6 = var0.hitVec.zCoord - (double)var0.blockZ - 0.5D;
  824.         float var8 = 0.25F;
  825.  
  826.         switch (var0.sideHit)
  827.         {
  828.             case 0:
  829.             case 1:
  830.                 if (var6 > (double)(-var8) && var6 < (double)var8 && var2 > (double)(-var8) && var2 < (double)var8)
  831.                 {
  832.                     return var0.sideHit;
  833.                 }
  834.                 else if (var6 > var2)
  835.                 {
  836.                     if (var6 > -var2)
  837.                     {
  838.                         return 3;
  839.                     }
  840.  
  841.                     return 4;
  842.                 }
  843.                 else
  844.                 {
  845.                     if (var6 > -var2)
  846.                     {
  847.                         return 5;
  848.                     }
  849.  
  850.                     return 2;
  851.                 }
  852.  
  853.             case 2:
  854.             case 3:
  855.                 if (var4 > (double)(-var8) && var4 < (double)var8 && var2 > (double)(-var8) && var2 < (double)var8)
  856.                 {
  857.                     return var0.sideHit;
  858.                 }
  859.                 else if (var4 > var2)
  860.                 {
  861.                     if (var4 > -var2)
  862.                     {
  863.                         return 1;
  864.                     }
  865.  
  866.                     return 4;
  867.                 }
  868.                 else
  869.                 {
  870.                     if (var4 > -var2)
  871.                     {
  872.                         return 5;
  873.                     }
  874.  
  875.                     return 0;
  876.                 }
  877.  
  878.             case 4:
  879.             case 5:
  880.                 if (var4 > (double)(-var8) && var4 < (double)var8 && var6 > (double)(-var8) && var6 < (double)var8)
  881.                 {
  882.                     return var0.sideHit;
  883.                 }
  884.                 else if (var4 > var6)
  885.                 {
  886.                     if (var4 > -var6)
  887.                     {
  888.                         return 1;
  889.                     }
  890.  
  891.                     return 2;
  892.                 }
  893.                 else
  894.                 {
  895.                     if (var4 > -var6)
  896.                     {
  897.                         return 3;
  898.                     }
  899.  
  900.                     return 0;
  901.                 }
  902.  
  903.             default:
  904.                 return var1;
  905.         }
  906.     }
  907.  
  908.     private static int extractCoverAxis(MovingObjectPosition var0)
  909.     {
  910.         switch (var0.sideHit)
  911.         {
  912.             case 0:
  913.             case 1:
  914.                 return var0.hitVec.yCoord - (double)var0.blockY > 0.5D ? 1 : 0;
  915.  
  916.             case 2:
  917.             case 3:
  918.                 return var0.hitVec.zCoord - (double)var0.blockZ > 0.5D ? 1 : 0;
  919.  
  920.             default:
  921.                 return var0.hitVec.xCoord - (double)var0.blockX > 0.5D ? 1 : 0;
  922.         }
  923.     }
  924.  
  925.     private static void stepDir(MovingObjectPosition var0)
  926.     {
  927.         switch (var0.sideHit)
  928.         {
  929.             case 0:
  930.                 --var0.blockY;
  931.                 break;
  932.  
  933.             case 1:
  934.                 ++var0.blockY;
  935.                 break;
  936.  
  937.             case 2:
  938.                 --var0.blockZ;
  939.                 break;
  940.  
  941.             case 3:
  942.                 ++var0.blockZ;
  943.                 break;
  944.  
  945.             case 4:
  946.                 --var0.blockX;
  947.                 break;
  948.  
  949.             default:
  950.                 ++var0.blockX;
  951.         }
  952.     }
  953.  
  954.     private static boolean isClickOutside(MovingObjectPosition var0)
  955.     {
  956.         if (var0.subHit < 0)
  957.         {
  958.             return true;
  959.         }
  960.         else if (var0.subHit < 6)
  961.         {
  962.             return var0.sideHit != (var0.subHit ^ 1);
  963.         }
  964.         else
  965.         {
  966.             int var1;
  967.  
  968.             if (var0.subHit < 14)
  969.             {
  970.                 var1 = var0.subHit - 6;
  971.                 var1 = var1 >> 2 | (var1 & 3) << 1;
  972.                 return ((var0.sideHit ^ var1 >> (var0.sideHit >> 1)) & 1) == 0;
  973.             }
  974.             else if (var0.subHit < 26)
  975.             {
  976.                 var1 = var0.subHit - 14;
  977.                 var1 = stripToCoverMask(var1);
  978.                 return (var1 & 1 << (var0.sideHit ^ 1)) <= 0;
  979.             }
  980.             else
  981.             {
  982.                 return var0.subHit < 29 ? true : var0.subHit == 29;
  983.             }
  984.         }
  985.     }
  986.  
  987.     public static MovingObjectPosition getPlacement(World var0, MovingObjectPosition var1, int var2)
  988.     {
  989.         MovingObjectPosition var7 = new MovingObjectPosition(var1.blockX, var1.blockY, var1.blockZ, var1.sideHit, var1.hitVec);
  990.         int var8 = damageToCoverValue(var2);
  991.         int var3;
  992.  
  993.         switch (var2 >> 8)
  994.         {
  995.             case 0:
  996.             case 16:
  997.             case 17:
  998.             case 24:
  999.             case 25:
  1000.             case 26:
  1001.             case 27:
  1002.             case 28:
  1003.             case 29:
  1004.             case 30:
  1005.             case 31:
  1006.             case 32:
  1007.             case 33:
  1008.             case 34:
  1009.                 var3 = extractCoverSide(var1);
  1010.  
  1011.                 if (var3 != var7.sideHit)
  1012.                 {
  1013.                     var7.subHit = var3;
  1014.  
  1015.                     if (!isClickOutside(var1) && canAddCover(var0, var7, var8))
  1016.                     {
  1017.                         return var7;
  1018.                     }
  1019.                     else
  1020.                     {
  1021.                         stepDir(var7);
  1022.  
  1023.                         if (canAddCover(var0, var7, var8))
  1024.                         {
  1025.                             return var7;
  1026.                         }
  1027.  
  1028.                         return null;
  1029.                     }
  1030.                 }
  1031.                 else
  1032.                 {
  1033.                     if (!isClickOutside(var1))
  1034.                     {
  1035.                         var7.subHit = var3 ^ 1;
  1036.  
  1037.                         if (canAddCover(var0, var7, var8))
  1038.                         {
  1039.                             return var7;
  1040.                         }
  1041.                     }
  1042.  
  1043.                     var7.subHit = var3;
  1044.  
  1045.                     if (canAddCover(var0, var7, var8))
  1046.                     {
  1047.                         return var7;
  1048.                     }
  1049.                     else if (!isClickOutside(var1))
  1050.                     {
  1051.                         return null;
  1052.                     }
  1053.                     else
  1054.                     {
  1055.                         stepDir(var7);
  1056.                         var7.subHit = var3 ^ 1;
  1057.  
  1058.                         if (canAddCover(var0, var7, var8))
  1059.                         {
  1060.                             return var7;
  1061.                         }
  1062.  
  1063.                         return null;
  1064.                     }
  1065.                 }
  1066.  
  1067.             case 1:
  1068.             case 2:
  1069.             case 3:
  1070.             case 4:
  1071.             case 5:
  1072.             case 6:
  1073.             case 7:
  1074.             case 8:
  1075.             case 9:
  1076.             case 10:
  1077.             case 11:
  1078.             case 12:
  1079.             case 13:
  1080.             case 14:
  1081.             case 15:
  1082.             default:
  1083.                 return null;
  1084.  
  1085.             case 18:
  1086.             case 19:
  1087.             case 20:
  1088.             case 35:
  1089.             case 36:
  1090.             case 37:
  1091.             case 38:
  1092.                 double var9 = var1.hitVec.xCoord - (double)var1.blockX;
  1093.                 double var11 = var1.hitVec.yCoord - (double)var1.blockY;
  1094.                 double var13 = var1.hitVec.zCoord - (double)var1.blockZ;
  1095.                 var3 = 0;
  1096.  
  1097.                 if (var13 > 0.5D)
  1098.                 {
  1099.                     ++var3;
  1100.                 }
  1101.  
  1102.                 if (var9 > 0.5D)
  1103.                 {
  1104.                     var3 += 2;
  1105.                 }
  1106.  
  1107.                 if (var11 > 0.5D)
  1108.                 {
  1109.                     var3 += 4;
  1110.                 }
  1111.  
  1112.                 switch (var1.sideHit)
  1113.                 {
  1114.                     case 0:
  1115.                         var3 &= 3;
  1116.                         break;
  1117.  
  1118.                     case 1:
  1119.                         var3 |= 4;
  1120.                         break;
  1121.  
  1122.                     case 2:
  1123.                         var3 &= 6;
  1124.                         break;
  1125.  
  1126.                     case 3:
  1127.                         var3 |= 1;
  1128.                         break;
  1129.  
  1130.                     case 4:
  1131.                         var3 &= 5;
  1132.                         break;
  1133.  
  1134.                     default:
  1135.                         var3 |= 2;
  1136.                 }
  1137.  
  1138.                 int var4;
  1139.  
  1140.                 switch (var1.sideHit)
  1141.                 {
  1142.                     case 0:
  1143.                     case 1:
  1144.                         var4 = var3 ^ 4;
  1145.                         break;
  1146.  
  1147.                     case 2:
  1148.                     case 3:
  1149.                         var4 = var3 ^ 1;
  1150.                         break;
  1151.  
  1152.                     default:
  1153.                         var4 = var3 ^ 2;
  1154.                 }
  1155.  
  1156.                 if (isClickOutside(var1))
  1157.                 {
  1158.                     var7.subHit = var4 + 6;
  1159.                     stepDir(var7);
  1160.  
  1161.                     if (canAddCover(var0, var7, var8))
  1162.                     {
  1163.                         return var7;
  1164.                     }
  1165.  
  1166.                     return null;
  1167.                 }
  1168.                 else
  1169.                 {
  1170.                     var7.subHit = var4 + 6;
  1171.  
  1172.                     if (canAddCover(var0, var7, var8))
  1173.                     {
  1174.                         return var7;
  1175.                     }
  1176.                     else
  1177.                     {
  1178.                         var7.subHit = var3 + 6;
  1179.  
  1180.                         if (canAddCover(var0, var7, var8))
  1181.                         {
  1182.                             return var7;
  1183.                         }
  1184.  
  1185.                         return null;
  1186.                     }
  1187.                 }
  1188.  
  1189.             case 21:
  1190.             case 22:
  1191.             case 23:
  1192.             case 39:
  1193.             case 40:
  1194.             case 41:
  1195.             case 42:
  1196.                 var3 = extractCoverSide(var1);
  1197.  
  1198.                 if (var3 == var7.sideHit)
  1199.                 {
  1200.                     return null;
  1201.                 }
  1202.                 else
  1203.                 {
  1204.                     int var5 = coverToStripMask(var3);
  1205.                     int var6;
  1206.  
  1207.                     if (!isClickOutside(var1))
  1208.                     {
  1209.                         var6 = var5 & coverToStripMask(var7.sideHit ^ 1);
  1210.                         var7.subHit = 14 + Integer.numberOfTrailingZeros(var6);
  1211.  
  1212.                         if (canAddCover(var0, var7, var8))
  1213.                         {
  1214.                             return var7;
  1215.                         }
  1216.                         else
  1217.                         {
  1218.                             var6 = var5 & coverToStripMask(var7.sideHit);
  1219.                             var7.subHit = 14 + Integer.numberOfTrailingZeros(var6);
  1220.  
  1221.                             if (canAddCover(var0, var7, var8))
  1222.                             {
  1223.                                 return var7;
  1224.                             }
  1225.  
  1226.                             return null;
  1227.                         }
  1228.                     }
  1229.                     else
  1230.                     {
  1231.                         stepDir(var7);
  1232.                         var6 = var5 & coverToStripMask(var7.sideHit ^ 1);
  1233.                         var7.subHit = 14 + Integer.numberOfTrailingZeros(var6);
  1234.  
  1235.                         if (canAddCover(var0, var7, var8))
  1236.                         {
  1237.                             return var7;
  1238.                         }
  1239.  
  1240.                         return null;
  1241.                     }
  1242.                 }
  1243.  
  1244.             case 43:
  1245.             case 44:
  1246.             case 45:
  1247.                 var3 = extractCoverSide(var1);
  1248.  
  1249.                 if (var3 != var7.sideHit && var3 != (var7.sideHit ^ 1))
  1250.                 {
  1251.                     return null;
  1252.                 }
  1253.                 else
  1254.                 {
  1255.                     if (isClickOutside(var1))
  1256.                     {
  1257.                         stepDir(var7);
  1258.                     }
  1259.  
  1260.                     var7.subHit = (var3 >> 1) + 26;
  1261.                     return canAddCover(var0, var7, var8) ? var7 : null;
  1262.                 }
  1263.         }
  1264.     }
  1265.  
  1266.     public static void replaceWithCovers(World var0, int var1, int var2, int var3, int var4, short[] var5)
  1267.     {
  1268.         BlockMultipart.removeMultipart(var0, var1, var2, var3);
  1269.  
  1270.         if (blockCoverPlate != null)
  1271.         {
  1272.             if (var4 != 0)
  1273.             {
  1274.                 var0.setBlockAndMetadata(var1, var2, var3, blockCoverPlate.blockID, 0);
  1275.                 TileCovered var6 = (TileCovered)CoreLib.getTileEntity(var0, var1, var2, var3, TileCovered.class);
  1276.  
  1277.                 if (var6 != null)
  1278.                 {
  1279.                     var6.CoverSides = var4;
  1280.                     var6.Covers = var5;
  1281.                     RedPowerLib.updateIndirectNeighbors(var0, var1, var2, var3, blockCoverPlate.blockID);
  1282.                 }
  1283.             }
  1284.         }
  1285.     }
  1286.  
  1287.     public static boolean tryMakeCompatible(World var0, WorldCoord var1, int var2, int var3)
  1288.     {
  1289.         TileCovered var4 = (TileCovered)CoreLib.getTileEntity(var0, var1, TileCovered.class);
  1290.  
  1291.         if (var4 == null)
  1292.         {
  1293.             return false;
  1294.         }
  1295.         else
  1296.         {
  1297.             int var5 = var3 >> 8;
  1298.             int var6 = var3 & 255;
  1299.             int var7 = var4.getExtendedID();
  1300.  
  1301.             if (var7 == var5)
  1302.             {
  1303.                 return var4.getExtendedMetadata() == var6;
  1304.             }
  1305.             else if (var7 != 0)
  1306.             {
  1307.                 return false;
  1308.             }
  1309.             else
  1310.             {
  1311.                 short[] var8 = var4.Covers;
  1312.                 int var9 = var4.CoverSides;
  1313.                 BlockMultipart.removeMultipart(var0, var1.x, var1.y, var1.z);
  1314.  
  1315.                 if (!var0.setBlockAndMetadata(var1.x, var1.y, var1.z, var2, var5))
  1316.                 {
  1317.                     return false;
  1318.                 }
  1319.                 else
  1320.                 {
  1321.                     var4 = (TileCovered)CoreLib.getTileEntity(var0, var1, TileCovered.class);
  1322.  
  1323.                     if (var4 == null)
  1324.                     {
  1325.                         return true;
  1326.                     }
  1327.                     else
  1328.                     {
  1329.                         var4.Covers = var8;
  1330.                         var4.CoverSides = var9;
  1331.                         var4.setExtendedMetadata(var6);
  1332.                         return true;
  1333.                     }
  1334.                 }
  1335.             }
  1336.         }
  1337.     }
  1338.  
  1339.     public static ItemStack getItemStack(int var0)
  1340.     {
  1341.         return materials[var0];
  1342.     }
  1343.  
  1344.     public static Block getBlock(int var0)
  1345.     {
  1346.         ItemStack var1 = materials[var0];
  1347.         return Block.blocksList[var1.itemID];
  1348.     }
  1349.  
  1350.     public static String getName(int var0)
  1351.     {
  1352.         return names[var0];
  1353.     }
  1354.  
  1355.     public static String getDesc(int var0)
  1356.     {
  1357.         return descs[var0];
  1358.     }
  1359.  
  1360.     public static int getHardness(int var0)
  1361.     {
  1362.         return hardness[var0];
  1363.     }
  1364.  
  1365.     public static float getMiningHardness(int var0)
  1366.     {
  1367.         return miningHardness[var0];
  1368.     }
  1369.  
  1370.     public static boolean isTransparent(int var0)
  1371.     {
  1372.         return transparency[var0];
  1373.     }
  1374. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!