private static void block(Player player) {
    for (int id : instances.keySet()) {
      EarthBlast blast = instances.get(id);

      if (blast.player.equals(player)) {
        continue;
      }

      if (!blast.location.getWorld().equals(player.getWorld())) {
        continue;
      }

      if (!blast.progressing) {
        continue;
      }

      if (GeneralMethods.isRegionProtectedFromBuild(player, "EarthBlast", blast.location)) {
        continue;
      }

      Location location = player.getEyeLocation();
      Vector vector = location.getDirection();
      Location mloc = blast.location;
      if (mloc.distance(location) <= RANGE
          && GeneralMethods.getDistanceFromLine(vector, location, blast.location) < deflectrange
          && mloc.distance(location.clone().add(vector))
              < mloc.distance(location.clone().add(vector.clone().multiply(-1)))) {
        blast.breakBlock();
      }
    }
  }
  private static void redirectTargettedBlasts(Player player, ArrayList<EarthBlast> ignore) {
    for (int id : instances.keySet()) {
      EarthBlast blast = instances.get(id);

      if (!blast.progressing || ignore.contains(blast)) {
        continue;
      }

      if (!blast.location.getWorld().equals(player.getWorld())) {
        continue;
      }

      if (GeneralMethods.isRegionProtectedFromBuild(player, "EarthBlast", blast.location)) {
        continue;
      }

      if (blast.player.equals(player)) {
        blast.redirect(player, getTargetLocation(player));
      }

      Location location = player.getEyeLocation();
      Vector vector = location.getDirection();
      Location mloc = blast.location;
      if (mloc.distance(location) <= RANGE
          && GeneralMethods.getDistanceFromLine(vector, location, blast.location) < deflectrange
          && mloc.distance(location.clone().add(vector))
              < mloc.distance(location.clone().add(vector.clone().multiply(-1)))) {
        blast.redirect(player, getTargetLocation(player));
      }
    }
  }
Beispiel #3
0
  public void bOOM() {
    Vector v = p.getVelocity();
    v.setY(2.3);
    p.teleport(p.getLocation().add(0, 0.5, 0));
    p.setVelocity(v);
    p.setFallDistance(0F);
    TempData.sonicRainBoomMap.put(p.getUniqueId(), System.currentTimeMillis());
    p.sendMessage(ChatColor.LIGHT_PURPLE + "SONIC RAINBOOM!");
    TempData.fallMap.add(p.getUniqueId());

    // Particles
    final World world = p.getWorld();

    for (int i = 0; i < 20 * 4; i++) {
      Bukkit.getScheduler()
          .scheduleSyncDelayedTask(
              Main.PLUGIN,
              new Runnable() {

                @Override
                public void run() {

                  world
                      .spigot()
                      .playEffect(p.getLocation(), Effect.COLOURED_DUST, 1, 1, 1, 1, 1, 1, 48, 30);
                }
              },
              i);
    }
  }
Beispiel #4
0
  private void calculateRay(int ox, int oy, int oz, Collection<BlockVector> result) {
    double x = ox / 7.5 - 1;
    double y = oy / 7.5 - 1;
    double z = oz / 7.5 - 1;
    Vector direction = new Vector(x, y, z);
    direction.normalize();
    direction.multiply(0.3f); // 0.3 blocks away with each step

    Location current = location.clone();

    float currentPower = calculateStartPower();

    while (currentPower > 0) {
      GlowBlock block = world.getBlockAt(current);

      if (block.getType() != Material.AIR) {
        double blastDurability = getBlastDurability(block) / 5d;
        blastDurability += 0.3F;
        blastDurability *= 0.3F;
        currentPower -= blastDurability;

        if (currentPower > 0) {
          result.add(new BlockVector(block.getX(), block.getY(), block.getZ()));
        }
      }

      current.add(direction);
      currentPower -= 0.225f;
    }
  }
