Advertisement
Corosus

PathfinderEnh

Oct 24th, 2011
137
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 25.25 KB | None | 0 0
  1. package net.minecraft.src;
  2.  
  3. import net.minecraft.src.Block;
  4. import net.minecraft.src.BlockDoor;
  5. import net.minecraft.src.Entity;
  6. import net.minecraft.src.IBlockAccess;
  7. import net.minecraft.src.MCHash;
  8. import net.minecraft.src.Material;
  9. import net.minecraft.src.MathHelper;
  10. import net.minecraft.src.Path;
  11. import net.minecraft.src.PathEntity;
  12. import net.minecraft.src.PathPoint;
  13. import java.util.LinkedList;
  14. import java.util.Iterator;
  15.  
  16. public class PathfinderEnh implements Runnable {
  17.  
  18.     private IBlockAccess worldMap;
  19.     private Path path = new Path();
  20.     private MCHash pointMap = new MCHash();
  21.     private PathPoint[] pathOptions = new PathPoint[32];
  22.  
  23.     public boolean foundEnd;
  24.     public boolean canClimb = false;
  25.     public boolean canUseLadder = false;
  26.  
  27.     public boolean isPathing = false;
  28.     public PathEntity t_path;
  29.     public Entity t_ent;
  30.     public Entity t_targ;
  31.     public float t_dist;
  32.  
  33.     public ChunkCache cc;
  34.     public boolean firstUse = true;
  35.    
  36.     public boolean tryAgain = false;
  37.  
  38.     public PathfinderEnh(IBlockAccess var1) {
  39.         this.worldMap = var1;
  40.     }
  41.  
  42.     public void run() {
  43.         //}
  44.         t_path = createEntityPathTo(t_ent, t_targ, t_dist);
  45.         ((EntityCreature)t_ent).setPathToEntity(t_path);
  46.         isPathing = false;
  47.  
  48.         if (t_path != null) {
  49.             //System.out.println(t_path.points.length);
  50.         }
  51.     }
  52.  
  53.     public static PathEntity requestPath() {
  54.         //try transparent way:
  55.         //ent asks for path, insta return 1 node path with ent pos Y+4 to keep it still, start thread
  56.         //then once thread has path, replace fake path with actual path
  57.         return null;
  58.     }
  59.  
  60.     public PathEntity getPathToEntity(Entity var1, Entity var2, float var3) {
  61.         return getPathToEntity(var1, var2, var3, false);
  62.     }
  63.  
  64.  
  65.  
  66.     public PathEntity getPathToEntity(Entity var1, Entity var2, float var3, boolean canClimb) {
  67.        
  68.         boolean threaded = true;
  69.         tryAgain = false;
  70.         /*if (mod_PathingActivated.lastPathfindTime < System.currentTimeMillis()) {
  71.             mod_PathingActivated.lastPathfindTime = System.currentTimeMillis() + 200;
  72.         } else {
  73.             tryAgain = true;
  74.             PathPoint points[] = new PathPoint[1];
  75.             points[0] = new PathPoint((int)(var1.posX-0.5), (int)(var1.posY + 4D), (int)(var1.posZ-0.5));
  76.             return new PathEntity(points);
  77.         }*/
  78.         mod_PathingActivated.PFCount++;
  79.         if (!isPathing) {
  80.             isPathing = true;
  81.  
  82.             //PathfinderEnh pf = new PathfinderEnh(var14);
  83.             if (var1 instanceof EntityHooks) {
  84.                 this.canClimb = canClimb;
  85.                 //this.worldMap = var14;
  86.                 this.t_ent = var1;
  87.                 this.t_targ = var2;
  88.                 this.t_dist = var3;
  89.                 this.t_path = null;
  90.                 if (t_ent instanceof EntityHooks && ((EntityHooks)t_ent).team == 1 || mod_PathingActivated.hostilesUseLadders) {
  91.                     this.canUseLadder = true;
  92.                 }
  93.                
  94.                
  95.                
  96.                 int var4 = MathHelper.floor_double(t_ent.posX);
  97.                 int var5 = MathHelper.floor_double(t_ent.posY);
  98.                 int var6 = MathHelper.floor_double(t_ent.posZ);
  99.                 int var7 = (int)(t_dist + 16.0F);
  100.                 int var8 = var4 - var7;
  101.                 int var9 = var5 - var7;
  102.                 int var10 = var6 - var7;
  103.                 int var11 = var4 + var7;
  104.                 int var12 = var5 + var7;
  105.                 int var13 = var6 + var7;
  106.                 //if (firstUse) {
  107.                 //firstUse = false;
  108.                 //System.out.println("pf chunkcache!");
  109.                
  110.                 //threaded method!
  111.                 if (threaded) {
  112.                     if (mod_PathingActivated.lastWorldCacheTime < System.currentTimeMillis() || mod_PathingActivated.worldCache == null) {
  113.                         mod_PathingActivated.lastWorldCacheTime = System.currentTimeMillis() + 5000;
  114.                         //mod_PathingActivated.worldCache = new ChunkCache(ModLoader.getMinecraftInstance().theWorld, var8, var9, var10, var11, var12, var13);
  115.                     }
  116.                     //worldMap = mod_PathingActivated.worldCache;
  117.                     worldMap = ModLoader.getMinecraftInstance().theWorld;
  118.                     (new Thread(this)).start();
  119.                    
  120.                     PathPoint points[] = new PathPoint[1];
  121.                     points[0] = new PathPoint((int)(var1.posX-0.5), (int)(var1.posY + 4D), (int)(var1.posZ-0.5));
  122.                     return new PathEntity(points);
  123.                 } else {
  124.                     worldMap = new ChunkCache(ModLoader.getMinecraftInstance().theWorld, var8, var9, var10, var11, var12, var13);
  125.                     //worldMap = t_ent.worldObj;
  126.                     t_path = createEntityPathTo(t_ent, t_targ, t_dist);
  127.                     //((EntityCreature)t_ent).setPathToEntity(t_path);
  128.                     isPathing = false; 
  129.                 }
  130.                
  131.                 //non threaded method
  132.                 //worldMap = t_ent.worldObj;
  133.                 //t_path = createEntityPathTo(t_ent, t_targ, t_dist);
  134.                 //((EntityCreature)t_ent).setPathToEntity(t_path);
  135.                 //isPathing = false;
  136.                
  137.                 //TRIM PATHFIND CODE!!
  138.                 //http://pastebin.com/6bGdzFBJ
  139.             }
  140.  
  141.             //return ((EntityHooks)var1).pf.createEntityPathTo(var1, var2, var3);
  142.         } else {
  143.         }
  144.  
  145.        
  146.             return t_path;
  147.        
  148.     }
  149.  
  150.     public PathEntity getEntityPathToXYZ(Entity var1, int var2, int var3, int var4, float var5) {
  151.         int var6 = MathHelper.floor_double(var1.posX);
  152.         int var7 = MathHelper.floor_double(var1.posY);
  153.         int var8 = MathHelper.floor_double(var1.posZ);
  154.         int var9 = (int)(var5 + 8.0F);
  155.         int var10 = var6 - var9;
  156.         int var11 = var7 - var9;
  157.         int var12 = var8 - var9;
  158.         int var13 = var6 + var9;
  159.         int var14 = var7 + var9;
  160.         int var15 = var8 + var9;
  161.         ChunkCache var16 = new ChunkCache(ModLoader.getMinecraftInstance().theWorld, var10, var11, var12, var13, var14, var15);
  162.         PathfinderEnh pf = new PathfinderEnh(var16);
  163.         pf.canClimb = false;
  164.         return (pf).createEntityPathTo(var1, var2, var3, var4, var5);
  165.     }
  166.  
  167.     public PathEntity createEntityPathTo(Entity var1, Entity var2, float var3) {
  168.         return this.createEntityPathTo(var1, var2.posX, var2.boundingBox.minY, var2.posZ, var3);
  169.     }
  170.  
  171.     public PathEntity createEntityPathTo(Entity var1, int var2, int var3, int var4, float var5) {
  172.         return this.createEntityPathTo(var1, (double)((float)var2 + 0.5F), (double)((float)var3 + 0.5F), (double)((float)var4 + 0.5F), var5);
  173.     }
  174.  
  175.     private PathEntity createEntityPathTo(Entity var1, double var2, double var4, double var6, float var8) {
  176.         this.path.clearPath();
  177.         this.pointMap.clearMap();
  178.         foundEnd = false;
  179.         PathPoint var9 = this.openPoint(MathHelper.floor_double(var1.boundingBox.minX), MathHelper.floor_double(var1.boundingBox.minY), MathHelper.floor_double(var1.boundingBox.minZ));
  180.         PathPoint var10 = this.openPoint(MathHelper.floor_double(var2 - (double)(var1.width / 2.0F)), MathHelper.floor_double(var4), MathHelper.floor_double(var6 - (double)(var1.width / 2.0F)));
  181.         PathPoint var11 = new PathPoint(MathHelper.floor_float(var1.width + 1.0F), MathHelper.floor_float(var1.height + 1.0F), MathHelper.floor_float(var1.width + 1.0F));
  182.         PathEntity var12 = this.addToPath(var1, var9, var10, var11, var8);
  183.  
  184.         if (var12 != null) {
  185.             var12.foundEnd = foundEnd;
  186.         }
  187.  
  188.         try {
  189.             //Thread.sleep(500L);
  190.         } catch (Throwable ex) {
  191.         }
  192.        
  193.         var12 = simplifyPath(var12, var11);
  194.  
  195.         return var12;
  196.     }
  197.  
  198.     private PathEntity addToPath(Entity var1, PathPoint var2, PathPoint var3, PathPoint var4, float var5) {
  199.         var2.totalPathDistance = 0.0F;
  200.         var2.distanceToNext = var2.distanceTo(var3);
  201.         var2.distanceToTarget = var2.distanceToNext;
  202.         this.path.clearPath();
  203.         this.path.addPoint(var2);
  204.         PathPoint var6 = var2;
  205.  
  206.         while(!this.path.isPathEmpty()) {
  207.             PathPoint var7 = this.path.dequeue();
  208.  
  209.             if(var7.equals(var3)) {
  210.                 return this.createEntityPath(var2, var3);
  211.             }
  212.  
  213.             if(var7.distanceTo(var3) < var6.distanceTo(var3)) {
  214.                 var6 = var7;
  215.             }
  216.  
  217.             var7.isFirst = true;
  218.             int var8 = this.findPathOptions(var1, var7, var4, var3, var5);
  219.  
  220.             for(int var9 = 0; var9 < var8; ++var9) {
  221.                 PathPoint var10 = this.pathOptions[var9];
  222.                 float var11 = var7.totalPathDistance + var7.distanceTo(var10);
  223.  
  224.                 if(!var10.isAssigned() || var11 < var10.totalPathDistance) {
  225.                     var10.previous = var7;
  226.                     var10.totalPathDistance = var11;
  227.                     var10.distanceToNext = var10.distanceTo(var3);
  228.  
  229.                     if(var10.isAssigned()) {
  230.                         this.path.changeDistance(var10, var10.totalPathDistance + var10.distanceToNext);
  231.                     } else {
  232.                         var10.distanceToTarget = var10.totalPathDistance + var10.distanceToNext;
  233.                         this.path.addPoint(var10);
  234.                     }
  235.                 }
  236.             }
  237.         }
  238.  
  239.         if (Math.abs(var3.xCoord - var6.xCoord) < 2 && Math.abs(var3.yCoord - var6.yCoord) < 2 && Math.abs(var3.zCoord - var6.zCoord) < 2) {
  240.             foundEnd = true;
  241.         }
  242.  
  243.         if(var6 == var2) {
  244.             return null;
  245.         } else {
  246.             return this.createEntityPath(var2, var6);
  247.         }
  248.     }
  249.  
  250.     private int findPathOptions(Entity var1, PathPoint var2, PathPoint var3, PathPoint var4, float var5) {
  251.         int var6 = 0;
  252.         byte var7 = 0;
  253.  
  254.         if(this.getVerticalOffset(var1, var2.xCoord, var2.yCoord + 1, var2.zCoord, var3) == 1) {
  255.             var7 = 1;
  256.         }
  257.  
  258.         PathPoint var8 = this.getSafePoint(var1, var2.xCoord, var2.yCoord, var2.zCoord + 1, var3, var7);
  259.         PathPoint var9 = this.getSafePoint(var1, var2.xCoord - 1, var2.yCoord, var2.zCoord, var3, var7);
  260.         PathPoint var10 = this.getSafePoint(var1, var2.xCoord + 1, var2.yCoord, var2.zCoord, var3, var7);
  261.         PathPoint var11 = this.getSafePoint(var1, var2.xCoord, var2.yCoord, var2.zCoord - 1, var3, var7);
  262.  
  263.         if(var8 != null && !var8.isFirst && var8.distanceTo(var4) < var5) {
  264.             this.pathOptions[var6++] = var8;
  265.         }
  266.  
  267.         if(var9 != null && !var9.isFirst && var9.distanceTo(var4) < var5) {
  268.             this.pathOptions[var6++] = var9;
  269.         }
  270.  
  271.         if(var10 != null && !var10.isFirst && var10.distanceTo(var4) < var5) {
  272.             this.pathOptions[var6++] = var10;
  273.         }
  274.  
  275.         if(var11 != null && !var11.isFirst && var11.distanceTo(var4) < var5) {
  276.             this.pathOptions[var6++] = var11;
  277.         }
  278.  
  279.         if (canClimb) {
  280.             PathPoint vvar8 = this.getClimbPoint(var1, var2.xCoord, var2.yCoord, var2.zCoord + 1, var3, var7, var2.xCoord, var2.zCoord);
  281.             PathPoint vvar9 = this.getClimbPoint(var1, var2.xCoord - 1, var2.yCoord, var2.zCoord, var3, var7, var2.xCoord, var2.zCoord);
  282.             PathPoint vvar10 = this.getClimbPoint(var1, var2.xCoord + 1, var2.yCoord, var2.zCoord, var3, var7, var2.xCoord, var2.zCoord);
  283.             PathPoint vvar11 = this.getClimbPoint(var1, var2.xCoord, var2.yCoord, var2.zCoord - 1, var3, var7, var2.xCoord, var2.zCoord);
  284.  
  285.             if(vvar8 != null && !vvar8.isFirst && vvar8.distanceTo(var4) < var5) {
  286.                 this.pathOptions[var6++] = vvar8;
  287.             }
  288.  
  289.             if(vvar9 != null && !vvar9.isFirst && vvar9.distanceTo(var4) < var5) {
  290.                 this.pathOptions[var6++] = vvar9;
  291.             }
  292.  
  293.             if(vvar10 != null && !vvar10.isFirst && vvar10.distanceTo(var4) < var5) {
  294.                 this.pathOptions[var6++] = vvar10;
  295.             }
  296.  
  297.             if(vvar11 != null && !vvar11.isFirst && vvar11.distanceTo(var4) < var5) {
  298.                 this.pathOptions[var6++] = vvar11;
  299.             }
  300.         }
  301.  
  302.         if (canUseLadder) {
  303.             if (getBlockId(var2.xCoord, var2.yCoord, var2.zCoord) == Block.ladder.blockID) {
  304.                 PathPoint vvar8 = this.getLadderPoint(var1, var2.xCoord, var2.yCoord, var2.zCoord + 1, var3, var7, var2.xCoord, var2.zCoord);
  305.                 PathPoint vvar9 = this.getLadderPoint(var1, var2.xCoord - 1, var2.yCoord, var2.zCoord, var3, var7, var2.xCoord, var2.zCoord);
  306.                 PathPoint vvar10 = this.getLadderPoint(var1, var2.xCoord + 1, var2.yCoord, var2.zCoord, var3, var7, var2.xCoord, var2.zCoord);
  307.                 PathPoint vvar11 = this.getLadderPoint(var1, var2.xCoord, var2.yCoord, var2.zCoord - 1, var3, var7, var2.xCoord, var2.zCoord);
  308.        
  309.                 if(vvar8 != null && !vvar8.isFirst && vvar8.distanceTo(var4) < var5) {
  310.                     this.pathOptions[var6++] = vvar8;
  311.                 }
  312.        
  313.                 if(vvar9 != null && !vvar9.isFirst && vvar9.distanceTo(var4) < var5) {
  314.                     this.pathOptions[var6++] = vvar9;
  315.                 }
  316.        
  317.                 if(vvar10 != null && !vvar10.isFirst && vvar10.distanceTo(var4) < var5) {
  318.                     this.pathOptions[var6++] = vvar10;
  319.                 }
  320.        
  321.                 if(vvar11 != null && !vvar11.isFirst && vvar11.distanceTo(var4) < var5) {
  322.                     this.pathOptions[var6++] = vvar11;
  323.                 }
  324.             }
  325.         }
  326.  
  327.         return var6;
  328.     }
  329.  
  330.     private PathPoint getLadderPoint(Entity var1, int x, int y, int z, PathPoint var5, int var6, int origX, int origZ) {
  331.         PathPoint var7 = null;
  332.  
  333.         if(this.getVerticalOffset(var1, x, y, z, var5) == 1) {
  334.             var7 = this.openPoint(x, y, z);
  335.         }
  336.  
  337.         if(var7 == null && var6 > 0 && this.getVerticalOffset(var1, x, y + var6, z, var5) == 1) {
  338.             var7 = this.openPoint(x, y + var6, z);
  339.             y += var6;
  340.         }
  341.  
  342.         if(var7 == null) {
  343.             int var8 = 0;
  344.             int var9 = 0;
  345.             int var10 = 0;
  346.  
  347.             //while(y > 0 && y < 128 && (worldMap.getBlockId(x, y + 1, z)) == Block.ladder.blockID && (var10 = this.getVerticalOffset(var1, origX, y + 1, origZ, var5)) == 1) {
  348.             while(y > 0 && y < 128 && ((var9 = this.getVerticalOffset(var1, x, y + 1, z, var5)) == 0) && (getBlockId(origX, y + 1, origZ)) == Block.ladder.blockID) {
  349.                 var10 = this.getVerticalOffset(var1, origX, y + 1, origZ, var5);
  350.                 ++var8;
  351.                 /*if(var8 >= 3) {
  352.                    return null;
  353.                 }*/
  354.                 ++y;
  355.  
  356.                 if(y > 0 && y < 128) {
  357.                     var7 = this.openPoint(x, y, z);
  358.                 }
  359.             }
  360.  
  361.             if (var10 != 1) {
  362.                 return null;
  363.             }
  364.  
  365.             if(var9 == -2) {
  366.                 return null;
  367.             }
  368.         }
  369.  
  370.         return var7;
  371.     }
  372.  
  373.     private PathPoint getClimbPoint(Entity var1, int x, int y, int z, PathPoint var5, int var6, int origX, int origZ) {
  374.         PathPoint var7 = null;
  375.  
  376.         if(this.getVerticalOffset(var1, x, y, z, var5) == 1) {
  377.             var7 = this.openPoint(x, y, z);
  378.         }
  379.  
  380.         if(var7 == null && var6 > 0 && this.getVerticalOffset(var1, x, y + var6, z, var5) == 1) {
  381.             var7 = this.openPoint(x, y + var6, z);
  382.             y += var6;
  383.         }
  384.  
  385.         if(var7 == null && canClimb) {
  386.             int var8 = 0;
  387.             int var9 = 0;
  388.             int var10 = 0;
  389.  
  390.             //while(y > 0 && y < 128 && (worldMap.getBlockId(x, y + 1, z)) == Block.ladder.blockID && (var10 = this.getVerticalOffset(var1, origX, y + 1, origZ, var5)) == 1) {
  391.             while(y > 0 && y < 128 && ((var9 = this.getVerticalOffset(var1, x, y + 1, z, var5)) == 0) && (var10 = this.getVerticalOffset(var1, origX, y + 1, origZ, var5)) == 1) {
  392.                 //;
  393.                 ++var8;
  394.  
  395.                 if(var8 >= 3) {
  396.                     return null;
  397.                 }
  398.  
  399.                 ++y;
  400.  
  401.                 if(y > 0 && y < 128) {
  402.                     var7 = this.openPoint(x, y, z);
  403.                 }
  404.             }
  405.  
  406.             if (var10 != 1) {
  407.                 return null;
  408.             }
  409.  
  410.             if(var9 == -2) {
  411.                 return null;
  412.             }
  413.         }
  414.  
  415.         return var7;
  416.     }
  417.  
  418.     private PathPoint getSafePoint(Entity var1, int var2, int var3, int var4, PathPoint var5, int var6) {
  419.         PathPoint var7 = null;
  420.  
  421.         if(this.getVerticalOffset(var1, var2, var3, var4, var5) == 1) {
  422.             var7 = this.openPoint(var2, var3, var4);
  423.         }
  424.  
  425.         if(var7 == null && var6 > 0 && this.getVerticalOffset(var1, var2, var3 + var6, var4, var5) == 1) {
  426.             var7 = this.openPoint(var2, var3 + var6, var4);
  427.             var3 += var6;
  428.         }
  429.  
  430.         if(var7 != null) {
  431.             int var8 = 0;
  432.             int var9 = 0;
  433.  
  434.             while(var3 > 0 && (var9 = this.getVerticalOffset(var1, var2, var3 - 1, var4, var5)) == 1) {
  435.                 ++var8;
  436.  
  437.                 if(var8 >= 4) {
  438.                     return null;
  439.                 }
  440.  
  441.                 --var3;
  442.  
  443.                 if(var3 > 0) {
  444.                     var7 = this.openPoint(var2, var3, var4);
  445.                 }
  446.             }
  447.  
  448.             if(var9 == -2) {
  449.                 return null;
  450.             }
  451.         }
  452.  
  453.         return var7;
  454.     }
  455.  
  456.     private final PathPoint openPoint(int var1, int var2, int var3) {
  457.         int var4 = PathPoint.func_22329_a(var1, var2, var3);
  458.         PathPoint var5 = (PathPoint)this.pointMap.lookup(var4);
  459.  
  460.         if(var5 == null) {
  461.             var5 = new PathPoint(var1, var2, var3);
  462.             this.pointMap.addKey(var4, var5);
  463.         }
  464.  
  465.         return var5;
  466.     }
  467.    
  468.    
  469.  
  470.     private int getVerticalOffset(Entity var1, int var2, int var3, int var4, PathPoint var5) {
  471.         for(int var6 = var2; var6 < var2 + var5.xCoord; ++var6) {
  472.             for(int var7 = var3; var7 < var3 + var5.yCoord; ++var7) {
  473.                 for(int var8 = var4; var8 < var4 + var5.zCoord; ++var8) {
  474.                     int var9 = getBlockId(var6, var7, var8);
  475.  
  476.                     if(var9 > 0) {
  477.                         if(var9 != Block.doorSteel.blockID && var9 != Block.doorWood.blockID) {
  478.                             if (var9 == Block.fence.blockID) {
  479.                                 return -2;
  480.                             }
  481.  
  482.                             if (var9 == Block.pressurePlatePlanks.blockID || var9 == Block.pressurePlateStone.blockID) {
  483.                                 return 1;
  484.                             }
  485.  
  486.                             Material var11 = Block.blocksList[var9].blockMaterial;
  487.  
  488.                             if(var11.getIsSolid()) {
  489.                                 return 0;
  490.                             }
  491.  
  492.                             if(var11 == Material.water) {
  493.                                 return -1;
  494.                             }
  495.  
  496.                             if(var11 == Material.lava) {
  497.                                 return -2;
  498.                             }
  499.                         } else {
  500.                             int var10 = getBlockMetadata(var6, var7, var8);
  501.  
  502.                             if(!BlockDoor.isOpen(var10)) {
  503.                                 return 0;
  504.                             }
  505.                         }
  506.                     }
  507.                 }
  508.             }
  509.         }
  510.  
  511.         return 1;
  512.     }
  513.  
  514.     private PathEntity createEntityPath(PathPoint var1, PathPoint var2) {
  515.         int var3 = 1;
  516.         PathPoint var4;
  517.  
  518.         for(var4 = var2; var4.previous != null; var4 = var4.previous) {
  519.             ++var3;
  520.         }
  521.  
  522.         PathPoint[] var5 = new PathPoint[var3];
  523.         var4 = var2;
  524.         --var3;
  525.  
  526.         for(var5[var3] = var2; var4.previous != null; var5[var3] = var4) {
  527.             var4 = var4.previous;
  528.             --var3;
  529.         }
  530.  
  531.         return new PathEntity(var5);
  532.     }
  533.    
  534.     private PathEntity simplifyPath(PathEntity pathentity, PathPoint pathpoint)
  535.     {
  536.         if(pathentity == null)
  537.         {
  538.             return pathentity;
  539.         }
  540.         LinkedList linkedlist = new LinkedList();
  541.         PathPoint pathpoint1 = null;
  542.         PathPoint pathpoint2 = null;
  543.         PathPoint pathpoint3 = null;
  544.         //PathPoint apathpoint[] = (PathPoint)pathentity.points;
  545.         PathPoint apathpoint[] = pathentity.points;
  546.         int j = apathpoint.length;
  547.         for(int k = 0; k < j; k++)
  548.         {
  549.             PathPoint pathpoint4 = apathpoint[k];
  550.             if(pathpoint1 == null)
  551.             {
  552.                 pathpoint1 = pathpoint4;
  553.                 linkedlist.add(pathpoint4);
  554.                 continue;
  555.             }
  556.             if(pathpoint2 == null)
  557.             {
  558.                 if(pathpoint1.yCoord != pathpoint4.yCoord)
  559.                 {
  560.                     pathpoint1 = pathpoint4;
  561.                     linkedlist.add(pathpoint4);
  562.                 } else
  563.                 {
  564.                     pathpoint2 = pathpoint4;
  565.                 }
  566.                 continue;
  567.             }
  568.             if(pathpoint2.yCoord != pathpoint4.yCoord)
  569.             {
  570.                 linkedlist.add(pathpoint2);
  571.                 linkedlist.add(pathpoint4);
  572.                 pathpoint1 = pathpoint4;
  573.                 pathpoint2 = null;
  574.                 continue;
  575.             }
  576.             int l = pathpoint4.xCoord - pathpoint1.xCoord;
  577.             int i1 = pathpoint4.zCoord - pathpoint1.zCoord;
  578.             if(Math.abs(l) < Math.abs(i1))
  579.             {
  580.                 float f = 0.0F;
  581.                 float f2 = (float)l / (float)Math.abs(i1);
  582.                 byte byte0 = 1;
  583.                 if(i1 < 0)
  584.                 {
  585.                     byte0 = -1;
  586.                 }
  587.                 for(int j1 = 1; j1 < Math.abs(i1); j1++)
  588.                 {
  589.                     if(getVerticalOffset(null, pathpoint1.xCoord + (int)f, pathpoint1.yCoord, pathpoint1.zCoord + j1 * byte0, pathpoint) != 1 || getVerticalOffset(null, pathpoint1.xCoord + (int)f, pathpoint1.yCoord - 1, pathpoint1.zCoord + j1 * byte0, pathpoint) == 1 || getVerticalOffset(null, pathpoint1.xCoord + (int)f + 1, pathpoint1.yCoord, pathpoint1.zCoord + j1 * byte0, pathpoint) != 1 || getVerticalOffset(null, pathpoint1.xCoord + (int)f + 1, pathpoint1.yCoord - 1, pathpoint1.zCoord + j1 * byte0, pathpoint) == 1 || getVerticalOffset(null, (pathpoint1.xCoord + (int)f) - 1, pathpoint1.yCoord, pathpoint1.zCoord + j1 * byte0, pathpoint) != 1 || getVerticalOffset(null, (pathpoint1.xCoord + (int)f) - 1, pathpoint1.yCoord - 1, pathpoint1.zCoord + j1 * byte0, pathpoint) == 1)
  590.                     {
  591.                         pathpoint1 = pathpoint2;
  592.                         linkedlist.add(pathpoint2);
  593.                         pathpoint2 = pathpoint4;
  594.                     } else
  595.                     {
  596.                         f += f2;
  597.                     }
  598.                 }
  599.  
  600.             } else
  601.             {
  602.                 float f1 = 0.0F;
  603.                 float f3 = (float)i1 / (float)Math.abs(l);
  604.                 byte byte1 = 1;
  605.                 if(l < 0)
  606.                 {
  607.                     byte1 = -1;
  608.                 }
  609.                 for(int k1 = 1; k1 < Math.abs(l); k1++)
  610.                 {
  611.                     if(getVerticalOffset(null, pathpoint1.xCoord + k1 * byte1, pathpoint1.yCoord, pathpoint1.zCoord + (int)f1, pathpoint) != 1 || getVerticalOffset(null, pathpoint1.xCoord + k1 * byte1, pathpoint1.yCoord - 1, pathpoint1.zCoord + (int)f1, pathpoint) == 1 || getVerticalOffset(null, pathpoint1.xCoord + k1 * byte1, pathpoint1.yCoord, pathpoint1.zCoord + (int)f1 + 1, pathpoint) != 1 || getVerticalOffset(null, pathpoint1.xCoord + k1 * byte1, pathpoint1.yCoord - 1, pathpoint1.zCoord + (int)f1 + 1, pathpoint) == 1 || getVerticalOffset(null, pathpoint1.xCoord + k1 * byte1, pathpoint1.yCoord, (pathpoint1.zCoord + (int)f1) - 1, pathpoint) != 1 || getVerticalOffset(null, pathpoint1.xCoord + k1 * byte1, pathpoint1.yCoord - 1, (pathpoint1.zCoord + (int)f1) - 1, pathpoint) == 1)
  612.                     {
  613.                         pathpoint1 = pathpoint2;
  614.                         linkedlist.add(pathpoint2);
  615.                         pathpoint2 = pathpoint4;
  616.                     } else
  617.                     {
  618.                         f1 += f3;
  619.                     }
  620.                 }
  621.  
  622.             }
  623.             pathpoint3 = pathpoint4;
  624.         }
  625.  
  626.         if(pathpoint3 != null)
  627.         {
  628.             linkedlist.add(pathpoint3);
  629.         } else
  630.         if(pathpoint2 != null)
  631.         {
  632.             linkedlist.add(pathpoint2);
  633.         }
  634.         int i = 0;
  635.         PathPoint apathpoint1[] = new PathPoint[linkedlist.size()];
  636.         for(Iterator iterator = linkedlist.iterator(); iterator.hasNext();)
  637.         {
  638.             PathPoint pathpoint5 = (PathPoint)iterator.next();
  639.             apathpoint1[i++] = pathpoint5;
  640.         }
  641.         return new PathEntity(apathpoint1);
  642.     }
  643.    
  644.     private int getBlockId(int x, int y, int z) {
  645.         if (!ModLoader.getMinecraftInstance().theWorld.checkChunksExist(x, 0, z , x, 128, z)) return 10;
  646.         return ModLoader.getMinecraftInstance().theWorld.getBlockId(x, y, z);
  647.     }
  648.    
  649.     private int getBlockMetadata(int x, int y, int z) {
  650.         if (!ModLoader.getMinecraftInstance().theWorld.checkChunksExist(x, 0, z , x, 128, z)) return 0;
  651.         return ModLoader.getMinecraftInstance().theWorld.getBlockMetadata(x, y, z);
  652.     }
  653. }
  654.  
  655.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement