skadistats.clarity.model.FieldPath Java Examples

default String dump(String title, Function<FieldPath, String> nameResolver) {
    final TextTable table = new TextTable.Builder()
            .setFrame(TextTable.FRAME_COMPAT)
            .addColumn("FP")
            .addColumn("Property")
            .addColumn("Value")
            .setTitle(title)
            .build();

    int i = 0;
    final Iterator<FieldPath> iter = fieldPathIterator();
    while (iter.hasNext()) {
        FieldPath fp = iter.next();
        table.setData(i, 0, fp);
        table.setData(i, 1, nameResolver.apply(fp));
        table.setData(i, 2, getValueForFieldPath(fp));
        i++;
    }

    return table.toString();
}
 

boolean applyInternal(Object[] value) {
    Entity e = (Entity) value[0];
    int eIdx = e.getIndex();
    TriState classMatchState = classMatchesForEntity.get(eIdx);
    if (classMatchState == TriState.UNSET) {
        classMatchState = TriState.fromBoolean(classPattern.matcher(e.getDtClass().getDtName()).matches());
        classMatchesForEntity.set(eIdx, classMatchState);
    }
    if (classMatchState != TriState.YES) {
        return false;
    }
    FieldPath fp = (FieldPath) value[1];
    TriState propertyMatchState = propertyMatchesForEntity[eIdx].get(fp);
    if (propertyMatchState == null) {
        propertyMatchState = TriState.fromBoolean(propertyPattern.matcher(e.getDtClass().getNameForFieldPath(fp)).matches());
        propertyMatchesForEntity[eIdx].put(fp, propertyMatchState);
    }
    if (propertyMatchState != TriState.YES) {
        return false;
    }
    return true;
}
 

private void processLifeStateChange(Entity e, FieldPath p) {
    int oldState = currentLifeState.containsKey(e.getIndex()) ? currentLifeState.get(e.getIndex()) : 2;
    int newState = e.getPropertyForFieldPath(p);
    if (oldState != newState) {
        currentLifeState.put(e.getIndex(), newState);
        switch(newState) {
            case 0:
                if (evSpawned != null) {
                    evSpawned.raise(e);
                }
                break;
            case 1:
                if (evDying != null) {
                    evDying.raise(e);
                }
                break;
            case 2:
                if (evDied != null) {
                    evDied.raise(e);
                }
                break;
        }
    }
}
 

@OnEntityUpdated
public void onUpdated(Entity e, FieldPath[] updatedPaths, int updateCount) {
    if (!isHero(e)) {
        return;
    }
    ensureFieldPaths(e);
    boolean update = false;
    for (int i = 0; i < updateCount; i++) {
        if (updatedPaths[i].equals(mana) || updatedPaths[i].equals(maxMana)) {
            update = true;
            break;
        }
    }
    if (update) {
        System.out.format("%s (%s/%s)\n", e.getDtClass().getDtName(), e.getPropertyForFieldPath(mana), e.getPropertyForFieldPath(maxMana));
    }
}
 

@OnEntityCreated
public void onCreated(Entity e) {
    FieldPath fp = e.getDtClass().getFieldPathForName("CBodyComponent.m_hModel");
    if (fp == null) {
        return;
    }
    Long resourceHandle = e.getPropertyForFieldPath(fp);
    if (resourceHandle == null || resourceHandle == 0L) {
        return;
    }
    Resources.Entry entry = resources.getEntryForResourceHandle(resourceHandle);
    System.out.format("model for entity at %d (%d): %s\n", e.getIndex(), resourceHandle, entry);
}
 

@OnEntityCreated
@Order(1000)
public void onEntityCreated(Entity e) {
    final Iterator<FieldPath> iter = e.getState().fieldPathIterator();
    while(iter.hasNext()) {
        evPropertyChanged.raise(e, iter.next());
    }
}
 

@Override
public Iterator<FieldPath> fieldPathIterator() {
    return new SimpleIterator<FieldPath>() {
        int i = 0;
        @Override
        public FieldPath readNext() {
            return i < state.length ? new S1FieldPath(i++) : null;
        }
    };
}
 

