Files
Draconic-Evolution/src/main/java/net/smart/moving/Orientation.java
T
2016-03-24 15:39:17 +11:00

2481 lines
74 KiB
Java

// ==================================================================
// This file is part of Smart Moving.
//
// Smart Moving is free software: you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// Smart Moving is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Smart Moving. If not, see <http://www.gnu.org/licenses/>.
// ==================================================================
package net.smart.moving;
import java.lang.reflect.*;
import java.util.*;
import net.minecraft.block.*;
import net.minecraft.block.material.*;
import net.minecraft.client.*;
import net.minecraft.entity.*;
import net.minecraft.entity.player.*;
import net.minecraft.tileentity.*;
import net.minecraft.util.*;
import net.minecraft.world.*;
import net.smart.moving.config.*;
import net.smart.utilities.*;
public class Orientation extends SmartMovingContext
{
public static final Orientation ZZ = new Orientation(0, 0);
public static final Orientation PZ = new Orientation(1, 0);
public static final Orientation ZP = new Orientation(0, 1);
public static final Orientation NZ = new Orientation(-1, 0);
public static final Orientation ZN = new Orientation(0, -1);
public static final Orientation PP = new Orientation(1, 1);
public static final Orientation NN = new Orientation(-1, -1);
public static final Orientation PN = new Orientation(1, -1);
public static final Orientation NP = new Orientation(-1, 1);
public static final int DefaultMeta = -1;
public static final int VineFrontMeta = 0;
public static final int VineSideMeta = 1;
private static final int top = 2;
private static final int middle = 1;
private static final int base = 0;
private static final int sub = -1;
private static final int subSub = -2;
private static final int NoGrab = 0;
private static final int HalfGrab = 1;
private static final int AroundGrab = 2;
public static final HashSet<Orientation> Orthogonals = new HashSet<Orientation>();
static
{
Orthogonals.add(PZ);
Orthogonals.add(ZP);
Orthogonals.add(NZ);
Orthogonals.add(ZN);
}
protected int _i, _k;
private boolean _isDiagonal;
private float _directionAngle;
private float _mimimumClimbingAngle;
private float _maximumClimbingAngle;
private Orientation(int i, int k)
{
_i = i;
_k = k;
_isDiagonal = _i != 0 && _k != 0;
setClimbingAngles();
}
@SuppressWarnings("incomplete-switch")
public Orientation rotate(int angle)
{
if (this == ZZ)
throw new RuntimeException("unrotatable orientation");
switch(angle)
{
case 0:
return this;
case 45:
if(this == PZ)
return PP;
if(this == PP)
return ZP;
if(this == ZP)
return NP;
if(this == NP)
return NZ;
if(this == NZ)
return NN;
if(this == NN)
return ZN;
if(this == ZN)
return PN;
if(this == PN)
return PZ;
throw new RuntimeException("unknown orientation \"" + this + "\"");
case -45:
if(this == PZ)
return PN;
if(this == PN)
return ZN;
if(this == ZN)
return NN;
if(this == NN)
return NZ;
if(this == NZ)
return NP;
if(this == NP)
return ZP;
if(this == ZP)
return PP;
if(this == PP)
return PZ;
throw new RuntimeException("unknown orientation \"" + this + "\"");
case 90:
return rotate(45).rotate(45);
case -90:
return rotate(-45).rotate(-45);
case 135:
return rotate(180).rotate(-45);
case -135:
return rotate(-180).rotate(45);
case 180:
case -180:
if(this == PZ)
return NZ;
if(this == PN)
return NP;
if(this == ZN)
return ZP;
if(this == NN)
return PP;
if(this == NZ)
return PZ;
if(this == NP)
return PN;
if(this == ZP)
return ZN;
if(this == PP)
return NN;
throw new RuntimeException("unknown orientation");
}
throw new RuntimeException("angle \"" + angle + "\" not supported");
}
public static Orientation getOrientation(EntityPlayer p, float tolerance, boolean orthogonals, boolean diagonals)
{
float rotation = p.rotationYaw % 360F;
if(rotation < 0)
rotation += 360F;
float minimumRotation = rotation - tolerance;
if(minimumRotation < 0)
minimumRotation += 360F;
float maximumRotation = rotation + tolerance;
if(maximumRotation >= 360F)
maximumRotation -= 360F;
if(orthogonals)
{
if(NZ.isWithinAngle(minimumRotation, maximumRotation))
return NZ;
if(PZ.isWithinAngle(minimumRotation, maximumRotation))
return PZ;
if(ZN.isWithinAngle(minimumRotation, maximumRotation))
return ZN;
if(ZP.isWithinAngle(minimumRotation, maximumRotation))
return ZP;
}
if(diagonals)
{
if(NP.isWithinAngle(minimumRotation, maximumRotation))
return NP;
if(PN.isWithinAngle(minimumRotation, maximumRotation))
return PN;
if(NN.isWithinAngle(minimumRotation, maximumRotation))
return NN;
if(PP.isWithinAngle(minimumRotation, maximumRotation))
return PP;
}
return null;
}
public double getHorizontalBorderGap(Entity entity)
{
return getHorizontalBorderGap(entity.posX, entity.posZ);
}
private double getHorizontalBorderGap()
{
return getHorizontalBorderGap(base_id, base_kd);
}
private double getHorizontalBorderGap(double i, double k)
{
if(this == NZ)
return i % 1;
if(this == PZ)
return 1 - (i % 1);
if(this == ZN)
return k % 1;
if(this == ZP)
return 1 - (k % 1);
return 0D;
}
public boolean isTunnelAhead(World world, int i, int j, int k)
{
Block remoteId = world.getBlock(i + _i, j + 1, k + _k);
if(isFullEmpty(remoteId))
{
Material aboveMaterial = world.getBlock(i + _i, j + 2, k + _k).getMaterial();
if(aboveMaterial != null && isSolid(aboveMaterial))
return true;
}
return false;
}
public static HashSet<Orientation> getClimbingOrientations(EntityPlayer p, boolean orthogonals, boolean diagonals)
{
float rotation = p.rotationYaw % 360F;
if(rotation < 0)
rotation += 360F;
if(_getClimbingOrientationsHashSet == null)
_getClimbingOrientationsHashSet = new HashSet<Orientation>();
else
_getClimbingOrientationsHashSet.clear();
if(orthogonals)
{
NZ.addTo(rotation);
PZ.addTo(rotation);
ZN.addTo(rotation);
ZP.addTo(rotation);
}
if(diagonals)
{
NP.addTo(rotation);
PN.addTo(rotation);
NN.addTo(rotation);
PP.addTo(rotation);
}
return _getClimbingOrientationsHashSet;
}
private static HashSet<Orientation> _getClimbingOrientationsHashSet = null;
private void addTo(float rotation)
{
if(isRotationForClimbing(rotation))
_getClimbingOrientationsHashSet.add(this);
}
public boolean isFeetLadderSubstitute(World world, int bi, int j, int bk)
{
int i = bi + _i;
int k = bk + _k;
return isLadderSubstitute(world, i, j, k, middle) > 0 || isLadderSubstitute(world, i, j, k, base) > 0;
}
public boolean isHandsLadderSubstitute(World world, int bi, int j, int bk)
{
int i= bi + _i;
int k = bk + _k;
return isLadderSubstitute(world, i, j, k, middle) > 0 || isLadderSubstitute(world, i, j, k, base) > 0 || isLadderSubstitute(world, i, j, k, sub) > 0;
}
private int isLadderSubstitute(World worldObj, int i, int j, int k, int halfOffset)
{
world = worldObj;
remote_i = i;
all_j = j;
remote_k = k;
all_offset = 0;
return isLadderSubstitute(halfOffset, null);
}
public void seekClimbGap(float rotation, World world, int i, double id, double jhd, int k, double kd, boolean isClimbCrawling, boolean isCrawlClimbing, boolean isCrawling, HandsClimbing[] inout_handsClimbing, FeetClimbing[] inout_feetClimbing, ClimbGap out_handsClimbGap, ClimbGap out_feetClimbGap)
{
if(isRotationForClimbing(rotation))
{
initialize(world, i, id, jhd, k, kd);
inout_handsClimbing[0] = inout_handsClimbing[0].max(handsClimbing(isClimbCrawling, isCrawlClimbing, isCrawling, _climbGapOuterTemp), out_handsClimbGap, _climbGapOuterTemp);
inout_feetClimbing[0] = inout_feetClimbing[0].max(feetClimbing(isClimbCrawling, isCrawlClimbing, isCrawling, _climbGapOuterTemp), out_feetClimbGap, _climbGapOuterTemp);
}
}
private HandsClimbing handsClimbing(boolean isClimbCrawling, boolean isCrawlClimbing, boolean isCrawling, ClimbGap out_climbGap)
{
out_climbGap.reset();
_climbGapTemp.reset();
initializeOffset(3D, isClimbCrawling, isCrawlClimbing, isCrawling);
HandsClimbing result = HandsClimbing.None;
int gap;
if((gap = isLadderSubstitute(middle, _climbGapTemp)) > 0)
if(jh_offset > 1D - _handClimbingHoldGap)
result = result.max(HandsClimbing.Up, out_climbGap, _climbGapTemp);
else
result = result.max(HandsClimbing.None, out_climbGap, _climbGapTemp); // No climbing (hands not long enough - up)
if((gap = isLadderSubstitute(base, _climbGapTemp)) > 0)
if(jh_offset < _handClimbingHoldGap)
result = result.max(HandsClimbing.BottomHold, out_climbGap, _climbGapTemp); // Climbing speed 1 (pulling weight up) or hold when climbing down
else
result = result.max(HandsClimbing.Up, out_climbGap, _climbGapTemp); // Climbing speed 1 (pulling weight up)
_climbGapTemp.SkipGaps = isClimbCrawling || isCrawlClimbing;
if((gap = isLadderSubstitute(sub, _climbGapTemp)) > 0 && !(isCrawling && gap > 1))
if(!isClimbCrawling && gap > 2)
result = result.max(HandsClimbing.FastUp, out_climbGap, _climbGapTemp); // Climbing speed 1 (pulling upper body into gap)
else if(isClimbCrawling && gap > 1)
result = result.max(HandsClimbing.FastUp, out_climbGap, _climbGapTemp); // Climbing speed 1 (crawling into upper gap)
else // (no gap for balancing upper body)
if(jh_offset < _handClimbingHoldGap)
if(grabType == AroundGrab)
result = result.max(HandsClimbing.Up, out_climbGap, _climbGapTemp); // Lower climbing up ladder
else
result = result.max(HandsClimbing.TopHold, out_climbGap, _climbGapTemp); // Lower holding
else
if(grabType == AroundGrab)
result = result.max(HandsClimbing.TopHold, out_climbGap, _climbGapTemp); // Sinking to lower holding level
else
result = result.max(HandsClimbing.Sink, out_climbGap, _climbGapTemp); // Sinking to lower holding level
if((gap = isLadderSubstitute(subSub, _climbGapTemp)) > 0 && !isCrawling)
if((gap > 2 && !isCrawlClimbing) || grabType == AroundGrab || (gap > 1 && isClimbCrawling)) // (hands not long enough - down)
if(jh_offset < _handClimbingHoldGap && !isClimbCrawling)
result = result.max(HandsClimbing.TopHold, out_climbGap, _climbGapTemp); // Upper holding
else if(isClimbCrawling)
result = result.max(HandsClimbing.FastUp, out_climbGap, _climbGapTemp); // Sinking to upper holding level
else
result = result.max(HandsClimbing.Sink, out_climbGap, _climbGapTemp); // Sinking to upper holding level
return result;
}
private FeetClimbing feetClimbing(boolean isClimbCrawling, boolean isCrawlClimbing, boolean isCrawling, ClimbGap out_climbGap)
{
out_climbGap.reset();
_climbGapTemp.reset();
initializeOffset(0D, isClimbCrawling, isCrawlClimbing, isCrawling);
FeetClimbing result = FeetClimbing.None;
int gap;
if((gap = isLadderSubstitute(top, _climbGapTemp)) > 0) // No climbing (feet not long enough - up)
result = result.max(FeetClimbing.None, out_climbGap, _climbGapTemp);
_climbGapTemp.SkipGaps = isClimbCrawling || isCrawlClimbing;
if((gap = isLadderSubstitute(middle, _climbGapTemp)) > 0 && !isCrawling)
if(gap > 3 && !isClimbCrawling)
if(!isCrawlClimbing)
result = result.max(FeetClimbing.FastUp, out_climbGap, _climbGapTemp); // Climbing speed 2 (pushing upper body up into big gap)
else
result = result.max(FeetClimbing.None, out_climbGap, _climbGapTemp);
else if((isClimbCrawling || isCrawlClimbing) && gap > 1)
if(isCrawlClimbing)
result = result.max(FeetClimbing.BaseWithHands, out_climbGap, _climbGapTemp);
else
result = result.max(FeetClimbing.FastUp, out_climbGap, _climbGapTemp);
else if(gap > 2)
if(!isClimbCrawling)
result = result.max(FeetClimbing.SlowUpWithHoldWithoutHands, out_climbGap, _climbGapTemp); // Climbing speed 1 (no gap for balancing upper body)
else
result = result.max(FeetClimbing.None, out_climbGap, _climbGapTemp);
else
result = result.max(FeetClimbing.TopWithHands,out_climbGap, _climbGapTemp); // Climbing with hands only
if((gap = isLadderSubstitute(base, _climbGapTemp)) > 0)
if(gap > 3 && !isCrawling && !isCrawlClimbing)
result = result.max(FeetClimbing.FastUp, out_climbGap, _climbGapTemp); // Climbing speed 2 (pushing whole body up into big gap)
else if(gap > 2 && !isCrawling)
if(!isClimbCrawling)
if(jh_offset < _handClimbingHoldGap)
result = result.max(FeetClimbing.SlowUpWithHoldWithoutHands, out_climbGap, _climbGapTemp);
else
result = result.max(FeetClimbing.SlowUpWithSinkWithoutHands, out_climbGap, _climbGapTemp); // Climbing speed 1 (no gap for balancing whole body)
else
result = result.max(FeetClimbing.None, out_climbGap, _climbGapTemp);
else
if(jh_offset < 1D - _handClimbingHoldGap)
result = result.max(FeetClimbing.BaseWithHands, out_climbGap, _climbGapTemp); // Climbing with hands only
else
result = result.max(FeetClimbing.BaseHold, out_climbGap, _climbGapTemp);
if((isLadderSubstitute(sub, _climbGapTemp)) > 0)
result = result.max(FeetClimbing.None, out_climbGap, _climbGapTemp); // No climbing (feet not long enough - down)
if(isCrawlClimbing || isCrawling)
result = result.max(FeetClimbing.BaseWithHands, out_climbGap, _climbGapTemp);
return result;
}
private int isLadderSubstitute(int local_Offset, ClimbGap out_climbGap)
{
initializeLocal(local_Offset);
int gap;
if(local_half == 1)
if(hasHalfHold())
{
if(!grabRemote)
{
boolean overLadder = isOnLadderOrVine(0) || isOnOpenTrapDoor(0) || isRope(0) || isOnWallRope(0);
boolean overOverLadder = isOnLadderOrVine(1) || isOnOpenTrapDoor(1) || isRope(1) || isOnWallRope(1);
boolean overAccessible = isBaseAccessible(1, false, true);
boolean overOverAccessible = isBaseAccessible(2, false, true);
boolean overFullAccessible = overAccessible && isFullAccessible(1, grabRemote);
boolean overOverFullAccessible = overAccessible && isFullExtentAccessible(2, grabRemote);
if(overLadder)
if(overOverLadder)
gap = 1;
else if(overOverAccessible)
gap = 1;
else
gap = 1;
else if(overAccessible)
if(overFullAccessible)
if(overOverFullAccessible)
gap = 5;
else
gap = crawl ? 3 : 5;
else if(overOverLadder)
gap = 5;
else
gap = 1;
else
gap = 1;
}
else if(isBaseAccessible(0))
if(isUpperHalfFrontEmpty(remote_i, 0, remote_k))
if(isFullAccessible(1, grabRemote))
if(isFullExtentAccessible(2, grabRemote))
gap = 5;
else if(isJustLowerHalfExtentAccessible(2))
gap = 4;
else
gap = 3;
else
gap = 1;
else
gap = 1;
else
gap = 0;
}
else
gap = 0;
else
if(hasBottomHold())
{
if(!grabRemote)
{
boolean overLadder = isOnLadderOrVine(0) || isOnOpenTrapDoor(0) || isRope(0) || isOnWallRope(0);
boolean overOverLadder = isOnLadderOrVine(1) || isOnOpenTrapDoor(1) || isRope(1) || isOnWallRope(0);
boolean overAccessible = isBaseAccessible(0, false, true);
boolean overOverAccessible = isBaseAccessible(1, false, true);
boolean overFullAccessible = overAccessible && isFullAccessible(0, grabRemote);
boolean overOverFullAccessible = overAccessible && isFullExtentAccessible(1, grabRemote);
if(overLadder)
if(overOverLadder)
gap = 1;
else if(overOverAccessible)
gap = 1;
else
gap = 1;
else if(overAccessible)
if(overFullAccessible)
if(overOverAccessible)
if(overOverFullAccessible)
gap = 4;
else
gap = crawl ? 2 : 4;
else
gap = 2;
else if(overOverLadder)
gap = 2;
else
gap = 1;
else
gap = 1;
}
else if(isBaseAccessible(0))
if(isFullAccessible(0, grabRemote))
if(isFullExtentAccessible(1, grabRemote))
gap = 4;
else
gap = 2;
else
gap = 1;
else
gap = 0;
}
else
gap = 0;
if(out_climbGap != null && gap > 0)
{
out_climbGap.Block = grabBlock;
out_climbGap.Meta = grabMeta;
out_climbGap.CanStand = gap > 3;
out_climbGap.MustCrawl = gap > 1 && gap < 4;
out_climbGap.Direction = this;
}
return gap;
}
private boolean hasHalfHold()
{
if(Config.isFreeBaseClimb())
{
if(isOnLadder(0) && isOnLadderFront(0))
return setHalfGrabType(AroundGrab, getBaseBlockId(0), false);
if(remoteLadderClimbing(0))
return setHalfGrabType(AroundGrab, getRemoteBlockId(0), true);
}
if(SmartMovingOptions.hasBetterThanWolves || SmartMovingOptions.hasRopesPlus)
{
Block id;
if((id = getRopeId(0)) != null && isHeadedToRope())
return setHalfGrabType(AroundGrab, id, false);
if((id = getAnchorId(0)) != null && isOnAnchorFront(0))
return setHalfGrabType(HalfGrab, id, false);
}
Block remoteId = getRemoteBlockId(0);
if(isEmpty(base_i, 0, base_k))
{
if(remoteId == Block.getBlockFromName("iron_bars") && headedToFrontWall(remote_i, 0, remote_k, remoteId))
return setHalfGrabType(HalfGrab, remoteId);
}
Block wallId = getWallBlockId(base_i, 0, base_k);
if(wallId == Block.getBlockFromName("iron_bars") && headedToBaseWall(0, wallId))
return setHalfGrabType(HalfGrab, wallId, false);
if(wallId != null && isOnMiddleLadderFront(0))
return setHalfGrabType(AroundGrab, remoteId, false);
if(Config._freeFenceClimbing.value)
{
if(isFence(remoteId, remote_i, 0, remote_k) && headedToFrontWall(remote_i, 0, remote_k, remoteId))
if(!isFence(getBaseBlockId(0), base_i, 0, base_k))
return setHalfGrabType(HalfGrab, remoteId);
else if(headedToFrontSideWall(remote_i, 0, remote_k, remoteId))
return setHalfGrabType(HalfGrab, remoteId);
Block remoteBelowId = getRemoteBlockId(-1);
if(isFence(remoteBelowId, remote_i, -1, remote_k) && headedToFrontWall(remote_i, -1, remote_k, remoteBelowId))
if(!isFence(getBaseBlockId(-1), remote_i, -1, remote_k))
return setHalfGrabType(HalfGrab, remoteId);
else if(headedToFrontSideWall(remote_i, -1, remote_k, remoteBelowId))
return setHalfGrabType(HalfGrab, remoteId);
if(isFence(wallId, base_i, 0, base_k) && headedToBaseWall(0, wallId))
return setHalfGrabType(HalfGrab, wallId, false);
Block belowWallId = getWallBlockId(base_i, -1, base_k);
if(isFence(belowWallId, base_i, -1, base_k) && headedToBaseWall(-1, belowWallId))
return setHalfGrabType(HalfGrab, belowWallId, false);
if(remoteId == Block.getBlockFromName("cobblestone_wall") && !headedToRemoteFlatWall(remoteId, 0))
return setHalfGrabType(HalfGrab, remoteId);
if(remoteBelowId == Block.getBlockFromName("cobblestone_wall") && !headedToRemoteFlatWall(remoteBelowId, -1))
return setHalfGrabType(HalfGrab, remoteBelowId);
}
int remoteMetadata = getRemoteBlockMetadata(0);
if(isBottomHalfBlock(remoteId, remoteMetadata) || (isStairCompact(remoteId) && isBottomStairCompactNotBack(remoteMetadata) && !(isStairCompact(getBaseBlockId(-1)) && isBottomStairCompactFront(getBaseBlockMetadata(-1)))))
return setHalfGrabType(HalfGrab, remoteId);
if(isTrapDoor(remoteId) && isClosedTrapDoor(getRemoteBlockMetadata(0)))
return setHalfGrabType(HalfGrab, remoteId);
Block baseId = getBaseBlockId(0);
if(isTrapDoor(baseId) && !isClosedTrapDoor(getBaseBlockMetadata(0)))
return setHalfGrabType(HalfGrab, baseId, false);
if(SmartMovingOptions.hasASGrapplingHook && Config._replaceRopeClimbing.value || SmartMovingOptions.hasRopesPlus)
{
if(isASRope(baseId) && isASGrapplingHookFront(getBaseBlockMetadata(0)))
return setHalfGrabType(HalfGrab, baseId, false);
if(isASRope(remoteId) && rotate(180).isASGrapplingHookFront(remoteMetadata))
return setHalfGrabType(HalfGrab, remoteId, true);
}
if(Config.isFreeBaseClimb())
{
int meta = baseVineClimbing(0);
if(meta > -1)
return setHalfGrabType(HalfGrab, Block.getBlockFromName("vine"), false, meta);
meta = remoteVineClimbing(0);
if(meta > -1)
return setHalfGrabType(HalfGrab, Block.getBlockFromName("vine"), false, meta);
}
return setHalfGrabType(NoGrab, null);
}
private boolean hasBottomHold()
{
if(Config.isFreeBaseClimb())
{
if(isOnLadder(-1) && isOnLadderFront(-1))
return setBottomGrabType(AroundGrab, getBaseBlockId(-1) , false);
if(isOnLadder(0) && isOnLadderFront(0))
return setBottomGrabType(AroundGrab, getBaseBlockId(0), false);
if(remoteLadderClimbing(-1))
return setBottomGrabType(AroundGrab, getRemoteBlockId(-1), true);
if(remoteLadderClimbing(0))
return setBottomGrabType(AroundGrab, getRemoteBlockId(0), true);
}
if(SmartMovingOptions.hasBetterThanWolves || SmartMovingOptions.hasRopesPlus)
{
Block id;
if((id = getRopeId(-1)) != null && isHeadedToRope() || (id = getRopeId(0)) != null && isHeadedToRope())
return setBottomGrabType(AroundGrab, id, false);
if((id = getAnchorId(-1)) != null && isOnAnchorFront(-1) || (id = getAnchorId(0)) != null && isOnAnchorFront(0))
return setBottomGrabType(HalfGrab, id, false);
}
Block remoteId = getRemoteBlockId(0);
Block remoteBelowId = getRemoteBlockId(-1);
boolean remoteLowerHalfEmpty = isLowerHalfFrontFullEmpty(remote_i, 0, remote_k);
if(SmartMovingOptions.hasRedPowerWire)
{
if(isRedPowerWire(remoteBelowId))
{
int coverSides = getRpCoverSides(remote_i, -1, remote_k);
if((isRedPowerWireFullFront(coverSides) || isRedPowerWireTop(coverSides)) && remoteLowerHalfEmpty)
return setBottomGrabType(HalfGrab, remoteBelowId);
}
if(isRedPowerWire(remoteId))
{
int coverSides = getRpCoverSides(remote_i, 0, remote_k);
if(isRedPowerWireBottom(coverSides) && remoteLowerHalfEmpty)
return setBottomGrabType(HalfGrab, remoteBelowId);
}
Block baseId = getBaseBlockId(-1);
if(isRedPowerWire(baseId))
{
int coverSides = getRpCoverSides(base_i, -1, base_k);
if(isRedPowerWireFullBack(coverSides) && remoteLowerHalfEmpty)
return setBottomGrabType(HalfGrab, remoteBelowId);
}
if(isRedPowerWire(remoteBelowId))
return false;
}
if(isEmpty(base_i, -1, base_k))
{
if(remoteBelowId == Block.getBlockFromName("iron_bars") && headedToFrontWall(remote_i, -1, remote_k, remoteBelowId))
return setBottomGrabType(HalfGrab, remoteBelowId);
}
if(Config._freeFenceClimbing.value)
{
Block baseBelowBlockId = getBaseBlockId(-1);
if(isFence(remoteBelowId, remote_i, -1, remote_k) && headedToFrontWall(remote_i, -1, remote_k, remoteBelowId))
if(!isFence(baseBelowBlockId, base_i, -1, base_k))
return setBottomGrabType(HalfGrab, remoteBelowId);
else if(headedToFrontSideWall(remote_i, -1, remote_k, remoteBelowId))
return setBottomGrabType(HalfGrab, remoteBelowId);
if(remoteBelowId == Block.getBlockFromName("cobblestone_wall") && !headedToRemoteFlatWall(remoteBelowId, -1))
return setHalfGrabType(HalfGrab, remoteBelowId);
if(remoteId == Block.getBlockFromName("cobblestone_wall") && !headedToRemoteFlatWall(remoteId, 0))
return setHalfGrabType(HalfGrab, remoteId);
}
Block belowWallBlockId = getWallBlockId(base_i, -1, base_k);
if(belowWallBlockId != null)
{
if(isEmpty(base_i - _i, 0, base_k - _k) && isEmpty(base_i - _i, -1, base_k - _k))
{
if(belowWallBlockId == Block.getBlockFromName("iron_bars") && headedToBaseWall(-1, belowWallBlockId))
return setBottomGrabType(HalfGrab, belowWallBlockId, false);
if(isOnMiddleLadderFront(-1))
return setHalfGrabType(AroundGrab, remoteId, false);
if(headedToBaseGrabWall(-1, belowWallBlockId))
return setBottomGrabType(HalfGrab, belowWallBlockId, false);
}
if(Config._freeFenceClimbing.value && isFence(belowWallBlockId, base_i, -1, base_k) && headedToBaseWall(-1, belowWallBlockId))
return setBottomGrabType(HalfGrab, belowWallBlockId, false);
}
int remoteBelowMetadata = getRemoteBlockMetadata(-1);
if(remoteLowerHalfEmpty && isBaseAccessible(-1, true, false))
if(isUpperHalfFrontAnySolid(remote_i, -1, remote_k))
if(!isBottomHalfBlock(remoteBelowId, remoteBelowMetadata))
if(!isStairCompact(remoteBelowId) || !isBottomStairCompactFront(remoteBelowMetadata))
if(!isDoor(remoteBelowId) || isDoorTop(remoteBelowMetadata))
if(!isDoor(getBaseBlockId(0)) || !isDoorFrontBlocked(base_i, 0, base_k))
if(Config._freeFenceClimbing.value || !isFence(remote_i, -1, remote_k))
return setBottomGrabType(HalfGrab, remoteBelowId);
if(isStairCompact(remoteId))
{
int remoteMetadata = getRemoteBlockMetadata(0);
if(isTopStairCompact(remoteMetadata) && !isTopStairCompactBack(remoteMetadata) && isUpperHalfFrontFullSolid(remote_i, -1, remote_k))
return setBottomGrabType(HalfGrab, remoteBelowId);
}
Block baseBelowId = getBaseBlockId(-1);
int baseBelowMetadata = getBaseBlockMetadata(-1);
// for trap door bottom hold
//if(isTrapDoor(remoteId) && isClosedTrapDoor(remote_i, local_offset, remote_k))
// return setBottomGrabType(HalfGrab, remoteId);
// for trap door top hold
if(isTrapDoor(baseBelowId) && !isClosedTrapDoor(getBaseBlockMetadata(-1)))
return setBottomGrabType(HalfGrab,baseBelowId, false);
if(isDoor(baseBelowId) && isDoorTop(baseBelowMetadata) && isDoorFrontBlocked(base_i, -1, base_k) && isBaseAccessible(0))
return setBottomGrabType(HalfGrab, baseBelowId, false);
if(SmartMovingOptions.hasASGrapplingHook && Config._replaceRopeClimbing.value || SmartMovingOptions.hasRopesPlus)
{
if(isASRope(baseBelowId) && isASGrapplingHookFront(getBaseBlockMetadata(0)))
return setBottomGrabType(HalfGrab, baseBelowId, false);
Block baseId = getBaseBlockId(0);
if(isASRope(baseId) && isASGrapplingHookFront(getBaseBlockMetadata(0)))
return setBottomGrabType(HalfGrab, baseId, false);
if(isASRope(remoteBelowId) && rotate(180).isASGrapplingHookFront(remoteBelowMetadata))
return setHalfGrabType(HalfGrab, remoteBelowId, true);
if(isASRope(remoteId) && rotate(180).isASGrapplingHookFront(getRemoteBlockMetadata(0)))
return setHalfGrabType(HalfGrab, remoteId, true);
}
if(Config.isFreeBaseClimb())
{
int meta = baseVineClimbing(-1);
if(meta != DefaultMeta)
return setHalfGrabType(HalfGrab, Block.getBlockFromName("vine"), false, meta);
meta = baseVineClimbing(0);
if(meta != DefaultMeta)
return setHalfGrabType(HalfGrab, Block.getBlockFromName("vine"), false, meta);
meta = remoteVineClimbing(-1);
if(meta != DefaultMeta)
return setHalfGrabType(HalfGrab, Block.getBlockFromName("vine"), false, meta);
meta = remoteVineClimbing(0);
if(meta != DefaultMeta)
return setHalfGrabType(HalfGrab, Block.getBlockFromName("vine"), false, meta);
}
return setBottomGrabType(NoGrab, null);
}
private boolean setHalfGrabType(int type, Block block)
{
return setHalfGrabType(type, block, true);
}
private boolean setHalfGrabType(int type, Block block, boolean remote)
{
return setHalfGrabType(type, block, remote, -1);
}
private boolean setHalfGrabType(int type, Block block, boolean remote, int metaClimb)
{
boolean hasGrab = type != NoGrab;
if(hasGrab && remote && _isDiagonal)
{
boolean edgeConnectCCW = rotate(90).isUpperHalfFrontEmpty(base_i, 0, remote_k);
boolean edgeConnectCW = rotate(-90).isUpperHalfFrontEmpty(remote_i, 0, base_k);
hasGrab &= edgeConnectCCW && edgeConnectCW;
}
return setGrabType(type, block, remote, hasGrab, metaClimb);
}
private boolean setBottomGrabType(int type, Block block)
{
return setBottomGrabType(type, block, true);
}
private boolean setBottomGrabType(int type, Block block, boolean remote)
{
return setBottomGrabType(type, block, remote, -1);
}
private boolean setBottomGrabType(int type, Block block, boolean remote, int metaClimb)
{
boolean hasGrab = type != NoGrab;
if(hasGrab && remote && _isDiagonal)
{
boolean edgeConnectCCW = rotate(90).isLowerHalfFrontFullEmpty(base_i, 0, remote_k);
boolean edgeConnectCW = rotate(-90).isLowerHalfFrontFullEmpty(remote_i, 0, base_k);
hasGrab &= edgeConnectCCW && edgeConnectCW;
}
return setGrabType(type, block, remote, hasGrab, metaClimb);
}
private static boolean setGrabType(int type, Block block, boolean remote, boolean hasGrab, int metaClimb)
{
grabRemote = remote;
grabType = hasGrab ? type : NoGrab;
grabBlock = block;
grabMeta = metaClimb;
return hasGrab;
}
@SuppressWarnings("incomplete-switch")
private boolean setClimbingAngles()
{
switch(_i)
{
case -1:
switch(_k)
{
case -1:
return setClimbingAngles(135); //NN
case 0:
return setClimbingAngles(90); // NZ
case 1:
return setClimbingAngles(45); // NP
}
break;
case 0:
switch(_k)
{
case -1:
return setClimbingAngles(180); // ZN
case 0:
return setClimbingAngles(0, 360); // ZZ
case 1:
return setClimbingAngles(0); // ZP
}
break;
case 1:
switch(_k)
{
case -1:
return setClimbingAngles(225); // PN
case 0:
return setClimbingAngles(270); // PZ
case 1:
return setClimbingAngles(315); // PP
}
break;
}
return false;
}
private boolean setClimbingAngles(float directionAngle)
{
_directionAngle = directionAngle;
float halfAreaAngle = (_isDiagonal ? Config._freeClimbingDiagonalDirectionAngle.value : Config._freeClimbingOrthogonalDirectionAngle.value) / 2F;
return setClimbingAngles(directionAngle - halfAreaAngle, directionAngle + halfAreaAngle);
}
private boolean setClimbingAngles(float mimimumClimbingAngle, float maximumClimbingAngle)
{
if(mimimumClimbingAngle < 0F)
mimimumClimbingAngle += 360F;
if(maximumClimbingAngle > 360F)
maximumClimbingAngle -= 360F;
_mimimumClimbingAngle = mimimumClimbingAngle;
_maximumClimbingAngle = maximumClimbingAngle;
return mimimumClimbingAngle != maximumClimbingAngle;
}
private boolean isWithinAngle(float minimumRotation, float maximumRotation)
{
return isWithinAngle(_directionAngle, minimumRotation, maximumRotation);
}
private boolean isRotationForClimbing(float rotation)
{
return isWithinAngle(rotation, _mimimumClimbingAngle, _maximumClimbingAngle);
}
private static boolean isWithinAngle(float rotation, float minimumRotation, float maximumRotation)
{
if(minimumRotation > maximumRotation)
return rotation >= minimumRotation || rotation <= maximumRotation;
return rotation >= minimumRotation && rotation <= maximumRotation;
}
private int baseVineClimbing(int j_offset)
{
boolean result = isOnVine(j_offset);
if(result)
{
result = isOnVineFront(j_offset);
if(result)
return VineFrontMeta;
if(baseVineClimbing(j_offset, PZ) || baseVineClimbing(j_offset, NZ) || baseVineClimbing(j_offset, ZP) || baseVineClimbing(j_offset, ZN))
return VineSideMeta;
}
return DefaultMeta;
}
private boolean baseVineClimbing(int j_offset, Orientation orientation)
{
if(orientation == this)
return false;
return orientation.rotate(180).hasVineOrientation(world, base_i, local_offset + j_offset, base_k) && orientation.getHorizontalBorderGap() >= 0.65;
}
private boolean remoteLadderClimbing(int j_offset)
{
return isBehindLadder(j_offset) && isOnLadderBack(j_offset);
}
private int remoteVineClimbing(int j_offset)
{
if(isBehindVine(j_offset) && isOnVineBack(j_offset))
return VineFrontMeta;
if(remoteVineClimbing(j_offset, PZ) || remoteVineClimbing(j_offset, NZ) || remoteVineClimbing(j_offset, ZP) || remoteVineClimbing(j_offset, ZN))
return VineSideMeta;
return DefaultMeta;
}
private boolean remoteVineClimbing(int j_offset, Orientation orientation)
{
if(orientation == this)
return false;
int i = base_i - orientation._i;
int k = base_k - orientation._k;
return isVine(getBlock(i, j_offset, k)) && orientation.hasVineOrientation(world, i, local_offset + j_offset, k) && orientation.getHorizontalBorderGap() >= 0.65F;
}
private static boolean isOnLadder(int j_offset)
{
Block block = getBaseBlockId(j_offset);
if(isLadder(block))
return true;
if(isVine(block))
return false;
if(isClimbable(world, base_i, local_offset + j_offset, base_k))
return true;
return false;
}
private static boolean isBehindLadder(int j_offset)
{
Block block = getRemoteBlockId(j_offset);
if(isLadder(block))
return true;
if(isVine(block))
return false;
if(isClimbable(world, remote_i, local_offset + j_offset, remote_k))
return true;
return false;
}
private static boolean isOnVine(int j_offset)
{
return isVine(getBaseBlockId(j_offset));
}
private static boolean isBehindVine(int j_offset)
{
return isVine(getRemoteBlockId(j_offset));
}
private static boolean isOnLadderOrVine(int j_offset)
{
return isLadderOrVine(getBaseBlockId(j_offset)) || isVine(grabBlock);
}
public static boolean isLadder(Block block)
{
return block == Block.getBlockFromName("ladder");
}
public static boolean isVine(Block block)
{
return block == Block.getBlockFromName("vine");
}
public static boolean isLadderOrVine(Block block)
{
return isLadder(block) || isVine(block) || isBlockIdOfType(block, _ladderKitLadderTypes);
}
public static boolean isKnownLadder(Block block)
{
return isLadder(block) || isBlockIdOfType(block, _ladderKitLadderTypes);
}
public static boolean isClimbable(World world, int i, int j, int k)
{
Block block = world.getBlock(i, j, k);
return block != null && block.isLadder(world, i, j, k, Minecraft.getMinecraft().thePlayer);
}
private boolean isOnLadderFront(int j_offset)
{
return hasLadderOrientation(base_i, j_offset, base_k);
}
private boolean isOnLadderBack(int j_offset)
{
return rotate(180).hasLadderOrientation(remote_i, j_offset, remote_k);
}
private boolean isOnVineFront(int j_offset)
{
return hasVineOrientation(world, base_i, local_offset + j_offset, base_k);
}
private boolean isOnVineBack(int j_offset)
{
return rotate(180).hasVineOrientation(world, remote_i, local_offset + j_offset, remote_k);
}
@SuppressWarnings("incomplete-switch")
private boolean isOnMiddleLadderFront(int j_offset)
{
switch(getCarpentersBlockData(base_i, j_offset, base_k))
{
case 0:
if(this == ZN)
return isTopHalf(base_kd);
if(this == ZP)
return !isTopHalf(base_kd);
break;
case 1:
if(this == NZ)
return isTopHalf(base_id);
if(this == PZ)
return !isTopHalf(base_id);
break;
}
return false;
}
private static int getCarpentersBlockData(int i, int j_offset, int k)
{
if (isExternalBlockType(getBlock(i, j_offset, k), _blockCarpentersLadder))
{
TileEntity entity = getBlockTileEntity(i, j_offset, k);
if (entity != null)
return (Integer)Reflect.Invoke(_carpentersTEBaseBlockGetData, entity);
}
return -1;
}
@SuppressWarnings("incomplete-switch")
public static Orientation getKnownLadderOrientation(World world, int i, int j, int k)
{
Block block = world.getBlock(i, j, k);
int metadata = world.getBlockMetadata(i, j, k);
if(isBlockIdOfType(block, _ladderKitLadderTypes))
{
switch(metadata & 0x3)
{
case 1:
return NZ;
case 3:
return PZ;
case 0:
return ZP;
case 2:
return ZN;
}
return null;
}
switch(metadata & 0x7)
{
case 5:
return NZ;
case 4:
return PZ;
case 2:
return ZP;
case 3:
return ZN;
}
return null;
}
public boolean hasVineOrientation(World world, int i, int j, int k)
{
int metaData = world.getBlockMetadata(i, j, k);
if(this == NZ)
return (metaData & 2) != 0;
if(this == PZ)
return (metaData & 8) != 0;
if(this == ZP)
return (metaData & 1) != 0;
if(this == ZN)
return (metaData & 4) != 0;
return false;
}
private boolean hasLadderOrientation(int i, int j_offset, int k)
{
Block block = getBlock(i, j_offset, k);
int metadata = getBlockMetadata(i, j_offset, k);
if(isBlockIdOfType(block, _ladderKitLadderTypes))
{
metadata &= 0x3;
if(this == NZ)
return metadata == 1;
if(this == PZ)
return metadata == 3;
if(this == ZP)
return metadata == 0;
if(this == ZN)
return metadata == 2;
return false;
}
int carpentersBlockData = getCarpentersBlockData(i, j_offset, k);
if(carpentersBlockData > -1)
metadata = carpentersBlockData;
else
metadata &= 0x7;
if(this == NZ)
return metadata == 5;
if(this == PZ)
return metadata == 4;
if(this == ZP)
return metadata == 2;
if(this == ZN)
return metadata == 3;
return false;
}
public boolean isRemoteSolid(World world, int i, int j, int k)
{
return isSolid(world.getBlock(i + _i, j, k + _k).getMaterial());
}
@SuppressWarnings("incomplete-switch")
public static Orientation getOpenTrapDoorOrientation(World world, int i, int j, int k)
{
int metadata = world.getBlockMetadata(i, j, k);
if(!isClosedTrapDoor(metadata))
switch(metadata & 3)
{
case 0:
return ZP;
case 1:
return ZN;
case 2:
return PZ;
case 3:
return NZ;
}
return null;
}
private boolean isHeadedToRope()
{
int iTriple = getTriple(base_id, base_kd);
int kTriple = getTriple(base_kd, base_id);
if(iTriple > 0)
if(kTriple > 0)
return this == NN;
else if(kTriple < 0)
return this == NP;
else
return this == NZ;
else if(iTriple < 0)
if(kTriple > 0)
return this == PN;
else if(kTriple < 0)
return this == PP;
else
return this == PZ;
else
if(kTriple > 0)
return this == ZN;
else if(kTriple < 0)
return this == ZP;
else
return this == ZZ;
}
@SuppressWarnings("incomplete-switch")
private boolean isOnAnchorFront(int j_offset)
{
switch(getBaseBlockMetadata(j_offset))
{
case 0:
return false;
case 1:
return false;
case 2:
return this._k == 1;
case 3:
return this._k == -1;
case 4:
return this._i == 1;
case 5:
return this._i == -1;
}
return false;
}
private static Block getRopeId(int j_offset)
{
Block block = getBaseBlockId(j_offset);
if(isRopeId(block))
return block;
return null;
}
private static boolean isRope(int j_offset)
{
return getRopeId(j_offset) != null;
}
private static boolean isRopeId(Block block)
{
return
SmartMovingOptions.hasBetterThanWolves && hasBlockName(block, "tile.fcRopeBlock") ||
SmartMovingOptions.hasRopesPlus && hasBlockName(block, "tile.blockRopeCentral");
}
private static Block getAnchorId(int j_offset)
{
Block block = getBaseBlockId(j_offset);
if(isAnchorId(block))
return block;
return null;
}
private static boolean isAnchorId(Block block)
{
return hasBlockName(block, "tile.fcAnchor");
}
private static boolean isOnWallRope(int j_offset)
{
return (SmartMovingOptions.hasASGrapplingHook || SmartMovingOptions.hasRopesPlus) && isASRope(getBaseBlockId(j_offset));
}
private static boolean isASRope(Block block)
{
return hasBlockName(block, "tile.blockRope");
}
private static boolean isASGrapplingHook(Block block)
{
return hasBlockName(block, "tile.blockGrHk");
}
private boolean isASGrapplingHookFront(int metaData)
{
boolean kPos = metaData % 2 != 0;
boolean iNeg = (metaData / 2) % 2 != 0;
boolean kNeg = (metaData / 4) % 2 != 0;
boolean iPos = (metaData / 8) % 2 != 0;
if(_i > 0 && iPos || _i < 0 && iNeg)
if(_k > 0)
return kPos;
else if(_k < 0)
return kNeg;
else
return true;
if(_k > 0 && kPos || _k < 0 && kNeg)
if(_i > 0)
return iPos;
else if(_i < 0)
return iNeg;
else
return true;
return false;
}
private static boolean isOnOpenTrapDoor(int j_offset)
{
return isTrapDoor(getBaseBlockId(j_offset)) && !isClosedTrapDoor(getBaseBlockMetadata(j_offset));
}
private boolean isTrapDoorFront(int trapDoorMetadata)
{
if(this == NZ)
return (trapDoorMetadata & 3) == 3;
if(this == PZ)
return (trapDoorMetadata & 3) == 2;
if(this == ZP)
return (trapDoorMetadata & 3) == 0;
if(this == ZN)
return (trapDoorMetadata & 3) == 1;
if(this == PN)
return (trapDoorMetadata & 3) == 2 || (trapDoorMetadata & 3) == 1;
if(this == PP)
return (trapDoorMetadata & 3) == 2 || (trapDoorMetadata & 3) == 0;
if(this == NN)
return (trapDoorMetadata & 3) == 3 || (trapDoorMetadata & 3) == 1;
if(this == NP)
return (trapDoorMetadata & 3) == 3 || (trapDoorMetadata & 3) == 0;
return false;
}
private boolean isBottomStairCompactNotBack(int stairMetadata)
{
return !isTopStairCompact(stairMetadata) && !isStairCompactBack(stairMetadata);
}
private boolean isBottomStairCompactFront(int stairMetadata)
{
return !isTopStairCompact(stairMetadata) && isStairCompactFront(stairMetadata);
}
private boolean isTopStairCompactFront(int stairMetadata)
{
return isTopStairCompact(stairMetadata) && isStairCompactFront(stairMetadata);
}
private boolean isTopStairCompactBack(int stairMetadata)
{
return isTopStairCompact(stairMetadata) && isStairCompactBack(stairMetadata);
}
private boolean isStairCompactFront(int stairMetadata)
{
stairMetadata = stairMetadata & 3;
if(this == NZ)
return stairMetadata == 1;
if(this == PZ)
return stairMetadata == 0;
if(this == ZP)
return stairMetadata == 2;
if(this == ZN)
return stairMetadata == 3;
if(this == PN)
return stairMetadata == 0 || stairMetadata == 3;
if(this == PP)
return stairMetadata == 0 || stairMetadata == 2;
if(this == NN)
return stairMetadata == 1 || stairMetadata == 3;
if(this == NP)
return stairMetadata == 1 || stairMetadata == 2;
return false;
}
private boolean isStairCompactBack(int stairMetadata)
{
stairMetadata = stairMetadata & 3;
if(this == NZ)
return stairMetadata == 0;
if(this == PZ)
return stairMetadata == 1;
if(this == ZP)
return stairMetadata == 3;
if(this == ZN)
return stairMetadata == 2;
if(this == PN)
return stairMetadata == 1 || stairMetadata == 2;
if(this == PP)
return stairMetadata == 1 || stairMetadata == 3;
if(this == NN)
return stairMetadata == 0 || stairMetadata == 2;
if(this == NP)
return stairMetadata == 0 || stairMetadata == 3;
return false;
}
private static boolean isTopStairCompact(int stairMetadata)
{
return (stairMetadata & 4) != 0;
}
private static boolean isRedPowerWireTop(int coverSides)
{
return (coverSides >> 1) % 2 == 1;
}
private static boolean isRedPowerWireBottom(int coverSides)
{
return (coverSides >> 0) % 2 == 1;
}
private boolean isRedPowerWireFullFront(int coverSides)
{
if(this == NZ)
return (coverSides >> 5) % 2 == 1;
if(this == PZ)
return (coverSides >> 4) % 2 == 1;
if(this == ZP)
return (coverSides >> 2) % 2 == 1;
if(this == ZN)
return (coverSides >> 3) % 2 == 1;
if(this == PN)
return PZ.isRedPowerWireFullFront(coverSides) && ZN.isRedPowerWireFullFront(coverSides);
if(this == PP)
return PZ.isRedPowerWireFullFront(coverSides) && ZP.isRedPowerWireFullFront(coverSides);
if(this == NN)
return NZ.isRedPowerWireFullFront(coverSides) && ZN.isRedPowerWireFullFront(coverSides);
if(this == NP)
return NZ.isRedPowerWireFullFront(coverSides) && ZP.isRedPowerWireFullFront(coverSides);
return false;
}
private boolean isRedPowerWireAnyFront(int coverSides)
{
if(this == NZ)
return (coverSides >> 5) % 2 == 1;
if(this == PZ)
return (coverSides >> 4) % 2 == 1;
if(this == ZP)
return (coverSides >> 2) % 2 == 1;
if(this == ZN)
return (coverSides >> 3) % 2 == 1;
if(this == PN)
return PZ.isRedPowerWireFullFront(coverSides) || ZN.isRedPowerWireFullFront(coverSides);
if(this == PP)
return PZ.isRedPowerWireFullFront(coverSides) || ZP.isRedPowerWireFullFront(coverSides);
if(this == NN)
return NZ.isRedPowerWireFullFront(coverSides) || ZN.isRedPowerWireFullFront(coverSides);
if(this == NP)
return NZ.isRedPowerWireFullFront(coverSides) || ZP.isRedPowerWireFullFront(coverSides);
return false;
}
private boolean isRedPowerWireFullBack(int coverSides)
{
if(this == NZ)
return (coverSides >> 4) % 2 == 1;
if(this == PZ)
return (coverSides >> 5) % 2 == 1;
if(this == ZP)
return (coverSides >> 3) % 2 == 1;
if(this == ZN)
return (coverSides >> 2) % 2 == 1;
if(this == PN)
return PZ.isRedPowerWireFullBack(coverSides) && ZN.isRedPowerWireFullBack(coverSides);
if(this == PP)
return PZ.isRedPowerWireFullBack(coverSides) && ZP.isRedPowerWireFullBack(coverSides);
if(this == NN)
return NZ.isRedPowerWireFullBack(coverSides) && ZN.isRedPowerWireFullBack(coverSides);
if(this == NP)
return NZ.isRedPowerWireFullBack(coverSides) && ZP.isRedPowerWireFullBack(coverSides);
return false;
}
private boolean isRedPowerWireAnyBack(int coverSides)
{
if(this == NZ)
return (coverSides >> 4) % 2 == 1;
if(this == PZ)
return (coverSides >> 5) % 2 == 1;
if(this == ZP)
return (coverSides >> 3) % 2 == 1;
if(this == ZN)
return (coverSides >> 2) % 2 == 1;
if(this == PN)
return PZ.isRedPowerWireFullBack(coverSides) || ZN.isRedPowerWireFullBack(coverSides);
if(this == PP)
return PZ.isRedPowerWireFullBack(coverSides) || ZP.isRedPowerWireFullBack(coverSides);
if(this == NN)
return NZ.isRedPowerWireFullBack(coverSides) || ZN.isRedPowerWireFullBack(coverSides);
if(this == NP)
return NZ.isRedPowerWireFullBack(coverSides) || ZP.isRedPowerWireFullBack(coverSides);
return false;
}
private boolean isFenceGateFront(int metaData)
{
int direction = metaData % 4;
if(this == NZ)
return direction == 0 || direction == 2;
if(this == PZ)
return direction == 0 || direction == 2;
if(this == ZP)
return direction == 1 || direction == 3;
if(this == ZN)
return direction == 1 || direction == 3;
return false;
}
private boolean headedToFrontWall(int i, int j_offset, int k, Block block)
{
boolean zn = getWallFlag(ZN, i, j_offset, k, block);
boolean zp = getWallFlag(ZP, i, j_offset, k, block);
boolean nz = getWallFlag(NZ, i, j_offset, k, block);
boolean pz = getWallFlag(PZ, i, j_offset, k, block);
boolean allOnNone = getAllWallsOnNoWall(block);
if(allOnNone && !zn && !zp && !nz && !pz)
zn = zp = nz = pz = true;
return
headedToWall(NZ, pz) ||
headedToWall(PZ, nz) ||
headedToWall(ZN, zp) ||
headedToWall(ZP, zn);
}
private boolean headedToFrontSideWall(int i, int j_offset, int k, Block block)
{
boolean zn = getWallFlag(ZN, i, j_offset, k, block);
boolean zp = getWallFlag(ZP, i, j_offset, k, block);
boolean nz = getWallFlag(NZ, i, j_offset, k, block);
boolean pz = getWallFlag(PZ, i, j_offset, k, block);
boolean allOnNone = getAllWallsOnNoWall(block);
if(allOnNone && !zn && !zp && !nz && !pz)
zn = zp = nz = pz = true;
boolean iTop = isTopHalf(base_id);
boolean kTop = isTopHalf(base_kd);
if(iTop)
if(kTop)
return
headedToWall(NZ, zp) ||
headedToWall(PZ, zp) ||
headedToWall(ZN, pz) ||
headedToWall(ZP, pz);
else
return
headedToWall(NZ, zn) ||
headedToWall(PZ, zn) ||
headedToWall(ZN, pz) ||
headedToWall(ZP, pz);
else
if(kTop)
return
headedToWall(NZ, zp) ||
headedToWall(PZ, zp) ||
headedToWall(ZN, nz) ||
headedToWall(ZP, nz);
else
return
headedToWall(NZ, zn) ||
headedToWall(PZ, zn) ||
headedToWall(ZN, nz) ||
headedToWall(ZP, nz);
}
private boolean headedToWall(Orientation base, boolean result)
{
if(this == base || this == base.rotate(45) || this == base.rotate(-45))
return result;
return false;
}
private boolean headedToBaseWall(int j_offset, Block block)
{
boolean zn = getWallFlag(ZN, base_i, j_offset, base_k, block);
boolean zp = getWallFlag(ZP, base_i, j_offset, base_k, block);
boolean nz = getWallFlag(NZ, base_i, j_offset, base_k, block);
boolean pz = getWallFlag(PZ, base_i, j_offset, base_k, block);
boolean allOnNone = getAllWallsOnNoWall(block);
if(allOnNone && !zn && !zp && !nz && !pz)
zn = zp = nz = pz = true;
boolean leaf = zn || zp || nz || pz;
boolean coreOnly = !allOnNone && !leaf;
boolean iTop = isTopHalf(base_id);
boolean kTop = isTopHalf(base_kd);
if(iTop)
if(kTop)
return headedToBaseWall(NN, NZ, ZN, zp, nz, pz, zn, coreOnly, leaf);
else
return headedToBaseWall(NP, NZ, ZP, zn, nz, pz, zp, coreOnly, leaf);
else
if(kTop)
return headedToBaseWall(PN, PZ, ZN, zp, pz, nz, zn, coreOnly, leaf);
else
return headedToBaseWall(PP, PZ, ZP, zn, pz, nz, zp, coreOnly, leaf);
}
private boolean headedToBaseWall(Orientation diagonal, Orientation left, Orientation right, boolean leftFront, boolean rightFrontOpposite, boolean rightFront, boolean leftFrontOpposite, boolean co, boolean leaf)
{
if(this == diagonal)
return leaf || co;
if(this == left)
return headedToBaseWall(leftFront, rightFrontOpposite, rightFront, leftFrontOpposite, co);
if(this == right)
return headedToBaseWall(rightFront, leftFrontOpposite, leftFront, rightFrontOpposite, co);
return false;
}
private static boolean headedToBaseWall(boolean front, boolean sideOpposite, boolean side, boolean frontOpposite, boolean coreOnly)
{
return front || sideOpposite && !side || frontOpposite && !front && !side || coreOnly;
}
private boolean headedToBaseGrabWall(int j_offset, Block block)
{
boolean zn = getWallFlag(ZN, base_i, j_offset, base_k, block);
boolean zp = getWallFlag(ZP, base_i, j_offset, base_k, block);
boolean nz = getWallFlag(NZ, base_i, j_offset, base_k, block);
boolean pz = getWallFlag(PZ, base_i, j_offset, base_k, block);
boolean allOnNone = getAllWallsOnNoWall(block);
if(allOnNone && !zn && !zp && !nz && !pz)
zn = zp = nz = pz = true;
boolean azn, azp, anz, apz;
Block aboveBlock = getBlock(base_i, j_offset + 1, base_k);
if(isFullEmpty(aboveBlock))
azn = azp = anz = apz = false;
else if(isWallBlock(aboveBlock, base_i, j_offset + 1, base_k))
{
azn = getWallFlag(ZN, base_i, j_offset + 1, base_k, aboveBlock);
azp = getWallFlag(ZP, base_i, j_offset + 1, base_k, aboveBlock);
anz = getWallFlag(NZ, base_i, j_offset + 1, base_k, aboveBlock);
apz = getWallFlag(PZ, base_i, j_offset + 1, base_k, aboveBlock);
boolean aboveAllOnNone = getAllWallsOnNoWall(aboveBlock);
if(aboveAllOnNone && !azn && !azp && !anz && !apz)
azn = azp = anz = apz = true;
}
else
azn = azp = anz = apz = true;
boolean iTop = isTopHalf(base_id);
boolean kTop = isTopHalf(base_kd);
if(iTop)
if(kTop)
return headedToBaseGrabWall(-this._i, -this._k, zp, pz, nz, zn, azp, apz, anz, azn);
else
return headedToBaseGrabWall(-this._i, this._k, pz, zn, zp, nz, apz, azn, azp, anz);
else
if(kTop)
return headedToBaseGrabWall(this._i, -this._k, nz, zp, zn, pz, anz, azp, azn, apz);
else
return headedToBaseGrabWall(this._i, this._k, zn, nz, pz, zp, azn, anz, apz, azp);
}
private static boolean headedToBaseGrabWall(int i, int k, boolean front, boolean side, boolean frontOpposite, boolean sideOpposite, boolean aboveFront, boolean aboveSide, boolean aboveFrontOpposite, boolean aboveSideOpposite)
{
if(sideOpposite && !aboveSideOpposite && !front && !aboveFront && i == 1)
return true;
if(frontOpposite && !aboveFrontOpposite && !side && !aboveSide && k == 1)
return true;
if(side && !aboveSide && k >= 0)
return true;
if(front && !aboveFront && k >= 0)
return true;
if(frontOpposite && !aboveFrontOpposite && !aboveFront && i == 1 && k >= 0)
return true;
if(sideOpposite && !aboveSideOpposite && !aboveSide && k == 1 && i >= 0)
return true;
return false;
}
private boolean headedToRemoteFlatWall(Block block, int j_offset)
{
return
!getWallFlag(this, remote_i, j_offset, remote_k, block) &&
getWallFlag(this.rotate(90), remote_i, j_offset, remote_k, block) &&
!getWallFlag(this.rotate(180), remote_i, j_offset, remote_k, block) &&
getWallFlag(this.rotate(-90), remote_i, j_offset, remote_k, block);
}
@SuppressWarnings("incomplete-switch")
private boolean getWallFlag(Orientation direction, int i, int j_offset, int k, Block block)
{
if(block instanceof BlockPane)
return ((BlockPane)block).canPaneConnectToBlock(getBlock(i + direction._i, j_offset, k + direction._k));
else if(isFenceBase(block))
{
if(block instanceof BlockFence)
return ((BlockFence)block).canConnectFenceTo(world, i + direction._i, local_offset + j_offset, k + direction._k);
if(block instanceof BlockWall)
return ((BlockWall)block).canConnectWallTo(world, i + direction._i, local_offset + j_offset, k + direction._k);
else if(SmartMovingOptions.hasBetterMisc && _canConnectFenceTo != null)
return (Boolean)Reflect.Invoke(_canConnectFenceTo, block, world, i + direction._i, local_offset + j_offset, k + direction._k);
}
else if (isFenceGate(block))
{
int metaData = getBlockMetadata(i, j_offset, k);
return isClosedFenceGate(metaData) && isFenceGateFront(metaData);
}
else
{
switch(getCarpentersBlockData(i, j_offset, k))
{
case -1:
break;
case 0:
if (direction._k == 0 && direction._i != 0)
return true;
break;
case 1:
if (direction._i == 0 && direction._k != 0)
return true;
break;
}
}
return false;
}
private static boolean getAllWallsOnNoWall(Block block)
{
return block instanceof BlockPane;
}
private static boolean isTopHalf(double d)
{
return (int)Math.abs(Math.floor(d * 2D)) % 2 == 1;
}
private static int getTriple(double primary, double secondary)
{
primary = primary - Math.floor(primary) - 0.5;
secondary = secondary - Math.floor(secondary) - 0.5;
if(Math.abs(primary) * 2 < Math.abs(secondary))
return 0;
else if(primary > 0)
return 1;
else if(primary < 0)
return -1;
else
return 0;
}
private static boolean isBottomHalfBlock(Block block, int metadata)
{
if(isHalfBlock(block) && isHalfBlockBottomMetaData(metadata))
return true;
if(block == Block.getBlockFromName("bed"))
return true;
if(SmartMovingOptions.hasBetterThanWolves && isAnchorId(block) && metadata == 1)
return true;
return false;
}
private static boolean isTopHalfBlock(Block block, int metadata)
{
return isHalfBlock(block) && isHalfBlockTopMetaData(metadata);
}
private static boolean isHalfBlockBottomMetaData(int metadata)
{
return (metadata & 8) == 0;
}
private static boolean isHalfBlockTopMetaData(int metadata)
{
return (metadata & 8) != 0;
}
private static boolean isHalfBlock(Block block)
{
return isBlock(block, BlockSlab.class, _knownHalfBlocks) && !((BlockSlab)block).isOpaqueCube();
}
private static boolean isStairCompact(Block block)
{
return isBlock(block, BlockStairs.class, _knownCompactStairBlocks);
}
private boolean isLowerHalfFrontFullEmpty(int i, int j_offset, int k)
{
Block block = getBlock(i, j_offset, k);
boolean empty = isFullEmpty(block);
if(!empty && SmartMovingOptions.hasRedPowerWire)
{
if(isRedPowerWire(block))
{
int coverSides = getRpCoverSides(i, j_offset, k);
if(!isRedPowerWireAnyFront(coverSides))
empty = true;
}
}
if(!empty && SmartMovingOptions.hasBetterThanWolves)
{
if(isAnchorId(block))
{
empty = getBlockMetadata(i, j_offset, k) == 0;
}
}
if(!empty && isStairCompact(block) && isTopStairCompactFront(getBlockMetadata(i, j_offset, k)))
empty = true;
if(!empty && isHalfBlock(block) && isHalfBlockTopMetaData(getBlockMetadata(i, j_offset, k)))
empty = true;
if(!empty && isWallBlock(block, i, j_offset, k) && !headedToFrontWall(i, j_offset, k, block))
empty = true;
if(!empty && isDoor(block) && !rotate(180).isDoorFrontBlocked(i, j_offset, k))
empty = true;
if(!empty && (SmartMovingOptions.hasASGrapplingHook || SmartMovingOptions.hasRopesPlus) && isASRope(block) && !rotate(180).isASGrapplingHookFront(getRemoteBlockMetadata(j_offset)))
empty = true;
if(empty && isBlockIdOfType(block, _ladderKitLadderTypes) && rotate(180).hasLadderOrientation(i, j_offset, k))
empty = false;
return empty;
}
private boolean isUpperHalfFrontAnySolid(int i, int j_offset, int k)
{
Block block = getBlock(i, j_offset, k);
boolean solid = isUpperHalfFrontFullSolid(i, j_offset, k);
if(solid && isWallBlock(block, i, j_offset, k) && !headedToFrontWall(i, j_offset, k, block))
solid = false;
return solid;
}
private static boolean isUpperHalfFrontFullSolid(int i, int j_offset, int k)
{
Block block = getBlock(i, j_offset, k);
if(block == null)
return false;
boolean solid = isSolid(block.getMaterial());
if(solid && block == Block.getBlockFromName("standing_sign"))
solid = false;
if(solid && block == Block.getBlockFromName("wall_sign"))
solid = false;
if(solid && block instanceof BlockPressurePlate)
solid = false;
if(solid && isTrapDoor(block))
solid = false;
if(solid && SmartMovingOptions.hasASGrapplingHook && isASGrapplingHook(block))
solid = false;
if(solid && isOpenFenceGate(block, getBlockMetadata(i, j_offset, k)))
solid = false;
if(solid && isExternalBlockType(block, _blockCarpentersLadder))
solid = false;
return solid;
}
private static boolean isFullEmpty(Block block)
{
if(block == null)
return true;
boolean empty = !isSolid(block.getMaterial());
if(!empty && block == Block.getBlockFromName("standing_sign"))
empty = true;
if(!empty && block == Block.getBlockFromName("wall_sign"))
empty = true;
if(!empty && block instanceof BlockPressurePlate)
empty = true;
if(!empty && (SmartMovingOptions.hasASGrapplingHook || SmartMovingOptions.hasRopesPlus) && isASGrapplingHook(block))
empty = true;
if(empty && (SmartMovingOptions.hasASGrapplingHook || SmartMovingOptions.hasRopesPlus) && isASRope(block))
empty = false;
return empty;
}
private static boolean isFenceBase(Block block)
{
return isBlock(block, BlockFence.class, _knownFenceBlocks) || isBlock(block, BlockWall.class, _knownWallBlocks);
}
private static boolean isFence(Block block, int i, int j_offset, int k)
{
return isFenceBase(block) || isClosedFenceGate(block, getBlockMetadata(i, j_offset, k));
}
private static boolean isFence(int i, int j_offset, int k)
{
return getFenceId(i, j_offset, k) != null;
}
private static Block getFenceId(int i, int j_offset, int k)
{
Block block = getBlock(i, j_offset, k);
if(isFenceBase(block) || isClosedFenceGate(block, getBlockMetadata(i, j_offset, k)))
return block;
return null;
}
private static boolean isClosedFenceGate(Block block, int metdata)
{
return isFenceGate(block) && isClosedFenceGate(metdata);
}
private static boolean isFenceGate(Block block)
{
return isBlock(block, BlockFenceGate.class, _knownFanceGateBlocks);
}
private static boolean isOpenFenceGate(Block block, int metdata)
{
return isFenceGate(block) && !isClosedFenceGate(metdata);
}
private static boolean isClosedFenceGate(int metdata)
{
return (metdata & 4) == 0;
}
private static boolean isOpenTrapDoor(int i, int j_offset, int k)
{
return isTrapDoor(i, j_offset, k) && !isClosedTrapDoor(getBlockMetadata(i, j_offset, k));
}
private static boolean isClosedTrapDoor(int i, int j_offset, int k)
{
return isTrapDoor(i, j_offset, k) && isClosedTrapDoor(getBlockMetadata(i, j_offset, k));
}
private static boolean isTrapDoor(int i, int j_offset, int k)
{
return isTrapDoor(getBlock(i, j_offset, k));
}
public static boolean isTrapDoor(Block block)
{
return isBlock(block, BlockTrapDoor.class, _knownTrapDoorBlocks);
}
private static boolean isBlock(Block block, Class<?> type, Block[] baseBlocks)
{
if(block == null)
return false;
if(type != null && baseBlocks.length > 1 && isBlockType(block, type))
return true;
for(int i=0; i<baseBlocks.length; i++)
if(baseBlocks[i] != null && block == baseBlocks[i])
return true;
if(type != null && isBlockType(block, type))
return true;
Class<?> blockType = block.getClass();
for(int i=0; i<baseBlocks.length; i++)
if(baseBlocks[i] != null && baseBlocks[i].getClass().isAssignableFrom(blockType))
return true;
return false;
}
private static boolean isExternalBlockType(Block block, Class<?> externalType)
{
return externalType != null && isBlockType(block, externalType);
}
private static boolean isBlockType(Block block, Class<?> type)
{
return block != null && type.isAssignableFrom(block.getClass());
}
public static boolean isClosedTrapDoor(int metaData)
{
return (metaData & 4) == 0;
}
private static boolean isDoor(Block block)
{
return block == Block.getBlockFromName("wooden_door") || block == Block.getBlockFromName("iron_door");
}
private static boolean isDoorTop(int metaData)
{
return metaData == 8;
}
@SuppressWarnings("incomplete-switch")
private boolean isDoorFrontBlocked(int i, int j_offset, int k)
{
int metaData = getBlockMetadata(i, j_offset, k);
switch(metaData)
{
case 8:
return isDoorFrontBlocked(i, j_offset - 1, k);
case 4:
case 1:
return this._k < 0;
case 5:
case 2:
return this._i > 0;
case 6:
case 3:
return this._k > 0;
case 7:
case 0:
return this._i < 0;
}
return true;
}
private static Block getWallBlockId(int i, int j_offset, int k)
{
Block block = getBlock(i, j_offset, k);
if(isWallBlock(block, i, j_offset, k))
return block;
return null;
}
private static boolean isWallBlock(Block block, int i, int j_offset, int k)
{
return isBlock(block, BlockPane.class, _knownThinWallBlocks) || isFence(block, i, j_offset, k) || (isExternalBlockType(block, _blockCarpentersLadder) && getCarpentersBlockData(i, j_offset, k) < 2);
}
private static boolean isBaseAccessible(int j_offset)
{
return isBaseAccessible(j_offset, false, false);
}
private static boolean isBaseAccessible(int j_offset, boolean bottom, boolean full)
{
Block id = getBaseBlockId(j_offset);
boolean accessible = isEmpty(base_i, j_offset, base_k);
if(SmartMovingOptions.hasRedPowerWire && !accessible)
{
if(isRedPowerWire(id))
{
int coverSides = getRpCoverSides(base_i, j_offset, base_k);
accessible = !isRedPowerWireBottom(coverSides);
Block lowerId = getBaseBlockId(j_offset - 1);
if(isRedPowerWire(lowerId))
{
int lowerCoverSides = getRpCoverSides(base_i, j_offset - 1, base_k);
accessible &= !isRedPowerWireTop(lowerCoverSides);
}
}
}
if(!accessible && isFullEmpty(id))
accessible = true;
if(!accessible && isOpenTrapDoor(base_i, j_offset, base_k))
accessible = true;
if(!accessible && bottom && isClosedTrapDoor(base_i, j_offset, base_k))
accessible = true;
if(!accessible && !full && isWallBlock(id, base_i, j_offset, base_k))
accessible = true;
if(!accessible && !full && (SmartMovingOptions.hasASGrapplingHook || SmartMovingOptions.hasRopesPlus) && isASRope(id))
accessible = true;
if(!accessible && isDoor(id))
accessible = true;
if(!accessible && isExternalBlockType(id, _blockCarpentersLadder))
accessible = true;
return accessible;
}
private boolean isRemoteAccessible(int j_offset)
{
boolean accessible = isEmpty(remote_i, j_offset, remote_k);
if(SmartMovingOptions.hasRedPowerWire && !accessible)
{
Block id = getRemoteBlockId(j_offset);
if(isRedPowerWire(id))
{
int coverSides = getRpCoverSides(remote_i, j_offset, remote_k);
accessible = !isRedPowerWireAnyFront(coverSides);
Block baseId = getBaseBlockId(j_offset);
if(isRedPowerWire(baseId))
{
int baseCoverSides = getRpCoverSides(base_i, j_offset, base_k);
accessible &= !isRedPowerWireAnyBack(baseCoverSides);
}
}
}
if(accessible)
{
Block id = getBaseBlockId(j_offset);
if(isTrapDoor(id))
accessible = !isTrapDoorFront(getBlockMetadata(base_i, j_offset, base_k));
if(accessible && isDoor(id))
accessible = !isDoorFrontBlocked(base_i, j_offset, base_k);
if(remoteLadderClimbing(j_offset))
accessible = false;
}
if(!accessible && isTrapDoor(remote_i, j_offset, remote_k))
accessible = isClosedTrapDoor(getRemoteBlockMetadata(j_offset));
if(!accessible)
{
Block id = getRemoteBlockId(j_offset);
if(isWallBlock(id, remote_i, j_offset, remote_k) && !headedToFrontWall(remote_i, j_offset, remote_k, id) && !isFence(remote_i, j_offset - 1, remote_k))
accessible = true;
Block belowId = getRemoteBlockId(j_offset - 1);
if(!accessible && isFence(belowId, remote_i, j_offset - 1, remote_k) && (!headedToFrontWall(remote_i, j_offset - 1, remote_k, belowId) || isWallBlock(getBaseBlockId(j_offset - 1), base_i, j_offset - 1, base_k)))
if(belowId != Block.getBlockFromName("cobblestone_wall") || headedToRemoteFlatWall(belowId, -1))
accessible = true;
if(!accessible && isDoor(id) && !rotate(180).isDoorFrontBlocked(remote_i, j_offset, remote_k))
accessible = true;
if((SmartMovingOptions.hasASGrapplingHook || SmartMovingOptions.hasRopesPlus) && isASRope(id) && !rotate(180).isASGrapplingHookFront(getRemoteBlockMetadata(j_offset)))
accessible = true;
}
return accessible;
}
private boolean isAccessAccessible(int j_offset)
{
if(!_isDiagonal)
return true;
return isEmpty(remote_i, j_offset, base_k) && isEmpty(base_i, j_offset, remote_k);
}
private boolean isFullExtentAccessible(int j_offset, boolean grabRemote)
{
boolean accessible = isFullAccessible(j_offset, grabRemote);
if(SmartMovingOptions.hasRedPowerWire && accessible)
{
Block topId = getRemoteBlockId(j_offset);
if(isRedPowerWire(topId))
{
int coverSides = getRpCoverSides(remote_i, j_offset, remote_k);
if(isRedPowerWireBottom(coverSides))
accessible = false;
}
Block bottomId = getRemoteBlockId(j_offset - 1);
if(isRedPowerWire(bottomId))
{
int coverSides = getRpCoverSides(remote_i, j_offset - 1, remote_k);
if(isRedPowerWireTop(coverSides))
accessible = false;
}
}
return accessible;
}
private boolean isJustLowerHalfExtentAccessible(int j_offset)
{
Block remoteId = getRemoteBlockId(j_offset);
int remoteMetaData = getRemoteBlockMetadata(j_offset);
boolean accessible = false;
if(!accessible)
accessible = isTopHalfBlock(remoteId, remoteMetaData);
if(!accessible)
accessible = isStairCompact(remoteId) && isTopStairCompactFront(remoteMetaData);
return accessible;
}
private boolean isFullAccessible(int j_offset, boolean grabRemote)
{
if(grabRemote)
return isBaseAccessible(j_offset) && isRemoteAccessible(j_offset) && isAccessAccessible(j_offset);
return isEmpty(base_i, j_offset, base_k);
}
private static boolean isEmpty(int i, int j_offset, int k)
{
return isFullEmpty(getBlock(i, j_offset, k)) && !isFence(i, j_offset - 1, k);
}
private boolean isUpperHalfFrontEmpty(int i, int j_offset, int k)
{
Block block = getBlock(i, j_offset, k);
boolean empty = isFullEmpty(block);
if(!empty)
{
int metadata = getBlockMetadata(i, j_offset, k);
if(isBottomHalfBlock(block, metadata))
empty = true;
if(!empty && isStairCompact(block) && isBottomStairCompactFront(metadata))
empty = true;
}
if(SmartMovingOptions.hasRedPowerWire && !empty)
{
if(isRedPowerWire(block))
{
int coverSides = getRpCoverSides(i, j_offset, k);
if(!isRedPowerWireAnyFront(coverSides))
empty = true;
}
}
if(!empty && isTrapDoor(block))
empty = true;
if(!empty)
{
Block wallId = getWallBlockId(i, j_offset, k);
if(wallId != null && (!headedToFrontWall(i, j_offset, k, wallId) || isWallBlock(getBlock(i - _i, j_offset, k - _k), i - _i, j_offset, k - _k)))
empty = true;
}
if(empty && isBlockIdOfType(block, _ladderKitLadderTypes) && rotate(180).hasLadderOrientation(i, j_offset, k))
empty = false;
return empty;
}
private static int getRpCoverSides(int i, int j_offset, int k)
{
TileEntity tileEntity = getBlockTileEntity(i, j_offset, k);
Class<?> tileEntityClass = tileEntity.getClass();
while(!tileEntityClass.getSimpleName().equals("TileCovered"))
tileEntityClass = tileEntityClass.getSuperclass();
return (Integer)Reflect.GetField(tileEntityClass, tileEntity, new Name("CoverSides"));
}
private static boolean isRedPowerWire(Block block)
{
return hasBlockName(block, "tile.rpwire");
}
public static int getFiniteLiquidWater(Block block)
{
String blockName = getBlockName(block);
if(blockName == null)
return 0;
if(blockName.equals("tile.nocean"))
return 2;
if(blockName.equals("tile.nwater_still"))
return 1;
return 0;
}
private static boolean isSolid(Material material)
{
return material.isSolid() && material.blocksMovement();
}
private static Block getBlock(int i, int j_offset, int k)
{
return world.getBlock(i, local_offset + j_offset, k);
}
private static int getBlockMetadata(int i, int j_offset, int k)
{
return world.getBlockMetadata(i, local_offset + j_offset, k);
}
private static TileEntity getBlockTileEntity(int i, int j_offset, int k)
{
return world.getTileEntity(i, local_offset + j_offset, k);
}
private static Block getBaseBlockId(int j_offset)
{
return world.getBlock(base_i, local_offset + j_offset, base_k);
}
private static int getBaseBlockMetadata(int j_offset)
{
return world.getBlockMetadata(base_i, local_offset + j_offset, base_k);
}
private static boolean isBlockIdOfType(Block block, Class<?>... types)
{
if(types == null || block == null)
return false;
Class<?> blockType = block.getClass();
for(Class<?> type : types)
if(type.isAssignableFrom(blockType))
return true;
return false;
}
private static Block getRemoteBlockId(int j_offset)
{
return world.getBlock(remote_i, local_offset + j_offset, remote_k);
}
private static int getRemoteBlockMetadata(int j_offset)
{
return world.getBlockMetadata(remote_i, local_offset + j_offset, remote_k);
}
private static boolean hasBlockName(Block block, String name)
{
String blockName = getBlockName(block);
return blockName != null && blockName.equals(name);
}
private static String getBlockName(Block block)
{
if(block == null)
return null;
return block.getUnlocalizedName();
}
private void initialize(World w, int i, double id, double jhd, int k, double kd)
{
world = w;
base_i = i;
base_id = id;
base_jhd = jhd;
base_k = k;
base_kd = kd;
remote_i = i + _i;
remote_k = k + _k;
}
private static void initializeOffset(double offset_halfs, boolean isClimbCrawling, boolean isCrawlClimbing, boolean isCrawling)
{
crawl = isClimbCrawling || isCrawlClimbing || isCrawling;
double offset_jhd = base_jhd + offset_halfs;
int offset_jh = MathHelper.floor_double(offset_jhd);
jh_offset = offset_jhd - offset_jh;
all_j = offset_jh / 2;
all_offset = offset_jh % 2;
}
private static void initializeLocal(int localOffset)
{
local_halfOffset = localOffset + all_offset;
local_half = Math.abs(local_halfOffset) % 2;
local_offset = all_j + (local_halfOffset - local_half) / 2;
}
private final static float _handClimbingHoldGap = Math.min(0.25F, 0.06F * Math.max(Config._freeClimbingUpSpeedFactor.value, Config._freeClimbingDownSpeedFactor.value));
private static ClimbGap _climbGapTemp = new ClimbGap();
private static ClimbGap _climbGapOuterTemp = new ClimbGap();
private static World world;
private static double base_jhd, jh_offset;
private static int all_j, all_offset;
private static int base_i, base_k;
private static double base_id, base_kd;
private static int remote_i, remote_k;
private static boolean crawl;
private static int local_halfOffset;
private static int local_half;
private static int local_offset;
private static boolean grabRemote;
private static int grabType;
private static Block grabBlock;
private static int grabMeta;
@Override
public String toString()
{
if(this == ZZ)
return "ZZ";
if(this == NZ)
return "NZ";
if(this == PZ)
return "PZ";
if(this == ZP)
return "ZP";
if(this == ZN)
return "ZN";
if(this == PN)
return "PN";
if(this == PP)
return "PP";
if(this == NN)
return "NN";
if(this == NP)
return "NP";
return "UNKNOWN(" + _i + "," + _k + ")";
}
private static final Method _canConnectFenceTo;
private static final Block[] _knownFanceGateBlocks;
private static final Block[] _knownFenceBlocks;
private static final Block[] _knownWallBlocks;
private static final Block[] _knownHalfBlocks;
private static final Block[] _knownCompactStairBlocks;
private static final Block[] _knownTrapDoorBlocks;
private static final Block[] _knownThinWallBlocks;
private static final Class<?>[] _ladderKitLadderTypes;
private static final Class<?> _blockCarpentersLadder;
private static final Method _carpentersTEBaseBlockGetData;
static
{
Class<?> modFenceBlock = Reflect.LoadClass(Block.class, SmartMovingInstall.ModBlockFence, false);
_canConnectFenceTo = modFenceBlock != null ? Reflect.GetMethod(modFenceBlock, new Name("canConnectFenceTo"), false, IBlockAccess.class, int.class, int.class, int.class) : null;
_blockCarpentersLadder = Reflect.LoadClass(Block.class, SmartMovingInstall.CarpentersBlockLadder, false);
if (_blockCarpentersLadder != null)
{
Class<?> carpentersTEBaseBlock = Reflect.LoadClass(Block.class, SmartMovingInstall.CarpentersTEBaseBlock, false);
_carpentersTEBaseBlockGetData = Reflect.GetMethod(carpentersTEBaseBlock, SmartMovingInstall.CarpentersTEBaseBlock_getData);
}
else
_carpentersTEBaseBlockGetData = null;
_knownFanceGateBlocks = new Block[] { Block.getBlockFromName("fence_gate") };
_knownFenceBlocks = new Block[] { Block.getBlockFromName("fence"), Block.getBlockFromName("nether_brick_fence") };
_knownWallBlocks = new Block[] { Block.getBlockFromName("cobblestone_wall") };
_knownHalfBlocks = new Block[] {Block.getBlockFromName("stone_slab"), Block.getBlockFromName("double_stone_slab"), Block.getBlockFromName("wooden_slab"), Block.getBlockFromName("double_wooden_slab") };
_knownCompactStairBlocks = new Block[] { Block.getBlockFromName("stone_stairs"), Block.getBlockFromName("oak_stairs"), Block.getBlockFromName("dark_oak_stairs"), Block.getBlockFromName("brick_stairs"), Block.getBlockFromName("nether_brick_stairs"), Block.getBlockFromName("sandstone_stairs"), Block.getBlockFromName("stone_brick_stairs"), Block.getBlockFromName("birch_stairs"), Block.getBlockFromName("jungle_stairs"), Block.getBlockFromName("spruce_stairs"), Block.getBlockFromName("quartz_stairs"), Block.getBlockFromName("acacia_stairs") };
_knownTrapDoorBlocks = new Block[] { Block.getBlockFromName("trapdoor") };
_knownThinWallBlocks = new Block[] { Block.getBlockFromName("iron_bars"), Block.getBlockFromName("glass_pane") };
Class<?> blockRopeLadder = Reflect.LoadClass(Block.class, SmartMovingInstall.BlockRopeLadder, false);
Class<?> blockSturdyLadder = Reflect.LoadClass(Block.class, SmartMovingInstall.BlockSturdyLadder, false);
if(blockRopeLadder != null)
if(blockSturdyLadder != null)
_ladderKitLadderTypes = new Class<?>[] { blockRopeLadder, blockSturdyLadder };
else
_ladderKitLadderTypes = new Class<?>[] { blockRopeLadder };
else
if(blockSturdyLadder != null)
_ladderKitLadderTypes = new Class<?>[] { blockSturdyLadder };
else
_ladderKitLadderTypes = null;
}
}