@Command(
aliases = {"/move"},
usage = "[count] [direction] [leave-id]",
flags = "s",
desc = "Move the contents of the selection",
min = 0,
max = 3)
@CommandPermissions("worldedit.region.move")
@Logging(ORIENTATION_REGION)
public static void move(
CommandContext args,
WorldEdit we,
LocalSession session,
LocalPlayer player,
EditSession editSession)
throws WorldEditException {
int count = args.argsLength() > 0 ? Math.max(1, args.getInteger(0)) : 1;
Vector dir =
we.getDirection(player, args.argsLength() > 1 ? args.getString(1).toLowerCase() : "me");
BaseBlock replace;
// Replacement block argument
if (args.argsLength() > 2) {
replace = we.getBlock(player, args.getString(2));
} else {
replace = new BaseBlock(BlockID.AIR);
}
int affected =
editSession.moveCuboidRegion(
session.getSelection(player.getWorld()), dir, count, true, replace);
if (args.hasFlag('s')) {
try {
Region region = session.getSelection(player.getWorld());
region.expand(dir.multiply(count));
region.contract(dir.multiply(count));
session.getRegionSelector().learnChanges();
session.getRegionSelector().explainRegionAdjust(player, session);
} catch (RegionOperationException e) {
player.printError(e.getMessage());
}
}
player.print(affected + " blocks moved.");
}
public Vector backProp(Vector error) {
derivs = fcn.applyDerivative(outputs);
errors = derivs.multiply(error);
Vector blame = weights.transpose().multiply(errors);
// take off the bias signal, the previous layer need not know
return blame.slice(blame.dim() - 1);
}
double distance(Point p) {
double sb, sn, sd;
sn = -n.dot(p.minus(v));
sd = n.dot(n);
sb = sn / sd;
Point pb = p.plus(n.multiply(sb)); // base point in plane
return p.distance(pb);
}
@Command(
aliases = {"/stack"},
usage = "[count] [direction]",
flags = "sa",
desc = "Repeat the contents of the selection",
min = 0,
max = 2)
@CommandPermissions("worldedit.region.stack")
@Logging(ORIENTATION_REGION)
public static void stack(
CommandContext args,
WorldEdit we,
LocalSession session,
LocalPlayer player,
EditSession editSession)
throws WorldEditException {
int count = args.argsLength() > 0 ? Math.max(1, args.getInteger(0)) : 1;
Vector dir =
we.getDiagonalDirection(
player, args.argsLength() > 1 ? args.getString(1).toLowerCase() : "me");
int affected =
editSession.stackCuboidRegion(
session.getSelection(player.getWorld()), dir, count, !args.hasFlag('a'));
if (args.hasFlag('s')) {
try {
Region region = session.getSelection(player.getWorld());
region.expand(dir.multiply(count));
region.contract(dir.multiply(count));
session.getRegionSelector().learnChanges();
session.getRegionSelector().explainRegionAdjust(player, session);
} catch (RegionOperationException e) {
player.printError(e.getMessage());
}
}
player.print(affected + " blocks changed. Undo with //undo");
}
private void update(Particle particle) {
float intervalInSecs = (float) intervalInMillis / 1000f; // e.g. 0.033
// position
Vector velocity = particle.getVelocity().clone();
velocity.multiply(intervalInSecs);
Vector newPosition = particle.getPosition();
newPosition.add(velocity);
particle.setPosition(newPosition);
// velocity
float dampPowTime = (float) Math.pow(particle.getMass(), intervalInSecs);
Vector velocityMult = particle.getVelocity().clone();
velocityMult.multiply(dampPowTime);
Vector acceleration = particle.getAcceleration().clone();
acceleration.multiply(intervalInSecs);
velocityMult.add(acceleration);
particle.setVelocity(velocityMult);
}
// 0: disjoint, 1: intersection, 2: segment lies in the plane
int intersect3D(Line s) {
Point inter; // intersection point
Vector u = s.p1.minus(s.p0);
Vector w = s.p0.minus(v);
double d = n.dot(u);
double N = -n.dot(w);
if (Math.abs(d) < EPS) // parallel
if (N == 0) // lies in the plane
return 2;
else return 0; // no intersection
double sI = N / d; // intersect param
if (sI < 0 || sI > 1) return 0;
inter = s.p0.plus(u.multiply(sI));
return 1;
}
@Override
public Vector subtract(Vector vector, Factory factory) {
return add(vector.multiply(-1.0), factory);
}
public void testMultiply() {
Vector vector = new Vector(3, 4);
vector.multiply(0.1);
assertEquals(0.5, vector.getLength(), 0.001);
}
public void placeVelocityMultiple(Vector posit, Vector veloc) {
place(posit, veloc.multiply(Double.parseDouble(projectileSpeed.getText())));
}
Vector getReflectionVector(Vector normal) {
return new Vector(this.subtract(normal.multiply(this.dot(normal) * 2)));
}
@Override
public final BoundingBox getBounds() {
BoundingBox boundingBox = BoundingBox.newInstance();
double minimum = Double.MAX_VALUE;
Vector u = Vector.newInstance(0.0D, 0.0D, 0.0D);
Vector v;
Vector d = Vector.newInstance(0.0D, 0.0D, 0.0D);
int size = vectors.size();
for (int i = 0; i < size; i++) {
Vector vector1 = vectors.get((i + 1) % size);
Vector vector2 = vectors.get(i);
u.set(vector1);
u.subtract(vector2);
u.normalize();
v = Vector.toCrossProduct(getNormal(), u);
v.normalize();
double uMaximum = 0.0D;
double uMinimum = 0.0D;
double vMaximum = 0.0D;
double vMinimum = 0.0D;
for (int j = 0; j < size; j++) {
if (i != j) {
Vector vector3 = vectors.get(j);
d.set(vector3);
d.subtract(vector2);
double uLength = d.getDotProduct(u);
double vLength = d.getDotProduct(v);
uMaximum = Math.max(uLength, uMaximum);
uMinimum = Math.min(uLength, uMinimum);
vMaximum = Math.max(vLength, vMaximum);
vMinimum = Math.min(vLength, vMinimum);
}
}
double current = (uMaximum - uMinimum) * (vMaximum - vMinimum);
if (current < minimum) {
minimum = current;
Vector origin = boundingBox.getOrigin();
origin.set(vector2);
d.set(u);
d.multiply(uMinimum);
origin.add(d);
d.set(v);
d.multiply(vMinimum);
origin.add(d);
boundingBox.getU().set(u);
boundingBox.getV().set(v);
boundingBox.setHeight(vMaximum - vMinimum);
boundingBox.setWidth(uMaximum - uMinimum);
}
}
return boundingBox;
}
