关于WorldModel的一些说明

WorldModel接口

public interface WorldModel<T extends Entity> extends Iterable<T> {
    void addWorldModelListener(WorldModelListener<? super T> var1);//设置监听

    void removeWorldModelListener(WorldModelListener<? super T> var1);//删除监听

    Collection<T> getAllEntities();//获得所有的实体

    void addEntity(Entity var1);//加入一个实体

    void addEntities(Collection<? extends Entity> var1);//加入多个实体

    void removeEntity(T var1);//通过指定实体删除实体

    void removeEntity(EntityID var1);//通过实体ID删除实体

    void removeAllEntities();//删除所有实体

    T getEntity(EntityID var1);//通过ID获得实体

    void merge(Collection<? extends Entity> var1);//合并

    void merge(ChangeSet var1);//合并
}

AbstractWorldModel类:

实现了WorldModel接口,但依旧是抽象类。它实现了接口的部分功能，包括监听集合listeners，和容许类集合allowedClasses，或者说已注册的类的集合。它还实现了如下方法

void addWorldModelListener(WorldModelListener<? super T> var1);//对集合listeners的操作
void removeWorldModelListener(WorldModelListener<? super T> var1);//对集合listeners的操作
void addEntity(Entity var1);//在方法中调用了addEntityImpl方法，但此方法并没有实现，所以这个方法并没有真正实现。因为当前的属性还没有实体集合，这个是为后续DefaultWorldModel继承做准备.
void addEntities(Collection<? extends Entity> var1);//同上
void removeEntity(T var1);//同上也是一个通过调用其他方法的逻辑上的实现
void merge(Collection<? extends Entity> var1);//对ChangeSet的操作
void merge(ChangeSet var1);//对ChangeSet的操作

新增的属性和方法：

    private Set<WorldModelListener<? super T>> listeners = new HashSet();//对每一个类的监听集合（新增）
    private Collection<Class<? extends T>> allowedClasses = new HashSet();//容许类列表（新增）
    protected abstract void addEntityImpl(T var1);
    protected final void fireEntityRemoved(T e)//增加两个有关火的方法
    protected final void fireEntityAdded(T e)
    protected boolean isAllowed(Entity e) //一个判断,是否在容许类列表里

DefaultWorldModel类：

继承了AbstractWorldModelm，增加了实体集合entities属性，实现了如下方法

    Collection<T> getAllEntities();//获得所有的实体
    public final void addEntityImpl(T e);//该方法是AbstractWorldModelm声明的，用于addEntity方法中，是对集合entities的操作
    void removeEntity(T var1);//对entities的操作
    void removeEntity(EntityID var1);//对entities的操作
    void removeAllEntities();//对entities的操作
    T getEntity(EntityID var1);//通过ID获得实体
    public final Iterator<T> iterator()//返回的迭代器是集合entities的迭代

新增的属性和方法

private Map<EntityID, T> entities = new HashMap();//实体的集合（新增）
    public static DefaultWorldModel<Entity> create() {//新增的创建一个空的世界的方法
            return new DefaultWorldModel(Entity.class);
    }
    public final Iterator<T> iterator() {//重写了得到迭代器的方法，返回值是实体集合的迭代器，迭代的还是实体的集合
            return this.entities.values().iterator();
    }
    public static DefaultWorldModel<Entity> create()//创建一个空的世界

到这里接口的方法已经完全实现，DefaultWorldModel不再是抽象类，现在一共有三个属性，实体集合entities、监听集合listeners和容许类集合allowedClasses，除了merge（）其他方法都是对这三个属性的操作。

StandardWorldModel类：

继承了DefaultWorldModel类，重写了merge（ChangeSet changeSet）方法，并增加了一些属性与方法。此外该类还有两个内部类。

新增的属性

    private SpatialIndex index;
    private Map<StandardEntityURN, Collection<StandardEntity>> storedTypes = new EnumMap(StandardEntityURN.class);//存储标准实体的类型的映射集合
    private Set<StandardEntity> unindexedEntities = new HashSet();//未编入索引的实体集合
    private Map<Human, Rectangle> humanRectangles = new HashMap();//人类-矩形映射???
    private boolean indexed;//是否建立索引
    private int minX;//最小值，下同
    private int maxX;
    private int minY;
    private int maxY;

