API tools faq
paste
Advertisement
Corosus

Untitled

Corosus
Sep 16th, 2011
123
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 60.41 KB | None | 0 0
raw download clone embed print report
  1. //EntityCreature.java
  2.  
  3. package net.minecraft.src;
  4.  
  5. import net.minecraft.src.Entity;
  6. import net.minecraft.src.EntityLiving;
  7. import net.minecraft.src.MathHelper;
  8. import net.minecraft.src.PathEntity;
  9. import net.minecraft.src.Vec3D;
  10. import net.minecraft.src.World;
  11.  
  12. public class EntityCreature extends EntityHooks {
  13.  
  14.    private PathEntity pathToEntity;
  15.    public Entity playerToAttack;
  16.    protected boolean hasAttacked = false;
  17.  
  18.  
  19.    public EntityCreature(World var1) {
  20.       super(var1);
  21.    }
  22.  
  23.    protected boolean isMovementCeased() {
  24.       return false;
  25.    }
  26.  
  27.    protected void updatePlayerActionState() {
  28.       this.hasAttacked = this.isMovementCeased();
  29.       float var1 = 16.0F;
  30.      
  31.       if(this.playerToAttack == null) {
  32.          
  33.          //override
  34.          this.playerToAttack = tryFindPlayer();
  35.          
  36.          //save for the path call below - this might make entities not attack player until they finish their idle move path
  37.          /*if(this.playerToAttack != null) {
  38.              
  39.              
  40.             this.pathToEntity = this.worldObj.getPathToEntity(this, this.playerToAttack, var1);
  41.          }*/
  42.       } else if(!this.playerToAttack.isEntityAlive()) {
  43.          this.playerToAttack = null;
  44.          this.setPathToEntity(null); //addition
  45.          pathfindDelay = 0;
  46.       } else {
  47.          float var2 = this.playerToAttack.getDistanceToEntity(this);
  48.          if(this.canEntityBeSeen(this.playerToAttack)) {
  49.             //override
  50.             this.tryAttackEntity(this.playerToAttack, var2);
  51.          } else {
  52.             this.attackBlockedEntity(this.playerToAttack, var2);
  53.          }
  54.       }
  55.  
  56.       if(!this.hasAttacked && this.playerToAttack != null && (this.pathToEntity == null/* || this.rand.nextInt(20) == 0*/)) {
  57.          //override
  58.          /*this.pathToEntity = */tryPath(this.playerToAttack, var1); //this.worldObj.getPathToEntity(this, this.playerToAttack, var1);
  59.       } else if(!this.hasAttacked && (this.pathToEntity == null && (this.rand.nextInt(80) == 0 || this.rand.nextInt(80) == 0))) {
  60.          this.func_31026_E();
  61.       }
  62.      
  63.       //AI Tick hook - after targeting logic, before path tracking and movement logic
  64.       EntAPI.RunHooks_AITick((EntityCreature)this);
  65.  
  66.       int var21 = MathHelper.floor_double(this.boundingBox.minY + 0.5D);
  67.       boolean var3 = this.isInWater();
  68.       boolean var4 = this.handleLavaMovement();
  69.       this.rotationPitch = 0.0F;
  70.       if(this.pathToEntity != null/* && this.rand.nextInt(100) != 0*/) {
  71.          Vec3D var5 = this.pathToEntity.getPosition(this);
  72.          double var6 = (double)(this.width * pathFollowDist); //override on path track distance
  73.  
  74.          while(var5 != null && var5.squareDistanceTo(this.posX, var5.yCoord, this.posZ) < var6 * var6) {
  75.             this.pathToEntity.incrementPathIndex();
  76.             if(this.pathToEntity.isFinished()) {
  77.                var5 = null;
  78.                this.pathToEntity = null;
  79.                //remove pf delay!
  80.                //this.pathfindDelay = 50;
  81.             } else {
  82.                var5 = this.pathToEntity.getPosition(this);
  83.             }
  84.          }
  85.  
  86.          this.isJumping = false;
  87.          if(var5 != null) {
  88.             double var8 = var5.xCoord - this.posX;
  89.             double var10 = var5.zCoord - this.posZ;
  90.             double var12 = var5.yCoord - (double)var21;
  91.             float var14 = (float)(Math.atan2(var10, var8) * 180.0D / 3.1415927410125732D) - 90.0F;
  92.             float var15 = var14 - this.rotationYaw;
  93.  
  94.             for(this.moveForward = this.moveSpeed; var15 < -180.0F; var15 += 360.0F) {
  95.                ;
  96.             }
  97.  
  98.             while(var15 >= 180.0F) {
  99.                var15 -= 360.0F;
  100.             }
  101.  
  102.             if(var15 > 30.0F) {
  103.                var15 = 30.0F;
  104.             }
  105.  
  106.             if(var15 < -30.0F) {
  107.                var15 = -30.0F;
  108.             }
  109.  
  110.             this.rotationYaw += var15;
  111.             if(this.hasAttacked && this.playerToAttack != null) {
  112.                double var16 = this.playerToAttack.posX - this.posX;
  113.                double var18 = this.playerToAttack.posZ - this.posZ;
  114.                float var20 = this.rotationYaw;
  115.                this.rotationYaw = (float)(Math.atan2(var18, var16) * 180.0D / 3.1415927410125732D) - 90.0F;
  116.                var15 = (var20 - this.rotationYaw + 90.0F) * 3.1415927F / 180.0F;
  117.                this.moveStrafing = -MathHelper.sin(var15) * this.moveForward * 1.0F;
  118.                this.moveForward = MathHelper.cos(var15) * this.moveForward * 1.0F;
  119.             }
  120.  
  121.             if(var12 > 0.0D) {
  122.                this.isJumping = true;
  123.             }
  124.          }
  125.  
  126.          //override
  127.          if(this.shouldFaceTarget()) {
  128.             this.faceEntity(this.playerToAttack, 30.0F, 30.0F);
  129.          }
  130.  
  131.          if(this.isCollidedHorizontally && !this.hasPath()) {
  132.             this.isJumping = true;
  133.          }
  134.  
  135.          if(this.rand.nextFloat() < 0.8F && (var3 || var4)) {
  136.             this.isJumping = true;
  137.          }
  138.          //super.updatePlayerActionState();
  139.       } else {
  140.           //override/addition - i think this will give the ability to move without a path
  141.           if(this.shouldFaceTarget()) {
  142.               this.moveForward = this.moveSpeed;
  143.               this.faceEntity(this.playerToAttack, 30.0F, 30.0F);
  144.           } else {
  145.               super.updatePlayerActionState();
  146.           }
  147.          
  148.          //this.pathToEntity = null;
  149.       }
  150.    }
  151.  
  152.    protected void func_31026_E() {
  153.       //if (true) return;
  154.       boolean var1 = false;
  155.       int var2 = -1;
  156.       int var3 = -1;
  157.       int var4 = -1;
  158.       float var5 = -99999.0F;
  159.  
  160.       for(int var6 = 0; var6 < 10; ++var6) {
  161.          int var7 = MathHelper.floor_double(this.posX + (double)this.rand.nextInt(13) - 6.0D);
  162.          int var8 = MathHelper.floor_double(this.posY + (double)this.rand.nextInt(7) - 3.0D);
  163.          int var9 = MathHelper.floor_double(this.posZ + (double)this.rand.nextInt(13) - 6.0D);
  164.          float var10 = this.getBlockPathWeight(var7, var8, var9);
  165.          if(var10 > var5) {
  166.             var5 = var10;
  167.             var2 = var7;
  168.             var3 = var8;
  169.             var4 = var9;
  170.             var1 = true;
  171.          }
  172.       }
  173.  
  174.       if(var1) {
  175.          this.pathToEntity = this.worldObj.getEntityPathToXYZ(this, var2, var3, var4, 10.0F);
  176.       }
  177.  
  178.    }
  179.  
  180.    protected void attackEntity(Entity var1, float var2) {}
  181.  
  182.    protected void attackBlockedEntity(Entity var1, float var2) {}
  183.  
  184.    protected float getBlockPathWeight(int var1, int var2, int var3) {
  185.       return 0.0F;
  186.    }
  187.  
  188.    protected Entity findPlayerToAttack() {
  189.       return null;
  190.    }
  191.  
  192.    public boolean getCanSpawnHere() {
  193.       int var1 = MathHelper.floor_double(this.posX);
  194.       int var2 = MathHelper.floor_double(this.boundingBox.minY);
  195.       int var3 = MathHelper.floor_double(this.posZ);
  196.       return super.getCanSpawnHere() && this.getBlockPathWeight(var1, var2, var3) >= 0.0F;
  197.    }
  198.  
  199.    public boolean hasPath() {
  200.       return this.pathToEntity != null;
  201.    }
  202.  
  203.    public void setPathToEntity(PathEntity var1) {
  204.       this.pathToEntity = var1;
  205.    }
  206.    
  207.    public PathEntity getPath() {
  208.        return this.pathToEntity;
  209.    }
  210.  
  211.    public Entity getTarget() {
  212.       return this.playerToAttack;
  213.    }
  214.  
  215.    public void setTarget(Entity var1) {
  216.       this.playerToAttack = var1;
  217.    }
  218. }
  219.  
  220.  
  221.  
  222. //EntityHooks.java
  223.  
  224. package net.minecraft.src;
  225.  
  226. import java.util.List;
  227.  
  228. // Referenced classes of package net.minecraft.src:
  229. //            Entity, Vec3D, StepSound, AxisAlignedBB,
  230. //            World, MathHelper, Material, NBTTagCompound,
  231. //            Block, MovingObjectPosition, ItemStack
  232.  
  233. public abstract class EntityHooks extends EntityLiving {
  234.    
  235.     private static boolean sdkGrapplingHookNotFound = false;
  236.     private static int sdkBlockRopeId = -1;
  237.    
  238.     public int uID;
  239.     public int mobtype;
  240.     public int team;
  241.     public int orders;
  242.     public int guardX;
  243.     public int guardY;
  244.     public int guardZ;
  245.     public int enhanced;
  246.     public int guardEntID;
  247.     public int mountEntID;
  248.     public int kills;
  249.    
  250.    
  251.     public Entity guardEnt;
  252.     public Entity attackingEnt;
  253.     public int state;
  254.     public int maxhealth;
  255.     public int AIDelay;
  256.     public int mineDelay;
  257.     public int PFDelay;
  258.     public float curBlockDmg;
  259.     public int curBlockX;
  260.     public int curBlockZ;
  261.     public boolean mining;
  262.     public boolean forcejump;
  263.     public int noMoveTicks;
  264.     public float info;
  265.     public String info2;
  266.     public int nearbyMinerCount;
  267.     public boolean canSwitchTarget;
  268.     public boolean noTick;
  269.    
  270.     public float pathFollowDist = 2.0F;
  271.    
  272.     public int noSeeTicks = 0;
  273.     public int pathfindDelay = 0;
  274.     public float plDist;
  275.    
  276.     public boolean swingArm = false;
  277.     public int swingTick = 0;
  278.    
  279.     public int lastNodeTimer;
  280.     public int lastNode;
  281.    
  282.     public PathfinderEnh pf;
  283.    
  284.     public EntityHooks(World world)
  285.     {
  286.         super(world);
  287.        
  288.         //
  289.         uID = -1;
  290.         mobtype = 0;
  291.         team = 0;
  292.         orders = 0;
  293.         guardX = -1;
  294.         guardY = -1;
  295.         guardZ = -1;
  296.         enhanced = 0;
  297.         guardEntID = -1;
  298.         mountEntID = -1;
  299.         guardEnt = null;
  300.         attackingEnt = null;
  301.         maxhealth = 0;
  302.         noTick = false;
  303.         pathFollowDist = 1.2F;
  304.        
  305.         pf = new PathfinderEnh(world);
  306.         //
  307.        
  308.         EntAPI.RunHooks_Init((EntityCreature)this,world);
  309.     }
  310.    
  311.    
  312.    
  313.    
  314.     //Main Hooks
  315.    
  316.     public void onUpdate()
  317.     {
  318.         EntAPI.RunHooks_onUpdate_pre((EntityCreature)this);
  319.         super.onUpdate();
  320.         EntAPI.RunHooks_onUpdate_post((EntityCreature)this);
  321.        
  322.     }
  323.    
  324.     public boolean canClimb() {
  325.         if (/*this instanceof EntityCreeper || */this instanceof EntityCreeper && false) {
  326.             return true;
  327.         }
  328.         return false;
  329.     }
  330.    
  331.     public boolean isOnLadder() {
  332.         if (canClimb() && this.isCollidedHorizontally) {
  333.             return true;
  334.         }
  335.         return false;
  336.     }
  337.    
  338.     public boolean attackEntityFrom(Entity entity, int i)
  339.     {
  340.         if (EntAPI.RunHooks_AttackEntityFrom((EntityCreature)this, entity, i)) {
  341.             return super.attackEntityFrom(entity, i);
  342.         }
  343.         return false;
  344.     }
  345.    
  346.     public void writeEntityToNBT(NBTTagCompound nbttagcompound)
  347.     {
  348.         nbttagcompound.setShort("uID", (short)this.uID);
  349.         nbttagcompound.setShort("MobType", (short)this.mobtype);
  350.         nbttagcompound.setShort("Team", (short)this.team);
  351.         nbttagcompound.setShort("Orders", (short)this.orders);
  352.         nbttagcompound.setShort("guardX", (short)this.guardX);
  353.         nbttagcompound.setShort("guardY", (short)this.guardY);
  354.         nbttagcompound.setShort("guardZ", (short)this.guardZ);
  355.         nbttagcompound.setShort("enhanced", (short)this.enhanced);
  356.         nbttagcompound.setShort("guardEntID", (short)this.guardEntID);
  357.         nbttagcompound.setShort("mineDelay", (short)this.mineDelay);
  358.         nbttagcompound.setShort("kills", (short)this.kills);
  359.        
  360.  
  361.        
  362.        
  363.         super.writeEntityToNBT(nbttagcompound);
  364.         EntAPI.RunHooks_Saved((EntityCreature)this, nbttagcompound);
  365.     }
  366.    
  367.     public void readEntityFromNBT(NBTTagCompound nbttagcompound)
  368.     {
  369.         this.uID = nbttagcompound.getShort("uID");
  370.         this.mobtype = nbttagcompound.getShort("MobType");
  371.         this.team = nbttagcompound.getShort("Team");
  372.         this.orders = nbttagcompound.getShort("Orders");
  373.         this.guardX = nbttagcompound.getShort("guardX");
  374.         this.guardY = nbttagcompound.getShort("guardY");
  375.         this.guardZ = nbttagcompound.getShort("guardZ");
  376.         this.enhanced = nbttagcompound.getShort("enhanced");
  377.         this.guardEntID = nbttagcompound.getShort("guardEntID");
  378.         this.mountEntID = nbttagcompound.getShort("mountEntID");
  379.         this.mineDelay = nbttagcompound.getShort("mineDelay");
  380.         this.kills = nbttagcompound.getShort("kills");
  381.  
  382.         if(this instanceof EntityMob) {
  383.             this.maxhealth = 20;
  384.         /*} else if(this instanceof EntityPlayer) {
  385.             this.maxhealth = 20;
  386.             firstTick = true;
  387.             this.team = playerTeamInit;*/
  388.         } else if(this instanceof EntityAnimal) {
  389.             this.maxhealth = 10;
  390.         }
  391.  
  392.         if(this.health > this.maxhealth) {
  393.             this.maxhealth = this.health;
  394.         }
  395.  
  396.         if(mod_AITools.isGuardian(this)) {
  397.             this.noTick = true;
  398.         }
  399.        
  400.         super.readEntityFromNBT(nbttagcompound);
  401.         EntAPI.RunHooks_Loaded((EntityCreature)this, nbttagcompound);
  402.     }
  403.    
  404.     public void setEntityDead() {
  405.         //System.out.println("hmmm!");
  406.         if (deathTime < 1 && team == 1) { return; }
  407.         super.setEntityDead();
  408.     }
  409.    
  410.     public void onDeath(Entity var1) {
  411.         EntAPI.RunHooks_Killed((EntityCreature)this, var1);
  412.           if(this instanceof EntityAnimal) {
  413.              mod_PathingActivated.spawnScent(this);
  414.           }
  415.  
  416.           super.onDeath(var1);
  417.        }
  418.    
  419.     protected void tryAttackEntity(Entity var1, float var2) {
  420.        
  421.         if (EntAPI.RunHooks_TryAttackEntity(this, var1, var2)) {
  422.             this.attackEntity(var1, var2);
  423.         }
  424.     }
  425.    
  426.     protected Entity tryFindPlayer() {
  427.         Entity ent = findPlayerToAttack();
  428.         if (mod_PathingActivated.sameTeam(this, ent)) {
  429.             return null;
  430.         } else {
  431.             return ent;
  432.         }
  433.        
  434.     }
  435.    
  436.     protected Entity findPlayerToAttack() {
  437.         return null;
  438.     }
  439.    
  440.    
  441.     protected void attackEntity(Entity var1, float var2) {}
  442.    
  443.     public int getTalkInterval()
  444.     {
  445.         if (team == 1) {
  446.             return 400;
  447.         }
  448.         return 80;
  449.     }
  450.    
  451.     //Entity creature stuff
  452.    
  453.     protected void updatePlayerActionState() {
  454.         super.updatePlayerActionState();
  455.     }
  456.    
  457.     public Entity getTarget() {
  458.         return null;
  459.     }
  460.    
  461.     public boolean shouldFaceTarget() {
  462.        
  463.         //if (mod_PathingActivated.hasPetMod) {
  464.             //System.out.println(state);
  465.             (new StringBuilder()).append("state - ").append(state).toString();
  466.             if(state != 1) {
  467.                 if((state == 3 || state == 4) && getTarget() != null) {
  468.                     if(state == 3) {
  469.                        
  470.                         if (this.guardEnt != null && this.getDistanceToEntity(this.guardEnt) > 32.0F) {
  471.                             if (teleportToTarget(this.guardEnt)) {
  472.                                 setPathToEntity(null);
  473.                             }
  474.                         }
  475.                        
  476.                         if (this.guardEnt != null && isSolidPath(this.guardEnt)) {
  477.                             setPathToEntity(null);
  478.                            
  479.                            
  480.                             this.moveForward = this.moveSpeed;
  481.                             faceEntity(this.guardEnt, 30.0F, 30.0F);
  482.                             //faceEntity(getTarget(), 30.0F, 30.0F);
  483.                             //System.out.println(getTarget());
  484.                             return true;
  485.                         }
  486.                        
  487.                         //faceEntity(this.guardEnt, 30.0F, 30.0F);
  488.                         return false;
  489.                         /*d1 = guardEnt.posX - posX;
  490.                         d2 = guardEnt.posZ - posZ;
  491.                         double d5 = guardEnt.posY - (double)i;*/
  492.                     } else if(state == 4) {
  493.                         if (getTarget() != null && (isSolidPath(getTarget()) || this.getPath() == null)) {
  494.                             this.moveForward = this.moveSpeed;
  495.                             faceEntity(getTarget(), 30.0F, 30.0F);
  496.                             setPathToEntity(null);
  497.                             return true;
  498.                         }
  499.                         return false;
  500.                         /*d1 = playerToAttack.posX - posX;
  501.                         d2 = playerToAttack.posZ - posZ;
  502.                         double d6 = playerToAttack.posY - (double)i;*/
  503.                     }
  504.                 } else if(state == 2) {
  505.                     return false;
  506.                     //this code is depreciated, pet mod needs to try to pathfind to this spot
  507.                     //d1 = (double)guardX - posX;
  508.                     //d2 = (double)guardZ - posZ;
  509.                     //double d7 = (double)guardY - (double)i;
  510.                 }
  511.             }
  512.            
  513.            
  514.         //} else {
  515.            
  516.             if(this.isCollidedHorizontally) {
  517.                 this.isJumping = true;
  518.              }
  519.        
  520.             /*if (((EntityCreature)this).getTarget() != null && (isSolidPath(((EntityCreature)this).getTarget()) || this.getPath() == null)) {
  521.                 return true;
  522.             }*/
  523.        
  524.         //}
  525.        
  526.         return false;
  527.     }
  528.    
  529.    
  530.  
  531.    public boolean shouldTarget(Entity var1) {
  532.        if (mod_PathingActivated.sameTeam(this, var1)) {
  533.            /*if (getDistanceToEntity(var1) < 5.0F) {
  534.                return false;
  535.            }*/
  536.            return false;
  537.        }
  538.       if(mod_PathingActivated.useEnt(this) && !(this instanceof EntityWolf)) {
  539.          if(mod_PathingActivated.OmnipotentHostiles.get().booleanValue()) {
  540.             return true;
  541.          } else {
  542.             float var2 = (float)mod_PathingActivated.AwarenessRange.get().intValue();
  543.             this.plDist = this.getDistanceToEntity(var1);
  544.             return this.plDist <= var2 && (this.canEntityBeSeen(var1) || mod_PathingActivated.XRayVision.get());
  545.          }
  546.       } else {
  547.          return false;
  548.       }
  549.    }
  550.    
  551.    public boolean isSolidPath(Entity var1) {
  552.        if (this.team != 1 && !mod_PathingActivated.useEnt(this)) { return true; }
  553.        if (this.getDistanceToEntity(var1) > mod_PathingActivated.MaxPFRange.get()) { return true; }
  554.       return this.canEntityBeSeen(var1) && (this.getDistanceToEntity(var1) < 5.0F) && Math.abs(this.posY - (double)this.yOffset - (var1.posY - (double)var1.yOffset)) <= 3.5D;
  555.    }
  556.    
  557.    public boolean shouldPath() {
  558.       return mod_PathingActivated.useEnt(this);
  559.    }
  560.    
  561.    public boolean tryPath(Entity var1, float var2) {
  562.        return tryPath(var1, var2, false);
  563.    }
  564.  
  565.    public boolean tryPath(Entity var1, float var2, boolean pet) {
  566.        if (pathfindDelay > 0) { return false; }
  567.        
  568.        if (mod_PathingActivated.hasPetMod) {
  569.            if (mod_PathingActivated.sameTeam(this, var1) && !pet) {
  570.                return false;
  571.            }
  572.        }
  573.        
  574.       if((this.shouldPath() || pet) && var1 != null) {
  575.          float var3 = this.getDistanceToEntity(var1);
  576.          if(var3 > var2) {
  577.             return false;
  578.          } else {
  579.              //mod_MovePlus.displayMessage((new StringBuilder()).append("PFCount: ").append(mod_PathingActivated.PFCount++).toString());
  580.              pathfindDelay = (int)var2*2 + rand.nextInt(100);
  581.              setPathToEntity(pf.getPathToEntity(this, var1, var2, canClimb()));
  582.              //System.out.println(this);
  583.              //setPathToEntity(this.worldObj.getPathToEntity(this, var1, var2));
  584.              if(this.getPath() == null)
  585.              {
  586.                  pathfindDelay = (int)var2*2 + rand.nextInt(200);
  587.              }
  588.              
  589.             return true;
  590.          }
  591.       } else {
  592.          return false;
  593.       }
  594.    }
  595.  
  596.    public boolean tryPathXYZ(int x, int y, int z, float var2) {
  597.        if (pathfindDelay > 0) { return false; }
  598.        
  599.          float var3 = (float)this.getDistance((double)x, (double)y, (double)z);
  600.          if(var3 > var2) {
  601.             return false;
  602.          } else {
  603.              //mod_MovePlus.displayMessage((new StringBuilder()).append("PFCount: ").append(mod_PathingActivated.PFCount++).toString());
  604.              //System.out.println("path XYZ");
  605.              pathfindDelay = (int)var2*2 + rand.nextInt(100);
  606.              setPathToEntity(this.worldObj.getEntityPathToXYZ(this, x, y, z, var2));
  607.              if(this.getPath() == null)
  608.              {
  609.                  pathfindDelay = (int)var2*2 + rand.nextInt(200);
  610.              }
  611.             return true;
  612.          }
  613.          //return false;
  614.      
  615.    }
  616.    
  617.    public PathEntity getPath() {
  618.        return null;
  619.    }
  620.    
  621.    public void setPathToEntity(PathEntity var1) {
  622.      
  623.    }
  624.  
  625.    public float getPathDist() {
  626.       float var1 = this.plDist + 32.0F;
  627.       if(var1 > (float)mod_PathingActivated.MaxPFRange.get()) {
  628.          var1 = (float)mod_PathingActivated.MaxPFRange.get();
  629.       }
  630.  
  631.       if((float)mod_PathingActivated.MaxPFRange.get().intValue() > 0.0F) {
  632.          var1 = (float)mod_PathingActivated.MaxPFRange.get().intValue();
  633.       }
  634.  
  635.       return var1;
  636.    }
  637.  
  638.    public static boolean notMoving(EntityLiving var0, float var1) {
  639.       double var2 = var0.prevPosX - var0.posX;
  640.       double var4 = var0.prevPosZ - var0.posZ;
  641.       float var6 = (float)Math.sqrt(var2 * var2 + var4 * var4);
  642.       return var6 < var1;
  643.    }
  644.  
  645.    public float getXZDistanceToEntity(Entity var1) {
  646.       float var2 = (float)(this.posX - var1.posX);
  647.       float var3 = (float)(this.posZ - var1.posZ);
  648.       return (float)Math.sqrt((double)(var2 * var2 + var3 * var3));
  649.    }
  650.  
  651.    
  652.  
  653.    public void onLivingUpdate() {
  654.        
  655.       if (mod_PathingActivated.hasNMMode) {
  656.           if (mod_NMMode.entFireImmune(this)) {
  657.               this.fire = 0;
  658.           }
  659.       }
  660.      
  661.       if (mod_PathingActivated.hasPetMod) {
  662.           if (this.team == 1) {
  663.               this.fire = 0;
  664.           }
  665.       }
  666.  
  667.       super.onLivingUpdate();
  668.      
  669.       if(swingArm) {
  670.             if (swingTick > 3 && swingTick < 9) {
  671.                 swingTick+=2;
  672.             } else {
  673.                 swingTick++;
  674.             }
  675.  
  676.             if(swingTick >= 24) {
  677.                 swingTick = 0;
  678.                 swingArm = false;
  679.             }
  680.         } else {
  681.             swingTick = 0;
  682.         }
  683.  
  684.         if (swingTick <= 16) {
  685.             swingProgress = (float)swingTick / 8F;
  686.         } else {
  687.             swingProgress = 0F;
  688.         }
  689.    }
  690.    
  691.    
  692.     //Feature extra overrides
  693.    
  694.     public void moveEntity(double d, double d1, double d2) {
  695.         //AI Added
  696.         if(orders != 2) {
  697.             if(enhanced == 1) {
  698.                 if(!mod_PathingActivated.freezePets || team != 1) {
  699.                     super.moveEntity(motionX * (double)mod_PathingActivated.enhPetSpeedMultiplier, motionY, motionZ * (double)mod_PathingActivated.enhPetSpeedMultiplier);
  700.                 }
  701.             } else if(!mod_PathingActivated.freezePets || team != 1) {
  702.                 super.moveEntity(motionX, motionY, motionZ);
  703.             }
  704.         } else {
  705.             super.moveEntity(0.0D, motionY, 0.0D);
  706.         }
  707.     }
  708.    
  709.     protected boolean canDespawn()
  710.     {
  711.         //AI Modded
  712.         if (team != 1 && orders == 0) {
  713.             return true;
  714.         } return false;
  715.     }
  716.    
  717.     public boolean isInRangeToRenderVec3D(Vec3D vec3d) {
  718.         if(mod_PathingActivated.unlimitedEntityRenderRange) {
  719.             return true;
  720.         } else {
  721.             double d = posX - vec3d.xCoord;
  722.             double d1 = posY - vec3d.yCoord;
  723.             double d2 = posZ - vec3d.zCoord;
  724.             double d3 = d * d + d1 * d1 + d2 * d2;
  725.             return isInRangeToRenderDist(d3);
  726.         }
  727.     }
  728.    
  729.     public void applyEntityCollision(Entity entity) {
  730.         if(entity.riddenByEntity == this || entity.ridingEntity == this) {
  731.             return;
  732.         }
  733.  
  734.         double d = entity.posX - posX;
  735.         double d1 = entity.posY - posY;
  736.         double d2 = entity.posZ - posZ;
  737.         double d3 = MathHelper.abs_max(d, d2);
  738.         d3 = MathHelper.abs_max(d, d1);
  739.  
  740.         if(d3 >= 0.0099999997764825821D) {
  741.             d3 = MathHelper.sqrt_double(d3);
  742.             d /= d3;
  743.             d1 /= d3;
  744.             d2 /= d3;
  745.             double d4 = 1.0D / d3;
  746.  
  747.             if(d4 > 1.0D) {
  748.                 d4 = 1.0D;
  749.             }
  750.  
  751.             d *= d4;
  752.             d1 *= d4;
  753.             d2 *= d4;
  754.             d *= 0.05000000074505806D;
  755.             d1 *= 0.05000000074505806D;
  756.             d2 *= 0.05000000074505806D;
  757.             d *= 1.0F - entityCollisionReduction;
  758.             d2 *= 1.0F - entityCollisionReduction;
  759.            
  760.             if (!mod_PathingActivated.VerticalCollision) {
  761.                 d1 = 0;
  762.             }
  763.  
  764.             if(mod_PathingActivated.NothingPushesPlayer) {
  765.                 /*if(!(this instanceof EntityPlayer)) {
  766.                     addVelocity(-d, -d1, -d2);
  767.                 }*/
  768.                 addVelocity(-d, -d1, -d2);
  769.                 if(!(entity instanceof EntityPlayer)) {
  770.                     entity.addVelocity(d, d1, d2);
  771.                 }
  772.             } else {
  773.                 addVelocity(-d, -d1, -d2);
  774.                 entity.addVelocity(d, d1, d2);
  775.             }
  776.         }
  777.     }
  778.    
  779.     public boolean isEntityInsideOpaqueBlock()
  780.     {
  781.        
  782.         if (this.ridingEntity != null) {
  783.             return false;
  784.         }
  785.        
  786.         for(int i = 0; i < 8; i++)
  787.         {
  788.             float f = ((float)((i >> 0) % 2) - 0.5F) * width * 0.9F;
  789.             float f1 = ((float)((i >> 1) % 2) - 0.5F) * 0.1F;
  790.             float f2 = ((float)((i >> 2) % 2) - 0.5F) * width * 0.9F;
  791.             int j = MathHelper.floor_double(posX + (double)f);
  792.             int k = MathHelper.floor_double(posY + (double)getEyeHeight() + (double)f1);
  793.             int l = MathHelper.floor_double(posZ + (double)f2);
  794.             if(worldObj.isBlockNormalCube(j, k, l))
  795.             {
  796.                 return true;
  797.             }
  798.         }
  799.  
  800.         return false;
  801.     }
  802.    
  803.     public boolean teleportToTarget(Entity var1) {
  804.            int var4 = MathHelper.floor_double(var1.posX) - 2;
  805.            int var5 = MathHelper.floor_double(var1.posZ) - 2;
  806.            int var6 = MathHelper.floor_double(var1.boundingBox.minY);
  807.  
  808.            for(int var7 = 0; var7 <= 4; ++var7) {
  809.               for(int var8 = 0; var8 <= 4; ++var8) {
  810.                  if((var7 < 1 || var8 < 1 || var7 > 3 || var8 > 3) &&
  811.                          this.worldObj.isBlockNormalCube(var4 + var7, var6 - 1, var5 + var8) &&
  812.                          !this.worldObj.isBlockNormalCube(var4 + var7, var6, var5 + var8) &&
  813.                          !this.worldObj.isBlockNormalCube(var4 + var7+1, var6, var5 + var8) &&
  814.                          !this.worldObj.isBlockNormalCube(var4 + var7, var6, var5 + var8+1) &&
  815.                          !this.worldObj.isBlockNormalCube(var4 + var7+1, var6, var5 + var8+1) &&
  816.                          
  817.                          !this.worldObj.isBlockNormalCube(var4 + var7, var6 + 1, var5 + var8) &&
  818.                          !this.worldObj.isBlockNormalCube(var4 + var7+1, var6 + 1, var5 + var8) &&
  819.                          !this.worldObj.isBlockNormalCube(var4 + var7, var6 + 1, var5 + var8+1) &&
  820.                          !this.worldObj.isBlockNormalCube(var4 + var7+1, var6 + 1, var5 + var8+1)) {
  821.                     this.setLocationAndAngles((double)((float)(var4 + var7) + 0.5F), (double)var6, (double)((float)(var5 + var8) + 0.5F), this.rotationYaw, this.rotationPitch);
  822.                     return true;
  823.                  }
  824.               }
  825.            }
  826.            
  827.            return false;
  828.  
  829.      }
  830. }
  831.  
  832.  
  833. //mod_PathingActivated.java
  834. package net.minecraft.src;
  835.  
  836. import java.io.File;
  837.  
  838. public class mod_PathingActivated extends BaseMod implements BaseEntityHooks {
  839.  
  840.    @MLProp2
  841.    public static STBoolean OmnipotentHostiles;
  842.    
  843.    @MLProp2
  844.    public static STBoolean ScentAwareness;
  845.    @MLProp2
  846.    public static STBoolean SoundAwareness;
  847.    @MLProp2
  848.    public static STInt ScentStrength;
  849.    @MLProp2
  850.    public static STInt SoundStrength;
  851.    @MLProp2
  852.    public static STBoolean XRayVision;
  853.    @MLProp2
  854.    public static STBoolean TargetLocking;
  855.    /*@MLProp2
  856.    public static STInt PFRange;*/
  857.    @MLProp2
  858.    public static STInt AwarenessRange;
  859.    @MLProp2
  860.    public static STInt MaxPFRange;
  861.    @MLProp2
  862.    public static STText MobBlacklist;
  863.    @MLProp2
  864.    public static int frequentSoundThreshold = 1000;
  865.    
  866.    public ModSettings settings;
  867.    public ModSettingScreen modscreen;
  868.    
  869.    public static Map mobsToUse = new HashMap();
  870.    public static Map hostilesToNames = new HashMap();
  871.    public static boolean inUse = false;
  872.  
  873.    public static Map classToUseMapping = new HashMap();
  874.    
  875.    
  876.    public static int lastHealth;
  877.    public static long lastBleedTime;
  878.    public static long lastSoundTime;
  879.    public static float lastMultiply = 1.0F;
  880.  
  881.    public static EntityLiving thePlayer;
  882.    
  883.    public static long PFCount = 0;
  884.    
  885.    public static boolean hasPetMod = false;
  886.    public static boolean hasNMMode = false;
  887.    public static boolean hasMinerZombie = false;
  888.    
  889.    public static boolean freezePets = false;
  890.    public static double enhPetSpeedMultiplier = 0.0D;
  891.    public static boolean unlimitedEntityRenderRange = false;
  892.    public static boolean VerticalCollision = false;
  893.    public static boolean NothingPushesPlayer = false;
  894.    
  895.    public static long lastTickRun = 0;
  896.    public static boolean inMenu = false;
  897.    
  898.    public static long traceCount = 0;
  899.    
  900.  
  901.    public mod_PathingActivated() {
  902.       OmnipotentHostiles = new STBoolean("OmnipotentHostiles", Boolean.valueOf(false));
  903.       TargetLocking = new STBoolean("TargetLocking", Boolean.valueOf(false));
  904.       XRayVision = new STBoolean("XRayVision", Boolean.valueOf(false));
  905.       //PFRange = new STInt("PFRange", 64, 0, 8, 512);
  906.       MaxPFRange = new STInt("PFRange", 64, 0, 8, 512);
  907.       AwarenessRange = new STInt("AwarenessRange", 16, 0, 8, 512);
  908.       MobBlacklist = new STText("MobBlacklist", "Skeleton");
  909.       ScentAwareness = new STBoolean("ScentAwareness", Boolean.valueOf(true));
  910.       SoundAwareness = new STBoolean("SoundAwareness", Boolean.valueOf(true));
  911.       ScentStrength = new STInt("ScentStrength", 75, 0, 5, 100);
  912.       SoundStrength = new STInt("SoundStrength", 30, 0, 5, 100);
  913.      
  914.      
  915.      
  916.      
  917.       try {
  918.          //setupProperties(this.getClass());
  919.       } catch (Exception var2) {
  920.          var2.printStackTrace();
  921.       }
  922.  
  923.       ModLoader.RegisterEntityID(EntityScent.class, "EntityScent", ModLoader.getUniqueEntityId());
  924.       ModLoader.SetInGameHook(this, true, false);
  925.       ModLoader.SetInGUIHook(this, true, false);
  926.      
  927.       EntAPI.SetHook_AITick(this);
  928.       EntAPI.SetHook_onUpdate_pre(this);
  929.       EntAPI.SetHook_TryAttackEntity(this);
  930.      
  931.       try {
  932.           //readURL hmm = new readURL("http://dl.dropbox.com/u/24987042/splashes.txt");
  933.           //hmm.readTextFromURL();
  934.       } catch (Exception ex) {
  935.          
  936.       }
  937.      
  938.      
  939.       settings = new ModSettings("mod_ZombieAwareness");
  940.       modscreen = new ModSettingScreen("Zombie Awareness");
  941.      
  942.       modscreen.append(new WidgetBoolean(ScentAwareness, "Scent Awareness", "Yes", "No"));
  943.       settings.append(ScentAwareness);
  944.       modscreen.append(new WidgetBoolean(SoundAwareness, "Sound Awareness", "Yes", "No"));
  945.       settings.append(SoundAwareness);
  946.      
  947.       modscreen.append(new WidgetInt(ScentStrength, "Scent Strength"));
  948.       settings.append(ScentStrength);
  949.       modscreen.append(new WidgetInt(SoundStrength, "Sound Strength"));
  950.       settings.append(SoundStrength);
  951.      
  952.       modscreen.append(new WidgetInt(AwarenessRange, "Sight Range"));
  953.       settings.append(AwarenessRange);
  954.       modscreen.append(new WidgetBoolean(XRayVision, "X-Ray Sight"));
  955.       settings.append(XRayVision);
  956.      
  957.       modscreen.append(new WidgetInt(MaxPFRange, "Pathfind Range"));
  958.       settings.append(MaxPFRange);
  959.       modscreen.append(new WidgetText(MobBlacklist, "Mob Blacklist"));
  960.       settings.append(MobBlacklist);
  961.      
  962.       modscreen.append(new WidgetBoolean(TargetLocking, "Lose target", "never", "dist. + LOS"));
  963.       settings.append(TargetLocking);
  964.       modscreen.append(new WidgetBoolean(OmnipotentHostiles, "Auto target player", "Yes", "No"));
  965.       settings.append(OmnipotentHostiles);
  966.      
  967.      
  968.      
  969.      
  970.      
  971.      
  972.      
  973.       /*hostilesToNames.put(net.minecraft.src.EntityCreeper.class, "Creeper");
  974.       hostilesToNames.put(net.minecraft.src.EntitySkeleton.class, "Skeleton");
  975.       hostilesToNames.put(net.minecraft.src.EntityZombie.class, "Zombie");
  976.       hostilesToNames.put(net.minecraft.src.EntitySpider.class, "Spider");
  977.       hostilesToNames.put(net.minecraft.src.EntityPigZombie.class, "PigZombie");
  978.       Subscreen subscreen = new Subscreen("button", "Choose Monsters", new WidgetSinglecolumn(new Widget[0]));
  979.       subscreen.setText("Choose Monsters");
  980.       for(int i = 0; i < mobs.length; i++)
  981.       {
  982.           String s = (String)hostilesToNames.get(mobs[i]);
  983.           SettingBoolean settingboolean = new SettingBoolean((new StringBuilder()).append("pf_").append(s).toString(), Boolean.valueOf(true));
  984.           settings.append(settingboolean);
  985.           subscreen.add(new WidgetBoolean(settingboolean, s));
  986.           mobsToUse.put(s, settingboolean);
  987.       }
  988.  
  989.       modscreen.append(subscreen);*/
  990.       SimpleButtonModel simplebuttonmodel = new SimpleButtonModel();
  991.       simplebuttonmodel.addActionCallback(new ModAction(settings, "resetAll", new Class[0]));
  992.       Button button = new Button(simplebuttonmodel);
  993.       button.setText("Reset all to defaults");
  994.       modscreen.append(button);
  995.       settings.load();
  996.      
  997.       //doMobList();
  998.      
  999.    }
  1000.    
  1001.    public void ModsLoaded() {
  1002.     try {
  1003.         //mod_PathingActivated.hasPetMod = true;
  1004.     } catch (Exception ex) {
  1005.        
  1006.     }
  1007.     doMobList();
  1008.    }
  1009.    
  1010.    public static void doMobList() {
  1011.        
  1012.        classToUseMapping.clear();
  1013.        
  1014.         //System.out.println("Blacklist: ");
  1015.         String[] splEnts = MobBlacklist.get().split(",");
  1016.         for (int i = 0; i < splEnts.length; i++) {
  1017.             splEnts[i] = splEnts[i].trim();
  1018.             //System.out.println(splEnts[i]);
  1019.         }
  1020.        
  1021.         HashMap hashmap = null;
  1022.         /*try
  1023.         {
  1024.           hashmap = (HashMap)ModLoader.getPrivateValue(EntityList.class, null, "a");
  1025.         } catch (Throwable throwable) {
  1026.           //ModLoader.getLogger().throwing(getClass().getSimpleName(), "setupConfig", throwable);
  1027.           return;
  1028.         }*/
  1029.         try
  1030.         {
  1031.           try {
  1032.               hashmap = (HashMap)ModLoader.getPrivateValue(EntityList.class, null, "a");
  1033.           }
  1034.           catch (NoSuchFieldException ex)
  1035.           {
  1036.               hashmap = (HashMap)ModLoader.getPrivateValue(EntityList.class, null, "stringToClassMapping");
  1037.           }
  1038.  
  1039.         } catch (Exception ex) {
  1040.             ex.printStackTrace();
  1041.         }
  1042.         //WidgetClassicTwocolumn widgetclassictwocolumn = new WidgetClassicTwocolumn(new Widget[0]);
  1043.         //widgetclassictwocolumn.add(new WidgetMulti(mode, "Mode"));
  1044.         Iterator iterator = hashmap.entrySet().iterator();
  1045.  
  1046.         //System.out.print("Zombie Awareness BlackList: ");
  1047.         StringBuilder blackList = (new StringBuilder()).append("Zombie Awareness BlackList: ");
  1048.         StringBuilder entList = (new StringBuilder()).append("List Options: ");
  1049.         for (Iterator i$ = hashmap.keySet().iterator(); i$.hasNext(); ) {
  1050.           Object o = i$.next();
  1051.           String s = (String)o;
  1052.          
  1053.           Class class1 = (Class)hashmap.get(o);
  1054.           try
  1055.           {
  1056.             class1.getDeclaredConstructor(new Class[] { EntityList.class }); } catch (Throwable throwable1) {
  1057.                 classToUseMapping.put(class1, false);//continue;
  1058.           }
  1059.          
  1060.           if ((!Modifier.isAbstract(class1.getModifiers())))
  1061.           {
  1062.             //SettingBoolean settingboolean = new SettingBoolean("mobarrow_" + s, Boolean.valueOf(true));
  1063.             //mod_Arrows303.Settings.append(settingboolean);
  1064.             //widgetclassictwocolumn.add(new WidgetBoolean(settingboolean, s));
  1065.             //mobSettings.put(s, settingboolean);
  1066.               if ((IMob.class.isAssignableFrom(class1))) {
  1067.                   boolean foundEnt = false;
  1068.                   for (int i = 0; i < splEnts.length; i++) {
  1069.                       if (s.compareToIgnoreCase(splEnts[i]) == 0) {
  1070.                           foundEnt = true;
  1071.                          
  1072.                           blackList.append(s + " ");
  1073.                           //System.out.println("adding to blacklist: " + splEnts[i]);
  1074.                           break;
  1075.                          
  1076.                       }
  1077.                   }
  1078.                  
  1079.                   entList.append(s + " ");
  1080.                   classToUseMapping.put(class1, !foundEnt);
  1081.               } else {
  1082.                   //non mobs
  1083.                   classToUseMapping.put(class1, false);
  1084.               }
  1085.              
  1086.              
  1087.            
  1088.             //System.out.println("hmmmm? " + s);
  1089.           }
  1090.         }
  1091.         System.out.println(entList.toString());
  1092.         System.out.println(blackList.toString());
  1093.    }
  1094.    
  1095.    /*public static boolean shouldEnableEnt(Entity var0) {
  1096.       return ((Boolean)classToUseMapping.get(var0.getClass())).booleanValue();
  1097.    }*/
  1098.    
  1099.    public void EntHook_Init(EntityCreature ent, World world) {
  1100.     //entInit(world, ent);
  1101.    }
  1102.    public void EntHook_Loaded(EntityCreature ent, NBTTagCompound data) {
  1103.  
  1104.        //AI Added
  1105.        //mod_AIManager.entLoaded(ent, data);
  1106.     }
  1107.     public void EntHook_Saved(EntityCreature ent, NBTTagCompound data) {
  1108.  
  1109.        //AI Added
  1110.        //mod_AIManager.entSaved(ent, data);
  1111.     }
  1112.     public void EntHook_Killed(EntityCreature ent, Entity from) {
  1113.        
  1114.     }
  1115.     //_303 suggests setting field_9346_af to 0 before attackEntityFrom is called, would prevent having to overload this?
  1116.     public boolean EntHook_AttackEntityFrom(EntityCreature ent, Entity entFrom, int damage) {
  1117.        
  1118.         return true;
  1119.     }
  1120.    
  1121.     public boolean EntHook_TryAttackEntity(Entity entFrom, Entity entTo, float dist) {
  1122.         if (sameTeam(entFrom, entTo)) {
  1123.             return false;
  1124.         }
  1125.         if((double)dist < 2.0D && entTo.boundingBox.maxY > entFrom.boundingBox.minY && entTo.boundingBox.minY < entFrom.boundingBox.maxY && ((EntityLiving)entFrom).attackTime == 0) {
  1126.                if (entFrom instanceof EntityZombie) {
  1127.                    ((EntityCreature)entFrom).swingArm = true;
  1128.                    ((EntityCreature)entFrom).swingTick = 0;
  1129.                }
  1130.            }
  1131.         return true;
  1132.     }
  1133.        
  1134.     public static boolean sameTeam(Entity ent1, Entity ent2) {
  1135.         //if both 0, more of a neutral setup than teams
  1136.         if (getTeam(ent1) == 0 && getTeam(ent2) == 0) {
  1137.             return false;
  1138.         }
  1139.         if (getTeam(ent1) == getTeam(ent2)) {
  1140.             return true;
  1141.         }
  1142.         return false;
  1143.     }
  1144.    
  1145.     public static int getTeam(Entity entity) {
  1146.         if (entity instanceof EntityCreature) {
  1147.             return ((EntityCreature)entity).team;
  1148.         } else if (entity instanceof EntityPlayer) {
  1149.             return 1;
  1150.         }
  1151.         return 0;
  1152.     }
  1153.    
  1154.    public void EntHook_onUpdate_pre(EntityCreature ent) {
  1155.        //if (true) return;
  1156.     //displayMessage((new StringBuilder()).append("yay!").append("").toString());
  1157.        
  1158.        //ent.info2 = (new StringBuilder()).append("playerToAttack - ").append(ent.playerToAttack).toString();
  1159.    
  1160.        if(ent.pathfindDelay > 0)
  1161.        {
  1162.            ent.pathfindDelay--;
  1163.        }
  1164.        if(ent.playerToAttack != null) {
  1165.          if(!ent.canEntityBeSeen(ent.playerToAttack)) {
  1166.             ++ent.noSeeTicks;
  1167.          } else {
  1168.              ent.noSeeTicks = 0;
  1169.          }
  1170.  
  1171.          //uhhhhhh, what if an entity is pathfinding towards you from somewhere? wouldnt this break the pursuit eventually if they get out of sight?
  1172.          if(ent.noSeeTicks > 150) {
  1173.              ent.noSeeTicks = 0;
  1174.             //System.out.println("no see trigger!");
  1175.              ent.playerToAttack = null;
  1176.              ent.setPathToEntity(null);
  1177.          }
  1178.       }
  1179.        if(ent.notMoving(ent, 0.15F)) {
  1180.              ++ent.noMoveTicks;
  1181.              if(ent.noMoveTicks > 50) {
  1182.                 if(ent.rand.nextInt(10) == 0) {
  1183.                    //System.out.println("idle trigger!");
  1184.                     ent.playerToAttack = null;
  1185.                     ent.setPathToEntity(null);
  1186.                 } else {
  1187.                     ent.noMoveTicks = 0;
  1188.                 }
  1189.              }
  1190.           } else {
  1191.               ent.noMoveTicks = 0;
  1192.           }
  1193.        
  1194.        //put a 'cant navigate' detector here using pathentity size changing, and timer
  1195.        if (ent.hasPath() && ent.getPath() != null) {
  1196.            if (ent.lastNode != ent.getPath().pathLength) {
  1197.                ent.lastNode = ent.getPath().pathLength;
  1198.                ent.lastNodeTimer = 0;
  1199.                //System.out.println("lastNodeTimer = 0");
  1200.            } else {
  1201.                ent.lastNodeTimer++;
  1202.            }
  1203.            if (ent.lastNodeTimer > 200) {
  1204.                //System.out.println("path reset");
  1205.                ent.setPathToEntity(null);
  1206.            }
  1207.        }
  1208.        
  1209.        
  1210.        
  1211.        
  1212.    }
  1213.    
  1214.    public void EntHook_onUpdate_post(EntityCreature ent) {
  1215.    
  1216.    }
  1217.    
  1218.    public void EntHook_AITick(EntityCreature ent) {
  1219.        
  1220.        //ent.isJumping = false;
  1221.        
  1222.        thePlayer = ModLoader.getMinecraftInstance().thePlayer;
  1223.        
  1224.        if(ent.playerToAttack == null && ent.shouldTarget(thePlayer)) {
  1225.            //System.out.println("targetted player");
  1226.            ent.playerToAttack = thePlayer;
  1227.            ent.state = 4;
  1228.            if(thePlayer != null && ent.tryPath(ent.playerToAttack, ent.getPathDist())) {
  1229.               ;
  1230.            }
  1231.         } else if(!ent.hasPath() && getTeam(ent) != 1) {
  1232.            Entity var3 = mod_PathingActivated.getScent(ent);
  1233.            if(var3 != null) {
  1234.               ent.state = 1;
  1235.               if (ent.tryPath(var3, ent.getPathDist())) {
  1236.                  //System.out.println("chance!");
  1237.               }
  1238.            }
  1239.         }
  1240.        
  1241.        //state stuff
  1242.        if (ent.playerToAttack != null && getTeam(ent) != 1) {
  1243.            if (!TargetLocking.get() && ent.getDistanceToEntity(ent.playerToAttack) > AwarenessRange.get()) {
  1244.                ent.playerToAttack = null;
  1245.                ent.state = 1;
  1246.            } else {
  1247.                ent.state = 4;
  1248.            }
  1249.        }
  1250.        
  1251.        if(ent.isCollidedHorizontally) {
  1252.            ent.isJumping = true;
  1253.        }
  1254.        
  1255.        if (ent instanceof EntityCreeper) {
  1256.            if (ent.playerToAttack != null && !(ent.playerToAttack instanceof EntityPlayer)) {
  1257.                ent.playerToAttack = thePlayer;
  1258.            }
  1259.        }
  1260.        
  1261.        int pSize = 0;
  1262.        
  1263.        if(ent instanceof EntityCreature) {
  1264.         PathEntity pEnt = ((EntityCreature)ent).getPath();
  1265.            if(pEnt != null) { pSize = pEnt.pathLength; }
  1266.        }
  1267.        
  1268.        //ent.info2 = (new StringBuilder()).append("pet state: "+ent.state+" - targ: "+ent.playerToAttack+" - pathsize: "+pSize).toString();
  1269.    }
  1270.    
  1271.    public boolean OnTickInGUI(Minecraft game, GuiScreen gui)
  1272.    {
  1273.     if (ModLoader.getMinecraftInstance().thePlayer != null) {
  1274.         //long ticksRan = System.currentTimeMillis();
  1275.         if (!(gui instanceof GuiContainer)) {
  1276.                 inMenu = true;
  1277.                 lastTickRun = 0;
  1278.         }
  1279.        
  1280.         //System.out.println(gui);
  1281.         //playerTick(mc.thePlayer);
  1282.     }
  1283.     return true;
  1284.    }
  1285.  
  1286.    public boolean OnTickInGame(Minecraft var1) {
  1287.        
  1288.       if (inMenu) {
  1289.         //System.out.println(lastTickRun);
  1290.         if (lastTickRun > 10) {
  1291.             doMobList();
  1292.             inMenu = false;
  1293.         }
  1294.         lastTickRun++;
  1295.       }
  1296.      
  1297.       if (!inMenu) {
  1298.           EntityPlayerSP var2 = var1.thePlayer;
  1299.           if(var2.health != lastHealth) {
  1300.              if(var2.health < lastHealth) {
  1301.                 //spawnScent(var2);
  1302.              }
  1303.    
  1304.              lastHealth = var2.health;
  1305.           }
  1306.    
  1307.           if(var2.health < 12 && lastBleedTime < System.currentTimeMillis()) {
  1308.              lastBleedTime = System.currentTimeMillis() + 30000L;
  1309.              //spawnScent(var2);
  1310.           }
  1311.       }
  1312.  
  1313.       return true;
  1314.    }
  1315.  
  1316.    public static Entity getScent(Entity var0) {
  1317.        
  1318.       List var1 = var0.worldObj.getEntitiesWithinAABBExcludingEntity(var0, var0.boundingBox.expand((double)MaxPFRange.get().intValue(), (double)MaxPFRange.get().intValue(), (double)MaxPFRange.get().intValue()));
  1319.       Entity var2 = null;
  1320.       Entity var3 = null;
  1321.       Object var4 = null;
  1322.       float var5 = 90000.0F;
  1323.       float var6 = 90000.0F;
  1324.       boolean var7 = false;
  1325.  
  1326.       for(int var8 = 0; var8 < var1.size(); ++var8) {
  1327.          var2 = (Entity)var1.get(var8);
  1328.          if(var2 instanceof EntityScent && var0.getDistanceToEntity(var2) < ((EntityScent)var2).getRange() && var0.getDistanceToEntity(var2) > 5.0F && var0.rand.nextInt(1000) == 0) {
  1329.             var3 = var2;
  1330.          }
  1331.       }
  1332.  
  1333.       return var3;
  1334.    }
  1335.  
  1336.    public static void spawnSoundTrace(String var0, float var1, float var2, float var3, float var4, float var5) {
  1337.        //System.out.println("sound: " + var0);
  1338.        
  1339.        //TEEEEEMMMMMMMMPPPPPPPPP
  1340.        if (!ScentAwareness.get() || traceCount >= 0) { return; }
  1341.        
  1342.        if (!canSpawnTrace((int)var1, (int)var2, (int)var3)) {
  1343.            return;
  1344.        }
  1345.        
  1346.       EntityPlayerSP var6 = ModLoader.getMinecraftInstance().thePlayer;
  1347.       int var7 = (int)(20.0F * var4);
  1348.       boolean var8 = false;
  1349.       /*if(var0.substring(7).equals("drr")) {
  1350.          var8 = true;
  1351.       }*/
  1352.      
  1353.       if(var0.substring(7).equals("bow") || var0.substring(7).equals("pop") || var0.substring(7).equals("wood")) {
  1354.           return;
  1355.        }
  1356.      
  1357.       if((var8 || Math.abs(var6.posX - (double)var1) < 3.0D && Math.abs(var6.posY - (double)var6.getEyeHeight() - (double)var2) < 3.0D && Math.abs(var6.posZ - (double)var3) < 3.0D) && var7 > 15) {
  1358.          EntityScent var9 = new EntityScent(var6.worldObj);
  1359.          if(var7 < 25) {
  1360.             var9.setStrength(SoundStrength.get());
  1361.          }
  1362.  
  1363.          var7 = var9.strength;
  1364.          if(var0.substring(7).equals("drr")) {
  1365.             var7 += 10;
  1366.          }
  1367.  
  1368.          if(lastSoundTime + (long)frequentSoundThreshold > System.currentTimeMillis()) {
  1369.             lastMultiply += 0.1F;
  1370.             var7 = (int)((float)var7 * lastMultiply);
  1371.          } else {
  1372.             lastMultiply = 1.0F;
  1373.          }
  1374.  
  1375.          lastSoundTime = System.currentTimeMillis();
  1376.          var9.setStrength(var7);
  1377.          var9.type = 1;
  1378.          var9.setPosition((double)var1, (double)var2, (double)var3);
  1379.          var6.worldObj.entityJoinedWorld(var9);
  1380.          
  1381.          //System.out.println("sound: " + var0 + " - range: " + var9.getRange());
  1382.          //System.out.println(var9.getRange());
  1383.       }
  1384.  
  1385.    }
  1386.  
  1387.    public static void spawnScent(Entity var0) {
  1388.        
  1389.        if (!SoundAwareness.get() || traceCount > 75) { return; }
  1390.        
  1391.        if (!canSpawnTrace((int)var0.posX, (int)var0.posY, (int)var0.posZ)) {
  1392.            return;
  1393.        }
  1394.        
  1395.       double height = var0.posY - (double)var0.yOffset + 0.0D;
  1396.      
  1397.       /*if (var0 instanceof EntityPlayer) {
  1398.           height -= 1.0D;
  1399.       }*/
  1400.       //System.out.println(height);
  1401.       EntityScent var1 = new EntityScent(var0.worldObj);
  1402.       var1.setPosition(var0.posX, height, var0.posZ);
  1403.      
  1404.       var0.worldObj.entityJoinedWorld(var1);
  1405.       var1.setStrength(ScentStrength.get());
  1406.       var1.type = 0;
  1407.      
  1408.       //System.out.println("scent: " + var0 + " - range: " + var1.getRange());
  1409.       //System.out.println("?!?!?! - " + var1.type);
  1410.       //System.out.println(var1.getRange());
  1411.    }
  1412.    
  1413.    public static boolean canSpawnTrace(int x, int y, int z) {
  1414.        
  1415.        int id = Block.pressurePlatePlanks.blockID;
  1416.        
  1417.        if (ModLoader.getMinecraftInstance().theWorld.getBlockId(x-1,y,z) == id) {
  1418.            return false;
  1419.        }
  1420.        
  1421.        /*if (ModLoader.getMinecraftInstance().theWorld.getBlockId(x,y,z) == id) {
  1422.            return false;
  1423.        }
  1424.        if (ModLoader.getMinecraftInstance().theWorld.getBlockId(x+1,y,z) == id) {
  1425.            return false;
  1426.        }
  1427.        if (ModLoader.getMinecraftInstance().theWorld.getBlockId(x,y,z-1) == id) {
  1428.            return false;
  1429.        }
  1430.        if (ModLoader.getMinecraftInstance().theWorld.getBlockId(x,y,z+1) == id) {
  1431.            return false;
  1432.        }
  1433.        
  1434.        if (ModLoader.getMinecraftInstance().theWorld.getBlockId(x,y-1,z) == id) {
  1435.            return false;
  1436.        }
  1437.        if (ModLoader.getMinecraftInstance().theWorld.getBlockId(x,y+1,z) == id) {
  1438.            return false;
  1439.        }*/
  1440.        return true;
  1441.    }
  1442.  
  1443.    public void AddRenderer(Map var1) {
  1444.       var1.put(EntityScent.class, new RenderScent());
  1445.    }
  1446.  
  1447.    public static boolean useEnt(Entity var0) {
  1448.        try {
  1449.            return ((Boolean)classToUseMapping.get(var0.getClass())).booleanValue();
  1450.        } catch (Exception ex) {
  1451.            return false;
  1452.        }
  1453.    }
  1454.  
  1455.    public String Version() {
  1456.       return "v1.0 for MC b1.7.3";
  1457.    }
  1458.  
  1459. }
  1460.  
  1461. PathfinderEnh.java
  1462.  
  1463. package net.minecraft.src;
  1464.  
  1465. import net.minecraft.src.Block;
  1466. import net.minecraft.src.BlockDoor;
  1467. import net.minecraft.src.Entity;
  1468. import net.minecraft.src.IBlockAccess;
  1469. import net.minecraft.src.MCHash;
  1470. import net.minecraft.src.Material;
  1471. import net.minecraft.src.MathHelper;
  1472. import net.minecraft.src.Path;
  1473. import net.minecraft.src.PathEntity;
  1474. import net.minecraft.src.PathPoint;
  1475.  
  1476. public class PathfinderEnh implements Runnable {
  1477.  
  1478.    private IBlockAccess worldMap;
  1479.    private Path path = new Path();
  1480.    private MCHash pointMap = new MCHash();
  1481.    private PathPoint[] pathOptions = new PathPoint[32];
  1482.    
  1483.    public boolean foundEnd;
  1484.    public boolean canClimb = false;
  1485.    
  1486.    public boolean isPathing = false;
  1487.    public PathEntity t_path;
  1488.    public Entity t_ent;
  1489.    public Entity t_targ;
  1490.    public float t_dist;
  1491.    
  1492.    public ChunkCache cc;
  1493.    public boolean firstUse = true;
  1494.  
  1495.    public PathfinderEnh(IBlockAccess var1) {
  1496.       this.worldMap = var1;
  1497.    }
  1498.    
  1499.    public void run() {
  1500.        
  1501.           //}
  1502.          
  1503.           t_path = createEntityPathTo(t_ent, t_targ, t_dist);
  1504.           ((EntityCreature)t_ent).setPathToEntity(t_path);
  1505.           isPathing = false;
  1506.           if (t_path != null) {
  1507.               //System.out.println(t_path.points.length);
  1508.           }
  1509.        
  1510.    }
  1511.    
  1512.    public static PathEntity requestPath() {
  1513.        //try transparent way:
  1514.        //ent asks for path, insta return 1 node path with ent pos Y+4 to keep it still, start thread
  1515.        //then once thread has path, replace fake path with actual path
  1516.        
  1517.        return null;
  1518.    }
  1519.    
  1520.    public PathEntity getPathToEntity(Entity var1, Entity var2, float var3) {
  1521.        return getPathToEntity(var1, var2, var3, false);
  1522.    }
  1523.    
  1524.    
  1525.    
  1526.    public PathEntity getPathToEntity(Entity var1, Entity var2, float var3, boolean canClimb) {
  1527.        if (!isPathing) {
  1528.            isPathing = true;
  1529.            
  1530.          
  1531.          
  1532.          
  1533.           //PathfinderEnh pf = new PathfinderEnh(var14);
  1534.           if (var1 instanceof EntityHooks) {
  1535.               this.canClimb = canClimb;
  1536.               //this.worldMap = var14;
  1537.               this.t_ent = var1;
  1538.               this.t_targ = var2;
  1539.               this.t_dist = var3;
  1540.               this.t_path = null;
  1541.          
  1542.          
  1543.               int var4 = MathHelper.floor_double(t_ent.posX);
  1544.               int var5 = MathHelper.floor_double(t_ent.posY);
  1545.               int var6 = MathHelper.floor_double(t_ent.posZ);
  1546.               int var7 = (int)(t_dist + 16.0F);
  1547.               int var8 = var4 - var7;
  1548.               int var9 = var5 - var7;
  1549.               int var10 = var6 - var7;
  1550.               int var11 = var4 + var7;
  1551.               int var12 = var5 + var7;
  1552.               int var13 = var6 + var7;
  1553.              
  1554.               //if (firstUse) {
  1555.                   //firstUse = false;
  1556.               //System.out.println("pf chunkcache!");
  1557.               worldMap = new ChunkCache(ModLoader.getMinecraftInstance().theWorld, var8, var9, var10, var11, var12, var13);
  1558.              
  1559.               //thread!
  1560.               (new Thread(this)).start();
  1561.           }
  1562.          
  1563.           //return ((EntityHooks)var1).pf.createEntityPathTo(var1, var2, var3);
  1564.        } else {
  1565.            
  1566.        }
  1567.        PathPoint points[] = new PathPoint[1];
  1568.        points[0] = new PathPoint((int)(var1.posX-0.5), (int)(var1.posY + 4D), (int)(var1.posZ-0.5));
  1569.        return new PathEntity(points);
  1570.    }
  1571.  
  1572.    public PathEntity getEntityPathToXYZ(Entity var1, int var2, int var3, int var4, float var5) {
  1573.       int var6 = MathHelper.floor_double(var1.posX);
  1574.       int var7 = MathHelper.floor_double(var1.posY);
  1575.       int var8 = MathHelper.floor_double(var1.posZ);
  1576.       int var9 = (int)(var5 + 8.0F);
  1577.       int var10 = var6 - var9;
  1578.       int var11 = var7 - var9;
  1579.       int var12 = var8 - var9;
  1580.       int var13 = var6 + var9;
  1581.       int var14 = var7 + var9;
  1582.       int var15 = var8 + var9;
  1583.       ChunkCache var16 = new ChunkCache(ModLoader.getMinecraftInstance().theWorld, var10, var11, var12, var13, var14, var15);
  1584.      
  1585.       PathfinderEnh pf = new PathfinderEnh(var16);
  1586.       pf.canClimb = false;
  1587.      
  1588.       return (pf).createEntityPathTo(var1, var2, var3, var4, var5);
  1589.    }
  1590.  
  1591.    public PathEntity createEntityPathTo(Entity var1, Entity var2, float var3) {
  1592.       return this.createEntityPathTo(var1, var2.posX, var2.boundingBox.minY, var2.posZ, var3);
  1593.    }
  1594.  
  1595.    public PathEntity createEntityPathTo(Entity var1, int var2, int var3, int var4, float var5) {
  1596.       return this.createEntityPathTo(var1, (double)((float)var2 + 0.5F), (double)((float)var3 + 0.5F), (double)((float)var4 + 0.5F), var5);
  1597.    }
  1598.  
  1599.    private PathEntity createEntityPathTo(Entity var1, double var2, double var4, double var6, float var8) {
  1600.       this.path.clearPath();
  1601.       this.pointMap.clearMap();
  1602.       foundEnd = false;
  1603.       PathPoint var9 = this.openPoint(MathHelper.floor_double(var1.boundingBox.minX), MathHelper.floor_double(var1.boundingBox.minY), MathHelper.floor_double(var1.boundingBox.minZ));
  1604.       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)));
  1605.       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));
  1606.       PathEntity var12 = this.addToPath(var1, var9, var10, var11, var8);
  1607.       if (var12 != null) {
  1608.           var12.foundEnd = foundEnd;
  1609.       }
  1610.       try {
  1611.           //Thread.sleep(500L);
  1612.       } catch (Throwable ex) {
  1613.          
  1614.       }
  1615.       return var12;
  1616.    }
  1617.  
  1618.    private PathEntity addToPath(Entity var1, PathPoint var2, PathPoint var3, PathPoint var4, float var5) {
  1619.       var2.totalPathDistance = 0.0F;
  1620.       var2.distanceToNext = var2.distanceTo(var3);
  1621.       var2.distanceToTarget = var2.distanceToNext;
  1622.       this.path.clearPath();
  1623.       this.path.addPoint(var2);
  1624.       PathPoint var6 = var2;
  1625.  
  1626.       while(!this.path.isPathEmpty()) {
  1627.          PathPoint var7 = this.path.dequeue();
  1628.          if(var7.equals(var3)) {
  1629.             return this.createEntityPath(var2, var3);
  1630.          }
  1631.  
  1632.          if(var7.distanceTo(var3) < var6.distanceTo(var3)) {
  1633.             var6 = var7;
  1634.          }
  1635.  
  1636.          var7.isFirst = true;
  1637.          int var8 = this.findPathOptions(var1, var7, var4, var3, var5);
  1638.  
  1639.          for(int var9 = 0; var9 < var8; ++var9) {
  1640.             PathPoint var10 = this.pathOptions[var9];
  1641.             float var11 = var7.totalPathDistance + var7.distanceTo(var10);
  1642.             if(!var10.isAssigned() || var11 < var10.totalPathDistance) {
  1643.                var10.previous = var7;
  1644.                var10.totalPathDistance = var11;
  1645.                var10.distanceToNext = var10.distanceTo(var3);
  1646.                if(var10.isAssigned()) {
  1647.                   this.path.changeDistance(var10, var10.totalPathDistance + var10.distanceToNext);
  1648.                } else {
  1649.                   var10.distanceToTarget = var10.totalPathDistance + var10.distanceToNext;
  1650.                   this.path.addPoint(var10);
  1651.                }
  1652.             }
  1653.          }
  1654.          
  1655.       }
  1656.      
  1657.       if (Math.abs(var3.xCoord - var6.xCoord) < 2 && Math.abs(var3.yCoord - var6.yCoord) < 2 && Math.abs(var3.zCoord - var6.zCoord) < 2) {
  1658.           foundEnd = true;
  1659.       }
  1660.  
  1661.       if(var6 == var2) {
  1662.          return null;
  1663.       } else {
  1664.          return this.createEntityPath(var2, var6);
  1665.       }
  1666.    }
  1667.  
  1668.    private int findPathOptions(Entity var1, PathPoint var2, PathPoint var3, PathPoint var4, float var5) {
  1669.       int var6 = 0;
  1670.       byte var7 = 0;
  1671.       if(this.getVerticalOffset(var1, var2.xCoord, var2.yCoord + 1, var2.zCoord, var3) == 1) {
  1672.          var7 = 1;
  1673.       }
  1674.  
  1675.       PathPoint var8 = this.getSafePoint(var1, var2.xCoord, var2.yCoord, var2.zCoord + 1, var3, var7);
  1676.       PathPoint var9 = this.getSafePoint(var1, var2.xCoord - 1, var2.yCoord, var2.zCoord, var3, var7);
  1677.       PathPoint var10 = this.getSafePoint(var1, var2.xCoord + 1, var2.yCoord, var2.zCoord, var3, var7);
  1678.       PathPoint var11 = this.getSafePoint(var1, var2.xCoord, var2.yCoord, var2.zCoord - 1, var3, var7);
  1679.      
  1680.       if(var8 != null && !var8.isFirst && var8.distanceTo(var4) < var5) {
  1681.           this.pathOptions[var6++] = var8;
  1682.        }
  1683.  
  1684.        if(var9 != null && !var9.isFirst && var9.distanceTo(var4) < var5) {
  1685.           this.pathOptions[var6++] = var9;
  1686.        }
  1687.  
  1688.        if(var10 != null && !var10.isFirst && var10.distanceTo(var4) < var5) {
  1689.           this.pathOptions[var6++] = var10;
  1690.        }
  1691.  
  1692.        if(var11 != null && !var11.isFirst && var11.distanceTo(var4) < var5) {
  1693.           this.pathOptions[var6++] = var11;
  1694.        }
  1695.        
  1696.        if (canClimb) {
  1697.            PathPoint vvar8 = this.getClimbPoint(var1, var2.xCoord, var2.yCoord, var2.zCoord + 1, var3, var7, var2.xCoord, var2.zCoord);
  1698.            PathPoint vvar9 = this.getClimbPoint(var1, var2.xCoord - 1, var2.yCoord, var2.zCoord, var3, var7, var2.xCoord, var2.zCoord);
  1699.            PathPoint vvar10 = this.getClimbPoint(var1, var2.xCoord + 1, var2.yCoord, var2.zCoord, var3, var7, var2.xCoord, var2.zCoord);
  1700.            PathPoint vvar11 = this.getClimbPoint(var1, var2.xCoord, var2.yCoord, var2.zCoord - 1, var3, var7, var2.xCoord, var2.zCoord);
  1701.          
  1702.           if(vvar8 != null && !vvar8.isFirst && vvar8.distanceTo(var4) < var5) {
  1703.              this.pathOptions[var6++] = vvar8;
  1704.           }
  1705.    
  1706.           if(vvar9 != null && !vvar9.isFirst && vvar9.distanceTo(var4) < var5) {
  1707.              this.pathOptions[var6++] = vvar9;
  1708.           }
  1709.    
  1710.           if(vvar10 != null && !vvar10.isFirst && vvar10.distanceTo(var4) < var5) {
  1711.              this.pathOptions[var6++] = vvar10;
  1712.           }
  1713.    
  1714.           if(vvar11 != null && !vvar11.isFirst && vvar11.distanceTo(var4) < var5) {
  1715.              this.pathOptions[var6++] = vvar11;
  1716.           }
  1717.        }
  1718.  
  1719.       return var6;
  1720.    }
  1721.    
  1722.    private PathPoint getClimbPoint(Entity var1, int x, int y, int z, PathPoint var5, int var6, int origX, int origZ) {
  1723.           PathPoint var7 = null;
  1724.           if(this.getVerticalOffset(var1, x, y, z, var5) == 1) {
  1725.              var7 = this.openPoint(x, y, z);
  1726.           }
  1727.  
  1728.           if(var7 == null && var6 > 0 && this.getVerticalOffset(var1, x, y + var6, z, var5) == 1) {
  1729.              var7 = this.openPoint(x, y + var6, z);
  1730.              y += var6;
  1731.           }
  1732.  
  1733.           if(var7 == null && canClimb) {
  1734.              
  1735.               int var8 = 0;
  1736.               int var9 = 0;
  1737.               int var10 = 0;
  1738.               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) {
  1739.                   ++var8;
  1740.                   if(var8 >= 3) {
  1741.                      return null;
  1742.                   }
  1743.  
  1744.                   ++y;
  1745.                   if(y > 0 && y < 128) {
  1746.                      var7 = this.openPoint(x, y, z);
  1747.                   }
  1748.                }
  1749.                if (var10 != 1) {
  1750.                    return null;
  1751.                }
  1752.                if(var9 == -2) {
  1753.                   return null;
  1754.                }
  1755.           }
  1756.  
  1757.           return var7;
  1758.        }
  1759.  
  1760.    private PathPoint getSafePoint(Entity var1, int var2, int var3, int var4, PathPoint var5, int var6) {
  1761.       PathPoint var7 = null;
  1762.       if(this.getVerticalOffset(var1, var2, var3, var4, var5) == 1) {
  1763.          var7 = this.openPoint(var2, var3, var4);
  1764.       }
  1765.  
  1766.       if(var7 == null && var6 > 0 && this.getVerticalOffset(var1, var2, var3 + var6, var4, var5) == 1) {
  1767.          var7 = this.openPoint(var2, var3 + var6, var4);
  1768.          var3 += var6;
  1769.       }
  1770.  
  1771.       if(var7 != null) {
  1772.          int var8 = 0;
  1773.          int var9 = 0;
  1774.  
  1775.          while(var3 > 0 && (var9 = this.getVerticalOffset(var1, var2, var3 - 1, var4, var5)) == 1) {
  1776.             ++var8;
  1777.             if(var8 >= 4) {
  1778.                return null;
  1779.             }
  1780.  
  1781.             --var3;
  1782.             if(var3 > 0) {
  1783.                var7 = this.openPoint(var2, var3, var4);
  1784.             }
  1785.          }
  1786.  
  1787.          if(var9 == -2) {
  1788.             return null;
  1789.          }
  1790.       }
  1791.  
  1792.       return var7;
  1793.    }
  1794.  
  1795.    private final PathPoint openPoint(int var1, int var2, int var3) {
  1796.       int var4 = PathPoint.func_22329_a(var1, var2, var3);
  1797.       PathPoint var5 = (PathPoint)this.pointMap.lookup(var4);
  1798.       if(var5 == null) {
  1799.          var5 = new PathPoint(var1, var2, var3);
  1800.          this.pointMap.addKey(var4, var5);
  1801.       }
  1802.  
  1803.       return var5;
  1804.    }
  1805.  
  1806.    private int getVerticalOffset(Entity var1, int var2, int var3, int var4, PathPoint var5) {
  1807.       for(int var6 = var2; var6 < var2 + var5.xCoord; ++var6) {
  1808.          for(int var7 = var3; var7 < var3 + var5.yCoord; ++var7) {
  1809.             for(int var8 = var4; var8 < var4 + var5.zCoord; ++var8) {
  1810.                int var9 = this.worldMap.getBlockId(var6, var7, var8);
  1811.                if(var9 > 0) {
  1812.                    
  1813.                    if(var9 != Block.doorSteel.blockID && var9 != Block.doorWood.blockID) {
  1814.                      
  1815.                       if (var9 == Block.fence.blockID) {
  1816.                          return -2;
  1817.                        }
  1818.                      
  1819.                       if (var9 == Block.pressurePlatePlanks.blockID || var9 == Block.pressurePlateStone.blockID) {
  1820.                           return 1;
  1821.                       }
  1822.                      
  1823.                      
  1824.                       Material var11 = Block.blocksList[var9].blockMaterial;
  1825.                       if(var11.getIsSolid()) {
  1826.                          return 0;
  1827.                       }
  1828.  
  1829.                       if(var11 == Material.water) {
  1830.                          return -1;
  1831.                       }
  1832.  
  1833.                       if(var11 == Material.lava) {
  1834.                          return -2;
  1835.                       }
  1836.                      
  1837.                      
  1838.                    } else {
  1839.                       int var10 = this.worldMap.getBlockMetadata(var6, var7, var8);
  1840.                       if(!BlockDoor.isOpen(var10)) {
  1841.                          return 0;
  1842.                       }
  1843.                    }
  1844.                }
  1845.             }
  1846.          }
  1847.       }
  1848.  
  1849.       return 1;
  1850.    }
  1851.  
  1852.    private PathEntity createEntityPath(PathPoint var1, PathPoint var2) {
  1853.       int var3 = 1;
  1854.  
  1855.       PathPoint var4;
  1856.       for(var4 = var2; var4.previous != null; var4 = var4.previous) {
  1857.          ++var3;
  1858.       }
  1859.  
  1860.       PathPoint[] var5 = new PathPoint[var3];
  1861.       var4 = var2;
  1862.       --var3;
  1863.  
  1864.       for(var5[var3] = var2; var4.previous != null; var5[var3] = var4) {
  1865.          var4 = var4.previous;
  1866.          --var3;
  1867.       }
  1868.  
  1869.       return new PathEntity(var5);
  1870.    }
  1871. }
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!