org.bukkit.util.CachedServerIcon#ch.njol.skript.classes.Changer.ChangeMode源码实例Demo

@Override
public void change(final Event e, final @Nullable Object[] delta, final ChangeMode mode) {
	double d = delta == null ? 0 : ((Number) delta[0]).doubleValue();
	for (final LivingEntity en : getExpr().getArray(e)) {
		assert en != null : getExpr();
		switch (mode) {
			case SET:
				HealthUtils.setMaxHealth(en, d);
				break;
			case REMOVE:
				d = -d;
				//$FALL-THROUGH$
			case ADD:
				HealthUtils.setMaxHealth(en, HealthUtils.getMaxHealth(en) + d);
				break;
			case RESET:
				en.resetMaxHealth();
				break;
			case DELETE:
			case REMOVE_ALL:
				assert false;
				
		}
	}
}
 

@SuppressWarnings("unchecked")
@Override
@Nullable
public Class<?>[] acceptChange(final ChangeMode mode) {
    switch (mode) {
        case SET:
            return CollectionUtils.array(ItemStack.class);
        case ADD:
        case REMOVE:
        case DELETE:
        case REMOVE_ALL:
        case RESET:
        default:
            return null;
    }
}
 

@Override
@Nullable
public Class<?>[] acceptChange(final ChangeMode mode) {
	if (mode == ChangeMode.REMOVE_ALL)
		return null;
	if (ScriptLoader.isCurrentEvent(PlayerRespawnEvent.class) && !ScriptLoader.hasDelayBefore.isTrue()) {
		Skript.error("Cannot change a player's level in a respawn event. Add a delay of 1 tick or change the 'new level' in a death event.");
		return null;
	}
	if (ScriptLoader.isCurrentEvent(PlayerDeathEvent.class) && getTime() == 0 && getExpr().isDefault() && !ScriptLoader.hasDelayBefore.isTrue()) {
		Skript.warning("Changing the player's level in a death event will change the player's level before he dies. " +
				"Use either 'past level of player' or 'new level of player' to clearly state whether to change the level before or after he dies.");
	}
	if (getTime() == -1 && !ScriptLoader.isCurrentEvent(PlayerDeathEvent.class))
		return null;
	return new Class[] {Number.class};
}
 

@Override
@Nullable
public Class<?>[] acceptChange(final ChangeMode mode) {
	if (!getExpr().isSingle())
		return null;
	if (!ChangerUtils.acceptsChange(getExpr(), ChangeMode.SET, ItemStack.class, ItemType.class))
		return null;
	changeItemStack = ChangerUtils.acceptsChange(getExpr(), ChangeMode.SET, ItemStack.class);
	switch (mode) {
		case ADD:
		case REMOVE:
		case SET:
			return new Class[] {Number.class};
		case RESET:
		case DELETE:
		case REMOVE_ALL:
		default:
			return null;
	}
}
 

@Override
@Nullable
public Class<?>[] acceptChange(final ChangeMode mode) {
	boolean acceptsMany = lineNumber == null;
	switch (mode) {
		case REMOVE:
		case REMOVE_ALL:
		case DELETE:
			acceptsMany = false;
		case SET:
		case ADD:
			if (ChangerUtils.acceptsChange(item, ChangeMode.SET, ItemStack.class, ItemType.class)) {
				return CollectionUtils.array(acceptsMany ? String[].class : String.class);
			}
			return null;
		case RESET:
		default:
			return null;
	}
}
 

@SuppressWarnings("null")
@Override
public void change(final Event e, final @Nullable Object[] delta, final ChangeMode mode) {
	for (Block b : getExpr().getArray(e)) {
		if (b.getType() != MATERIAL_SPAWNER)
			continue;
		CreatureSpawner s = (CreatureSpawner) b.getState();
		switch (mode) {
			case SET:
				s.setSpawnedType(toBukkitEntityType((EntityData) delta[0]));
				break;
			case RESET:
				s.setSpawnedType(org.bukkit.entity.EntityType.PIG);
				break;
		}
		s.update(); // Actually trigger the spawner's update 
	}
}
 