Beispiel #5
0
  protected void triggersign(TriggerType type, Object args) {
    InputState is = this.getInput(1, (BlockRedstoneEvent) args);

    if (is == InputState.HIGH && !lastState) {
      lastState = true;

      Vector v =
          new Vector(
              to.getBlockX() - from.getBlockX(),
              to.getBlockY() - from.getBlockY(),
              to.getBlockZ() - from.getBlockZ());

      v.normalize();

      v.multiply(speed);

      while (from.getBlock().getType() != Material.AIR) {
        from = from.toVector().add(v.clone().normalize().multiply(.2)).toLocation(this.getWorld());
      }

      for (int i = 0; i < arrows; i++) {

        Arrow a = this.getWorld().spawn(from, Arrow.class);
        a.setVelocity(v.clone().add(getVariance(variance)));
        this.main.cleaner.register(a, 5000);
      }

      this.getWorld().playEffect(from, org.bukkit.Effect.BOW_FIRE, 0);
    } else if ((is == InputState.LOW || is == InputState.DISCONNECTED) && lastState) {
      lastState = false;
    } else {
      return;
    }
  }
Beispiel #6
0
  private void playOutExplosion(GlowPlayer player, Iterable<BlockVector> blocks) {
    Collection<ExplosionMessage.Record> records = new ArrayList<>();

    Location clientLoc = location.clone();
    clientLoc.setX((int) clientLoc.getX());
    clientLoc.setY((int) clientLoc.getY());
    clientLoc.setZ((int) clientLoc.getZ());

    for (BlockVector block : blocks) {
      byte x = (byte) (block.getBlockX() - clientLoc.getBlockX());
      byte y = (byte) (block.getBlockY() - clientLoc.getBlockY());
      byte z = (byte) (block.getBlockZ() - clientLoc.getBlockZ());
      records.add(new ExplosionMessage.Record(x, y, z));
    }

    Vector velocity = player.getVelocity();
    ExplosionMessage message =
        new ExplosionMessage(
            (float) location.getX(),
            (float) location.getY(),
            (float) location.getZ(),
            5,
            (float) velocity.getX(),
            (float) velocity.getY(),
            (float) velocity.getZ(),
            records);

    player.getSession().send(message);
  }
 @Override
 public boolean isInside(BlockRegion block) {
   Vector point = new Vector(block.getX(), block.getY(), block.getZ());
   return Math.pow(point.getX() - origin.getX(), 2.0D)
           + Math.pow(point.getZ() - origin.getZ(), 2.0D)
       < (radius * radius);
 }
