static Map<Imt, Map<Gmm, List<Double>>> initValueMaps(Set<Imt> imts, Set<Gmm> gmms, int size) {
Map<Imt, Map<Gmm, List<Double>>> imtMap = Maps.newEnumMap(Imt.class);
for (Imt imt : imts) {
Map<Gmm, List<Double>> gmmMap = Maps.newEnumMap(Gmm.class);
for (Gmm gmm : gmms) {
gmmMap.put(gmm, Doubles.asList(new double[size]));
}
imtMap.put(imt, gmmMap);
}
return imtMap;
}
/**
* Parses the search query.
*
* @param query the query.
* @return the result map with query tokens. Never returns null.
* @throws InvalidQueryException if the query contains invalid params.
*/
Map<TokenQueryType, Set<String>> parseQuery(String query) throws InvalidQueryException {
Preconditions.checkArgument(query != null);
query = query.trim();
// If query is empty - return.
if (query.isEmpty()) {
return Collections.emptyMap();
}
String[] tokens = query.split("\\s+");
Map<TokenQueryType, Set<String>> tokensMap = Maps.newEnumMap(TokenQueryType.class);
for (String token : tokens) {
String[] pair = token.split(":");
if (pair.length != 2 || !TokenQueryType.hasToken(pair[0])) {
String msg = "Invalid query param: " + token;
throw new InvalidQueryException(msg);
}
String tokenValue = pair[1];
TokenQueryType tokenType = TokenQueryType.fromToken(pair[0]);
// Verify the orderby param.
if (tokenType.equals(TokenQueryType.ORDERBY)) {
try {
OrderByValueType.fromToken(tokenValue);
} catch (IllegalArgumentException e) {
String msg = "Invalid orderby query value: " + tokenValue;
throw new InvalidQueryException(msg);
}
}
Set<String> valuesPerToken = tokensMap.get(tokenType);
if (valuesPerToken == null) {
valuesPerToken = Sets.newLinkedHashSet();
tokensMap.put(tokenType, valuesPerToken);
}
valuesPerToken.add(tokenValue);
}
return tokensMap;
}
public RequestDispatcher(Iterable<GrizzletHandler> grizzlets) {
Map<String, Map<HttpMethod, GrizzletHandler>> modifiableHandlersMap = Maps.newHashMap();
for (GrizzletHandler handler : grizzlets) {
Map<HttpMethod, GrizzletHandler> handlerByMethod =
modifiableHandlersMap.get(handler.getPath());
if (handlerByMethod == null) {
handlerByMethod = Maps.newEnumMap(HttpMethod.class);
modifiableHandlersMap.put(handler.getPath(), handlerByMethod);
}
for (HttpMethod method : handler.getMethods()) {
GrizzletHandler alreadyHandler = handlerByMethod.put(method, handler);
if (alreadyHandler != null) {
throw new IllegalArgumentException(
"More than one handler detected for path='"
+ handler.getPath()
+ "', method='"
+ method.name()
+ '\'');
}
}
}
for (Map.Entry<String, Map<HttpMethod, GrizzletHandler>> entry :
modifiableHandlersMap.entrySet()) {
modifiableHandlersMap.put(entry.getKey(), Collections.unmodifiableMap(entry.getValue()));
}
handlers = ImmutableMap.copyOf(modifiableHandlersMap);
}
private List<BlockFamily> processMultiBlockFamily(
AssetUri blockDefUri, BlockDefinition blockDef) {
List<BlockFamily> result = Lists.newArrayList();
for (String shapeString : blockDef.shapes) {
BlockShape shape = (BlockShape) Assets.get(AssetType.SHAPE, shapeString);
if (shape != null) {
BlockUri familyUri;
if (shape.equals(cubeShape)) {
familyUri = new BlockUri(blockDefUri.getModuleName(), blockDefUri.getAssetName());
} else {
familyUri =
new BlockUri(
blockDefUri.getModuleName(),
blockDefUri.getAssetName(),
shape.getURI().getModuleName(),
shape.getURI().getAssetName());
}
blockDef.shape = shapeString;
if (shape.isCollisionYawSymmetric()) {
Block block = constructSingleBlock(blockDefUri, blockDef);
result.add(new SymmetricFamily(familyUri, block, blockDef.categories));
} else {
Map<Side, Block> blockMap = Maps.newEnumMap(Side.class);
constructHorizontalBlocks(blockDefUri, blockDef, blockMap);
result.add(new HorizontalBlockFamily(familyUri, blockMap, blockDef.categories));
}
}
}
return result;
}
Map<IdProperty, String> getProps() {
Map<IdProperty, String> props = Maps.newEnumMap(IdProperty.class);
props.put(IdProperty.email, "alice@Net");
props.put(IdProperty.nick, "aliceW");
props.put(IdProperty.fullName, "Alice Wonderland");
props.put(IdProperty.firstName, "alice");
props.put(IdProperty.lastName, "wonderland");
props.put(IdProperty.derivedFullName, "alice wonderland");
return props;
}
public LibraryVariantData(
@NonNull AndroidConfig androidConfig,
@NonNull TaskManager taskManager,
@NonNull GradleVariantConfiguration config,
@NonNull ErrorReporter errorReporter) {
super(androidConfig, taskManager, config, errorReporter);
testVariants = Maps.newEnumMap(VariantType.class);
// create default output
createOutput(OutputFile.OutputType.MAIN, Collections.<FilterData>emptyList());
}
private BlockAppearance createAppearance(
BlockShape shape, Map<BlockPart, AssetUri> tileUris, Rotation rot) {
Map<BlockPart, BlockMeshPart> meshParts = Maps.newEnumMap(BlockPart.class);
Map<BlockPart, Vector2f> textureAtlasPositions = Maps.newEnumMap(BlockPart.class);
for (BlockPart part : BlockPart.values()) {
// TODO: Need to be more sensible with the texture atlas. Because things like block particles
// read from a part that may not exist, we're being fairly lenient
Vector2f atlasPos = atlas.getTexCoords(tileUris.get(part), shape.getMeshPart(part) != null);
BlockPart targetPart = part.rotate(rot);
textureAtlasPositions.put(targetPart, atlasPos);
if (shape.getMeshPart(part) != null) {
meshParts.put(
targetPart,
shape
.getMeshPart(part)
.rotate(rot.getQuat4f())
.mapTexCoords(atlasPos, atlas.getRelativeTileSize()));
}
}
return new BlockAppearance(meshParts, textureAtlasPositions);
}
public BlockFamily loadWithShape(BlockUri uri) {
try (ModuleContext.ContextSpan ignored = ModuleContext.setContext(uri.getModuleName())) {
BlockShape shape = cubeShape;
if (uri.hasShape()) {
AssetUri shapeUri = uri.getShapeUri();
if (!shapeUri.isValid()) {
return null;
}
shape = (BlockShape) Assets.get(shapeUri);
if (shape == null) {
return null;
}
}
AssetUri blockDefUri =
new AssetUri(AssetType.BLOCK_DEFINITION, uri.getModuleName(), uri.getFamilyName());
BlockDefinition def;
if (assetManager.getAssetURLs(blockDefUri).isEmpty()) {
// An auto-block
def = new BlockDefinition();
} else {
def =
createBlockDefinition(
inheritData(blockDefUri, readJson(blockDefUri).getAsJsonObject()));
}
def.shape = (shape.getURI().toSimpleString());
if (shape.isCollisionYawSymmetric()) {
Block block = constructSingleBlock(blockDefUri, def);
if (block.getDisplayName().isEmpty()) {
block.setDisplayName(shape.getDisplayName());
} else if (!shape.getDisplayName().isEmpty()) {
block.setDisplayName(block.getDisplayName() + " " + shape.getDisplayName());
}
return new SymmetricFamily(uri, block, def.categories);
} else {
Map<Side, Block> blockMap = Maps.newEnumMap(Side.class);
constructHorizontalBlocks(blockDefUri, def, blockMap);
for (Block block : blockMap.values()) {
if (block.getDisplayName().isEmpty()) {
block.setDisplayName(shape.getDisplayName());
} else if (!shape.getDisplayName().isEmpty()) {
block.setDisplayName(block.getDisplayName() + " " + shape.getDisplayName());
}
}
return new HorizontalBlockFamily(uri, blockMap, def.categories);
}
} catch (Exception e) {
logger.error("Error loading block shape {}", uri, e);
}
return null;
}
/**
* The type Open nLPPOS annotator.
*
* @author David B. Bracewell
*/
public class OpenNLPPOSAnnotator extends SentenceLevelAnnotator {
private static final long serialVersionUID = 1L;
private volatile Map<Language, POSModel> posModels = Maps.newEnumMap(Language.class);
@Override
public void annotate(Annotation sentence) {
POSTaggerME posTagger = new POSTaggerME(loadPOSTagger(sentence.getLanguage()));
String[] tokens = sentence.tokens().stream().map(Object::toString).toArray(String[]::new);
String[] tags = posTagger.tag(tokens);
for (int i = 0; i < tokens.length; i++) {
Annotation token = sentence.tokenAt(i);
token.put(Types.PART_OF_SPEECH, POS.fromString(tags[i]));
}
}
private POSModel loadPOSTagger(Language language) {
if (!posModels.containsKey(language)) {
synchronized (OpenNLPPOSAnnotator.class) {
if (!posModels.containsKey(language)) {
try {
posModels.put(
language,
new POSModel(
Config.get("opennlp", language, "part_of_speech", "model")
.asResource()
.inputStream()));
} catch (IOException e) {
throw Throwables.propagate(e);
}
}
}
}
return posModels.get(language);
}
@Override
public Set<AnnotatableType> satisfies() {
return Collections.singleton(Types.PART_OF_SPEECH);
}
@Override
public Set<AnnotatableType> furtherRequires() {
return Collections.singleton(Types.TOKEN);
}
@Override
public String getVersion() {
return "1.6.0";
}
} // END OF OpenNLPPOSAnnotator
private Map<BlockPart, Vector4f> prepareColorOffsets(BlockDefinition blockDef) {
Map<BlockPart, Vector4f> result = Maps.newEnumMap(BlockPart.class);
for (BlockPart part : BlockPart.values()) {
result.put(part, blockDef.colorOffset);
}
if (blockDef.colorOffsets != null) {
for (BlockPart part : BlockPart.values()) {
if (blockDef.colorOffsets.map.get(part) != null) {
result.put(part, blockDef.colorOffsets.map.get(part));
}
}
}
return result;
}
private Map<BlockPart, Block.ColorSource> prepareColorSources(BlockDefinition blockDef) {
Map<BlockPart, Block.ColorSource> result = Maps.newEnumMap(BlockPart.class);
for (BlockPart part : BlockPart.values()) {
result.put(part, blockDef.colorSource);
}
if (blockDef.colorSources != null) {
for (BlockPart part : BlockPart.values()) {
if (blockDef.colorSources.map.get(part) != null) {
result.put(part, blockDef.colorSources.map.get(part));
}
}
}
return result;
}
private static class Registration<P extends Event, S extends org.spongepowered.api.event.Event>
implements HandlerList.Adapter {
private final Class<P> pore;
private final Class<S> sponge;
private SimpleConstructor<P, S> constructor;
private final EnumMap<EventPriority, PoreEventHandler<S>> listeners =
Maps.newEnumMap(EventPriority.class);
public Registration(Class<P> pore, Class<S> sponge) {
this.pore = pore;
this.sponge = sponge;
}
@Override
public void register(EventPriority priority) {
PoreEventHandler<S> listener = listeners.get(priority);
if (listener == null) {
if (constructor == null) {
this.constructor = PoreConstructors.create(pore, sponge);
}
listener = new PoreEventHandler<>(priority, constructor);
listeners.put(priority, listener);
}
Pore.getGame()
.getEventManager()
.registerListener(
Pore.getPlugin(), sponge, EventPriorityConverter.of(priority), listener);
}
@Override
public void unregister() {
EventManager manager = Pore.getGame().getEventManager();
for (Object listener : listeners.values()) {
manager.unregisterListeners(listener);
}
}
@Override
public void unregister(EventPriority priority) {
Object listener = listeners.get(priority);
if (listener != null) {
Pore.getGame().getEventManager().unregisterListeners(listener);
}
}
}
public class EquipmentEditor extends Editor {
private final NPC npc;
private final Player player;
public EquipmentEditor(Player player, NPC npc) {
this.player = player;
this.npc = npc;
}
@Override
public void begin() {
Messaging.sendTr(player, Messages.EQUIPMENT_EDITOR_BEGIN);
}
@Override
public void end() {
Messaging.sendTr(player, Messages.EQUIPMENT_EDITOR_END);
}
@EventHandler
public void onPlayerInteract(PlayerInteractEvent event) {
if (event.getAction() == Action.RIGHT_CLICK_AIR && Editor.hasEditor(event.getPlayer()))
event.setUseItemInHand(Result.DENY);
}
@EventHandler
public void onPlayerInteractEntity(PlayerInteractEntityEvent event) {
if (!npc.isSpawned()
|| !event.getPlayer().equals(player)
|| !npc.equals(CitizensAPI.getNPCRegistry().getNPC(event.getRightClicked()))) return;
Equipper equipper = EQUIPPERS.get(npc.getEntity().getType());
if (equipper == null) equipper = new GenericEquipper();
equipper.equip(event.getPlayer(), npc);
event.setCancelled(true);
}
private static final Map<EntityType, Equipper> EQUIPPERS = Maps.newEnumMap(EntityType.class);
static {
EQUIPPERS.put(EntityType.PIG, new PigEquipper());
EQUIPPERS.put(EntityType.SHEEP, new SheepEquipper());
EQUIPPERS.put(EntityType.ENDERMAN, new EndermanEquipper());
EQUIPPERS.put(EntityType.HORSE, new HorseEquipper());
}
}
@Override
public List<BakedQuad> getFaceQuads(EnumFacing side) {
if (faces == null) {
// Create map of each face's quads.
EnumMap<EnumFacing, ImmutableList<BakedQuad>> faces = Maps.newEnumMap(EnumFacing.class);
for (EnumFacing face : EnumFacing.values()) {
ImmutableList.Builder<BakedQuad> faceQuads = ImmutableList.builder();
if (base != null) faceQuads.addAll(base.getFaceQuads(face));
for (IFlexibleBakedModel bakedPart : parts.values())
faceQuads.addAll(bakedPart.getFaceQuads(face));
faces.put(face, faceQuads.build());
}
this.faces = Maps.immutableEnumMap(faces);
}
return faces.get(side);
}
public DefOverviewModel() throws QuickFixException {
AuraContext context = Aura.getContextService().getCurrentContext();
BaseComponent<?, ?> component = context.getCurrentComponent();
String desc = (String) component.getAttributes().getValue("descriptor");
DefType defType =
DefType.valueOf(((String) component.getAttributes().getValue("defType")).toUpperCase());
DefinitionService definitionService = Aura.getDefinitionService();
DefDescriptor<?> descriptor =
definitionService.getDefDescriptor(desc, defType.getPrimaryInterface());
Definition def = descriptor.getDef();
ReferenceTreeModel.assertAccess(def);
Map<DefType, List<DefModel>> depsMap = Maps.newEnumMap(DefType.class);
Set<DefDescriptor<?>> deps = Sets.newHashSet();
def.appendDependencies(deps);
for (DefDescriptor<?> dep : deps) {
DefType type = dep.getDefType();
List<DefModel> depsList = depsMap.get(type);
if (depsList == null) {
depsList = Lists.newArrayList();
depsMap.put(type, depsList);
}
depsList.add(new DefModel(dep));
}
for (Entry<DefType, List<DefModel>> entry : depsMap.entrySet()) {
List<DefModel> list = entry.getValue();
Collections.sort(list);
Map<String, Object> group = Maps.newHashMap();
group.put("type", AuraTextUtil.initCap(entry.getKey().toString().toLowerCase()));
group.put("list", list);
dependencies.add(group);
}
}
private Map<BlockPart, AssetUri> prepareTiles(BlockDefinition blockDef, AssetUri uri) {
AssetUri tileUri = getDefaultTile(blockDef, uri);
Map<BlockPart, AssetUri> tileUris = Maps.newEnumMap(BlockPart.class);
for (BlockPart part : BlockPart.values()) {
tileUris.put(part, tileUri);
}
if (blockDef.tiles != null) {
for (BlockPart part : BlockPart.values()) {
String partTile = blockDef.tiles.map.get(part);
if (partTile != null) {
tileUri = assetManager.resolve(AssetType.BLOCK_TILE, blockDef.tiles.map.get(part));
tileUris.put(part, tileUri);
}
}
}
return tileUris;
}
@Override
public void fireEvent(final ClockTick event) {
if (Bootstrap.isFinished() && Hosts.isCoordinator()) {
final List<ResourceAvailabilityEvent> resourceAvailabilityEvents = Lists.newArrayList();
final Map<ResourceAvailabilityEvent.ResourceType, AvailabilityAccumulator> availabilities =
Maps.newEnumMap(ResourceAvailabilityEvent.ResourceType.class);
final Iterable<VmType> vmTypes = Lists.newArrayList(VmTypes.list());
for (final Cluster cluster : Clusters.getInstance().listValues()) {
availabilities.put(Core, new AvailabilityAccumulator(VmType.SizeProperties.Cpu));
availabilities.put(Disk, new AvailabilityAccumulator(VmType.SizeProperties.Disk));
availabilities.put(Memory, new AvailabilityAccumulator(VmType.SizeProperties.Memory));
for (final VmType vmType : vmTypes) {
final ResourceState.VmTypeAvailability va =
cluster.getNodeState().getAvailability(vmType.getName());
resourceAvailabilityEvents.add(
new ResourceAvailabilityEvent(
Instance,
new ResourceAvailabilityEvent.Availability(
va.getMax(),
va.getAvailable(),
Lists.<ResourceAvailabilityEvent.Tag>newArrayList(
new ResourceAvailabilityEvent.Dimension(
"availabilityZone", cluster.getPartition()),
new ResourceAvailabilityEvent.Dimension("cluster", cluster.getName()),
new ResourceAvailabilityEvent.Type("vm-type", vmType.getName())))));
for (final AvailabilityAccumulator availability : availabilities.values()) {
availability.total =
Math.max(
availability.total, va.getMax() * availability.valueExtractor.apply(vmType));
availability.available =
Math.max(
availability.available,
va.getAvailable() * availability.valueExtractor.apply(vmType));
}
}
for (final AvailabilityAccumulator availability : availabilities.values()) {
availability.rollUp(
Lists.<ResourceAvailabilityEvent.Tag>newArrayList(
new ResourceAvailabilityEvent.Dimension(
"availabilityZone", cluster.getPartition()),
new ResourceAvailabilityEvent.Dimension("cluster", cluster.getName())));
}
}
for (final Map.Entry<ResourceAvailabilityEvent.ResourceType, AvailabilityAccumulator> entry :
availabilities.entrySet()) {
resourceAvailabilityEvents.add(
new ResourceAvailabilityEvent(entry.getKey(), entry.getValue().availabilities));
}
for (final ResourceAvailabilityEvent resourceAvailabilityEvent : resourceAvailabilityEvents)
try {
ListenerRegistry.getInstance().fireEvent(resourceAvailabilityEvent);
} catch (Exception ex) {
logger.error(ex, ex);
}
}
}
protected void init() {
final ArrayList<ObjectTemplateWithChanged> objectTemplates =
Lists.newArrayList(
new ObjectTemplateWithChanged(
ObjectType.AS_BLOCK,
7,
new AttributeTemplate(AS_BLOCK, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(DESCR, OPTIONAL, MULTIPLE),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(ORG, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_LOWER, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.AS_SET,
9,
new AttributeTemplate(AS_SET, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(DESCR, MANDATORY, MULTIPLE),
new AttributeTemplate(MEMBERS, OPTIONAL, MULTIPLE),
new AttributeTemplate(MBRS_BY_REF, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(ORG, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(TECH_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(ADMIN_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_LOWER, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.AUT_NUM,
8,
new AttributeTemplate(AUT_NUM, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(AS_NAME, MANDATORY, SINGLE),
new AttributeTemplate(DESCR, MANDATORY, MULTIPLE),
new AttributeTemplate(MEMBER_OF, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(IMPORT_VIA, OPTIONAL, MULTIPLE, USER_ORDER),
new AttributeTemplate(IMPORT, OPTIONAL, MULTIPLE, USER_ORDER),
new AttributeTemplate(MP_IMPORT, OPTIONAL, MULTIPLE, USER_ORDER),
new AttributeTemplate(EXPORT_VIA, OPTIONAL, MULTIPLE, USER_ORDER),
new AttributeTemplate(EXPORT, OPTIONAL, MULTIPLE, USER_ORDER),
new AttributeTemplate(MP_EXPORT, OPTIONAL, MULTIPLE, USER_ORDER),
new AttributeTemplate(DEFAULT, OPTIONAL, MULTIPLE, USER_ORDER),
new AttributeTemplate(MP_DEFAULT, OPTIONAL, MULTIPLE, USER_ORDER),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(ORG, OPTIONAL, SINGLE, INVERSE_KEY),
new AttributeTemplate(SPONSORING_ORG, OPTIONAL, SINGLE),
new AttributeTemplate(ADMIN_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(TECH_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(STATUS, GENERATED, SINGLE),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_LOWER, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_ROUTES, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.DOMAIN,
30,
new AttributeTemplate(DOMAIN, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(DESCR, MANDATORY, MULTIPLE),
new AttributeTemplate(ORG, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(ADMIN_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(TECH_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(ZONE_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(NSERVER, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(DS_RDATA, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.FILTER_SET,
21,
new AttributeTemplate(FILTER_SET, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(DESCR, MANDATORY, MULTIPLE),
new AttributeTemplate(FILTER, OPTIONAL, SINGLE),
new AttributeTemplate(MP_FILTER, OPTIONAL, SINGLE),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(ORG, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(TECH_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(ADMIN_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_LOWER, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.INET_RTR,
15,
new AttributeTemplate(INET_RTR, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(DESCR, MANDATORY, MULTIPLE),
new AttributeTemplate(ALIAS, OPTIONAL, MULTIPLE),
new AttributeTemplate(LOCAL_AS, MANDATORY, SINGLE, INVERSE_KEY),
new AttributeTemplate(IFADDR, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(INTERFACE, OPTIONAL, MULTIPLE),
new AttributeTemplate(PEER, OPTIONAL, MULTIPLE),
new AttributeTemplate(MP_PEER, OPTIONAL, MULTIPLE),
new AttributeTemplate(MEMBER_OF, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(ORG, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(ADMIN_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(TECH_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.INET6NUM,
6,
new AttributeTemplate(INET6NUM, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(NETNAME, MANDATORY, SINGLE, LOOKUP_KEY),
new AttributeTemplate(DESCR, MANDATORY, MULTIPLE),
new AttributeTemplate(COUNTRY, MANDATORY, MULTIPLE),
new AttributeTemplate(GEOLOC, OPTIONAL, SINGLE),
new AttributeTemplate(LANGUAGE, OPTIONAL, MULTIPLE),
new AttributeTemplate(ORG, OPTIONAL, SINGLE, INVERSE_KEY),
new AttributeTemplate(SPONSORING_ORG, OPTIONAL, SINGLE),
new AttributeTemplate(ADMIN_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(TECH_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(STATUS, MANDATORY, SINGLE),
new AttributeTemplate(ASSIGNMENT_SIZE, OPTIONAL, SINGLE),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_LOWER, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_ROUTES, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_DOMAINS, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_IRT, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.INETNUM,
5,
new AttributeTemplate(INETNUM, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(NETNAME, MANDATORY, SINGLE, LOOKUP_KEY),
new AttributeTemplate(DESCR, MANDATORY, MULTIPLE),
new AttributeTemplate(COUNTRY, MANDATORY, MULTIPLE),
new AttributeTemplate(GEOLOC, OPTIONAL, SINGLE),
new AttributeTemplate(LANGUAGE, OPTIONAL, MULTIPLE),
new AttributeTemplate(ORG, OPTIONAL, SINGLE, INVERSE_KEY),
new AttributeTemplate(SPONSORING_ORG, OPTIONAL, SINGLE),
new AttributeTemplate(ADMIN_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(TECH_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(STATUS, MANDATORY, SINGLE),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_LOWER, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_DOMAINS, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_ROUTES, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_IRT, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.IRT,
41,
new AttributeTemplate(IRT, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(ADDRESS, MANDATORY, MULTIPLE),
new AttributeTemplate(PHONE, OPTIONAL, MULTIPLE),
new AttributeTemplate(FAX_NO, OPTIONAL, MULTIPLE),
new AttributeTemplate(E_MAIL, MANDATORY, MULTIPLE, LOOKUP_KEY),
new AttributeTemplate(ABUSE_MAILBOX, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(SIGNATURE, OPTIONAL, MULTIPLE),
new AttributeTemplate(ENCRYPTION, OPTIONAL, MULTIPLE),
new AttributeTemplate(ORG, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(ADMIN_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(TECH_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(AUTH, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(IRT_NFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.KEY_CERT,
45,
new AttributeTemplate(KEY_CERT, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(METHOD, GENERATED, SINGLE),
new AttributeTemplate(OWNER, GENERATED, MULTIPLE),
new AttributeTemplate(FINGERPR, GENERATED, SINGLE, INVERSE_KEY),
new AttributeTemplate(CERTIF, MANDATORY, MULTIPLE),
new AttributeTemplate(ORG, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(ADMIN_C, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(TECH_C, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.MNTNER,
40,
new AttributeTemplate(MNTNER, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(DESCR, MANDATORY, MULTIPLE),
new AttributeTemplate(ORG, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(ADMIN_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(TECH_C, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(UPD_TO, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_NFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(AUTH, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(ABUSE_MAILBOX, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.ORGANISATION,
48,
new AttributeTemplate(ORGANISATION, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(ORG_NAME, MANDATORY, SINGLE, LOOKUP_KEY),
new AttributeTemplate(ORG_TYPE, MANDATORY, SINGLE),
new AttributeTemplate(DESCR, OPTIONAL, MULTIPLE),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(ADDRESS, MANDATORY, MULTIPLE),
new AttributeTemplate(PHONE, OPTIONAL, MULTIPLE),
new AttributeTemplate(FAX_NO, OPTIONAL, MULTIPLE),
new AttributeTemplate(E_MAIL, MANDATORY, MULTIPLE, LOOKUP_KEY),
new AttributeTemplate(GEOLOC, OPTIONAL, SINGLE),
new AttributeTemplate(LANGUAGE, OPTIONAL, MULTIPLE),
new AttributeTemplate(ORG, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(ADMIN_C, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(TECH_C, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(ABUSE_C, OPTIONAL, SINGLE, INVERSE_KEY),
new AttributeTemplate(REF_NFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_REF, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(ABUSE_MAILBOX, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.PEERING_SET,
22,
new AttributeTemplate(PEERING_SET, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(DESCR, MANDATORY, MULTIPLE),
new AttributeTemplate(PEERING, OPTIONAL, MULTIPLE),
new AttributeTemplate(MP_PEERING, OPTIONAL, MULTIPLE),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(ORG, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(TECH_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(ADMIN_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_LOWER, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.PERSON,
50,
new AttributeTemplate(PERSON, MANDATORY, SINGLE, LOOKUP_KEY),
new AttributeTemplate(ADDRESS, MANDATORY, MULTIPLE),
new AttributeTemplate(PHONE, MANDATORY, MULTIPLE),
new AttributeTemplate(FAX_NO, OPTIONAL, MULTIPLE),
new AttributeTemplate(E_MAIL, OPTIONAL, MULTIPLE, LOOKUP_KEY),
new AttributeTemplate(ORG, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(NIC_HDL, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(ABUSE_MAILBOX, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.POEM,
37,
new AttributeTemplate(POEM, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(DESCR, OPTIONAL, MULTIPLE),
new AttributeTemplate(FORM, MANDATORY, SINGLE, INVERSE_KEY),
new AttributeTemplate(TEXT, MANDATORY, MULTIPLE),
new AttributeTemplate(AUTHOR, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, SINGLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.POETIC_FORM,
36,
new AttributeTemplate(POETIC_FORM, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(DESCR, OPTIONAL, MULTIPLE),
new AttributeTemplate(ADMIN_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.ROLE,
49,
new AttributeTemplate(ROLE, MANDATORY, SINGLE, LOOKUP_KEY),
new AttributeTemplate(ADDRESS, MANDATORY, MULTIPLE),
new AttributeTemplate(PHONE, OPTIONAL, MULTIPLE),
new AttributeTemplate(FAX_NO, OPTIONAL, MULTIPLE),
new AttributeTemplate(E_MAIL, MANDATORY, MULTIPLE, LOOKUP_KEY),
new AttributeTemplate(ORG, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(ADMIN_C, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(TECH_C, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(NIC_HDL, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(ABUSE_MAILBOX, OPTIONAL, SINGLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.ROUTE_SET,
12,
new AttributeTemplate(ROUTE_SET, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(DESCR, MANDATORY, MULTIPLE),
new AttributeTemplate(MEMBERS, OPTIONAL, MULTIPLE),
new AttributeTemplate(MP_MEMBERS, OPTIONAL, MULTIPLE),
new AttributeTemplate(MBRS_BY_REF, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(ORG, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(TECH_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(ADMIN_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_LOWER, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.ROUTE,
10,
new AttributeTemplate(ROUTE, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(DESCR, MANDATORY, MULTIPLE),
new AttributeTemplate(ORIGIN, MANDATORY, SINGLE, PRIMARY_KEY, INVERSE_KEY),
new AttributeTemplate(PINGABLE, OPTIONAL, MULTIPLE),
new AttributeTemplate(PING_HDL, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(HOLES, OPTIONAL, MULTIPLE),
new AttributeTemplate(ORG, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MEMBER_OF, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(INJECT, OPTIONAL, MULTIPLE),
new AttributeTemplate(AGGR_MTD, OPTIONAL, SINGLE),
new AttributeTemplate(AGGR_BNDRY, OPTIONAL, SINGLE),
new AttributeTemplate(EXPORT_COMPS, OPTIONAL, SINGLE),
new AttributeTemplate(COMPONENTS, OPTIONAL, SINGLE),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_LOWER, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_ROUTES, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.ROUTE6,
11,
new AttributeTemplate(ROUTE6, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(DESCR, MANDATORY, MULTIPLE),
new AttributeTemplate(ORIGIN, MANDATORY, SINGLE, PRIMARY_KEY, INVERSE_KEY),
new AttributeTemplate(PINGABLE, OPTIONAL, MULTIPLE),
new AttributeTemplate(PING_HDL, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(HOLES, OPTIONAL, MULTIPLE),
new AttributeTemplate(ORG, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MEMBER_OF, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(INJECT, OPTIONAL, MULTIPLE),
new AttributeTemplate(AGGR_MTD, OPTIONAL, SINGLE),
new AttributeTemplate(AGGR_BNDRY, OPTIONAL, SINGLE),
new AttributeTemplate(EXPORT_COMPS, OPTIONAL, SINGLE),
new AttributeTemplate(COMPONENTS, OPTIONAL, SINGLE),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_LOWER, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_ROUTES, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)),
new ObjectTemplateWithChanged(
ObjectType.RTR_SET,
23,
new AttributeTemplate(RTR_SET, MANDATORY, SINGLE, PRIMARY_KEY, LOOKUP_KEY),
new AttributeTemplate(DESCR, MANDATORY, MULTIPLE),
new AttributeTemplate(MEMBERS, OPTIONAL, MULTIPLE),
new AttributeTemplate(MP_MEMBERS, OPTIONAL, MULTIPLE),
new AttributeTemplate(MBRS_BY_REF, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(REMARKS, OPTIONAL, MULTIPLE),
new AttributeTemplate(ORG, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(TECH_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(ADMIN_C, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(NOTIFY, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_BY, MANDATORY, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(MNT_LOWER, OPTIONAL, MULTIPLE, INVERSE_KEY),
new AttributeTemplate(CHANGED, DEPRECATED, MULTIPLE),
new AttributeTemplate(CREATED, GENERATED, SINGLE),
new AttributeTemplate(LAST_MODIFIED, GENERATED, SINGLE),
new AttributeTemplate(SOURCE, MANDATORY, SINGLE)));
final Map<ObjectType, ObjectTemplate> templateMap = Maps.newEnumMap(ObjectType.class);
for (final ObjectTemplate objectTemplate : objectTemplates) {
templateMap.put(objectTemplate.getObjectType(), objectTemplate);
}
TEMPLATE_MAP = Collections.unmodifiableMap(templateMap);
}
@Override
public void generateChunkMesh(ChunkView view, ChunkMesh chunkMesh, int x, int y, int z) {
Biome selfBiome = view.getBiome(x, y, z);
Block selfBlock = view.getBlock(x, y, z);
// TODO: Needs review - too much hardcoded special cases and corner cases resulting from this.
ChunkVertexFlag vertexFlag = ChunkVertexFlag.NORMAL;
if (selfBlock.isWater()) {
if (view.getBlock(x, y + 1, z).isWater()) {
vertexFlag = ChunkVertexFlag.WATER;
} else {
vertexFlag = ChunkVertexFlag.WATER_SURFACE;
}
} else if (selfBlock.isLava()) {
vertexFlag = ChunkVertexFlag.LAVA;
} else if (selfBlock.isWaving() && selfBlock.isDoubleSided()) {
vertexFlag = ChunkVertexFlag.WAVING;
} else if (selfBlock.isWaving()) {
vertexFlag = ChunkVertexFlag.WAVING_BLOCK;
}
// Gather adjacent blocks
Map<Side, Block> adjacentBlocks = Maps.newEnumMap(Side.class);
for (Side side : Side.values()) {
Vector3i offset = side.getVector3i();
Block blockToCheck = view.getBlock(x + offset.x, y + offset.y, z + offset.z);
adjacentBlocks.put(side, blockToCheck);
}
BlockAppearance blockAppearance = selfBlock.getAppearance(adjacentBlocks);
/*
* Determine the render process.
*/
ChunkMesh.RenderType renderType = ChunkMesh.RenderType.TRANSLUCENT;
if (!selfBlock.isTranslucent()) {
renderType = ChunkMesh.RenderType.OPAQUE;
}
// TODO: Review special case, or alternatively compare uris.
if (selfBlock.isWater() || selfBlock.isIce()) {
renderType = ChunkMesh.RenderType.WATER_AND_ICE;
}
if (selfBlock.isDoubleSided()) {
renderType = ChunkMesh.RenderType.BILLBOARD;
}
if (blockAppearance.getPart(BlockPart.CENTER) != null) {
Vector4f colorOffset = selfBlock.calcColorOffsetFor(BlockPart.CENTER, selfBiome);
blockAppearance
.getPart(BlockPart.CENTER)
.appendTo(chunkMesh, x, y, z, colorOffset, renderType, vertexFlag);
}
boolean[] drawDir = new boolean[6];
for (Side side : Side.values()) {
drawDir[side.ordinal()] =
blockAppearance.getPart(BlockPart.fromSide(side)) != null
&& isSideVisibleForBlockTypes(adjacentBlocks.get(side), selfBlock, side);
}
// If the selfBlock is lowered, some more faces may have to be drawn
if (selfBlock.isLiquid()) {
Block bottomBlock = adjacentBlocks.get(Side.BOTTOM);
// Draw horizontal sides if visible from below
for (Side side : Side.horizontalSides()) {
Vector3i offset = side.getVector3i();
Block adjacentBelow = view.getBlock(x + offset.x, y - 1, z + offset.z);
Block adjacent = adjacentBlocks.get(side);
boolean visible =
(blockAppearance.getPart(BlockPart.fromSide(side)) != null
&& isSideVisibleForBlockTypes(adjacentBelow, selfBlock, side)
&& !isSideVisibleForBlockTypes(bottomBlock, adjacent, side.reverse()));
drawDir[side.ordinal()] |= visible;
}
// Draw the top if below a non-lowered selfBlock
// TODO: Don't need to render the top if each side and the selfBlock above each side are
// either liquid or opaque solids.
Block blockToCheck = adjacentBlocks.get(Side.TOP);
drawDir[Side.TOP.ordinal()] |= !blockToCheck.isLiquid();
if (bottomBlock.isLiquid() || bottomBlock.isInvisible()) {
for (Side dir : Side.values()) {
if (drawDir[dir.ordinal()]) {
Vector4f colorOffset = selfBlock.calcColorOffsetFor(BlockPart.fromSide(dir), selfBiome);
selfBlock
.getLoweredLiquidMesh(dir)
.appendTo(chunkMesh, x, y, z, colorOffset, renderType, vertexFlag);
}
}
return;
}
}
for (Side dir : Side.values()) {
if (drawDir[dir.ordinal()]) {
Vector4f colorOffset = selfBlock.calcColorOffsetFor(BlockPart.fromSide(dir), selfBiome);
// TODO: Needs review since the new per-vertex flags introduce a lot of special scenarios -
// probably a per-side setting?
if (selfBlock.isGrass() && dir != Side.TOP && dir != Side.BOTTOM) {
blockAppearance
.getPart(BlockPart.fromSide(dir))
.appendTo(chunkMesh, x, y, z, colorOffset, renderType, ChunkVertexFlag.COLOR_MASK);
} else {
// if(dir == Side.TOP) logger.info("Generating: " + (new Vector3i(x, y, z)).toString() + "
// " + view.getChunkRegion().toString() + " " + dir.toString());
blockAppearance
.getPart(BlockPart.fromSide(dir))
.appendTo(chunkMesh, x, y, z, colorOffset, renderType, vertexFlag);
}
}
}
}
static {
final IndexStrategy[] indexStrategies = {
new IndexWithReference(AttributeType.ABUSE_C, "abuse_c", "pe_ro_id"),
new IndexWithValueAndType(AttributeType.ABUSE_MAILBOX, "abuse_mailbox", "abuse_mailbox"),
new Unindexed(AttributeType.ADDRESS),
new IndexWithReference(AttributeType.ADMIN_C, "admin_c", "pe_ro_id"),
new Unindexed(AttributeType.AGGR_BNDRY),
new Unindexed(AttributeType.AGGR_MTD),
new Unindexed(AttributeType.ALIAS),
new Unindexed(AttributeType.ASSIGNMENT_SIZE),
new IndexWithAsBlock(AttributeType.AS_BLOCK),
new Unindexed(AttributeType.AS_NAME),
new IndexWithValue(AttributeType.AS_SET, "as_set", "as_set"),
new IndexWithAuth(AttributeType.AUTH, "auth", "auth"),
new IndexWithReference(AttributeType.AUTHOR, "author", "pe_ro_id"),
new IndexWithValue(AttributeType.AUT_NUM, "aut_num", "aut_num"),
new Unindexed(AttributeType.CERTIF),
new Unindexed(AttributeType.CHANGED),
new Unindexed(AttributeType.COMPONENTS),
new Unindexed(AttributeType.COUNTRY),
new Unindexed(AttributeType.DEFAULT),
new Unindexed(AttributeType.DESCR),
new IndexWithValue(AttributeType.DOMAIN, "domain", "domain"),
new IndexWithValue(AttributeType.DS_RDATA, "ds_rdata", "ds_rdata"),
new Unindexed(AttributeType.ENCRYPTION),
new Unindexed(AttributeType.EXPORT),
new Unindexed(AttributeType.EXPORT_VIA),
new Unindexed(AttributeType.EXPORT_COMPS),
new IndexWithValueAndType(AttributeType.E_MAIL, "e_mail", "e_mail"),
new Unindexed(AttributeType.FAX_NO),
new Unindexed(AttributeType.FILTER),
new IndexWithValue(AttributeType.FILTER_SET, "filter_set", "filter_set"),
new IndexWithValue(AttributeType.FINGERPR, "fingerpr", "fingerpr"),
new IndexWithReference(AttributeType.FORM, "form", "form_id"),
new Unindexed(AttributeType.GEOLOC),
new Unindexed(AttributeType.HOLES),
new IndexWithIfAddr(AttributeType.IFADDR),
new Unindexed(AttributeType.IMPORT),
new Unindexed(AttributeType.IMPORT_VIA),
new IndexWithInet6num(AttributeType.INET6NUM),
new IndexWithInetnum(AttributeType.INETNUM),
new IndexWithValue(AttributeType.INET_RTR, "inet_rtr", "inet_rtr"),
new Unindexed(AttributeType.INJECT),
new Unindexed(AttributeType.INTERFACE),
new IndexWithValue(AttributeType.IRT, "irt", "irt"),
new IndexWithValue(AttributeType.IRT_NFY, "irt_nfy", "irt_nfy"),
new IndexWithValue(AttributeType.KEY_CERT, "key_cert", "key_cert"),
new Unindexed(AttributeType.LANGUAGE),
new IndexWithLocalAs(AttributeType.LOCAL_AS),
new IndexWithReference(AttributeType.MBRS_BY_REF, "mbrs_by_ref", "mnt_id"),
new Unindexed(AttributeType.MEMBERS),
new IndexWithMemberOf(AttributeType.MEMBER_OF),
new Unindexed(AttributeType.METHOD),
new IndexWithMaintainer(AttributeType.MNTNER, "mntner", "mntner"),
new IndexWithReference(AttributeType.MNT_BY, "mnt_by", "mnt_id"),
new IndexWithReference(AttributeType.MNT_DOMAINS, "mnt_domains", "mnt_id"),
new IndexWithReference(AttributeType.MNT_IRT, "mnt_irt", "irt_id"),
new IndexWithReference(AttributeType.MNT_LOWER, "mnt_lower", "mnt_id"),
new IndexWithValue(AttributeType.MNT_NFY, "mnt_nfy", "mnt_nfy"),
new IndexWithReference(AttributeType.MNT_REF, "mnt_ref", "mnt_id"),
new IndexWithMntRoutes(AttributeType.MNT_ROUTES),
new Unindexed(AttributeType.MP_DEFAULT),
new Unindexed(AttributeType.MP_EXPORT),
new Unindexed(AttributeType.MP_FILTER),
new Unindexed(AttributeType.MP_IMPORT),
new Unindexed(AttributeType.MP_MEMBERS),
new Unindexed(AttributeType.MP_PEER),
new Unindexed(AttributeType.MP_PEERING),
new Unindexed(
AttributeType
.NETNAME), // TODO: [AH] ATM this is handled by JdbcInetnumDao/JdbcInet6numDao as a
// special case
new IndexWithValueAndType(AttributeType.NIC_HDL, "person_role", "nic_hdl"),
new IndexWithValueAndType(AttributeType.NOTIFY, "notify", "notify"),
new IndexWithNServer(AttributeType.NSERVER, "nserver", "host"),
new IndexWithReference(AttributeType.ORG, "org", "org_id"),
new Unindexed(AttributeType.ORG_TYPE),
new IndexWithValue(AttributeType.ORGANISATION, "organisation", "organisation"),
new IndexWithName(AttributeType.ORG_NAME, "org_name"),
new IndexWithOrigin(AttributeType.ORIGIN),
new Unindexed(AttributeType.OWNER),
new Unindexed(AttributeType.PEER),
new Unindexed(AttributeType.PEERING),
new IndexWithValue(AttributeType.PEERING_SET, "peering_set", "peering_set"),
new IndexWithNameAndType(AttributeType.PERSON, ObjectType.PERSON, "names"),
new Unindexed(AttributeType.PHONE),
new IndexWithReference(AttributeType.PING_HDL, "ping_hdl", "pe_ro_id"),
new Unindexed(AttributeType.PINGABLE),
new IndexWithValue(AttributeType.POEM, "poem", "poem"),
new IndexWithValue(AttributeType.POETIC_FORM, "poetic_form", "poetic_form"),
new IndexWithReference(AttributeType.REFERRAL_BY, "referral_by", "mnt_id"),
new IndexWithValue(AttributeType.REF_NFY, "ref_nfy", "ref_nfy"),
new Unindexed(AttributeType.REMARKS),
new IndexWithNameAndType(AttributeType.ROLE, ObjectType.ROLE, "names"),
new IndexWithRoute(AttributeType.ROUTE),
new IndexWithRoute6(AttributeType.ROUTE6),
new IndexWithValue(AttributeType.ROUTE_SET, "route_set", "route_set"),
new IndexWithValue(AttributeType.RTR_SET, "rtr_set", "rtr_set"),
new Unindexed(AttributeType.SIGNATURE),
new Unindexed(AttributeType.SOURCE),
new IndexWithReference(AttributeType.SPONSORING_ORG, "sponsoring_org", "org_id"),
new Unindexed(AttributeType.STATUS),
new IndexWithReference(AttributeType.TECH_C, "tech_c", "pe_ro_id"),
new Unindexed(AttributeType.TEXT),
new IndexWithValue(AttributeType.UPD_TO, "upd_to", "upd_to"),
new IndexWithReference(AttributeType.ZONE_C, "zone_c", "pe_ro_id")
};
final Map<AttributeType, IndexStrategy> indexByAttribute = Maps.newEnumMap(AttributeType.class);
for (final IndexStrategy indexStrategy : indexStrategies) {
final AttributeType attributeType = indexStrategy.getAttributeType();
final IndexStrategy previous = indexByAttribute.put(attributeType, indexStrategy);
Validate.isTrue(previous == null, "Multiple definitions for: " + attributeType);
}
INDEX_BY_ATTRIBUTE = Collections.unmodifiableMap(indexByAttribute);
final Map<ObjectType, List<IndexStrategy>> indexesReferingObject =
Maps.newEnumMap(ObjectType.class);
for (final ObjectType objectType : ObjectType.values()) {
final List<IndexStrategy> indexesRefererringCurrentObject = Lists.newArrayList();
for (final IndexStrategy indexStrategy : indexStrategies) {
if (indexStrategy.getAttributeType().getReferences().contains(objectType)) {
indexesRefererringCurrentObject.add(indexStrategy);
}
}
indexesReferingObject.put(
objectType, Collections.unmodifiableList(indexesRefererringCurrentObject));
}
INDEXES_REFERING_OBJECT = Collections.unmodifiableMap(indexesReferingObject);
}
@SuppressWarnings("unchecked")
public class NMS {
private NMS() {
// util class
}
private static final float DEFAULT_SPEED = 0.4F;
private static Map<Class<?>, Integer> ENTITY_CLASS_TO_INT;
private static final Map<Class<?>, Constructor<?>> ENTITY_CONSTRUCTOR_CACHE =
new WeakHashMap<Class<?>, Constructor<?>>();
private static Map<Integer, Class<?>> ENTITY_INT_TO_CLASS;
private static Field GOAL_FIELD;
private static Field LAND_SPEED_MODIFIER_FIELD;
private static final Map<EntityType, Float> MOVEMENT_SPEEDS = Maps.newEnumMap(EntityType.class);
private static Field NAVIGATION_WORLD_FIELD;
private static final Location packetCacheLocation = new Location(null, 0, 0, 0);
private static Field PATHFINDING_RANGE;
private static final Random RANDOM = Util.getFastRandom();
private static Field SPEED_FIELD;
private static Field THREAD_STOPPER;
public static void addOrRemoveFromPlayerList(LivingEntity bukkitEntity, boolean remove) {
if (bukkitEntity == null) return;
EntityLiving handle = getHandle(bukkitEntity);
if (handle.world == null) return;
if (remove) {
handle.world.players.remove(handle);
} else if (!handle.world.players.contains(handle)) {
handle.world.players.add(handle);
}
}
public static void attack(EntityLiving handle, Entity target) {
int damage = handle instanceof EntityMonster ? ((EntityMonster) handle).c(target) : 2;
if (handle.hasEffect(MobEffectList.INCREASE_DAMAGE)) {
damage += 3 << handle.getEffect(MobEffectList.INCREASE_DAMAGE).getAmplifier();
}
if (handle.hasEffect(MobEffectList.WEAKNESS)) {
damage -= 2 << handle.getEffect(MobEffectList.WEAKNESS).getAmplifier();
}
int knockbackLevel = 0;
if (target instanceof EntityLiving) {
damage += EnchantmentManager.a(handle, (EntityLiving) target);
knockbackLevel +=
EnchantmentManager.getKnockbackEnchantmentLevel(handle, (EntityLiving) target);
}
boolean success = target.damageEntity(DamageSource.mobAttack(handle), damage);
if (!success) return;
if (knockbackLevel > 0) {
target.g(
-MathHelper.sin((float) (handle.yaw * Math.PI / 180.0F)) * knockbackLevel * 0.5F,
0.1D,
MathHelper.cos((float) (handle.yaw * Math.PI / 180.0F)) * knockbackLevel * 0.5F);
handle.motX *= 0.6D;
handle.motZ *= 0.6D;
}
int fireAspectLevel = EnchantmentManager.getFireAspectEnchantmentLevel(handle);
if (fireAspectLevel > 0) target.setOnFire(fireAspectLevel * 4);
}
public static void clearGoals(PathfinderGoalSelector... goalSelectors) {
if (GOAL_FIELD == null || goalSelectors == null) return;
for (PathfinderGoalSelector selector : goalSelectors) {
try {
List<?> list = (List<?>) NMS.GOAL_FIELD.get(selector);
list.clear();
} catch (Exception e) {
Messaging.logTr(Messages.ERROR_CLEARING_GOALS, e.getMessage());
}
}
}
private static Constructor<?> getCustomEntityConstructor(Class<?> clazz, EntityType type)
throws SecurityException, NoSuchMethodException {
Constructor<?> constructor = ENTITY_CONSTRUCTOR_CACHE.get(clazz);
if (constructor == null) {
constructor = clazz.getConstructor(World.class);
constructor.setAccessible(true);
ENTITY_CLASS_TO_INT.put(clazz, (int) type.getTypeId());
ENTITY_CONSTRUCTOR_CACHE.put(clazz, constructor);
}
return constructor;
}
public static Field getField(Class<?> clazz, String field) {
Field f = null;
try {
f = clazz.getDeclaredField(field);
f.setAccessible(true);
} catch (Exception e) {
Messaging.logTr(Messages.ERROR_GETTING_FIELD, field, e.getMessage());
}
return f;
}
public static EntityLiving getHandle(LivingEntity entity) {
return ((CraftLivingEntity) entity).getHandle();
}
public static float getHeadYaw(EntityLiving handle) {
return handle.aA;
}
public static float getSpeedFor(NPC npc) {
EntityType entityType = npc.getBukkitEntity().getType();
Float cached = MOVEMENT_SPEEDS.get(entityType);
if (cached != null) return cached;
if (SPEED_FIELD == null) {
MOVEMENT_SPEEDS.put(entityType, DEFAULT_SPEED);
return DEFAULT_SPEED;
}
try {
float speed = SPEED_FIELD.getFloat(((CraftEntity) npc.getBukkitEntity()).getHandle());
MOVEMENT_SPEEDS.put(entityType, speed);
return speed;
} catch (IllegalAccessException ex) {
ex.printStackTrace();
return DEFAULT_SPEED;
}
}
public static boolean inWater(LivingEntity entity) {
EntityLiving mcEntity = getHandle(entity);
return mcEntity.G() || mcEntity.I();
}
public static void loadPlugins() {
((CraftServer) Bukkit.getServer()).enablePlugins(PluginLoadOrder.POSTWORLD);
}
public static void look(EntityLiving handle, Entity target) {
handle.getControllerLook().a(target, 10.0F, handle.bs());
}
public static void look(LivingEntity bukkitEntity, float yaw, float pitch) {
EntityLiving handle = getHandle(bukkitEntity);
handle.yaw = yaw;
setHeadYaw(handle, yaw);
handle.pitch = pitch;
}
public static float modifiedSpeed(float baseSpeed, NPC npc) {
return npc == null
? baseSpeed
: baseSpeed * npc.getNavigator().getLocalParameters().speedModifier();
}
public static void registerEntityClass(Class<?> clazz) {
if (ENTITY_CLASS_TO_INT.containsKey(clazz)) return;
Class<?> search = clazz;
while ((search = search.getSuperclass()) != null && Entity.class.isAssignableFrom(search)) {
if (!ENTITY_CLASS_TO_INT.containsKey(search)) continue;
int code = ENTITY_CLASS_TO_INT.get(search);
ENTITY_INT_TO_CLASS.put(code, clazz);
ENTITY_CLASS_TO_INT.put(clazz, code);
return;
}
throw new IllegalArgumentException("unable to find valid entity superclass");
}
public static void removeFromServerPlayerList(Player player) {
EntityPlayer handle = ((CraftPlayer) player).getHandle();
((CraftServer) Bukkit.getServer()).getHandle().players.remove(handle);
}
public static void sendPacket(Player player, Packet packet) {
((CraftPlayer) player).getHandle().playerConnection.sendPacket(packet);
}
public static void sendPacketNearby(Location location, Packet packet) {
NMS.sendPacketsNearby(location, Arrays.asList(packet), 64);
}
public static void sendPacketsNearby(Location location, Collection<Packet> packets) {
NMS.sendPacketsNearby(location, packets, 64);
}
public static void sendPacketsNearby(
Location location, Collection<Packet> packets, double radius) {
radius *= radius;
final org.bukkit.World world = location.getWorld();
for (Player ply : Bukkit.getServer().getOnlinePlayers()) {
if (ply == null || world != ply.getWorld()) {
continue;
}
if (location.distanceSquared(ply.getLocation(packetCacheLocation)) > radius) {
continue;
}
for (Packet packet : packets) {
sendPacket(ply, packet);
}
}
}
public static void sendPacketsNearby(Location location, Packet... packets) {
NMS.sendPacketsNearby(location, Arrays.asList(packets), 64);
}
public static void sendToOnline(Packet... packets) {
Validate.notNull(packets, "packets cannot be null");
for (Player player : Bukkit.getOnlinePlayers()) {
if (player == null || !player.isOnline()) continue;
for (Packet packet : packets) {
sendPacket(player, packet);
}
}
}
public static void setDestination(
LivingEntity bukkitEntity, double x, double y, double z, float speed) {
((CraftLivingEntity) bukkitEntity).getHandle().getControllerMove().a(x, y, z, speed);
}
public static void setHeadYaw(EntityLiving handle, float yaw) {
while (yaw < -180.0F) {
yaw += 360.0F;
}
while (yaw >= 180.0F) {
yaw -= 360.0F;
}
handle.aA = yaw;
if (!(handle instanceof EntityHuman)) handle.ay = yaw;
handle.aB = yaw;
}
public static void setLandSpeedModifier(EntityLiving handle, float speed) {
if (LAND_SPEED_MODIFIER_FIELD == null) return;
try {
LAND_SPEED_MODIFIER_FIELD.setFloat(handle, speed);
} catch (Exception e) {
Messaging.logTr(Messages.ERROR_UPDATING_SPEED, e.getMessage());
}
}
public static void setShouldJump(LivingEntity entity) {
ControllerJump controller = getHandle(entity).getControllerJump();
controller.a();
}
public static org.bukkit.entity.Entity spawnCustomEntity(
org.bukkit.World world, Location at, Class<? extends Entity> clazz, EntityType type) {
World handle = ((CraftWorld) world).getHandle();
Entity entity = null;
try {
Constructor<?> constructor = getCustomEntityConstructor(clazz, type);
entity = (Entity) constructor.newInstance(handle);
} catch (Exception e) {
Messaging.logTr(Messages.ERROR_SPAWNING_CUSTOM_ENTITY, e.getMessage());
return null;
}
handle.addEntity(entity);
entity.setLocation(at.getX(), at.getY(), at.getZ(), at.getYaw(), at.getPitch());
return entity.getBukkitEntity();
}
public static void stopNetworkThreads(NetworkManager manager) {
if (THREAD_STOPPER == null) return;
try {
THREAD_STOPPER.set(manager, false);
} catch (Exception e) {
Messaging.logTr(Messages.ERROR_STOPPING_NETWORK_THREADS, e.getMessage());
}
}
public static void trySwim(LivingEntity handle) {
trySwim(handle, 0.04F);
}
public static void trySwim(LivingEntity entity, float power) {
Entity handle = getHandle(entity);
if (RANDOM.nextFloat() < 0.8F && inWater(entity)) {
handle.motY += power;
}
}
public static void updateAI(EntityLiving entity) {
updateSenses(entity);
entity.getNavigation().e();
entity.getControllerMove().c();
entity.getControllerLook().a();
entity.getControllerJump().b();
}
public static void updateNavigationWorld(LivingEntity entity, org.bukkit.World world) {
if (NAVIGATION_WORLD_FIELD == null) return;
EntityLiving handle = ((CraftLivingEntity) entity).getHandle();
World worldHandle = ((CraftWorld) world).getHandle();
try {
NAVIGATION_WORLD_FIELD.set(handle.getNavigation(), worldHandle);
} catch (Exception e) {
Messaging.logTr(Messages.ERROR_UPDATING_NAVIGATION_WORLD, e.getMessage());
}
}
public static void updatePathfindingRange(NPC npc, float pathfindingRange) {
if (PATHFINDING_RANGE == null) return;
Navigation navigation = ((CraftLivingEntity) npc.getBukkitEntity()).getHandle().getNavigation();
try {
PATHFINDING_RANGE.set(navigation, pathfindingRange);
} catch (Exception e) {
Messaging.logTr(Messages.ERROR_UPDATING_PATHFINDING_RANGE, e.getMessage());
}
}
public static void updateSenses(EntityLiving entity) {
entity.aD().a();
}
static {
// true field above false and three synchronised lists
THREAD_STOPPER = getField(NetworkManager.class, "n");
// constants taken from source code
MOVEMENT_SPEEDS.put(EntityType.CHICKEN, 0.25F);
MOVEMENT_SPEEDS.put(EntityType.COW, 0.2F);
MOVEMENT_SPEEDS.put(EntityType.CREEPER, 0.3F);
MOVEMENT_SPEEDS.put(EntityType.IRON_GOLEM, 0.15F);
MOVEMENT_SPEEDS.put(EntityType.MUSHROOM_COW, 0.2F);
MOVEMENT_SPEEDS.put(EntityType.OCELOT, 0.23F);
MOVEMENT_SPEEDS.put(EntityType.SHEEP, 0.25F);
MOVEMENT_SPEEDS.put(EntityType.SNOWMAN, 0.25F);
MOVEMENT_SPEEDS.put(EntityType.PIG, 0.27F);
MOVEMENT_SPEEDS.put(EntityType.PLAYER, 1F);
MOVEMENT_SPEEDS.put(EntityType.VILLAGER, 0.3F);
LAND_SPEED_MODIFIER_FIELD = getField(EntityLiving.class, "bQ");
SPEED_FIELD = getField(EntityLiving.class, "bI");
NAVIGATION_WORLD_FIELD = getField(Navigation.class, "b");
PATHFINDING_RANGE = getField(Navigation.class, "e");
GOAL_FIELD = getField(PathfinderGoalSelector.class, "a");
try {
Field field = getField(EntityTypes.class, "d");
ENTITY_INT_TO_CLASS = (Map<Integer, Class<?>>) field.get(null);
field = getField(EntityTypes.class, "e");
ENTITY_CLASS_TO_INT = (Map<Class<?>, Integer>) field.get(null);
} catch (Exception e) {
Messaging.logTr(Messages.ERROR_GETTING_ID_MAPPING, e.getMessage());
}
}
}
public class EntitySheep extends EntityAnimal {
/**
* Internal crafting inventory used to check the result of mixing dyes corresponding to the fleece
* color when breeding sheep.
*/
private final InventoryCrafting inventoryCrafting =
new InventoryCrafting(
new Container() {
private static final String __OBFID = "CL_00001649";
public boolean canInteractWith(EntityPlayer playerIn) {
return false;
}
},
2,
1);
private static final Map field_175514_bm = Maps.newEnumMap(DyeColor.class);
/**
* Used to control movement as well as wool regrowth. Set to 40 on handleHealthUpdate and counts
* down with each tick.
*/
private int sheepTimer;
private EntityAIEatGrass entityAIEatGrass = new EntityAIEatGrass(this);
private static final String __OBFID = "CL_00001648";
public static float[] func_175513_a(DyeColor p_175513_0_) {
return (float[]) field_175514_bm.get(p_175513_0_);
}
public EntitySheep(World world) {
super(world);
this.setSize(0.9F, 1.3F);
((PathNavigateGround) this.getNavigator()).func_179690_a(true);
this.tasks.addTask(0, new EntityAISwimming(this));
this.tasks.addTask(1, new EntityAIPanic(this, 1.25D));
this.tasks.addTask(2, new EntityAIMate(this, 1.0D));
this.tasks.addTask(3, new EntityAITempt(this, 1.1D, Items.wheat, false));
this.tasks.addTask(4, new EntityAIFollowParent(this, 1.1D));
this.tasks.addTask(5, this.entityAIEatGrass);
this.tasks.addTask(6, new EntityAIWander(this, 1.0D));
this.tasks.addTask(7, new EntityAIWatchClosest(this, EntityPlayer.class, 6.0F));
this.tasks.addTask(8, new EntityAILookIdle(this));
this.inventoryCrafting.set(0, new ItemStack(Items.dye, 1, 0));
this.inventoryCrafting.set(1, new ItemStack(Items.dye, 1, 0));
}
protected void updateAITasks() {
this.sheepTimer = this.entityAIEatGrass.getEatingGrassTimer();
super.updateAITasks();
}
/**
* Called frequently so the entity can update its state every tick as required. For example,
* zombies and skeletons use this to react to sunlight and start to burn.
*/
public void onLivingUpdate() {
if (this.world.isRemote) {
this.sheepTimer = Math.max(0, this.sheepTimer - 1);
}
super.onLivingUpdate();
}
protected void applyEntityAttributes() {
super.applyEntityAttributes();
this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(8.0D);
this.getEntityAttribute(SharedMonsterAttributes.movementSpeed)
.setBaseValue(0.23000000417232513D);
}
protected void entityInit() {
super.entityInit();
this.dataWatcher.addObject(16, new Byte((byte) 0));
}
/** Drop 0-2 items of this living's type */
protected void dropFewItems(boolean p_70628_1_, int p_70628_2_) {
if (!this.getSheared()) {
this.dropItem(
new ItemStack(
Item.getItemForBlock(Blocks.wool),
1,
this.func_175509_cj().getInverseDyeColorValue()),
0.0F);
}
int var3 = this.rand.nextInt(2) + 1 + this.rand.nextInt(1 + p_70628_2_);
for (int var4 = 0; var4 < var3; ++var4) {
if (this.isBurning()) {
this.dropItem(Items.cooked_mutton, 1);
} else {
this.dropItem(Items.mutton, 1);
}
}
}
protected Item getDropItem() {
return Item.getItemForBlock(Blocks.wool);
}
public void handleHealthUpdate(byte value) {
if (value == 10) {
this.sheepTimer = 40;
} else {
super.handleHealthUpdate(value);
}
}
public float getHeadRotationPointY(float p_70894_1_) {
return this.sheepTimer <= 0
? 0.0F
: (this.sheepTimer >= 4 && this.sheepTimer <= 36
? 1.0F
: (this.sheepTimer < 4
? ((float) this.sheepTimer - p_70894_1_) / 4.0F
: -((float) (this.sheepTimer - 40) - p_70894_1_) / 4.0F));
}
public float getHeadRotationAngleX(float p_70890_1_) {
if (this.sheepTimer > 4 && this.sheepTimer <= 36) {
float var2 = ((float) (this.sheepTimer - 4) - p_70890_1_) / 32.0F;
return ((float) Math.PI / 5F) + ((float) Math.PI * 7F / 100F) * M.sin(var2 * 28.7F);
} else {
return this.sheepTimer > 0 ? ((float) Math.PI / 5F) : this.pitch / (180F / (float) Math.PI);
}
}
/**
* Called when a player interacts with a mob. e.g. gets milk from a cow, gets into the saddle on a
* pig.
*/
public boolean interact(EntityPlayer player) {
ItemStack var2 = player.inventory.getCurrentItem();
if (var2 != null && var2.getItem() == Items.shears && !this.getSheared() && !this.isChild()) {
if (!this.world.isRemote) {
this.setSheared(true);
int var3 = 1 + this.rand.nextInt(3);
for (int var4 = 0; var4 < var3; ++var4) {
EntityItem var5 =
this.dropItem(
new ItemStack(
Item.getItemForBlock(Blocks.wool),
1,
this.func_175509_cj().getInverseDyeColorValue()),
1.0F);
var5.motionY += (double) (this.rand.nextFloat() * 0.05F);
var5.motionX += (double) ((this.rand.nextFloat() - this.rand.nextFloat()) * 0.1F);
var5.motionZ += (double) ((this.rand.nextFloat() - this.rand.nextFloat()) * 0.1F);
}
}
var2.damageItem(1, player);
this.playSound("mob.sheep.shear", 1.0F, 1.0F);
}
return super.interact(player);
}
/** (abstract) Protected helper method to write subclass entity data to NBT. */
public void writeEntityToNBT(NBTTagCompound tag) {
super.writeEntityToNBT(tag);
tag.setBoolean("Sheared", this.getSheared());
tag.setByte("Color", (byte) this.func_175509_cj().getInverseDyeColorValue());
}
/** (abstract) Protected helper method to read subclass entity data from NBT. */
public void readEntityFromNBT(NBTTagCompound tag) {
super.readEntityFromNBT(tag);
this.setSheared(tag.getBoolean("Sheared"));
this.func_175512_b(DyeColor.getDyeColorForInverseValue(tag.getByte("Color")));
}
/** Returns the sound this mob makes while it's alive. */
protected String getLivingSound() {
return "mob.sheep.say";
}
/** Returns the sound this mob makes when it is hurt. */
protected String getHurtSound() {
return "mob.sheep.say";
}
/** Returns the sound this mob makes on death. */
protected String getDeathSound() {
return "mob.sheep.say";
}
protected void playStepSound(BlockPos p_180429_1_, IBlock p_180429_2_) {
this.playSound("mob.sheep.step", 0.15F, 1.0F);
}
public DyeColor func_175509_cj() {
return DyeColor.getDyeColorForInverseValue(this.dataWatcher.getWatchableObjectByte(16) & 15);
}
public void func_175512_b(DyeColor p_175512_1_) {
byte var2 = this.dataWatcher.getWatchableObjectByte(16);
this.dataWatcher.updateObject(
16, Byte.valueOf((byte) (var2 & 240 | p_175512_1_.getInverseDyeColorValue() & 15)));
}
/** returns true if a sheeps wool has been sheared */
public boolean getSheared() {
return (this.dataWatcher.getWatchableObjectByte(16) & 16) != 0;
}
/** make a sheep sheared if set to true */
public void setSheared(boolean p_70893_1_) {
byte var2 = this.dataWatcher.getWatchableObjectByte(16);
if (p_70893_1_) {
this.dataWatcher.updateObject(16, Byte.valueOf((byte) (var2 | 16)));
} else {
this.dataWatcher.updateObject(16, Byte.valueOf((byte) (var2 & -17)));
}
}
public static DyeColor func_175510_a(Random p_175510_0_) {
int var1 = p_175510_0_.nextInt(100);
return var1 < 5
? DyeColor.BLACK
: (var1 < 10
? DyeColor.GRAY
: (var1 < 15
? DyeColor.SILVER
: (var1 < 18
? DyeColor.BROWN
: (p_175510_0_.nextInt(500) == 0 ? DyeColor.PINK : DyeColor.WHITE))));
}
public EntitySheep func_180491_b(EntityAgeable p_180491_1_) {
EntitySheep var2 = (EntitySheep) p_180491_1_;
EntitySheep var3 = new EntitySheep(this.world);
var3.func_175512_b(this.func_175511_a(this, var2));
return var3;
}
/**
* This function applies the benefits of growing back wool and faster growing up to the acting
* entity. (This function is used in the AIEatGrass)
*/
public void eatGrassBonus() {
this.setSheared(false);
if (this.isChild()) {
this.addGrowth(60);
}
}
public IEntityLivingData setDifficulty(
DifficultyInstance p_180482_1_, IEntityLivingData p_180482_2_) {
p_180482_2_ = super.setDifficulty(p_180482_1_, p_180482_2_);
this.func_175512_b(func_175510_a(this.world.rand));
return p_180482_2_;
}
private DyeColor func_175511_a(EntityAnimal p_175511_1_, EntityAnimal p_175511_2_) {
int var3 = ((EntitySheep) p_175511_1_).func_175509_cj().getDyeColorValue();
int var4 = ((EntitySheep) p_175511_2_).func_175509_cj().getDyeColorValue();
this.inventoryCrafting.get(0).setItemDamage(var3);
this.inventoryCrafting.get(1).setItemDamage(var4);
ItemStack var5 =
CraftingManager.getInstance()
.findMatchingRecipe(this.inventoryCrafting, ((EntitySheep) p_175511_1_).world);
int var6;
if (var5 != null && var5.getItem() == Items.dye) {
var6 = var5.getMetadata();
} else {
var6 = this.world.rand.nextBoolean() ? var3 : var4;
}
return DyeColor.getDyeColorForValue(var6);
}
public float getEyeHeight() {
return 0.95F * this.height;
}
public EntityAgeable createChild(EntityAgeable p_90011_1_) {
return this.func_180491_b(p_90011_1_);
}
static {
field_175514_bm.put(DyeColor.WHITE, new float[] {1.0F, 1.0F, 1.0F});
field_175514_bm.put(DyeColor.ORANGE, new float[] {0.85F, 0.5F, 0.2F});
field_175514_bm.put(DyeColor.MAGENTA, new float[] {0.7F, 0.3F, 0.85F});
field_175514_bm.put(DyeColor.LIGHT_BLUE, new float[] {0.4F, 0.6F, 0.85F});
field_175514_bm.put(DyeColor.YELLOW, new float[] {0.9F, 0.9F, 0.2F});
field_175514_bm.put(DyeColor.LIME, new float[] {0.5F, 0.8F, 0.1F});
field_175514_bm.put(DyeColor.PINK, new float[] {0.95F, 0.5F, 0.65F});
field_175514_bm.put(DyeColor.GRAY, new float[] {0.3F, 0.3F, 0.3F});
field_175514_bm.put(DyeColor.SILVER, new float[] {0.6F, 0.6F, 0.6F});
field_175514_bm.put(DyeColor.CYAN, new float[] {0.3F, 0.5F, 0.6F});
field_175514_bm.put(DyeColor.PURPLE, new float[] {0.5F, 0.25F, 0.7F});
field_175514_bm.put(DyeColor.BLUE, new float[] {0.2F, 0.3F, 0.7F});
field_175514_bm.put(DyeColor.BROWN, new float[] {0.4F, 0.3F, 0.2F});
field_175514_bm.put(DyeColor.GREEN, new float[] {0.4F, 0.5F, 0.2F});
field_175514_bm.put(DyeColor.RED, new float[] {0.6F, 0.2F, 0.2F});
field_175514_bm.put(DyeColor.BLACK, new float[] {0.1F, 0.1F, 0.1F});
}
}
public BakedFluid(
Optional<TRSRTransformation> transformation,
ImmutableMap<TransformType, TRSRTransformation> transforms,
VertexFormat format,
int color,
TextureAtlasSprite still,
TextureAtlasSprite flowing,
boolean gas,
boolean statePresent,
int[] cornerRound,
int flowRound) {
this.transformation = transformation;
this.transforms = transforms;
this.format = format;
this.color = color;
this.still = still;
this.flowing = flowing;
this.gas = gas;
faceQuads = Maps.newEnumMap(EnumFacing.class);
for (EnumFacing side : EnumFacing.values()) {
faceQuads.put(side, ImmutableList.<BakedQuad>of());
}
if (statePresent) {
float[] y = new float[4];
for (int i = 0; i < 4; i++) {
if (gas) {
y[i] = 1 - cornerRound[i] / 768f;
} else {
y[i] = cornerRound[i] / 768f;
}
}
float flow = (float) Math.toRadians(flowRound);
// top
TextureAtlasSprite topSprite = flowing;
float scale = 4;
if (flow < -17F) {
flow = 0;
scale = 8;
topSprite = still;
}
float c = MathHelper.cos(flow) * scale;
float s = MathHelper.sin(flow) * scale;
EnumFacing side = gas ? EnumFacing.DOWN : EnumFacing.UP;
UnpackedBakedQuad.Builder builder;
ImmutableList.Builder<BakedQuad> topFaceBuilder = ImmutableList.builder();
for (int k = 0; k < 2; k++) {
builder = new UnpackedBakedQuad.Builder(format);
builder.setQuadOrientation(side);
builder.setTexture(topSprite);
for (int i = gas ? 3 : 0; i != (gas ? -1 : 4); i += (gas ? -1 : 1)) {
int l = (k * 3) + (1 - 2 * k) * i;
putVertex(
builder,
side,
x[l],
y[l],
z[l],
topSprite.getInterpolatedU(8 + c * (x[l] * 2 - 1) + s * (z[l] * 2 - 1)),
topSprite.getInterpolatedV(
8 + c * (x[(l + 1) % 4] * 2 - 1) + s * (z[(l + 1) % 4] * 2 - 1)));
}
topFaceBuilder.add(builder.build());
}
faceQuads.put(side, topFaceBuilder.build());
// bottom
side = side.getOpposite();
builder = new UnpackedBakedQuad.Builder(format);
builder.setQuadOrientation(side);
builder.setTexture(still);
for (int i = gas ? 3 : 0; i != (gas ? -1 : 4); i += (gas ? -1 : 1)) {
putVertex(
builder,
side,
z[i],
gas ? 1 : 0,
x[i],
still.getInterpolatedU(z[i] * 16),
still.getInterpolatedV(x[i] * 16));
}
faceQuads.put(side, ImmutableList.<BakedQuad>of(builder.build()));
// sides
for (int i = 0; i < 4; i++) {
side = EnumFacing.getHorizontal((5 - i) % 4);
BakedQuad q[] = new BakedQuad[2];
for (int k = 0; k < 2; k++) {
builder = new UnpackedBakedQuad.Builder(format);
builder.setQuadOrientation(side);
builder.setTexture(flowing);
for (int j = 0; j < 4; j++) {
int l = (k * 3) + (1 - 2 * k) * j;
float yl = z[l] * y[(i + x[l]) % 4];
if (gas && z[l] == 0) yl = 1;
putVertex(
builder,
side,
x[(i + x[l]) % 4],
yl,
z[(i + x[l]) % 4],
flowing.getInterpolatedU(x[l] * 8),
flowing.getInterpolatedV((gas ? yl : 1 - yl) * 8));
}
q[k] = builder.build();
}
faceQuads.put(side, ImmutableList.of(q[0], q[1]));
}
} else {
// 1 quad for inventory
UnpackedBakedQuad.Builder builder = new UnpackedBakedQuad.Builder(format);
builder.setQuadOrientation(EnumFacing.UP);
builder.setTexture(still);
for (int i = 0; i < 4; i++) {
putVertex(
builder,
EnumFacing.UP,
z[i],
x[i],
0,
still.getInterpolatedU(z[i] * 16),
still.getInterpolatedV(x[i] * 16));
}
faceQuads.put(EnumFacing.SOUTH, ImmutableList.<BakedQuad>of(builder.build()));
}
}
/** @author Immortius */
public class BlockShapeImpl extends BlockShape {
private String displayName;
private EnumMap<BlockPart, BlockMeshPart> meshParts = Maps.newEnumMap(BlockPart.class);
private EnumBooleanMap<Side> fullSide = new EnumBooleanMap<>(Side.class);
private CollisionShape baseCollisionShape;
private Vector3f baseCollisionOffset = new Vector3f();
private boolean yawSymmetric;
private boolean pitchSymmetric;
private boolean rollSymmetric;
private Map<Rotation, CollisionShape> collisionShape = Maps.newHashMap();
public BlockShapeImpl(
ResourceUrn urn, AssetType<?, BlockShapeData> assetType, BlockShapeData data) {
super(urn, assetType);
reload(data);
}
@Override
public String getDisplayName() {
return displayName;
}
public BlockMeshPart getMeshPart(BlockPart part) {
return meshParts.get(part);
}
public boolean isBlockingSide(Side side) {
return fullSide.get(side);
}
@Override
protected void doReload(BlockShapeData data) {
collisionShape.clear();
displayName = data.getDisplayName();
for (BlockPart part : BlockPart.values()) {
this.meshParts.put(part, data.getMeshPart(part));
}
for (Side side : Side.values()) {
this.fullSide.put(side, data.isBlockingSide(side));
}
this.baseCollisionShape = data.getCollisionShape();
this.baseCollisionOffset.set(data.getCollisionOffset());
collisionShape.put(Rotation.none(), baseCollisionShape);
yawSymmetric = data.isYawSymmetric();
pitchSymmetric = data.isPitchSymmetric();
rollSymmetric = data.isRollSymmetric();
}
@Override
protected void doDispose() {}
public CollisionShape getCollisionShape(Rotation rot) {
Rotation simplifiedRot = applySymmetry(rot);
CollisionShape result = collisionShape.get(simplifiedRot);
if (result == null && baseCollisionShape != null) {
result = rotate(baseCollisionShape, simplifiedRot.getQuat4f());
collisionShape.put(simplifiedRot, result);
}
return result;
}
public Vector3f getCollisionOffset(Rotation rot) {
Rotation simplifiedRot = applySymmetry(rot);
if (simplifiedRot.equals(Rotation.none())) {
return new Vector3f(baseCollisionOffset);
}
return QuaternionUtil.quatRotate(
simplifiedRot.getQuat4f(), baseCollisionOffset, new Vector3f());
}
@Override
public boolean isCollisionYawSymmetric() {
return yawSymmetric;
}
private Rotation applySymmetry(Rotation rot) {
return Rotation.rotate(
yawSymmetric ? Yaw.NONE : rot.getYaw(),
pitchSymmetric ? Pitch.NONE : rot.getPitch(),
rollSymmetric ? Roll.NONE : rot.getRoll());
}
private CollisionShape rotate(CollisionShape shape, Quat4f rot) {
if (shape instanceof BoxShape) {
BoxShape box = (BoxShape) shape;
javax.vecmath.Vector3f extents = box.getHalfExtentsWithMargin(new javax.vecmath.Vector3f());
com.bulletphysics.linearmath.QuaternionUtil.quatRotate(VecMath.to(rot), extents, extents);
extents.absolute();
return new BoxShape(extents);
} else if (shape instanceof CompoundShape) {
CompoundShape compound = (CompoundShape) shape;
CompoundShape newShape = new CompoundShape();
for (CompoundShapeChild child : compound.getChildList()) {
CollisionShape rotatedChild = rotate(child.childShape, rot);
javax.vecmath.Vector3f offset =
com.bulletphysics.linearmath.QuaternionUtil.quatRotate(
VecMath.to(rot), child.transform.origin, new javax.vecmath.Vector3f());
newShape.addChildShape(
new Transform(
new javax.vecmath.Matrix4f(VecMath.to(Rotation.none().getQuat4f()), offset, 1.0f)),
rotatedChild);
}
return newShape;
} else if (shape instanceof ConvexHullShape) {
ConvexHullShape convexHull = (ConvexHullShape) shape;
ObjectArrayList<javax.vecmath.Vector3f> transformedVerts = new ObjectArrayList<>();
for (javax.vecmath.Vector3f vert : convexHull.getPoints()) {
transformedVerts.add(
com.bulletphysics.linearmath.QuaternionUtil.quatRotate(
VecMath.to(rot), vert, new javax.vecmath.Vector3f()));
}
return new ConvexHullShape(transformedVerts);
}
return shape;
}
}
/** * A builder class to create JSON response for the Legacy Login RPC handler. * * @author [email protected] (Guibin Kong) */ public class LegacySigninJsonResponseBuilder { public static enum Status { OK("ok"), PASSWORD_ERROR("passwordError"), FEDERATED("federated"), EMAIL_NOT_EXIST("emailNotExist"); private String jsonString; private Status(String jsonString) { this.jsonString = jsonString; } public String toJsonString() { return this.jsonString; } } /** Enumerates the fields in the JSON response. */ protected static enum JsonField { STATUS, IDP, DISPLAY_NAME, PHOTO_URL } /** A map holds the value for each field. */ protected Map<JsonField, Object> values = Maps.newEnumMap(JsonField.class); /** * Builds the JSON format response string. * * @return the JSON format response string * @throws JSONException if error occurs when building the JSONObject */ public String build() throws JSONException { JSONObject result = new JSONObject(); Iterator<JsonField> iterator = values.keySet().iterator(); while (iterator.hasNext()) { JsonField key = iterator.next(); Object value = values.get(key); if (value != null) { switch (key) { case STATUS: { Status status = (Status) value; result.put("status", status.toJsonString()); break; } case IDP: { result.put("idp", value); break; } case DISPLAY_NAME: { result.put("displayName", value); break; } case PHOTO_URL: { result.put("photoUrl", value); break; } } } } return result.toString(); } /** * Clears the builder. * * @return the builder itself */ public LegacySigninJsonResponseBuilder reset() { values.clear(); return this; } /** * Sets the registered field. * * @param registered whether the user is registered * @return the builder itself */ public LegacySigninJsonResponseBuilder status(Status status) { if (status != null) { values.put(JsonField.STATUS, status); } return this; } /** * Sets the idp field. * * @param idp whether the user is registered * @return the builder itself */ public LegacySigninJsonResponseBuilder idp(String idp) { values.put(JsonField.IDP, idp); return this; } /** * Sets the displayName field. * * @param displayName the display name of the user. * @return the builder itself */ public LegacySigninJsonResponseBuilder displayName(String displayName) { values.put(JsonField.DISPLAY_NAME, displayName); return this; } /** * Sets the photoUrl field. * * @param photoUrl the photo url of the user. * @return the builder itself */ public LegacySigninJsonResponseBuilder photoUrl(String photoUrl) { values.put(JsonField.PHOTO_URL, photoUrl); return this; } }
public class PacketHandler {
public static final EnumMap<Side, FMLEmbeddedChannel> channels = Maps.newEnumMap(Side.class);
public static void init() {
if (!channels.isEmpty()) // avoid duplicate inits..
return;
Codec codec = new Codec();
codec.addDiscriminator(0, PacketMachine.class);
codec.addDiscriminator(1, PacketEntity.class);
codec.addDiscriminator(2, PacketDimInfo.class);
codec.addDiscriminator(3, PacketSatellite.class);
codec.addDiscriminator(4, PacketStellarInfo.class);
codec.addDiscriminator(5, PacketItemModifcation.class);
channels.putAll(
NetworkRegistry.INSTANCE.newChannel(AdvancedRocketry.modId, codec, new HandlerServer()));
// add handlers
if (FMLCommonHandler.instance().getSide().isClient()) {
// for the client
FMLEmbeddedChannel channel = channels.get(Side.CLIENT);
String codecName = channel.findChannelHandlerNameForType(Codec.class);
channel.pipeline().addAfter(codecName, "ClientHandler", new HandlerClient());
}
}
public static final void sendToServer(BasePacket packet) {
channels
.get(Side.CLIENT)
.attr(FMLOutboundHandler.FML_MESSAGETARGET)
.set(FMLOutboundHandler.OutboundTarget.TOSERVER);
channels.get(Side.CLIENT).writeOutbound(packet);
}
@SideOnly(Side.SERVER)
public static final void sendToPlayersTrackingEntity(BasePacket packet, Entity entity) {
for (EntityPlayer player :
((WorldServer) entity.worldObj).getEntityTracker().getTrackingPlayers(entity)) {
channels
.get(Side.SERVER)
.attr(FMLOutboundHandler.FML_MESSAGETARGET)
.set(FMLOutboundHandler.OutboundTarget.PLAYER);
channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(player);
channels.get(Side.SERVER).writeOutbound(packet);
}
}
public static final void sendToAll(BasePacket packet) {
channels
.get(Side.SERVER)
.attr(FMLOutboundHandler.FML_MESSAGETARGET)
.set(FMLOutboundHandler.OutboundTarget.ALL);
channels.get(Side.SERVER).writeOutbound(packet);
}
public static final void sendToPlayer(BasePacket packet, EntityPlayer player) {
channels
.get(Side.SERVER)
.attr(FMLOutboundHandler.FML_MESSAGETARGET)
.set(FMLOutboundHandler.OutboundTarget.PLAYER);
channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(player);
channels.get(Side.SERVER).writeOutbound(packet);
}
public static final void sendToDispatcher(BasePacket packet, NetworkManager netman) {
channels
.get(Side.SERVER)
.attr(FMLOutboundHandler.FML_MESSAGETARGET)
.set(FMLOutboundHandler.OutboundTarget.DISPATCHER);
channels
.get(Side.SERVER)
.attr(FMLOutboundHandler.FML_MESSAGETARGETARGS)
.set(NetworkDispatcher.get(netman));
channels.get(Side.SERVER).writeOutbound(packet);
}
public static final void sendToNearby(
BasePacket packet, int dimId, int x, int y, int z, double dist) {
channels
.get(Side.SERVER)
.attr(FMLOutboundHandler.FML_MESSAGETARGET)
.set(FMLOutboundHandler.OutboundTarget.ALLAROUNDPOINT);
channels
.get(Side.SERVER)
.attr(FMLOutboundHandler.FML_MESSAGETARGETARGS)
.set(new NetworkRegistry.TargetPoint(dimId, x, y, z, dist));
channels.get(Side.SERVER).writeOutbound(packet);
}
private static final class Codec extends FMLIndexedMessageToMessageCodec<BasePacket> {
@Override
public void encodeInto(ChannelHandlerContext ctx, BasePacket msg, ByteBuf data)
throws Exception {
msg.write(data);
}
@Override
public void decodeInto(ChannelHandlerContext ctx, ByteBuf data, BasePacket packet) {
switch (FMLCommonHandler.instance().getEffectiveSide()) {
case CLIENT:
packet.readClient(data);
// packet.executeClient((EntityPlayer)Minecraft.getMinecraft().thePlayer);
break;
case SERVER:
INetHandler netHandler = ctx.channel().attr(NetworkRegistry.NET_HANDLER).get();
packet.read(data);
// packet.executeServer(((NetHandlerPlayServer) netHandler).playerEntity);
break;
}
}
}
@Sharable
@SideOnly(Side.CLIENT)
private static final class HandlerClient extends SimpleChannelInboundHandler<BasePacket> {
@Override
protected void channelRead0(ChannelHandlerContext ctx, BasePacket packet) throws Exception {
Minecraft mc = Minecraft.getMinecraft();
packet.executeClient(mc.thePlayer); // actionClient(mc.theWorld, );
}
}
@Sharable
private static final class HandlerServer extends SimpleChannelInboundHandler<BasePacket> {
@Override
protected void channelRead0(ChannelHandlerContext ctx, BasePacket packet) throws Exception {
if (FMLCommonHandler.instance().getEffectiveSide().isClient()) {
// nothing on the client thread
return;
}
EntityPlayerMP player =
((NetHandlerPlayServer) ctx.channel().attr(NetworkRegistry.NET_HANDLER).get())
.playerEntity;
packet.executeServer(player); // (player.worldObj, player);
}
}
}
/** Chunk meshes are used to store the vertex data of tessellated chunks. */
@SuppressWarnings("PointlessArithmeticExpression")
public class ChunkMesh {
/** Possible rendering types. */
public enum RenderType {
OPAQUE(0),
TRANSLUCENT(1),
BILLBOARD(2),
WATER_AND_ICE(3);
private int meshIndex;
private RenderType(int index) {
meshIndex = index;
}
public int getIndex() {
return meshIndex;
}
}
public enum RenderPhase {
OPAQUE,
ALPHA_REJECT,
REFRACTIVE,
Z_PRE_PASS
}
/* CONST */
public static final int SIZE_VERTEX = 3;
public static final int SIZE_TEX0 = 3;
public static final int SIZE_TEX1 = 3;
public static final int SIZE_COLOR = 1;
public static final int SIZE_NORMAL = 3;
private static final int OFFSET_VERTEX = 0;
private static final int OFFSET_TEX_0 = OFFSET_VERTEX + SIZE_VERTEX * 4;
private static final int OFFSET_TEX_1 = OFFSET_TEX_0 + SIZE_TEX0 * 4;
private static final int OFFSET_COLOR = OFFSET_TEX_1 + SIZE_TEX1 * 4;
private static final int OFFSET_NORMAL = OFFSET_COLOR + SIZE_COLOR * 4;
private static final int STRIDE = OFFSET_NORMAL + SIZE_NORMAL * 4;
/* VERTEX DATA */
private final int[] vertexBuffers = new int[4];
private final int[] idxBuffers = new int[4];
private final int[] vertexCount = new int[4];
/* STATS */
private int triangleCount = -1;
/* TEMPORARY DATA */
private Map<RenderType, VertexElements> vertexElements = Maps.newEnumMap(RenderType.class);
private boolean disposed;
/* CONCURRENCY */
private ReentrantLock lock = new ReentrantLock();
/* MEASUREMENTS */
private int timeToGenerateBlockVertices;
private int timeToGenerateOptimizedBuffers;
private GLBufferPool bufferPool;
public ChunkMesh(GLBufferPool bufferPool) {
this.bufferPool = bufferPool;
for (RenderType type : RenderType.values()) {
vertexElements.put(type, new VertexElements());
}
}
public VertexElements getVertexElements(RenderType renderType) {
return vertexElements.get(renderType);
}
public boolean isGenerated() {
return vertexElements == null;
}
/**
* Generates the VBOs from the pre calculated arrays.
*
* @return True if something was generated
*/
public boolean generateVBOs() {
if (lock.tryLock()) {
try {
// IMPORTANT: A mesh can only be generated once.
if (vertexElements == null || disposed) {
return false;
}
for (RenderType type : RenderType.values()) {
generateVBO(type);
}
// Free unused space on the heap
vertexElements = null;
// Calculate the final amount of triangles
triangleCount = (vertexCount[0] + vertexCount[1] + vertexCount[2] + vertexCount[3]) / 3;
} finally {
lock.unlock();
}
return true;
}
return false;
}
private void generateVBO(RenderType type) {
VertexElements elements = vertexElements.get(type);
int id = type.getIndex();
if (!disposed && elements.finalIndices.limit() > 0 && elements.finalVertices.limit() > 0) {
vertexBuffers[id] = bufferPool.get("chunkMesh");
idxBuffers[id] = bufferPool.get("chunkMesh");
vertexCount[id] = elements.finalIndices.limit();
VertexBufferObjectUtil.bufferVboElementData(
idxBuffers[id], elements.finalIndices, GL15.GL_STATIC_DRAW);
VertexBufferObjectUtil.bufferVboData(
vertexBuffers[id], elements.finalVertices, GL15.GL_STATIC_DRAW);
} else {
vertexBuffers[id] = 0;
idxBuffers[id] = 0;
vertexCount[id] = 0;
}
}
private void renderVbo(int id) {
if (lock.tryLock()) {
try {
if (vertexBuffers[id] <= 0 || disposed) {
return;
}
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, idxBuffers[id]);
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vertexBuffers[id]);
glVertexPointer(SIZE_VERTEX, GL11.GL_FLOAT, STRIDE, OFFSET_VERTEX);
GL13.glClientActiveTexture(GL13.GL_TEXTURE0);
glTexCoordPointer(SIZE_TEX0, GL11.GL_FLOAT, STRIDE, OFFSET_TEX_0);
GL13.glClientActiveTexture(GL13.GL_TEXTURE1);
glTexCoordPointer(SIZE_TEX1, GL11.GL_FLOAT, STRIDE, OFFSET_TEX_1);
glColorPointer(SIZE_COLOR * 4, GL11.GL_UNSIGNED_BYTE, STRIDE, OFFSET_COLOR);
glNormalPointer(GL11.GL_FLOAT, STRIDE, OFFSET_NORMAL);
GL11.glDrawElements(GL11.GL_TRIANGLES, vertexCount[id], GL11.GL_UNSIGNED_INT, 0);
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
} finally {
lock.unlock();
}
}
}
public void render(RenderPhase type) {
switch (type) {
case OPAQUE:
renderVbo(0);
break;
case ALPHA_REJECT:
renderVbo(1);
glDisable(GL_CULL_FACE);
renderVbo(2);
glEnable(GL_CULL_FACE);
break;
case REFRACTIVE:
renderVbo(3);
break;
default:
break;
}
}
public void dispose() {
lock.lock();
try {
if (!disposed) {
for (int i = 0; i < vertexBuffers.length; i++) {
int id = vertexBuffers[i];
if (id != 0) {
bufferPool.dispose(id);
vertexBuffers[i] = 0;
}
id = idxBuffers[i];
if (id != 0) {
bufferPool.dispose(id);
idxBuffers[i] = 0;
}
}
disposed = true;
vertexElements = null;
}
} finally {
lock.unlock();
}
}
public boolean isDisposed() {
return disposed;
}
public int triangleCount(RenderPhase phase) {
if (phase == RenderPhase.OPAQUE) {
return vertexCount[0] / 3;
} else if (phase == RenderPhase.ALPHA_REJECT) {
return (vertexCount[1] + vertexCount[2]) / 3;
} else {
return vertexCount[3] / 3;
}
}
public int triangleCount() {
return triangleCount;
}
public boolean isEmpty() {
return triangleCount == 0;
}
public void setTimeToGenerateBlockVertices(int timeToGenerateBlockVertices) {
this.timeToGenerateBlockVertices = timeToGenerateBlockVertices;
}
public int getTimeToGenerateBlockVertices() {
return timeToGenerateBlockVertices;
}
public void setTimeToGenerateOptimizedBuffers(int timeToGenerateOptimizedBuffers) {
this.timeToGenerateOptimizedBuffers = timeToGenerateOptimizedBuffers;
}
public int getTimeToGenerateOptimizedBuffers() {
return timeToGenerateOptimizedBuffers;
}
/** Data structure for storing vertex data. Abused like a "struct" in C/C++. Just sad. */
public static class VertexElements {
public final TFloatList normals;
public final TFloatList vertices;
public final TFloatList tex;
public final TFloatList color;
public final TIntList indices;
public final TIntList flags;
public int vertexCount;
public IntBuffer finalVertices;
public IntBuffer finalIndices;
public VertexElements() {
vertexCount = 0;
normals = new TFloatArrayList();
vertices = new TFloatArrayList();
tex = new TFloatArrayList();
color = new TFloatArrayList();
indices = new TIntArrayList();
flags = new TIntArrayList();
}
}
}
public class EntityHumanNPC extends EntityPlayer implements NPCHolder, SkinnableEntity {
private final Map<PathType, Float> bz = Maps.newEnumMap(PathType.class);
private PlayerControllerJump controllerJump;
private PlayerControllerLook controllerLook;
private PlayerControllerMove controllerMove;
private int jumpTicks = 0;
private PlayerNavigation navigation;
private final CitizensNPC npc;
private final Location packetLocationCache = new Location(null, 0, 0, 0);
private final SkinPacketTracker skinTracker;
private int updateCounter = 0;
public EntityHumanNPC(
MinecraftServer minecraftServer,
WorldServer world,
GameProfile gameProfile,
PlayerInteractManager playerInteractManager,
NPC npc) {
super(minecraftServer, world, gameProfile, playerInteractManager);
this.npc = (CitizensNPC) npc;
if (npc != null) {
skinTracker = new SkinPacketTracker(this);
playerInteractManager.setGameMode(EnumGamemode.SURVIVAL);
initialise(minecraftServer);
} else {
skinTracker = null;
}
}
@Override
protected void a(double d0, boolean flag, IBlockData block, BlockPosition blockposition) {
if (npc == null || !npc.isFlyable()) {
super.a(d0, flag, block, blockposition);
}
}
public float a(PathType pathtype) {
return this.bz.containsKey(pathtype) ? this.bz.get(pathtype).floatValue() : pathtype.a();
}
public void a(PathType pathtype, float f) {
this.bz.put(pathtype, Float.valueOf(f));
}
@Override
public void A_() {
super.A_();
if (npc == null) return;
if (updateCounter + 1 > Setting.PACKET_UPDATE_DELAY.asInt()) {
updateEffects = true;
}
livingEntityBaseTick();
boolean navigating = npc.getNavigator().isNavigating();
updatePackets(navigating);
if (!navigating
&& getBukkitEntity() != null
&& npc.getTrait(Gravity.class).hasGravity()
&& Util.isLoaded(getBukkitEntity().getLocation(LOADED_LOCATION))) {
g(0, 0);
}
if (Math.abs(motX) < EPSILON && Math.abs(motY) < EPSILON && Math.abs(motZ) < EPSILON) {
motX = motY = motZ = 0;
}
if (navigating) {
if (!NMSImpl.isNavigationFinished(navigation)) {
NMSImpl.updateNavigation(navigation);
}
moveOnCurrentHeading();
}
NMSImpl.updateAI(this);
if (noDamageTicks > 0) {
--noDamageTicks;
}
npc.update();
}
@Override
public void collide(net.minecraft.server.v1_11_R1.Entity entity) {
// this method is called by both the entities involved - cancelling
// it will not stop the NPC from moving.
super.collide(entity);
if (npc != null) {
Util.callCollisionEvent(npc, entity.getBukkitEntity());
}
}
@Override
public boolean damageEntity(DamageSource damagesource, float f) {
// knock back velocity is cancelled and sent to client for handling when
// the entity is a player. there is no client so make this happen
// manually.
boolean damaged = super.damageEntity(damagesource, f);
if (damaged && velocityChanged) {
velocityChanged = false;
Bukkit.getScheduler()
.runTask(
CitizensAPI.getPlugin(),
new Runnable() {
@Override
public void run() {
EntityHumanNPC.this.velocityChanged = true;
}
});
}
return damaged;
}
@Override
public void die(DamageSource damagesource) {
// players that die are not normally removed from the world. when the
// NPC dies, we are done with the instance and it should be removed.
if (dead) {
return;
}
super.die(damagesource);
Bukkit.getScheduler()
.runTaskLater(
CitizensAPI.getPlugin(),
new Runnable() {
@Override
public void run() {
world.removeEntity(EntityHumanNPC.this);
}
},
35); // give enough time for death and smoke animation
}
@Override
public void e(float f, float f1) {
if (npc == null || !npc.isFlyable()) {
super.e(f, f1);
}
}
@Override
public void enderTeleportTo(double d0, double d1, double d2) {
if (npc == null) super.enderTeleportTo(d0, d1, d2);
NPCEnderTeleportEvent event = new NPCEnderTeleportEvent(npc);
Bukkit.getPluginManager().callEvent(event);
if (!event.isCancelled()) {
super.enderTeleportTo(d0, d1, d2);
}
}
@Override
public void f(double x, double y, double z) {
if (npc == null) {
super.f(x, y, z);
return;
}
if (NPCPushEvent.getHandlerList().getRegisteredListeners().length == 0) {
if (!npc.data().get(NPC.DEFAULT_PROTECTED_METADATA, true)) {
super.f(x, y, z);
}
return;
}
Vector vector = new Vector(x, y, z);
NPCPushEvent event = Util.callPushEvent(npc, vector);
if (!event.isCancelled()) {
vector = event.getCollisionVector();
super.f(vector.getX(), vector.getY(), vector.getZ());
}
// when another entity collides, this method is called to push the
// NPC so we prevent it from doing anything if the event is
// cancelled.
}
@Override
public void g(float f, float f1) {
if (npc == null || !npc.isFlyable()) {
super.g(f, f1);
} else {
NMSImpl.flyingMoveLogic(this, f, f1);
}
}
@Override
public CraftPlayer getBukkitEntity() {
if (npc != null && !(bukkitEntity instanceof NPCHolder)) {
bukkitEntity = new PlayerNPC(this);
}
return super.getBukkitEntity();
}
public PlayerControllerJump getControllerJump() {
return controllerJump;
}
public PlayerControllerMove getControllerMove() {
return controllerMove;
}
public NavigationAbstract getNavigation() {
return navigation;
}
@Override
public NPC getNPC() {
return npc;
}
@Override
public IChatBaseComponent getPlayerListName() {
if (Setting.REMOVE_PLAYERS_FROM_PLAYER_LIST.asBoolean()) {
return new ChatComponentText("");
}
return super.getPlayerListName();
}
@Override
public String getSkinName() {
MetadataStore meta = npc.data();
String skinName = meta.get(NPC.PLAYER_SKIN_UUID_METADATA);
if (skinName == null) {
skinName = ChatColor.stripColor(getName());
}
return skinName.toLowerCase();
}
@Override
public SkinPacketTracker getSkinTracker() {
return skinTracker;
}
private void initialise(MinecraftServer minecraftServer) {
Socket socket = new EmptySocket();
NetworkManager conn = null;
try {
conn = new EmptyNetworkManager(EnumProtocolDirection.CLIENTBOUND);
playerConnection = new EmptyNetHandler(minecraftServer, conn, this);
conn.setPacketListener(playerConnection);
socket.close();
} catch (IOException e) {
// swallow
}
AttributeInstance range = getAttributeInstance(GenericAttributes.FOLLOW_RANGE);
if (range == null) {
range = getAttributeMap().b(GenericAttributes.FOLLOW_RANGE);
}
range.setValue(Setting.DEFAULT_PATHFINDING_RANGE.asDouble());
controllerJump = new PlayerControllerJump(this);
controllerLook = new PlayerControllerLook(this);
controllerMove = new PlayerControllerMove(this);
navigation = new PlayerNavigation(this, world);
NMS.setStepHeight(getBukkitEntity(), 1); // the default (0) breaks step climbing
setSkinFlags((byte) 0xFF);
}
@Override
public boolean isCollidable() {
return npc == null ? super.isCollidable() : npc.data().get(NPC.COLLIDABLE_METADATA, true);
}
public boolean isNavigating() {
return npc.getNavigator().isNavigating();
}
public void livingEntityBaseTick() {
cA();
this.aC = this.aD;
this.aJ = this.aK;
if (this.hurtTicks > 0) {
this.hurtTicks -= 1;
}
tickPotionEffects();
this.aZ = this.aY;
this.aO = this.aN;
this.aQ = this.aP;
this.lastYaw = this.yaw;
this.lastPitch = this.pitch;
}
@Override
public boolean m_() {
if (npc == null || !npc.isFlyable()) {
return super.m_();
} else {
return false;
}
}
private void moveOnCurrentHeading() {
if (bd) {
if (onGround && jumpTicks == 0) {
cm();
jumpTicks = 10;
}
} else {
jumpTicks = 0;
}
be *= 0.98F;
bf *= 0.98F;
bg *= 0.9F;
g(be, bf); // movement method
NMS.setHeadYaw(getBukkitEntity(), yaw);
if (jumpTicks > 0) {
jumpTicks--;
}
}
public void setMoveDestination(double x, double y, double z, double speed) {
controllerMove.a(x, y, z, speed);
}
public void setShouldJump() {
controllerJump.a();
}
@Override
public void setSkinFlags(byte flags) {
// set skin flag byte
getDataWatcher().set(EntityHuman.bq, flags);
}
@Override
public void setSkinName(String name) {
setSkinName(name, false);
}
@Override
public void setSkinName(String name, boolean forceUpdate) {
Preconditions.checkNotNull(name);
npc.data().setPersistent(NPC.PLAYER_SKIN_UUID_METADATA, name.toLowerCase());
skinTracker.notifySkinChange(forceUpdate);
}
public void setTargetLook(Entity target, float yawOffset, float renderOffset) {
controllerLook.a(target, yawOffset, renderOffset);
}
public void setTargetLook(Location target) {
controllerLook.a(target.getX(), target.getY(), target.getZ(), 10, 40);
}
public void updateAI() {
controllerMove.c();
controllerLook.a();
controllerJump.b();
}
private void updatePackets(boolean navigating) {
if (updateCounter++ <= Setting.PACKET_UPDATE_DELAY.asInt()) return;
updateCounter = 0;
Location current = getBukkitEntity().getLocation(packetLocationCache);
Packet<?>[] packets =
new Packet[navigating ? EnumItemSlot.values().length : EnumItemSlot.values().length + 1];
if (!navigating) {
packets[5] =
new PacketPlayOutEntityHeadRotation(
this, (byte) MathHelper.d(NMSImpl.getHeadYaw(this) * 256.0F / 360.0F));
}
int i = 0;
for (EnumItemSlot slot : EnumItemSlot.values()) {
packets[i++] = new PacketPlayOutEntityEquipment(getId(), slot, getEquipment(slot));
}
NMSImpl.sendPacketsNearby(getBukkitEntity(), current, packets);
}
public void updatePathfindingRange(float pathfindingRange) {
this.navigation.setRange(pathfindingRange);
}
public static class PlayerNPC extends CraftPlayer implements NPCHolder, SkinnableEntity {
private final CraftServer cserver;
private final CitizensNPC npc;
private PlayerNPC(EntityHumanNPC entity) {
super((CraftServer) Bukkit.getServer(), entity);
this.npc = entity.npc;
this.cserver = (CraftServer) Bukkit.getServer();
npc.getTrait(Inventory.class);
}
@Override
public Player getBukkitEntity() {
return this;
}
@Override
public EntityHumanNPC getHandle() {
return (EntityHumanNPC) this.entity;
}
@Override
public List<MetadataValue> getMetadata(String metadataKey) {
return cserver.getEntityMetadata().getMetadata(this, metadataKey);
}
@Override
public NPC getNPC() {
return npc;
}
@Override
public String getSkinName() {
return ((SkinnableEntity) this.entity).getSkinName();
}
@Override
public SkinPacketTracker getSkinTracker() {
return ((SkinnableEntity) this.entity).getSkinTracker();
}
@Override
public boolean hasMetadata(String metadataKey) {
return cserver.getEntityMetadata().hasMetadata(this, metadataKey);
}
@Override
public void removeMetadata(String metadataKey, Plugin owningPlugin) {
cserver.getEntityMetadata().removeMetadata(this, metadataKey, owningPlugin);
}
@Override
public void setMetadata(String metadataKey, MetadataValue newMetadataValue) {
cserver.getEntityMetadata().setMetadata(this, metadataKey, newMetadataValue);
}
@Override
public void setSkinFlags(byte flags) {
((SkinnableEntity) this.entity).setSkinFlags(flags);
}
@Override
public void setSkinName(String name) {
((SkinnableEntity) this.entity).setSkinName(name);
}
@Override
public void setSkinName(String skinName, boolean forceUpdate) {
((SkinnableEntity) this.entity).setSkinName(skinName, forceUpdate);
}
}
private static final float EPSILON = 0.005F;
private static final Location LOADED_LOCATION = new Location(null, 0, 0, 0);
}
/** Default implementation for {@link RestRequestBuilderFactory}. */
public class DefaultRestRequestBuilderFactory implements RestRequestBuilderFactory {
private static final Map<HttpMethod, Method> HTTP_METHODS = Maps.newEnumMap(HttpMethod.class);
private static final String JSON_UTF8 = "application/json; charset=utf-8";
static {
HTTP_METHODS.put(HttpMethod.GET, RequestBuilder.GET);
HTTP_METHODS.put(HttpMethod.POST, RequestBuilder.POST);
HTTP_METHODS.put(HttpMethod.PUT, RequestBuilder.PUT);
HTTP_METHODS.put(HttpMethod.DELETE, RequestBuilder.DELETE);
HTTP_METHODS.put(HttpMethod.HEAD, RequestBuilder.HEAD);
}
private final ActionMetadataProvider metadataProvider;
private final Serialization serialization;
private final HttpRequestBuilderFactory httpRequestBuilderFactory;
private final UrlUtils urlUtils;
private final Multimap<HttpMethod, RestParameter> globalHeaderParams;
private final Multimap<HttpMethod, RestParameter> globalQueryParams;
private final String baseUrl;
private final String securityHeaderName;
private final Integer requestTimeoutMs;
@Inject
DefaultRestRequestBuilderFactory(
ActionMetadataProvider metadataProvider,
Serialization serialization,
HttpRequestBuilderFactory httpRequestBuilderFactory,
UrlUtils urlUtils,
@GlobalHeaderParams Multimap<HttpMethod, RestParameter> globalHeaderParams,
@GlobalQueryParams Multimap<HttpMethod, RestParameter> globalQueryParams,
@RestApplicationPath String baseUrl,
@XsrfHeaderName String securityHeaderName,
@RequestTimeout Integer requestTimeoutMs) {
this.metadataProvider = metadataProvider;
this.serialization = serialization;
this.httpRequestBuilderFactory = httpRequestBuilderFactory;
this.urlUtils = urlUtils;
this.globalHeaderParams = globalHeaderParams;
this.globalQueryParams = globalQueryParams;
this.baseUrl = baseUrl;
this.securityHeaderName = securityHeaderName;
this.requestTimeoutMs = requestTimeoutMs;
}
@Override
public <A extends RestAction<?>> RequestBuilder build(A action, String securityToken)
throws ActionException {
Method httpMethod = HTTP_METHODS.get(action.getHttpMethod());
String url = buildUrl(action);
String xsrfToken = action.isSecured() ? securityToken : "";
RequestBuilder requestBuilder = httpRequestBuilderFactory.create(httpMethod, url);
requestBuilder.setTimeoutMillis(requestTimeoutMs);
buildHeaders(requestBuilder, xsrfToken, action);
buildBody(requestBuilder, action);
return requestBuilder;
}
/**
* Encodes the given {@link RestParameter} as a path parameter. The default implementation
* delegates to {@link UrlUtils#encodePathSegment(String)}.
*
* @param value the value to encode.
* @return the encoded path parameter.
* @throws ActionException if an exception occurred while encoding the path parameter.
* @see #encode(com.gwtplatform.dispatch.rest.shared.RestParameter)
*/
protected String encodePathParam(String value) throws ActionException {
return urlUtils.encodePathSegment(value);
}
/**
* Encodes the given {@link RestParameter} as a query parameter. The default implementation
* delegates to {@link UrlUtils#encodeQueryString(String)}.
*
* @param value the value to encode.
* @return the encoded query parameter.
* @throws ActionException if an exception occurred while encoding the query parameter.
* @see #encode(com.gwtplatform.dispatch.rest.shared.RestParameter)
*/
protected String encodeQueryParam(String value) throws ActionException {
return urlUtils.encodeQueryString(value);
}
/**
* Verify if the provided <code>bodyType</code> can be serialized.
*
* @param bodyType the parameterized type to verify if it can be serialized.
* @return <code>true</code> if <code>bodyType</code> can be serialized, otherwise <code>false
* </code>.
*/
protected boolean canSerialize(String bodyType) {
return serialization.canSerialize(bodyType);
}
/**
* Serialize the given object. We assume {@link #canSerialize(String)} returns <code>true</code>
* or a runtime exception may be thrown.
*
* @param object the object to serialize.
* @param bodyType The parameterized type of the object to serialize.
* @return The serialized string.
*/
protected String serialize(Object object, String bodyType) {
return serialization.serialize(object, bodyType);
}
private void buildHeaders(RequestBuilder requestBuilder, String xsrfToken, RestAction<?> action)
throws ActionException {
String path = action.getPath();
List<RestParameter> actionParams = action.getHeaderParams();
Collection<RestParameter> applicableGlobalParams =
globalHeaderParams.get(action.getHttpMethod());
// By setting the most generic headers first, we make sure they can be overridden by more
// specific ones
requestBuilder.setHeader(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON);
requestBuilder.setHeader(HttpHeaders.CONTENT_TYPE, JSON_UTF8);
if (!isAbsoluteUrl(path)) {
requestBuilder.setHeader(MODULE_BASE_HEADER, baseUrl);
}
if (!Strings.isNullOrEmpty(xsrfToken)) {
requestBuilder.setHeader(securityHeaderName, xsrfToken);
}
for (RestParameter parameter : applicableGlobalParams) {
String value = parameter.getStringValue();
if (value != null) {
requestBuilder.setHeader(parameter.getName(), value);
}
}
for (RestParameter param : actionParams) {
requestBuilder.setHeader(param.getName(), param.getStringValue());
}
}
private <A extends RestAction<?>> void buildBody(RequestBuilder requestBuilder, A action)
throws ActionException {
if (action.hasFormParams()) {
requestBuilder.setRequestData(buildQueryString(action.getFormParams()));
} else if (action.hasBodyParam()) {
requestBuilder.setRequestData(getSerializedValue(action, action.getBodyParam()));
}
}
private String buildUrl(RestAction<?> action) throws ActionException {
List<RestParameter> queryParams = getGlobalQueryParamsForAction(action);
queryParams.addAll(action.getQueryParams());
String queryString = buildQueryString(queryParams);
if (!queryString.isEmpty()) {
queryString = "?" + queryString;
}
String path = buildPath(action.getPath(), action.getPathParams());
String prefix = "";
if (!isAbsoluteUrl(path)) {
prefix = baseUrl;
}
return prefix + path + queryString;
}
private List<RestParameter> getGlobalQueryParamsForAction(RestAction<?> action) {
List<RestParameter> queryParams = Lists.newArrayList();
for (RestParameter parameter : globalQueryParams.get(action.getHttpMethod())) {
String value = parameter.getStringValue();
if (value != null) {
queryParams.add(new RestParameter(parameter.getName(), value));
}
}
return queryParams;
}
private boolean isAbsoluteUrl(String path) {
return path.startsWith("http://") || path.startsWith("https://");
}
private String buildPath(String rawPath, List<RestParameter> params) throws ActionException {
String path = rawPath;
for (RestParameter param : params) {
String encodedParam = encodePathParam(param.getStringValue());
path = path.replace("{" + param.getName() + "}", encodedParam);
}
return path;
}
private String buildQueryString(List<RestParameter> params) throws ActionException {
StringBuilder queryString = new StringBuilder();
for (RestParameter param : params) {
queryString
.append("&")
.append(param.getName())
.append("=")
.append(encodeQueryParam(param.getStringValue()));
}
if (queryString.length() != 0) {
queryString.deleteCharAt(0);
}
return queryString.toString();
}
private String getSerializedValue(RestAction<?> action, Object object) throws ActionException {
String bodyType = (String) metadataProvider.getValue(action, MetadataType.BODY_TYPE);
if (bodyType != null && canSerialize(bodyType)) {
try {
return serialize(object, bodyType);
} catch (JsonMappingException e) {
throw new ActionException(
"Unable to serialize request body. An unexpected error occurred.", e);
}
}
throw new ActionException("Unable to serialize request body. No serializer found.");
}
}