@Override
@Nullable
public Class<?>[] acceptChange(ChangeMode mode) {
	if (mode == ChangeMode.DELETE && (type.acceptChange & ~PLAYER) != 0 || mode == ChangeMode.RESET)
		return new Class[0];
	if (mode != ChangeMode.SET)
		return null;
	if ((type.acceptChange & PLAYER) != 0 && Player.class.isAssignableFrom(getExpr().getReturnType())) {
		changeType = PLAYER;
	} else if ((type.acceptChange & INVENTORY) != 0 && Inventory.class.isAssignableFrom(getExpr().getReturnType())) {
		changeType = INVENTORY;
	} else if ((type.acceptChange & ITEM) != 0 && (getExpr().isSingle() && ChangerUtils.acceptsChange(getExpr(), ChangeMode.SET, ItemStack.class, ItemType.class) || Slot.class.isAssignableFrom(getExpr().getReturnType()))) {
		changeType = ITEM;
	} else if ((type.acceptChange & ENTITY) != 0 && Entity.class.isAssignableFrom(getExpr().getReturnType())) {
		if (type == NameType.NAME && Player.class.isAssignableFrom(getExpr().getReturnType())) {
			Skript.error("Can't change the Minecraft name of a player. Change the 'display name' or 'tab list name' instead.");
			return null;
		}
		changeType = ENTITY;
	}
	return changeType == 0 ? null : CollectionUtils.array(String.class);
}
 

@Override
@Nullable
public Class<?>[] acceptChange(ChangeMode mode) {
	if (!isReal) {
		if (ScriptLoader.hasDelayBefore.isTrue()) {
			Skript.error("Can't change the shown online players count anymore after the server list ping event has already passed");
			return null;
		}
		switch (mode) {
			case SET:
			case ADD:
			case REMOVE:
			case DELETE:
			case RESET:
				return CollectionUtils.array(Number.class);
		}
	}
	return null;
}
 

@Override
@SuppressWarnings("null")
public void change(Event e, @Nullable Object[] delta, ChangeMode mode) {
	assert delta != null;
	for (final Entity entity : getExpr().getArray(e)) {
		if (entity == null)
			return;
		switch (mode) {
			case ADD:
				entity.setVelocity(entity.getVelocity().add((Vector) delta[0]));
				break;
			case REMOVE:
				entity.setVelocity(entity.getVelocity().subtract((Vector) delta[0]));
				break;
			case REMOVE_ALL:
				break;
			case DELETE:
			case RESET:
				entity.setVelocity(new Vector());
				break;	
			case SET:
				entity.setVelocity((Vector) delta[0]);
		}
	}
}
 

@Override
public void change(final Event e, final @Nullable Object[] delta, final ChangeMode mode) {
	final WeatherType t = delta == null ? WeatherType.CLEAR : (WeatherType) delta[0];
	for (final World w : getExpr().getArray(e)) {
		assert w != null : getExpr();
		if (getTime() >= 0 && e instanceof WeatherEvent && w.equals(((WeatherEvent) e).getWorld()) && !Delay.isDelayed(e)) {
			if (e instanceof WeatherChangeEvent) {
				if (((WeatherChangeEvent) e).toWeatherState() && t == WeatherType.CLEAR)
					((WeatherChangeEvent) e).setCancelled(true);
				if (((WeatherChangeEvent) e).getWorld().isThundering() != (t == WeatherType.THUNDER))
					((WeatherChangeEvent) e).getWorld().setThundering(t == WeatherType.THUNDER);
			} else if (e instanceof ThunderChangeEvent) {
				if (((ThunderChangeEvent) e).toThunderState() && t != WeatherType.THUNDER)
					((ThunderChangeEvent) e).setCancelled(true);
				if (((ThunderChangeEvent) e).getWorld().hasStorm() == (t == WeatherType.CLEAR))
					((ThunderChangeEvent) e).getWorld().setStorm(t != WeatherType.CLEAR);
			}
		} else {
			t.setWeather(w);
		}
	}
}
 

