Java ObjectIntMap.put方法代码示例

import com.badlogic.gdx.utils.ObjectIntMap; //导入方法依赖的package包/类
private IActionResult calcResult(Creature creature, Grid2D.Coordinate cell) {
    Vector2 position = tmp.set(cell.x(), cell.y());
    ObjectIntMap<Creature> targets = new ObjectIntMap<Creature>();
    for (int i = cell.x() - MathUtils.ceil(radius); i <= cell.x() + radius; i++) {
        for (int j = cell.y() - MathUtils.ceil(radius); j <= cell.y() + radius; j++) {
            if (position.dst(i, j) <= radius) {
                WorldObject object = creature.world.get(i, j);
                if (object instanceof Creature
                    && ((Creature) object).get(Attribute.canBeSelected)
                    && !((Creature) object).get(Attribute.frozen)) {
                    targets.put((Creature) object, i == cell.x() && j == cell.y() ? epicenterTurns : turns);
                }
            }
        }
    }

    return new IceStormResult(owner, creature, cell, targets);
}
 

import com.badlogic.gdx.utils.ObjectIntMap; //导入方法依赖的package包/类
public ObjectIntMap read (Kryo kryo, Input input, Class<ObjectIntMap> type) {
    int length = input.readVarInt(true);
    input.readBoolean(); // currently unused
    ObjectIntMap map = create(length);

    Class keyClass = null;

    Serializer keySerializer = null;
    if (keyGenericType != null) {
        keyClass = keyGenericType;
        if (keySerializer == null) keySerializer = kryo.getSerializer(keyClass);
        keyGenericType = null;
    }

    kryo.reference(map);

    for (int i = 0; i < length; i++) {
        Object key;
        if (keySerializer != null) {
            key = kryo.readObject(input, keyClass, keySerializer);
        } else
            key = kryo.readClassAndObject(input);
        int value = input.readInt();
        map.put(key, value);
    }
    return map;
}
 

import com.badlogic.gdx.utils.ObjectIntMap; //导入方法依赖的package包/类
private void fetchAttributes () throws Exception {
    IntBuffer params = $getValue__params();
    IntBuffer type = $getValue__type();
    int program = $getValue__program();
    ObjectIntMap<String> attributes = $getValue__attributes();
    ObjectIntMap<String> attributeTypes = $getValue__attributeTypes();
    ObjectIntMap<String> attributeSizes = $getValue__attributeSizes();

    params.clear();
    Gdx.gl20.glGetProgramiv(program, GL20.GL_ACTIVE_ATTRIBUTES, params);
    int numAttributes = params.get(0);

    String[] attributeNames = new String[numAttributes];

    for (int i = 0; i < numAttributes; i++) {
        params.clear();
        params.put(0, 1);
        type.clear();
        String name = Gdx.gl20.glGetActiveAttrib(program, i, params, type);
        int location = Gdx.gl20.glGetAttribLocation(program, name);
        attributes.put(name, location);
        attributeTypes.put(name, type.get(0));
        attributeSizes.put(name, params.get(0));
        attributeNames[i] = name;
    }

    $setValue_attributeNames(attributeNames);
}
 

import com.badlogic.gdx.utils.ObjectIntMap; //导入方法依赖的package包/类
private void fetchUniforms () throws Exception {
    IntBuffer params = $getValue__params();
    IntBuffer type = $getValue__type();
    int program = $getValue__program();
    ObjectIntMap<String> uniforms = $getValue__uniforms();
    ObjectIntMap<String> uniformTypes = $getValue__uniformTypes();
    ObjectIntMap<String> uniformSizes = $getValue__uniformSizes();

    params.clear();
    Gdx.gl20.glGetProgramiv(program, GL20.GL_ACTIVE_UNIFORMS, params);
    int numUniforms = params.get(0);

    String[] uniformNames = new String[numUniforms];

    for (int i = 0; i < numUniforms; i++) {
        params.clear();
        params.put(0, 1);
        type.clear();
        String name = Gdx.gl20.glGetActiveUniform(program, i, params, type);
        int location = Gdx.gl20.glGetUniformLocation(program, name);
        uniforms.put(name, location);
        uniformTypes.put(name, type.get(0));
        uniformSizes.put(name, params.get(0));
        uniformNames[i] = name;
    }
    $setValue_uniformNames(uniformNames);
}
 

import com.badlogic.gdx.utils.ObjectIntMap; //导入方法依赖的package包/类
private IActionResult calcResult(Creature creature, Grid2D.Coordinate cell) {
    Vector2 position = tmp.set(cell.x(), cell.y());
    Array<Creature> underAttack = new Array<Creature>();
    Array<Creature> killed = new Array<Creature>();
    ObjectIntMap<Creature> expResults = new ObjectIntMap<Creature>();
    for (int i = cell.x() - MathUtils.ceil(radius); i <= cell.x() + radius; i++) {
        for (int j = cell.y() - MathUtils.ceil(radius); j <= cell.y() + radius; j++) {
            if (position.dst(i, j) <= radius) {
                WorldObject object = creature.world.get(i, j);
                if (object instanceof Creature && ((Creature) object).get(Attribute.canBeSelected)) {
                    underAttack.add((Creature) object);
                }
            }
        }
    }
    for (Creature c : underAttack) {
        int attackLevel = (c.getX() == cell.x() && c.getY() == cell.y()) ? this.epicenterAttackLevel : this.attackLevel;
        int defenceLevel = c.get(Attribute.defenceFor(attackType));
        if (attackLevel > defenceLevel) {
            killed.add(c);
            if (creature.inRelation(Creature.CreatureRelation.enemy, c)) {
                expResults.getAndIncrement(creature, 0, ExpHelper.expForKill(creature, c));
            }
        } else {
            if (creature.inRelation(Creature.CreatureRelation.enemy, c)) {
                expResults.put(c, ExpHelper.expForDefence(creature, c));
            } else {
                expResults.put(c, ExpHelper.MIN_EXP);
            }
        }
    }
    return new FirestormResult(creature, owner, underAttack, killed, expResults, cell);
}
 

import com.badlogic.gdx.utils.ObjectIntMap; //导入方法依赖的package包/类
/**
 * Compute the target influence on all tiles around the starting position.
 * <p>
 * Note: resulting target can be negative. It stops on tiles where there is no
 * influence from source AND target is not positive.
 */
private ObjectIntMap<Influence> getTargetInfluence(Entity source, MapPosition startPos, int startingPower) {
  Map<Terrain, Integer> costs = terrainCosts(source);
  Queue<Pos> frontier = new PriorityQueue<>();
  frontier.add(new Pos(startPos, startingPower));
  ObjectIntMap<Influence> targets = new ObjectIntMap<>();
  targets.put(map.getInfluenceAt(startPos), startingPower);

  while (!frontier.isEmpty()) {
    Pos current = frontier.poll();

    for (MapPosition next : map.getNeighbors(current.pos)) {
      Influence inf = map.getInfluenceAt(next);
      if (!inf.terrain.moveBlock()) {
        int newTarget = current.target - costs.get(inf.terrain);
        int oldTarget = targets.get(inf, Integer.MIN_VALUE);
        if (newTarget > oldTarget) {
          targets.put(inf, newTarget);
          /*
           * Increase only one tile from already influenced tiles. Decreases
           * wherever we have some influence (makes no sense to decrease
           * elsewhere.
           */
          if (inf.hasInfluence(source))
            frontier.offer(new Pos(next, newTarget));
        }
      }
    }
  }
  return targets;
}