import jalse.entities.Entity; //导入依赖的package包/类
@Override
   public void attributeAdded(final AttributeEvent<Double> event) {
final Person person = ((Entity) event.getContainer()).asType(Person.class);
final double infection = event.getValue();

// Check infected
if (infection >= 1.0) {
    person.unmarkAsType(Carrier.class);
    infectPerson(person);
    return;
}

// Base colours
final Color healthyColour = ZombiesProperties.getColour(Healthy.class);
final Color infectedColour = ZombiesProperties.getColour(Infected.class);

// Gradually transition from "healthy" to "infected" color
final float r = (float) ((healthyColour.getRed() * (1. - infection) + infectedColour.getRed() * infection)
	/ 255.);
final float g = (float) ((healthyColour.getGreen() * (1. - infection) + infectedColour.getGreen() * infection)
	/ 255.);
final float b = (float) ((healthyColour.getBlue() * (1. - infection) + infectedColour.getBlue() * infection)
	/ 255.);

person.setColour(new Color(r, g, b));
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
private static Optional<Person> getClosestPersonOfType(final Person person, final Set<Person> people,
    final Class<? extends Entity> type) {
final Point personPos = person.getPosition();
final Integer sightRange = person.getSightRange();
// Stream other entities of type
return people.stream().filter(not(person)).filter(isMarkedAsType(type)).filter(p -> {
    final Point pPos = p.getPosition();
    // Within range
    return Math.abs(pPos.x - personPos.x) <= sightRange && Math.abs(pPos.y - personPos.y) <= sightRange;
}).collect(Collectors.minBy((a, b) -> {
    final Point aPos = a.getPosition();
    final Point bPos = b.getPosition();
    // Closest person
    final int d1 = (aPos.x - personPos.x) * (aPos.x - personPos.x)
	    + (aPos.y - personPos.y) * (aPos.y - personPos.y);
    final int d2 = (bPos.x - personPos.x) * (bPos.x - personPos.x)
	    + (bPos.y - personPos.y) * (bPos.y - personPos.y);
    return d1 - d2;
}));
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
@Override
   public void perform(final ActionContext<Entity> context) throws InterruptedException {
// Get floor
final Floor floor = context.getActor().asType(Floor.class);

// Get mop
final Mop mop = floor.getMop();

for (;;) {
    final Point movedPos = getPositionInDirection(mop);
    // Check in bounds
    if (inFloorBounds(floor, movedPos)) {
	// Randomly ping off when at an edge
	if (isAtFloorEdge(floor, movedPos) && ThreadLocalRandom.current().nextBoolean()) {
	    mop.setRandomDirection();
	}

	// Move mop
	mop.setPosition(movedPos);
	break;
    }
    // Change direction
    mop.setRandomDirection();
}
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
@Override
   public void perform(final ActionContext<Entity> context) {
// Actor this action was for
final Entity actor = context.getActor();

// Creates random 'sentence'
final String text = createText();
System.out.println(String.format("%s -> %s: %s", actor.getID(), to, text));

// Get parent JALSE
final EntityContainer container = actor.getContainer();
// Get recipient messenger
final Messenger recipient = container.getEntityAsType(to, Messenger.class);

// Create message contents
final AttributeContainer contents = new DefaultAttributeContainer();
contents.setAttribute("text", STRING_TYPE, text);
contents.setAttribute("from", newTypeOf(UUID.class), actor.getID());

// Create the message and trigger response
recipient.newMessage(contents);
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
@Override
   public Object invoke(final Object proxy, final Entity entity, final Object[] args) throws Throwable {
// Check no args
if (args.length != 1) {
    throw new IllegalArgumentException("Should have 1 argument");
}
if (optional) {
    return entity.setOptAttribute(namedType, args[0]);
} else {
    Object result = entity.setAttribute(namedType, args[0]);
    if (result == null && primitive) {
	result = defaultValue;
    }
    return result;
}
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
private Predicate<Entity> newIDFilter() {
return e -> {
    // No filtering on empty suppliers.
    if (idSuppliers.isEmpty()) {
	return true;
    }
    boolean found = false;
    for (final Supplier<UUID> idSupplier : idSuppliers) {
	// Check is ID
	if (e.getID().equals(idSupplier.get())) {
	    found = true;
	    break;
	}
    }
    return found;
};
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
@Override
   public Object invoke(final Object proxy, final Entity entity, final Object[] args) throws Throwable {
// Check no args
if (args != null && args.length > 0) {
    throw new IllegalArgumentException("Should have no arguments");
}
if (optional) {
    return entity.getOptAttribute(namedType);
} else {
    Object result = entity.getAttribute(namedType);
    if (result == null && primitive) {
	result = defaultValue;
    }
    return result;
}
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
@Override
   public MarkAsTypeMethod apply(final Method m) {
// Check for annotation
final MarkAsType annonation = m.getAnnotation(MarkAsType.class);
if (annonation == null) {
    return null;
}

// Check subtype
final Class<? extends Entity> entityType = annonation.value();
if (!isEntitySubtype(entityType)) {
    throw new IllegalArgumentException("Entity type must be a subtype");
}

// Basic check method signature
checkNoParams(m);
checkNotDefault(m);

// Check return type.
if (hasReturnType(m) && !returnTypeIs(m, Boolean.TYPE)) {
    throw new IllegalArgumentException("Must have void or boolean return type");
}

// Create get entity method
return new MarkAsTypeMethod(entityType);
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
@Override
   public UnmarkAsTypeMethod apply(final Method m) {
// Check for annotation
final UnmarkAsType annonation = m.getAnnotation(UnmarkAsType.class);
if (annonation == null) {
    return null;
}

// Check subtype
final Class<? extends Entity> entityType = annonation.value();
if (!isEntitySubtype(entityType)) {
    throw new IllegalArgumentException("Entity type must be a subtype");
}

// Basic check method signature
checkNoParams(m);
checkNotDefault(m);

// Check return type.
if (hasReturnType(m) && !returnTypeIs(m, Boolean.TYPE)) {
    throw new IllegalArgumentException("Must have void or boolean return type");
}

// Create get entity method
return new UnmarkAsTypeMethod(entityType);
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
/**
    * Sets the correct {@link TreeMember} tag for the container.
    *
    * @param container
    *            Container to check for.
    * @return The member enum.
    */
   public static TreeMember getTreeMember(final EntityContainer container) {
// Must be identifiable to be a tree member
if (!(container instanceof Identifiable)) {
    return null;
}
// Entity with no identifable parent (or JALSE).
if (!(container instanceof Entity) || ((Entity) container).getContainer() == null) {
    return TreeMember.ROOT;
}
// Entity with children
else if (container.hasEntities()) {
    return TreeMember.NODE;
}
// Entity with no children
else {
    return TreeMember.LEAF;
}
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
@Test
   public void attributeTypeTest() {
Assert.assertEquals(new AttributeType<Boolean>() {}, Attributes.BOOLEAN_TYPE);
Assert.assertEquals(new AttributeType<Integer>() {}, Attributes.INTEGER_TYPE);
Assert.assertEquals(new AttributeType<String>() {}, Attributes.STRING_TYPE);
Assert.assertEquals(new AttributeType<Double>() {}, Attributes.DOUBLE_TYPE);
Assert.assertEquals(new AttributeType<Character>() {}, Attributes.CHARACTER_TYPE);
Assert.assertEquals(new AttributeType<Long>() {}, Attributes.LONG_TYPE);
Assert.assertEquals(new AttributeType<Byte>() {}, Attributes.BYTE_TYPE);
Assert.assertEquals(new AttributeType<Float>() {}, Attributes.FLOAT_TYPE);
Assert.assertEquals(new AttributeType<Short>() {}, Attributes.SHORT_TYPE);
Assert.assertEquals(new AttributeType<Object>() {}, Attributes.OBJECT_TYPE);

Assert.assertEquals(new AttributeType<Entity>() {}, Attributes.newTypeOf(Entity.class));
Assert.assertEquals(new AttributeType<Entity>() {}, Attributes.newUnknownType(Entity.class));
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
@Test
   public void killEntityTest() {
jalse = new DefaultJALSE(new UUID(0, 0), ForkJoinActionEngine.commonPoolEngine(), new DefaultEntityFactory());

final Entity entity1 = jalse.newEntity(new UUID(0, 1));
final Entity entity2 = jalse.newEntity(new UUID(0, 2));
final Entity entity3 = jalse.newEntity(new UUID(0, 3));

Assert.assertTrue(entity1.isAlive());
Assert.assertTrue(entity2.isAlive());
Assert.assertTrue(entity3.isAlive());

jalse.killEntity(new UUID(0, 1));
Assert.assertFalse(entity1.isAlive());
Assert.assertTrue(entity2.isAlive());
Assert.assertTrue(entity3.isAlive());

jalse.killEntities();
Assert.assertFalse(entity1.isAlive());
Assert.assertFalse(entity2.isAlive());
Assert.assertFalse(entity3.isAlive());
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
@Override
   public void attributeAdded(final AttributeEvent<Double> event) {
final Person person = ((Entity) event.getContainer()).asType(Person.class);
final double starvation = event.getValue();

// Check starvation
if (starvation >= 1.0) {
    person.cancelAllScheduledForActor();
    person.unmarkAsType(Infected.class);
    person.markAsType(Corpse.class);
}
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
@Override
   public void perform(final ActionContext<Entity> context) throws InterruptedException {
final Carrier carrier = context.getActor().asType(Carrier.class);

// Increase infection fraction a bit
final double infection = carrier.getInfectionPercentage() + 1. / 30 / ZombiesProperties.getInfectionTime();
carrier.setInfectionPercentage(infection);
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
@Override
   public void perform(final ActionContext<Entity> context) throws InterruptedException {
final Field field = context.getActor().asType(Field.class);
final Set<Person> people = field.getEntitiesOfType(Person.class);
people.stream().filter(notMarkedAsType(Corpse.class)).forEach(person -> {
    // Get correct move angle
    double moveAngle;
    if (person.isMarkedAsType(Infected.class)) {
	// Move towards healthy
	moveAngle = directionToHealthyAndBite(person, people);
    } else if (person.isMarkedAsType(Carrier.class)) {
	// Move randomly
	moveAngle = randomDirection(person);
    } else {
	// Run away
	moveAngle = directionAwayFromInfected(person, people);
    }
    person.setAngle(moveAngle);

    // Calculate move delta
    final double moveDist = person.getSpeed();
    final Point moveDelta = new Point((int) (moveDist * Math.cos(moveAngle)),
	    (int) (moveDist * Math.sin(moveAngle)));

    // Original values
    final Point pos = person.getPosition();
    final int size = ZombiesProperties.getSize();

    // Apply bounded move delta
    final int x = bounded(pos.x + moveDelta.x, 0, ZombiesPanel.WIDTH - size);
    final int y = bounded(pos.y + moveDelta.y, 0, ZombiesPanel.HEIGHT - size);

    if (pos.x != x || pos.y != y) {
	// Update if changed
	person.setPosition(new Point(x, y));
    }
});
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
@Override
   public void perform(final ActionContext<Entity> context) throws InterruptedException {
final Infected infected = context.getActor().asType(Infected.class);

// Infected slowly starve to death after biting
final double hunger = infected.getHungerPercentage() + 1. / 30 / ZombiesProperties.getStarveTime();
infected.setHungerPercentage(hunger);
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
@Override
   public void entityMarkedAsType(final EntityTypeEvent event) {
final Person person = event.getEntity().asType(Person.class);
final Class<? extends Entity> type = event.getTypeChange();

person.setColour(ZombiesProperties.getColour(type));
person.setSightRange(ZombiesProperties.getSightRange(type));
person.setSpeed(ZombiesProperties.getSpeed(type));
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
@Override
   public void perform(final ActionContext<JALSE> tick) {
// The actor for this action
final JALSE jalse = tick.getActor();

// Only process cows
jalse.streamEntitiesOfType(Cow.class).forEach(c -> {
    // Eat grass at the same position
    final Point pos = c.getPosition();
    jalse.streamEntitiesOfType(Grass.class).filter(g -> pos.equals(g.getPosition())).forEach(Entity::kill);
});
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
@Override
   public void entityKilled(final EntityEvent event) {
// Get entity that was killed
final Entity e = event.getEntity();

// Check it was grass
if (e.isMarkedAsType(Grass.class)) {
    System.out.println(String.format("Grass has been eaten [%s]", e.getID()));
    // Schedule another to be created
    ((JALSE) event.getContainer()).scheduleForActor(new SproutGrass(), 300, TimeUnit.MILLISECONDS);
}
   }
 

import jalse.entities.Entity; //导入依赖的package包/类
private EntitySummary entitySummary(final UUID jID, final UUID eID) {
final Entity entity = jalseService.getEntity(jID, eID);
return new EntitySummary(jID, Identifiable.getID(entity.getContainer()), eID,
	entity.getSingletonTag(OriginContainer.class).getValue(), entity.getEntityCount(),
	sdf.get().format(entity.getSingletonTag(Created.class).getValue()),
	entity.getSingletonTag(TreeMember.class), entity.getSingletonTag(TreeDepth.class).getValue());
   }