@SuppressWarnings({"null"})
@Override
public boolean init(final Expression<?>[] exprs, final int matchedPattern, final Kleenean isDelayed, final ParseResult parseResult) {
	haystack =  exprs[1 + matchedPattern % 2];
	replaceString = matchedPattern < 4;
	replaceFirst = matchedPattern > 1 && matchedPattern < 4;
	if (replaceString && !ChangerUtils.acceptsChange(haystack, ChangeMode.SET, String.class)) {
		Skript.error(haystack + " cannot be changed and can thus not have parts replaced.");
		return false;
	}
	if (SkriptConfig.caseSensitive.value() || parseResult.mark == 1) {
		caseSensitive = true;
	}
	needles = exprs[0];
	replacement = exprs[2 - matchedPattern % 2];
	return true;
}
 

@Override
	protected void execute(final Event e) {
		final Expression<?> changer = this.changer;
		Object[] delta = changer == null ? null : changer.getArray(e);
		delta = changer == null ? delta : changer.beforeChange(changed, delta);
		if (delta != null && delta.length == 0)
			return;
		if (delta == null && (mode != ChangeMode.DELETE && mode != ChangeMode.RESET))
			return;
		changed.change(e, delta, mode); // Trigger beforeChanged hook
		// REMIND use a random element out of delta if changed only supports changing a single instance
//		changed.change(e, new Changer2<Object>() {
//			@Override
//			public Object change(Object o) {
//				return delta;
//			}
//		}, mode);
	}
 

@Override
@Nullable
public Class<?>[] acceptChange(final ChangeMode mode) {
	if (mode == ChangeMode.SET || mode == ChangeMode.RESET)
		return new Class[] {Boolean.class};
	return null;
}
 

@Override
@Nullable
public Class<?>[] acceptChange(final ChangeMode mode) {
	ClassInfo<?> rti = returnTypeInfo;
	if (rti == null)
		returnTypeInfo = rti = Classes.getSuperClassInfo(getReturnType());
	final Changer<?> c = rti.getChanger();
	if (c == null)
		return null;
	return c.acceptChange(mode);
}
 

@SuppressWarnings("unchecked")
@Override
public void change(final Event e, final @Nullable Object[] delta, final ChangeMode mode) {
	final ClassInfo<?> rti = returnTypeInfo;
	if (rti == null)
		throw new UnsupportedOperationException();
	final Changer<?> c = rti.getChanger();
	if (c == null)
		throw new UnsupportedOperationException();
	((Changer<T>) c).change(getArray(e), delta, mode);
}
 

@Override
@Nullable
public Class<?>[] acceptChange(final ChangeMode mode) {
	if (mode == ChangeMode.DELETE || mode == ChangeMode.SET)
		return new Class[] {String.class};
	return null;
}
 

@Override
@Nullable
public Class<?>[] acceptChange(final ChangeMode mode) {
	ClassInfo<? super T> rti = returnTypeInfo;
	if (rti == null)
		returnTypeInfo = rti = Classes.getSuperClassInfo(getReturnType());
	final Changer<? super T> c = rti.getChanger();
	return c == null ? null : c.acceptChange(mode);
}
 

@Override
@Nullable
public Class<?>[] acceptChange(final ChangeMode mode) {
	if (mode == ChangeMode.REMOVE_ALL)
		return null;
	return new Class[] {Number.class};
}
 

@Override
@Nullable
public Class<?>[] acceptChange(final ChangeMode mode) {
	if (mode == ChangeMode.REMOVE_ALL)
		return null;
	return CollectionUtils.array(Number.class);
}
 

@SuppressWarnings("unchecked")
@Override
@Nullable
public Class<?>[] acceptChange(final ChangeMode mode) {
	Changer<? super T> ch = changer;
	if (ch == null)
		changer = ch = (Changer<? super T>) Classes.getSuperClassInfo(c).getChanger();
	return ch == null ? null : ch.acceptChange(mode);
}
 

@Override
@Nullable
public Class<?>[] acceptChange(final ChangeMode mode) {
	if (mode == ChangeMode.REMOVE_ALL)
		return null;
	if (Slot.class.isAssignableFrom(getExpr().getReturnType()) || getExpr().isSingle() && ChangerUtils.acceptsChange(getExpr(), ChangeMode.SET, ItemStack.class, ItemType.class))
		return CollectionUtils.array(Number.class);
	return null;
}
 