Beispiel #8
0
  @Override
  public void send(Player player) {
    final PacketPlayOutSpawnEntity p23 = new PacketPlayOutSpawnEntity();

    final Location position = player.getLocation();

    p23.a = entityId; // v1_7_R1
    p23.b = MathHelper.floor(position.getX() * 32.0D); // v1_7_R1
    p23.c = MathHelper.floor(position.getY() * 32.0D); // v1_7_R1
    p23.d = MathHelper.floor(position.getZ() * 32.0D); // v1_7_R1
    p23.h = MathHelper.d(position.getPitch() * 256.0F / 360.0F); // v1_7_R1
    p23.i = MathHelper.d(position.getYaw() * 256.0F / 360.0F); // v1_7_R1
    p23.j = vehicleTypeId; // v1_7_R1
    p23.k = dataValue; // v1_7_R1
    if (dataValue > 0) {
      final Vector velocity = getVelocity();
      double d1 = velocity.getX();
      double d2 = velocity.getY();
      double d3 = velocity.getZ();
      double d4 = 3.9D;
      if (d1 < -d4) d1 = -d4;
      if (d2 < -d4) d2 = -d4;
      if (d3 < -d4) d3 = -d4;
      if (d1 > d4) d1 = d4;
      if (d2 > d4) d2 = d4;
      if (d3 > d4) d3 = d4;
      p23.e = (int) (d1 * 8000.0D); // v1_7_R1
      p23.f = (int) (d2 * 8000.0D); // v1_7_R1
      p23.g = (int) (d3 * 8000.0D); // v1_7_R1
    }

    PlayerHelper.sendPacketToPlayer(player, p23);
  }
  @Override
  public void cast(Entity entity) {
    // entity.getWorld().playSound(entity.getLocation(), Sound.GHAST_FIREBALL, 1F, 1F);
    entity.getWorld().playSound(entity.getLocation(), Sound.NOTE_STICKS, 1F, 0.4F);

    // TODO - find a better way to launch block without needing Player
    if (entity instanceof Player) {
      Player player = (Player) entity;

      Vector velocity = player.getEyeLocation().getDirection();
      velocity.normalize().multiply(power);

      FallingBlock fb =
          DeprecatedMethods.spawnFallingBlock(
              entity.getLocation().clone().add(0, 1, 0),
              DeprecatedMethods.getMaterialByID(blockID),
              (byte) 0);
      fb.setDropItem(false);
      fb.setVelocity(velocity);

      // make it do damage
      if (damage) {
        DynamicClassFunctions.setFallingBlockHurtEntities(fb, hurt, hurt);
      }
    }
  }
 public void setBlock(Vector pos, Material type, int data) {
   Vector vec = translate(pos);
   if (boundingBox.isVectorInside(vec)) {
     delegate.setTypeAndRawData(
         world, vec.getBlockX(), vec.getBlockY(), vec.getBlockZ(), type, data);
   }
 }
  @Override
  public boolean doPowerSign(
      PowerSigns plugin, Block signBlock, String action, Matcher argsm, Boolean isOn) {
    Sign signState = (Sign) signBlock.getState();

    BlockFace signDir = PowerSigns.getSignDirection(signBlock);

    Vector dir = PowerSigns.strToVector(argsm.group(1), signDir);

    Block invBlock = signBlock.getRelative(dir.getBlockX(), dir.getBlockY(), dir.getBlockZ());

    Inventory inventory;
    BlockState state = invBlock.getState();
    if (state instanceof InventoryHolder) inventory = ((InventoryHolder) state).getInventory();
    else return plugin.debugFail("bad inv:" + invBlock.getType().toString() + " " + dir.toString());

    Material[] materials = PowerSigns.getMaterials(signState.getLine(1));

    int count = 0;

    for (Material material : materials) count += PowerSigns.inventoryCount(inventory, material);

    signState.setLine(2, Integer.toString(count));

    plugin.updateSignState(signState);

    return true;
  }
 public boolean spawnMob(Vector pos, EntityType entityType) {
   Vector vec = translate(pos);
   return boundingBox.isVectorInside(vec)
       && world.spawnEntity(
               new Location(world, vec.getBlockX(), vec.getBlockY(), vec.getBlockZ()), entityType)
           != null;
 }
  @Override
  public SpellResult step(CastContext context) {
    if (entity == null) {
      return SpellResult.FAIL;
    }
    SpellResult result = super.step(context);
    Location target = actionContext.getTargetLocation();

    // TODO: locationOffset and velocityOffset should be made relative
    if (locationOffset != null) {
      target = target.clone().add(locationOffset);
    }
    if (doVelocity) {
      Vector velocity = this.velocity.clone().multiply(distanceTravelledThisTick);
      if (velocityOffset != null) {
        velocity = velocity.add(velocityOffset);
      }
      entity.setVelocity(velocity);
    }
    Location currentLocation = entity.getLocation();
    if (doTeleport) {
      if (!orient) {
        target.setYaw(currentLocation.getYaw());
        target.setPitch(currentLocation.getPitch());
      }
      entity.teleport(target);
    }
    return result;
  }
  @Override
  public void run() {
    if (master.contchunks.isEmpty()) return;

    World world = master.team.getMatch().getWorld();
    Location loc = new Location(world, 0, 0, 0);
    Set<BlockData> goals = master.searching;
    for (int i = 0; i < 15; i++) // 15 chunks per run
    {
      Vector vec = master.entitychunks.poll();
      if (vec == null) {
        this.cancel();
        return;
      }
      BlockState[] containers =
          world
              .getChunkAt(vec.getBlockX(), vec.getBlockZ())
              .getTileEntities(); // actually chunk-coords

      for (BlockState state : containers) {
        if (state instanceof InventoryHolder) {
          Inventory inv = ((InventoryHolder) state).getInventory();
          if (state instanceof Chest) inv = ((Chest) state).getBlockInventory();
          checkInventory(inv, goals, state.getLocation(loc));
        }
        // TODO: spawners
      }
    }
  }