@OnEntityUpdated
@Order(1000)
public void onUpdate(Entity e, FieldPath[] fieldPaths, int num) {
    for (int i = 0; i < num; i++) {
        evPropertyChanged.raise(e, fieldPaths[i]);
    }
}
 

public <T> T getEntityProperty(Entity e, String property, Integer idx) {
	try {
     if (e == null) {
         return null;
     }
     if (idx != null) {
         property = property.replace("%i", Util.arrayIdxToString(idx));
     }
     FieldPath fp = e.getDtClass().getFieldPathForName(property);
     return e.getPropertyForFieldPath(fp);
	}
	catch (Exception ex) {
		return null;
	}
}
 

@Override
public void collectFieldPaths(S2ModifiableFieldPath fp, List<FieldPath> entries, ArrayEntityState state) {
    ArrayEntityState subState = state.sub(fp.cur());
    int len = subState.length();
    if (len > 0) {
        fp.down();
        fp.down();
        for (int i = 0; i < len; i++) {
            fp.set(fp.last() - 1, i);
            properties.getSerializer().collectFieldPaths(fp, entries, subState.sub(i));
        }
        fp.up(2);
    }
}
 

@Override
public void collectFieldPaths(S2ModifiableFieldPath fp, List<FieldPath> entries, ArrayEntityState state) {
    ArrayEntityState subState = state.sub(fp.cur());
    fp.down();
    for (int i = 0; i < subState.length(); i++) {
        if (subState.has(i)) {
            fp.cur(i);
            entries.add(fp.unmodifiable());
        }
    }
    fp.up(1);
}
 

@OnEntityUpdated
public void onUpdated(Context ctx, Entity e, FieldPath[] fieldPaths, int num) {
    FieldPath p = getFieldPathForEntity(e);
    if (p != null) {
        for (int i = 0; i < num; i++) {
            if (fieldPaths[i].equals(p)) {
                processLifeStateChange(e, p);
                break;
            }
        }
    }
}
 

@OnEntityCreated
public void onCreated(Context ctx, Entity e) {
    clearCachedState(e);
    ensureFieldPathForEntityInitialized(e);
    FieldPath p = getFieldPathForEntity(e);
    if (p != null) {
        processLifeStateChange(e, p);
    }
}
 

@OnEntityPropertyChanged(classPattern = "CDOTA_Unit_Hero_.*", propertyPattern = "m_lifeState")
public void onEntityPropertyChanged(Context ctx, Entity e, FieldPath fp) {
    System.out.format(
            "%6d %s: %s = %s\n",
            ctx.getTick(),
            e.getDtClass().getDtName(),
            e.getDtClass().getNameForFieldPath(fp),
            e.getPropertyForFieldPath(fp)
    );
}
 

public ObservableEntity(Entity entity) {
    this.entity = entity;
    index = new ReadOnlyStringWrapper(String.valueOf(entity.getIndex()));
    name = new ReadOnlyStringWrapper(entity.getDtClass().getDtName());
    Iterator<FieldPath> iter = entity.getState().fieldPathIterator();
    while (iter.hasNext()) {
        FieldPath fp = iter.next();
        indices.add(fp);
        properties.add(new ObservableEntityProperty(entity, fp));
    }
}
 

public void collectFieldPaths(S2ModifiableFieldPath fp, List<FieldPath> entries, ArrayEntityState state) {
    for (int i = 0; i < fields.length; i++) {
        if (state.has(i)) {
            fp.cur(i);
            fields[i].collectFieldPaths(fp, entries, state);
        }
    }
}
 

@OnEntityCreated
public void onCreated(Context ctx, Entity e) {      
    if (!isWard(e)) return;
    
    FieldPath lifeStatePath;
    
    clearCachedState(e);
    ensureFieldPathForEntityInitialized(e);
    if ((lifeStatePath = getFieldPathForEntity(e)) != null) {
        processLifeStateChange(e, lifeStatePath);
    }
}
 