@Override
@Nullable
public Class<?>[] acceptChange(ChangeMode mode) {
	switch (mode) {
		case SET:
		case ADD:
		case REMOVE:
		case DELETE:
		case RESET:
			return CollectionUtils.array(String[].class);
		default:
			return null;
	}
}
 

@Override
public void change(final Event e, final @Nullable Object[] delta, final ChangeMode mode) throws UnsupportedOperationException {
	final GameMode m = delta == null ? Bukkit.getDefaultGameMode() : (GameMode) delta[0];
	for (final Player p : getExpr().getArray(e)) {
		if (getTime() >= 0 && e instanceof PlayerGameModeChangeEvent && ((PlayerGameModeChangeEvent) e).getPlayer() == p && !Delay.isDelayed(e)) {
			if (((PlayerGameModeChangeEvent) e).getNewGameMode() != m)
				((PlayerGameModeChangeEvent) e).setCancelled(true);
		}
		p.setGameMode(m);
	}
}
 

@Override
public void change(final Event e, final @Nullable Object[] delta, final ChangeMode mode) {
	assert mode != ChangeMode.REMOVE_ALL;
	
	final int l = delta == null ? 0 : ((Number) delta[0]).intValue();
	
	for (final Player p : getExpr().getArray(e)) {
		int level;
		if (getTime() > 0 && e instanceof PlayerDeathEvent && ((PlayerDeathEvent) e).getEntity() == p && !Delay.isDelayed(e)) {
			level = ((PlayerDeathEvent) e).getNewLevel();
		} else {
			level = p.getLevel();
		}
		switch (mode) {
			case SET:
				level = l;
				break;
			case ADD:
				level += l;
				break;
			case REMOVE:
				level -= l;
				break;
			case DELETE:
			case RESET:
				level = 0;
				break;
			case REMOVE_ALL:
				assert false;
				continue;
		}
		if (getTime() > 0 && e instanceof PlayerDeathEvent && ((PlayerDeathEvent) e).getEntity() == p && !Delay.isDelayed(e)) {
			((PlayerDeathEvent) e).setNewLevel(level);
		} else {
			p.setLevel(level);
		}
	}
}
 

@Override
@Nullable
public Class<?>[] acceptChange(final ChangeMode mode) {
	if (mode == ChangeMode.RESET)
		return new Class[0];
	return null;
}
 

@Override
public void change(final Event e, final @Nullable Object[] delta, final ChangeMode mode) {
	assert mode == ChangeMode.RESET;
	
	final Chunk[] cs = getArray(e);
	for (final Chunk c : cs)
		c.getWorld().regenerateChunk(c.getX(), c.getZ());
}
 

@SuppressWarnings("unchecked")
@Override
@Nullable
public Class<?>[] acceptChange(final ChangeMode mode) {
	if (mode == ChangeMode.SET)
		return CollectionUtils.array(String.class);
	return null;
}
 

@Override
@Nullable
public Class<?>[] acceptChange(final ChangeMode mode) {
	if (mode == ChangeMode.SET || mode == ChangeMode.RESET || mode == ChangeMode.ADD || mode == ChangeMode.REMOVE)
		return new Class[] {Number.class};
	return null;
}
 

@Override
public void change(final Event e, final @Nullable Object[] delta, final ChangeMode mode) throws UnsupportedOperationException {
	float input = delta == null ? 0 : ((Number) delta[0]).floatValue();
	
	for (final Player p : getExpr().getArray(e)) {
		float oldSpeed = walk ? p.getWalkSpeed() : p.getFlySpeed();
		
		float newSpeed;
		switch (mode) {
			case SET:
				newSpeed = input;
				break;
			case ADD:
				newSpeed = oldSpeed + input;
				break;
			case REMOVE:
				newSpeed = oldSpeed - input;
				break;
				//$CASES-OMITTED$
			default:
				newSpeed = walk ? 0.2f : 0.1f;
				break;
		}
		
		final float d = Math2.fit(-1, newSpeed, 1);
		
		if (walk)
			p.setWalkSpeed(d);
		else
			p.setFlySpeed(d);
	}
}
 

@Override
@Nullable
public Class<?>[] acceptChange(final ChangeMode mode) {
	if (mode == ChangeMode.SET)
		return new Class[] {Biome.class};
	return super.acceptChange(mode);
}