Beispiel #15
0
  @Override
  public boolean onDamageOther(EntityDamageByEntityEvent e, Player p, int level) {
    if (e.getEntity() instanceof LivingEntity) {
      LivingEntity le = (LivingEntity) e.getEntity();

      try {
        fireworks.playFirework(
            le.getWorld(),
            le.getLocation(),
            FireworkEffect.builder().with(Type.BURST).withColor(Color.WHITE).build());
      } catch (Exception ex) {
        Logger.getLogger(Burst.class.getName()).log(Level.SEVERE, null, ex);
      }

      Vector unitVector =
          le.getLocation().toVector().subtract(e.getDamager().getLocation().toVector()).normalize();

      unitVector.setY(0.55 / level);

      le.setVelocity(unitVector.multiply(level * 2));

      e.setCancelled(true);

      return true;
    }
    return false;
  }
Beispiel #16
0
  public void manageAirVectors() {
    for (int i = 0; i < tasks.size(); i++) {
      if (((FireComboStream) tasks.get(i)).isCancelled()) {
        tasks.remove(i);
        i--;
      }
    }
    if (tasks.size() == 0) {
      remove();
      return;
    }
    for (int i = 0; i < tasks.size(); i++) {
      FireComboStream fstream = (FireComboStream) tasks.get(i);
      Location loc = fstream.getLocation();

      if (GeneralMethods.isRegionProtectedFromBuild(this, loc)) {
        fstream.remove();
        return;
      }

      if (!isTransparent(loc.getBlock())) {
        if (!isTransparent(loc.clone().add(0, 0.2, 0).getBlock())) {
          fstream.remove();
          return;
        }
      }
      if (i % 3 == 0) {
        for (Entity entity : GeneralMethods.getEntitiesAroundPoint(loc, 2.5)) {
          if (GeneralMethods.isRegionProtectedFromBuild(this, entity.getLocation())) {
            remove();
            return;
          }
          if (!entity.equals(player) && !affectedEntities.contains(entity)) {
            affectedEntities.add(entity);
            if (knockback != 0) {
              Vector force = fstream.getDirection();
              entity.setVelocity(force.multiply(knockback));
            }
            if (damage != 0) {
              if (entity instanceof LivingEntity) {
                if (fstream.getAbility().equalsIgnoreCase("AirSweep")) {
                  DamageHandler.damageEntity(entity, damage, this);
                } else {
                  DamageHandler.damageEntity(entity, damage, this);
                }
              }
            }
          }
        }

        if (GeneralMethods.blockAbilities(player, FireCombo.getBlockableAbilities(), loc, 1)) {
          fstream.remove();
        } else AirAbility.removeAirSpouts(loc, player);
        WaterAbility.removeWaterSpouts(loc, player);
        EarthAbility.removeSandSpouts(loc, player);
      }
    }
  }
Beispiel #17
0
 @SuppressWarnings("unchecked")
 protected String getVectorJSON(Vector vec) {
   JSONObject data = new JSONObject();
   // x, y, z
   data.put("x", String.valueOf(vec.getX()));
   data.put("y", String.valueOf(vec.getY()));
   data.put("z", String.valueOf(vec.getZ()));
   return data.toJSONString();
 }
Beispiel #18
0
  private void tossItem(ItemStack dropItem) {
    Location loc = player.getLocation();
    loc.setY(loc.getY() + 1);

    Item item = loc.getWorld().dropItem(loc, dropItem);
    Vector v = loc.getDirection().multiply(0.2);
    v.setY(0.2);
    item.setVelocity(v);
  }
  @Override
  public void g(double x, double y, double z) {
    if (this.m_remoteEntity == null) {
      super.g(x, y, z);
      return;
    }

    Vector vector = ((RemoteBaseEntity) this.m_remoteEntity).onPush(x, y, z);
    if (vector != null) super.g(vector.getX(), vector.getY(), vector.getZ());
  }
