@SuppressWarnings("rawtypes")
 private <O extends Operator> O newInstance(Class<O> c) {
   if (c.isInterface()) {
     return null;
   }
   if (Modifier.isAbstract(c.getModifiers())) {
     return null;
   }
   final Class<?>[] paramTypes;
   final Object[] args;
   if (Modifier.isStatic(c.getModifiers())) {
     paramTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
     args = ArrayUtils.EMPTY_OBJECT_ARRAY;
   } else {
     paramTypes = new Class[] {getClass()};
     args = new Object[] {this};
   }
   final Constructor<O> cs = ConstructorUtils.getMatchingAccessibleConstructor(c, paramTypes);
   if (cs == null) {
     return null;
   }
   try {
     return cs.newInstance(args);
   } catch (Exception e) {
     throw new RuntimeException(e);
   }
 }
 private MutantProducer<Schema> instantiateProducer(String name)
     throws ClassNotFoundException, InstantiationException, IllegalAccessException,
         IllegalArgumentException, InvocationTargetException {
   String className;
   if (name.contains(".")) {
     className = name;
   } else {
     className = "org.schemaanalyst.mutation.operator." + name;
   }
   Class<MutantProducer<Schema>> producerClass =
       (Class<MutantProducer<Schema>>) Class.forName(className);
   Constructor<MutantProducer<Schema>> constructor =
       ConstructorUtils.getMatchingAccessibleConstructor(producerClass, schema.getClass());
   MutantProducer<Schema> instance = constructor.newInstance(schema);
   return instance;
 };
Esempio n. 3
0
  @Override
  public Optional<Entity> createEntity(EntityType type, Vector3d position) {
    checkNotNull(type, "The entity type cannot be null!");
    checkNotNull(position, "The position cannot be null!");

    Entity entity = null;

    Class<? extends Entity> entityClass = type.getEntityClass();
    double x = position.getX();
    double y = position.getY();
    double z = position.getZ();

    if (entityClass.isAssignableFrom(EntityPlayerMP.class)
        || entityClass.isAssignableFrom(EntityDragonPart.class)) {
      // Unable to construct these
      return Optional.empty();
    }

    net.minecraft.world.World world = (net.minecraft.world.World) (Object) this;

    // Not all entities have a single World parameter as their constructor
    if (entityClass.isAssignableFrom(EntityLightningBolt.class)) {
      entity = (Entity) new EntityLightningBolt(world, x, y, z);
    } else if (entityClass.isAssignableFrom(EntityEnderPearl.class)) {
      EntityArmorStand tempEntity = new EntityArmorStand(world, x, y, z);
      tempEntity.posY -= tempEntity.getEyeHeight();
      entity = (Entity) new EntityEnderPearl(world, tempEntity);
      ((EnderPearl) entity).setShooter(ProjectileSource.UNKNOWN);
    }

    // Some entities need to have non-null fields (and the easiest way to
    // set them is to use the more specialised constructor).
    if (entityClass.isAssignableFrom(EntityFallingBlock.class)) {
      entity = (Entity) new EntityFallingBlock(world, x, y, z, Blocks.sand.getDefaultState());
    } else if (entityClass.isAssignableFrom(EntityItem.class)) {
      entity = (Entity) new EntityItem(world, x, y, z, new ItemStack(Blocks.stone));
    }

    if (entity == null) {
      try {
        entity = ConstructorUtils.invokeConstructor(entityClass, this);
        ((net.minecraft.entity.Entity) entity).setPosition(x, y, z);
      } catch (Exception e) {
        SpongeImpl.getLogger().error(ExceptionUtils.getStackTrace(e));
      }
    }

    // TODO - replace this with an actual check
    /*
    if (entity instanceof EntityHanging) {
        if (((EntityHanging) entity).facingDirection == null) {
            // TODO Some sort of detection of a valid direction?
            // i.e scan immediate blocks for something to attach onto.
            ((EntityHanging) entity).facingDirection = EnumFacing.NORTH;
        }
        if (!((EntityHanging) entity).onValidSurface()) {
            return Optional.empty();
        }
    }*/

    // Last chance to fix null fields
    if (entity instanceof EntityPotion) {
      // make sure EntityPotion.potionDamage is not null
      ((EntityPotion) entity).getPotionDamage();
    } else if (entity instanceof EntityPainting) {
      // This is default when art is null when reading from NBT, could
      // choose a random art instead?
      ((EntityPainting) entity).art = EnumArt.KEBAB;
    }

    return Optional.ofNullable(entity);
  }