@OnEntityUpdated
public void onUpdated(Context ctx, Entity e, FieldPath[] fieldPaths, int num) {
    FieldPath p;
    if ((p = getFieldPathForEntity(e)) != null) {
        for (int i = 0; i < num; i++) {
            if (fieldPaths[i].equals(p)) {
                toProcess.add(new ProcessEntityCommand(e, p));
                break;
            }
        }
    }
}
 

@Override
public String getNameForFieldPath(FieldPath fp) {
    List<String> parts = new ArrayList<>();
    serializer.accumulateName(fp.s2(), 0, parts);
    StringBuilder b = new StringBuilder();
    for (String part : parts) {
        if (b.length() != 0) {
            b.append('.');
        }
        b.append(part);
    }
    return b.toString();
}
 

public  void processLifeStateChange(Entity e, FieldPath p) {
    int oldState = currentLifeState.containsKey(e.getIndex()) ? currentLifeState.get(e.getIndex()) : 2;
    int newState = e.getPropertyForFieldPath(p);
    if (oldState != newState) {
        switch(newState) {
            case 0:
                if (evPlaced != null) {
                    evPlaced.raise(e);
                }
                break;
            case 1:
                String killer;
                if ((killer = wardKillersByWardClass.get(getWardTargetName(e.getDtClass().getDtName())).poll()) != null) {
                    if (evKilled != null) {
                        evKilled.raise(e, killer);
                    }
                } else {
                    if (evExpired != null) {
                        evExpired.raise(e);
                    }
                }
                break;
        }
    }
    
    currentLifeState.put(e.getIndex(), newState);
}
 

private void add(int from, List<? extends ObservableEntity> entities) {
    for (int i = 0; i < entities.size(); i++) {
        ObservableEntity oe = entities.get(i);
        Entity e = oe.getEntity();
        if (e == null) {
            continue;
        }
        FieldPath fp = e.getDtClass().getFieldPathForName("CBodyComponent.m_cellX");
        if (fp == null) {
            continue;
        }

        String name = oe.getEntity().getDtClass().getDtName();
        EntityIcon icon;
        if (name.equals("CDOTAPlayer")) {
            icon = new CameraIcon(oe);
        } else if (name.equals("CDOTA_BaseNPC_Barracks")) {
            icon = new BuildingIcon(oe, 250);
        } else if (name.equals("CDOTA_BaseNPC_Tower")) {
            icon = new BuildingIcon(oe, 200);
        } else if (name.equals("CDOTA_BaseNPC_Building")) {
            icon = new BuildingIcon(oe, 150);
        } else if (name.equals("CDOTA_BaseNPC_Fort")) {
            icon = new BuildingIcon(oe, 300);
        } else if (name.startsWith("CDOTA_Unit_Hero_")) {
            icon = new HeroIcon(oe);
        } else {
            icon = new DefaultIcon(oe);
        }

        mapEntities[from + i] = icon;
        icons.getChildren().add(icon.getShape());
    }
}
 

@Override
public V resolveValue(int index, int team, int pos) {
    String fieldPathString = pattern
            .replaceAll("%i", Util.arrayIdxToString(index))
            .replaceAll("%t", Util.arrayIdxToString(team))
            .replaceAll("%p", Util.arrayIdxToString(pos));
    String compiledName = entityName.replaceAll("%n", getTeamName(team));
    Entity entity = getEntity(compiledName);
    FieldPath fieldPath = entity.getDtClass().getFieldPathForName(fieldPathString);
    return entity.getPropertyForFieldPath(fieldPath);
}
 

@Override
public void collectFieldPaths(S2ModifiableFieldPath fp, List<FieldPath> entries, ArrayEntityState state) {
    int i = fp.cur();
    if (state.has(i)) {
        fp.down();
        properties.getSerializer().collectFieldPaths(fp, entries, state.sub(i));
        fp.up(1);
    }
}
 