Beispiel #20
0
  /**
   * Update the cached values for players velocity to be prepared to give them additional movement
   * freedom in their next move events
   *
   * @param v
   * @param data
   */
  public void updateVelocity(Vector v, MovingData data) {

    // Compare the velocity vector to the existing movement freedom that we've from previous events
    double tmp = (Math.abs(v.getX()) + Math.abs(v.getZ())) * 3D;
    if (tmp > data.horizFreedom) data.horizFreedom = tmp;

    if (v.getY() > data.maxYVelocity) {
      data.maxYVelocity = v.getY();
    }
  }
  /**
   * Set the location of the item and put it on the right place on the block
   *
   * @param location The location of the item/shop block
   */
  private void setLocation(Location location) {
    this.location = location.getBlock().getLocation(); // simply clear everything after the comma.
    Vector vec = this.location.toVector();
    vec.add(new Vector(0.5, 0.6, 0.5));
    this.location = vec.toLocation(this.location.getWorld());

    if (getItem() != null) {
      getItem().teleport(this.location);
    }
  }
  @Override
  public boolean isInside(BlockRegion block) {
    Vector point = new Vector(block.getX(), block.getY(), block.getZ());
    if (point.getY() >= origin.getY() && point.getY() <= origin.getY() + height) {
      return Math.pow(point.getX() - origin.getX(), 2.0D)
              + Math.pow(point.getZ() - origin.getZ(), 2.0D)
          < (radius * radius);
    }

    return false;

    /*
    if(infinite) {
    	return matchesXZ(block);
    }

    BlockRegion check = new BlockRegion(block.getStringX(), values.get(0).getStringY(), block.getStringZ());
    double max = check.getDoubleY() + height;

    for(BlockRegion region : getValues()) {
    	if(region.isInside(check) && block.getDoubleY() <= max) {
    		return true;
    	}
    }

    return false;
    */
  }
 @Override
 public void onRun() {
   Location location = getLocation();
   for (int i = 0; i < particles; i++) {
     Vector vector = RandomUtils.getRandomVector().multiply(radius);
     if (!sphere) vector.setY(Math.abs(vector.getY()));
     location.add(vector);
     particle.display(location, visibleRange);
     location.subtract(vector);
   }
 }
Beispiel #24
0
 /**
  * Fill the {@link Cube} with a specific block type.
  *
  * @param type Block type.
  * @see http://www.minecraftwiki.net/wiki/Data_values
  */
 public void fill(int type) {
   World world = point.getWorld();
   Vector end = end();
   for (int x = point.getBlockX(); x < end.getBlockX(); x++) {
     for (int y = point.getBlockY(); y < end.getBlockY(); y++) {
       for (int z = point.getBlockZ(); z < end.getBlockZ(); z++) {
         Block block = world.getBlockAt(x, y, z);
         block.setTypeId(type);
       }
     }
   }
 }
 @Override
 public void writeData(SpoutOutputStream output) throws IOException {
   output.writeString(text);
   output.writeDouble(location.getX());
   output.writeDouble(location.getY());
   output.writeDouble(location.getZ());
   output.writeFloat(scale);
   output.writeInt(duration);
   output.writeDouble(movement.getX());
   output.writeDouble(movement.getY());
   output.writeDouble(movement.getZ());
 }
Beispiel #26
0
 @EventHandler
 public void onChat(AsyncPlayerChatEvent event) {
   Player player = event.getPlayer();
   String message = event.getMessage();
   if (message.equalsIgnoreCase("test")) {
     event.setCancelled(true);
     player.sendMessage(message);
     Vector vector = getPlayerVector(player);
     // player.setVelocity(vector.multiply(2));
     player.launchProjectile(Fireball.class).setVelocity(vector.multiply(5));
   }
 }
  @EventHandler(priority = EventPriority.NORMAL)
  public void EnterCart(final VehicleEnterEvent event) {
    Entity e = event.getVehicle(); // get the vehicle
    Vector dir =
        event
            .getEntered()
            .getLocation()
            .getDirection(); // get who entered it and what direction they were looking

    if (e instanceof Minecart) {
      e.setVelocity(dir.multiply(1));
    }
  }