新增的方法

public void indexClass(StandardEntityURN... urns) //给一个或多个类建立索引
public void index()//为entities集合中的每一个human类的实体设置人对矩形即Map（human,Rectangles）的映射

后面都是一些工具函数和get函数,在此不再赘述,此外还包括三个内部类：
public static class QuickMap<K extends EntityID, V extends Map<String, Property>> implements Map<K, V>
public static final class ConstantHost；
private class AddRemoveListener implements WorldModelListener

CollapseWorldModel类,地震后的世界（崩塌世界）

新增两个属性aftershocks和collapseBuildings

public class CollapseWorldModel extends StandardWorldModel {
    private HashMap<Integer, Float> aftershocks = new HashMap();//地震后时间与强度的映射。key为time,value为float型强度
    private HashMap<Building, CSBuilding> collapseBuildings = new HashMap();//倒塌的建筑集合（新增）
    public CollapseWorldModel() {//调用父类的构造方法，它的主要功能和父类相似
    }
    public void merge(ChangeSet changes) {//合并改变,具体实现在父类
        super.merge(changes);
    }
    public void updateAftershocks(KSAfterShocksInfo msg) {//更新时间与受损强度的信息。
        this.aftershocks = msg.getAftershocks();
    }
    public boolean aftershockHappens(int time) {
        return this.aftershocks.get(time) != null;
    }
    public float aftershockIntensity(int time) {//返回这个time的强度
        return (Float)this.aftershocks.get(time);
    }
    public HashMap<Building, CSBuilding> getCollapseBuildings() {//如果倒塌建筑数量不为零，返回倒塌建筑的映射集合
        if (this.collapseBuildings.size() == 0) {
            this.createCollapseBuildings();
        }
        return this.collapseBuildings;
    }
    private void createCollapseBuildings() {//把entities里所有的buliding实体设置为倒塌建筑，并put入CollapseBulidings映射中
        Iterator var1 = this.iterator();
        while(var1.hasNext()) {
            StandardEntity entity = (StandardEntity)var1.next();
            if (entity instanceof Building) {
                this.collapseBuildings.put((Building)entity, new CSBuilding((Building)entity));
            }
        }
    }
    public CSBuilding getCSBuiding(EntityID id) {//通过id得到指定的倒塌建筑
        return (CSBuilding)this.getCollapseBuildings().get((Building)this.getEntity(id));
    }
    public CSBuilding getCSBuiding(Building building) {//通过buliding得到指定的倒塌建筑
        return (CSBuilding)this.getCollapseBuildings().get(building);
    }
}

CSBuilding 倒塌的建筑,相对Building多两个属性

public class CSBuilding {
    private final Building real;
    private float collapsedRatio = 0.0F;//倒塌的比率（严重程度）
    private boolean hasFireDamage = false;//是否着火
    public CSBuilding(Building building) {//
        this.real = building;
    }
    public float getCollapsedRatio() {
        return this.collapsedRatio;
    }
    public void setCollapsedRatio(float collapsedRatio) {
        this.collapsedRatio = collapsedRatio;
    }
    public void increaseCollapseRatio(float ratio) {
        this.setCollapsedRatio(this.getCollapsedRatio() + ratio);
    }
    public Building getReal() {
        return this.real;
    }
//得到剩余的将要倒塌的double值。每层的高度乘楼层数再乘(1-倒塌比率)
    public double getRemainingToCollapse(double floorHeight) {
        return floorHeight * (double)this.real.getFloors() * (double)(1.0F - this.getCollapsedRatio());
    }
    public boolean hasFireDamage() {
        return false;
    }
    public void setHasFireDamage(boolean hasFireDamage) {
        this.hasFireDamage = hasFireDamage;
    }
    public double getTotalCollapse(double floorHeight) {
        return floorHeight * (double)this.real.getFloors();
    }
}