@Override
public void collectFieldPaths(S2ModifiableFieldPath fp, List<FieldPath> entries, ArrayEntityState state) {
    ArrayEntityState subState = state.sub(fp.cur());
    fp.down();
    for (int i = 0; i < subState.length(); i++) {
        if (subState.has(i)) {
            fp.cur(i);
            entries.add(fp.unmodifiable());
        }
    }
    fp.up(1);
}
 

public <T> ObjectBinding<T> getPropertyBinding(Class<T> propertyClass, String property, T defaultValue) {
    FieldPath fp = entity.getDtClass().getFieldPathForName(property);
    if (fp == null) {
        return Bindings.createObjectBinding(() -> defaultValue);
    } else {
        ObjectBinding<T> ob = getPropertyForFieldPath(fp).rawProperty();
        return Bindings.createObjectBinding(() -> ob.get(), ob);
    }
}
 

void update(FieldPath[] fieldPaths, int num) {
    for (int i = 0; i < num; i++) {
        int idx = getIndexForFieldPath(fieldPaths[i]);
        if (idx < 0) {
            ensureChangeOpen();
            idx = - idx - 1;
            indices.add(idx, fieldPaths[i]);
            properties.add(idx, new ObservableEntityProperty(entity, fieldPaths[i]));
            nextAdd(idx, idx);
        } else {
            properties.get(idx).setDirty(true);
        }
    }
}
 

@OnEntityUpdated
public void onUpdate(Entity entity, FieldPath[] fieldPaths, int num) {
    lock.lock();
    try {
        markChange(CF_PROP);
        int i = entity.getIndex();
        ObservableEntity e = changes[i] == null ? entities[i] : changes[i];
        e.update(fieldPaths, num);
    } finally {
        lock.unlock();
    }
}
 

@Override
public void collectFieldPaths(S2ModifiableFieldPath fp, List<FieldPath> entries, ArrayEntityState state) {
    entries.add(fp.unmodifiable());
}
 

@Override
public String getNameForFieldPath(FieldPath fp) {
    return this.receiveProps[fp.s1().idx()].getVarName();
}
 

@OnReset
public void onReset(Demo.CDemoStringTables packet, ResetPhase phase) {
    switch (phase) {
        case START:
            resetInProgress = true;
            resetCapsule = entities.createCapsule();
            break;

        case CLEAR:
            entities = new ClientFrame(entityCount);
            for (int i = 0; i < classBaselines.length; i++) {
                classBaselines[i].reset();
            }
            for (int i = 0; i < entityBaselines.length; i++) {
                entityBaselines[i][0].reset();
                entityBaselines[i][1].reset();
            }
            break;

        case COMPLETE:
            resetInProgress = false;

            //updateEventDebug = true;

            Entity entity;
            for (int eIdx = 0; eIdx < entityCount; eIdx++) {
                entity = entities.getEntity(eIdx);
                if (resetCapsule.isExistent(eIdx)) {
                    if (entity == null || entity.getHandle() != resetCapsule.getHandle(eIdx)) {
                        Entity deletedEntity = entityRegistry.get(resetCapsule.getHandle(eIdx));
                        if (resetCapsule.isActive(eIdx)) {
                            emitLeftEvent(deletedEntity);
                        }
                        emitDeletedEvent(deletedEntity);
                    }
                }
                if (entity != null) {
                    if (!resetCapsule.isExistent(eIdx) || entity.getHandle() != resetCapsule.getHandle(eIdx)) {
                        emitCreatedEvent(entity);
                        if (entity.isActive()) {
                            emitEnteredEvent(entity);
                        }
                    } else {
                        Iterator<FieldPath> iter = entity.getState().fieldPathIterator();
                        int n = 0;
                        while (iter.hasNext()) {
                            updatedFieldPaths[n++] = iter.next();
                        }
                        emitUpdatedEvent(entity, n);
                    }
                }
            }

            resetCapsule = null;

            //updateEventDebug = false;

            evUpdatesCompleted.raise();
            break;
    }
}