Beispiel #28
0
 public static void checkSecond() {
   for (Item i : Bukkit.getWorld("PrisonMap").getEntitiesByClass(Item.class)) {
     if (tnts.contains(i.getUniqueId())) {
       ParticleEffect.SMOKE_NORMAL.display(
           0.25f, 0.25f, 0.25f, 0.0001f, 5, i.getLocation().clone().add(0, 0.5, 0), 100);
       if (i.getTicksLived() > 30) {
         ParticleEffect.EXPLOSION_HUGE.display(
             0.5f, 0.5f, 0.5f, 0.1f, 5, i.getLocation().clone().add(0, 1, 0), 100);
         for (Entity e : i.getNearbyEntities(3.5, 3.5, 3.5)) {
           if (e instanceof Player) {
             Location midPoint = i.getLocation();
             Vector direction =
                 e.getLocation().toVector().subtract(midPoint.toVector()).normalize();
             direction.multiply(1.1).setY(0.7);
             e.setVelocity(direction);
             ((Player) e).damage(0.0);
           }
         }
         final List<Location> blocks = new ArrayList<Location>();
         int radius = 3;
         int bX = i.getLocation().getBlockX();
         int bY = i.getLocation().getBlockY();
         int bZ = i.getLocation().getBlockZ();
         for (int x = bX - radius; x <= bX + radius; x++) {
           for (int y = bY - radius; y <= bY + radius; y++) {
             for (int z = bZ - radius; z <= bZ + radius; z++) {
               double distance =
                   ((bX - x) * (bX - x) + ((bZ - z) * (bZ - z)) + ((bY - y) * (bY - y)));
               if (distance < radius * radius) {
                 Location loc = new Location(i.getWorld(), x, y, z);
                 if (loc.getBlock().getType() != Material.AIR) {
                   blocks.add(loc);
                 }
               }
             }
           }
         }
         for (Location loc : blocks) {
           Random r = new Random();
           int i1 = r.nextInt(3) + 1;
           if (Game.isBreakable(loc.getBlock().getType()) && (i1 == 1 || i1 == 2)) {
             loc.getBlock().setType(Material.AIR);
           }
         }
         Game.playSound(Sound.EXPLODE, i.getLocation(), 1f, 1f);
         tnts.remove(i.getUniqueId());
         i.teleport(i.getLocation().subtract(0, 500, 0));
       }
     }
   }
 }
Beispiel #29
0
 protected String getVector(Vector vec) {
   String ret = "{";
   ret += "\"x\":\"" + vec.getX() + "\"";
   ret += ",\"y\":\"" + vec.getY() + "\"";
   ret += ",\"z\":\"" + vec.getZ() + "\"";
   ret += "}";
   if (!isJSON(ret)) return getVectorJSON(vec);
   try {
     getVector(ret);
   } catch (Exception ex) {
     return getVectorJSON(vec);
   }
   return ret;
 }
Beispiel #30
0
  // Finds points on a line extending infinitely through the points startLoc and endLoc intersecting
  // a circle centered at circleLoc
  private List<Location> getCollisionPoints(
      Location startLoc, Location endLoc, Location circleLoc, double radiusSquared) {
    Vector delta = vectorFromLocations(startLoc, endLoc);
    Vector circleLocInTermsOfStart = vectorFromLocations(startLoc, circleLoc);

    boolean flipped = false;
    if (delta.getX() == 0) {
      flipped = true;
      flipXZ(delta);
      flipXZ(circleLocInTermsOfStart);
    }
    circleLocInTermsOfStart.add(new Vector(0.5, 0, 0.5));

    double slope = delta.getZ() / delta.getX();

    double circleX = circleLocInTermsOfStart.getX();
    double circleZ = circleLocInTermsOfStart.getZ();

    double circleXSquared = circleX * circleX;
    double circleZSquared = circleZ * circleZ;

    List<Double> xs =
        getSolutions(
            slope * slope + 1,
            -(2 * circleZ * slope + 2 * circleX),
            circleXSquared + circleZSquared - radiusSquared);
    List<Location> results = new ArrayList<Location>();
    for (double x : xs) {
      Vector offset = new Vector(x, 0, x * slope);
      if (flipped) flipXZ(offset);
      results.add(startLoc.clone().add(offset));
    }

    return results;
  }