Example usage for com.badlogic.gdx.utils ObjectIntMap getAndIncrement

List of usage examples for com.badlogic.gdx.utils ObjectIntMap getAndIncrement

Introduction

In this page you can find the example usage for com.badlogic.gdx.utils ObjectIntMap getAndIncrement.

Prototype

public int getAndIncrement(K key, int defaultValue, int increment) 

Source Link

Document

Returns the key's current value and increments the stored value.

Usage

From source file:com.vlaaad.dice.achievements.conditions.imp.MaxUsedDice.java

License:Open Source License

@Override
protected boolean satisfied(EndLevelEvent event) {
    ObjectSet<Creature> creatures = event.result().viewer.creatures;
    if (maxCount != -1) {
        return creatures.size <= maxCount;
    }/*from   w ww.j a va  2 s .c o  m*/
    ObjectIntMap<ProfessionDescription> used = tmp;
    for (Creature c : creatures) {
        used.getAndIncrement(c.profession, 0, 1);
    }
    for (ObjectIntMap.Entry<ProfessionDescription> entry : used.entries()) {
        ProfessionDescription profession = entry.key;
        int count = entry.value;
        int maxCount = maxes.get(profession, 0);
        if (count > maxCount) {
            tmp.clear();
            return false;
        }
    }
    tmp.clear();
    return true;
}

From source file:com.vlaaad.dice.game.actions.imp.ChainLightning.java

License:Open Source License

private IActionResult calcResult(Ability ability, Creature caster, Creature target, World world) {
    ObjectSet<Creature> affected = tmpSet;
    Array<Creature> chain = new Array<Creature>();
    chain.add(target);//from  w  w  w. java  2s  .  c om
    affected.add(target);

    // i == 1 because we already have initial target
    RandomController random = world.getController(RandomController.class);

    for (int i = 1; i < targets; i++) {
        Creature last = chain.peek();
        tmpArray2.clear();
        Array<Creature> neighbours = getNeighbourCreatures(world, last.getX(), last.getY(), tmpArray2);
        Iterator<Creature> it = neighbours.iterator();
        while (it.hasNext()) {
            Creature toCheck = it.next();
            if (affected.contains(toCheck))
                it.remove();
        }
        if (neighbours.size == 0) {
            break;
        } else if (neighbours.size == 1) {
            addToChain(affected, chain, neighbours.first());
        } else {
            Array<Creature> betterTargets = tmpArray3;
            betterTargets.clear();
            for (Creature toCheck : neighbours) {
                if (toCheck.get(Attribute.defenceFor(attackType)) < attackLevel) {
                    betterTargets.add(toCheck);
                }
            }
            if (betterTargets.size > 0) {
                addToChain(affected, chain, random.random(betterTargets));
            } else {
                addToChain(affected, chain, random.random(neighbours));
            }
        }
    }

    ObjectIntMap<Creature> expResults = new ObjectIntMap<Creature>();
    Array<Creature> killed = new Array<Creature>();

    for (Creature creature : chain) {
        if (creature.get(Attribute.defenceFor(attackType)) < attackLevel) { // killed
            if (creature.player != caster.player) {
                expResults.getAndIncrement(caster, 0, ExpHelper.expForKill(caster, creature));
            }
            killed.add(creature);
        } else { // survived
            expResults.put(creature, ExpHelper.expForDefence(caster, creature));
        }
    }

    tmpSet.clear();
    tmpArray2.clear();
    tmpArray3.clear();

    return new ChainLightningResult(caster, ability, chain, killed, expResults);
}

From source file:com.vlaaad.dice.game.actions.imp.Firestorm.java

License:Open Source License

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);
                }/*  w  w w.  j  a v a  2 s .  c  om*/
            }
        }
    }
    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);
}

From source file:com.vlaaad.dice.game.config.abilities.Ability.java

License:Open Source License

public static Comparator<? super Ability> countComparator(UserData userData) {
    final ObjectIntMap<Ability> counts = new ObjectIntMap<Ability>();
    for (Die die : userData.dice()) {
        for (ObjectIntMap.Entry<Ability> e : die.inventory)
            counts.getAndIncrement(e.key, e.value, e.value);
        for (Ability ability : die.abilities)
            if (ability != null)
                counts.getAndIncrement(ability, 0, 1);
    }/*from w w  w  .j  a va 2s .c om*/
    return new Comparator<Ability>() {
        @Override
        public int compare(Ability o1, Ability o2) {
            return counts.get(o1, 0) - counts.get(o2, 0);
        }
    };
}

From source file:com.vlaaad.dice.game.config.items.drop.Drop.java

License:Open Source License

public ObjectIntMap<Item> roll() {
    ObjectIntMap<Item> res = new ObjectIntMap<Item>();
    for (Roll roll : rolls) {
        for (RangeItemCount rangeItemCount : roll.roll()) {
            res.getAndIncrement(rangeItemCount.item, 0, rangeItemCount.count);
        }//from   w w  w.  j  a  v  a  2 s.  com
    }
    return res;
}

From source file:com.vlaaad.dice.game.user.Die.java

License:Open Source License

public Die(ProfessionDescription profession, String name, int exp, Array<Ability> abilities,
        ObjectIntMap<Ability> inventory) {
    this.profession = profession;
    this.name = name;
    this.exp = exp;
    this.abilities = abilities;
    this.inventory = inventory;
    Iterator<Ability> it = abilities.iterator();
    while (it.hasNext()) {
        Ability ability = it.next();//from  w  w  w.  j  a  v  a 2 s.  c o  m
        if (ability != null && !profession.ignoreRequirements && (!ability.requirement.isSatisfied(this))) {
            inventory.getAndIncrement(ability, 0, 1);
            it.remove();
        }
    }
    int used = getUsedSkill();
    int total = getTotalSkill();
    if (used > total) {
        System.out.print(name + " has skill overdraft, " + used + " > " + total + ", inventory = ");
    }
    while (abilities.size > 0 && getUsedSkill() > getTotalSkill()) {
        Ability popped = abilities.pop();
        if (popped != null)
            inventory.getAndIncrement(popped, 0, 1);
    }
    if (used > total)
        System.out.println(inventory);

    while (abilities.size < 6)
        abilities.add(null);
}

From source file:com.vlaaad.dice.game.world.view.visualizers.CleaveVisualizer.java

License:Open Source License

@Override
public IFuture<Void> visualize(final CleaveResult result) {
    final Future<Void> future = new Future<Void>();
    final CountDown countDown = new CountDown(result.results.size + 1, new Runnable() {
        @Override//from w  w w .  j a v  a2  s .c  o m
        public void run() {
            future.happen();
        }
    });
    final WorldObjectView actorView = visualizer.viewController.getView(result.creature);
    final AnimationSubView appear = new AnimationSubView(0.05f,
            Config.findRegions("animation/attack-" + result.attackType + "-" + result.attackLevel),
            Animation.PlayMode.NORMAL);
    visualizer.viewController.world.dispatcher.dispatch(ResultVisualizer.VISUALIZE_ATTACK, result.creature);
    actorView.addSubView(appear);
    //appear
    actorView.addListener(new AnimationListener() {
        @Override
        protected void onAnimationEvent(AnimationEvent event) {
            actorView.removeListener(this);
            actorView.removeSubView(appear);
            final ImageSubView sword = new ImageSubView(
                    "animation/attack-" + result.attackType + "-" + result.attackLevel + "-diagonal");
            actorView.addSubView(sword);
            //cleave
            sword.getActor()
                    .addAction(Actions.sequence(
                            Actions.moveBy(ViewController.CELL_SIZE / 2, ViewController.CELL_SIZE / 2, 0.1f),
                            Actions.run(new Runnable() {
                                @Override
                                public void run() {
                                    for (Creature target : result.targets) {
                                        visualizer.viewController
                                                .visualize(new Defence(target, result.attackType));
                                    }

                                }
                            }), Actions.parallel(Actions.rotateBy(360, 0.15f),
                                    Actions.sequence(Actions.delay(0.07f), Actions.run(new Runnable() {
                                        @Override
                                        public void run() {
                                            for (IActionResult sub : result.results) {
                                                SequenceResult sequence = (SequenceResult) sub;
                                                AttackResult attackResult = (AttackResult) sequence.results
                                                        .get(0);
                                                String soundName = result.attackType.toString()
                                                        + (attackResult.success ? "-kill" : "-miss");
                                                SoundManager.instance.playSoundIfExists(soundName);
                                                if (attackResult.success) {

                                                    visualizer.viewController
                                                            .visualize(new Death(attackResult.creature,
                                                                    attackResult.target))
                                                            .addListener(countDown);
                                                } else {
                                                    countDown.tick();
                                                }
                                            }
                                        }
                                    }))),
                            Actions.run(new Runnable() {
                                @Override
                                public void run() {
                                    //disappear
                                    actorView.removeSubView(sword);
                                    Array<TextureAtlas.AtlasRegion> appearRegions = Config.findRegions(
                                            "animation/attack-" + result.attackType + "-" + result.attackLevel);
                                    Array<TextureAtlas.AtlasRegion> disappearRegions = new Array<TextureAtlas.AtlasRegion>(
                                            appearRegions);
                                    disappearRegions.removeIndex(1);
                                    disappearRegions.reverse();
                                    final AnimationSubView disappear = new AnimationSubView(0.1f,
                                            disappearRegions, Animation.PlayMode.NORMAL);
                                    actorView.addSubView(disappear);
                                    actorView.addListener(new AnimationListener() {
                                        @Override
                                        protected void onAnimationEvent(AnimationEvent event) {
                                            actorView.removeListener(this);
                                            actorView.removeSubView(disappear);
                                            ObjectIntMap<Creature> expResults = new ObjectIntMap<Creature>();
                                            for (IActionResult sub : result.results) {
                                                GiveExpResult expResult = (GiveExpResult) ((SequenceResult) sub).results
                                                        .get(1);

                                                if (expResult.creature.player == expResult.creature.world.viewer) {
                                                    expResults.getAndIncrement(expResult.creature, 0,
                                                            expResult.exp);
                                                }
                                            }
                                            if (expResults.size == 0) {
                                                countDown.tick();
                                                return;
                                            }
                                            IActionResult[] expArray = new IActionResult[expResults.size];
                                            int i = 0;
                                            for (Creature creature : expResults.keys()) {
                                                expArray[i] = new GiveExpResult(creature,
                                                        expResults.get(creature, 0));
                                                i++;
                                            }
                                            SequenceResult seq = new SequenceResult(expArray);
                                            visualizer.visualize(seq).addListener(new IFutureListener<Void>() {
                                                @Override
                                                public void onHappened(Void aVoid) {
                                                    countDown.tick();
                                                }
                                            });
                                        }
                                    });
                                }
                            })));
        }
    });

    return future;
}

From source file:com.vlaaad.dice.ui.components.CraftingPane.java

License:Open Source License

private boolean inputMatches(ObjectIntMap<Item> in, ObjectIntMap<Item> req) {
    ObjectIntMap<Item> cost = tmp2;
    cost.clear();//  w  ww  .  j  a va 2 s.c  o m
    cost.putAll(req);
    ObjectIntMap<Item> resources = tmp3;
    resources.clear();
    resources.putAll(in);
    for (Item item : resources.keys()) {
        int required = cost.get(item, 0);
        int existed = resources.get(item, 0);
        if (required > existed)
            return false;
        if (required == 0)
            continue;
        cost.remove(item, 0);
        resources.getAndIncrement(item, 0, -required);
    }
    if (cost.size == 0)
        return true;
    for (Item unsatisfied : cost.keys()) {
        if (unsatisfied.type != Item.Type.anyIngredient)
            return false;
        int required = cost.get(unsatisfied, 0);
        for (Item item : resources.keys()) {
            int withdrawCount = Math.min(resources.get(item, 0), required);
            if (withdrawCount == 0)
                continue;
            required -= withdrawCount;
            resources.getAndIncrement(item, 0, -withdrawCount);
            cost.getAndIncrement(unsatisfied, 0, -withdrawCount);
            if (required == 0)
                break;
        }
    }
    for (Item unsatisfied : cost.keys()) {
        if (cost.get(unsatisfied, 0) != 0)
            return false;
    }
    return true;
}

From source file:com.vlaaad.dice.ui.util.RewardViewHelper.java

License:Open Source License

public static Table createRewardsView(Iterable<RewardResult> rewards, ObjectIntMap<Item> earnedItems,
        UserData userData) {//  w ww .  j ava2  s  .co  m
    Table rewardList = new Table(Config.skin);
    rewardList.setTransform(true);
    rewardList.padTop(18).padBottom(14);

    Array<AddedDie> dieRewards = new Array<AddedDie>();
    Array<AddedAbility> abilityRewards = new Array<AddedAbility>();
    ObjectIntMap<Item> earned = new ObjectIntMap<Item>(earnedItems);

    for (RewardResult reward : rewards) {
        if (reward instanceof AddedItems) {
            final AddedItems addedItems = (AddedItems) reward;
            earned.getAndIncrement(addedItems.item, 0, addedItems.addedCount);
        } else if (reward instanceof AddedDie) {
            dieRewards.add(((AddedDie) reward));
        } else if (reward instanceof AddedAbility) {
            abilityRewards.add(((AddedAbility) reward));
        } else {
            throw new IllegalArgumentException("unknown reward: " + reward);
        }
    }

    if (earned.size > 0) {
        Table items = new Table();
        items.setTransform(true);
        Array<Item> sorted = earned.keys().toArray();
        sorted.sort(Item.ORDER_COMPARATOR);
        for (Item item : sorted) {
            Table rewardView = new Table(Config.skin);
            Image image = new Image(Config.skin, "item/" + item.name);
            Label counter = new Label(String.valueOf(earned.get(item, 0)), Config.skin, "default",
                    VICTORY_TEXT_COLOR);
            counter.setFontScale(2f);
            rewardView.add(image).size(image.getPrefWidth() * 2, image.getPrefHeight() * 2).pad(-6);
            rewardView.add(counter).padTop(-5);
            items.add(rewardView);
        }
        rewardList.add(items).padTop(-10).row();
    }

    if (dieRewards.size > 0) {
        Label joins = new LocLabel("ui-reward-window-new-die", VICTORY_TEXT_COLOR);
        joins.setWrap(true);
        joins.setAlignment(Align.center);
        rewardList.add(joins).width(80).row();
        Table dice = new Table();
        dice.setTransform(true);
        for (AddedDie reward : dieRewards) {
            dice.add(ViewController.createView(new Creature(reward.die, PlayerHelper.defaultProtagonist)));
        }
        rewardList.add(dice).padTop(15).row();
    }

    if (abilityRewards.size > 0) {
        HorizontalGroup abilities = new HorizontalGroup();
        abilities.center().padTop(15).space(10).padLeft(-4);
        for (AddedAbility reward : abilityRewards) {
            final AbilityIcon icon = new AbilityIcon(reward.ability);
            icon.setColor(UNIQUE_DARK);
            abilities.addActor(new Container<AbilityIcon>(icon)
                    .size(icon.getPrefWidth() * 2, icon.getPrefHeight() * 2).pad(-12));
            abilities.addActor(
                    ViewController.createView(new Creature(reward.die, PlayerHelper.defaultProtagonist)));
        }

        final VerticalGroup group = new VerticalGroup();
        final Label label = new Label(Thesaurus.Util.enumerate(Config.thesaurus, abilityRewards,
                new Thesaurus.Util.Stringifier<AddedAbility>() {
                    @Override
                    public String toString(AddedAbility info) {
                        return Config.thesaurus.localize("die-gets-ability",
                                Thesaurus.params().with("die", info.die.nameLocKey()).with("ability",
                                        info.ability.locNameKey() + ".acc"));
                    }
                }), Config.skin, "default", VICTORY_TEXT_COLOR);
        label.setAlignment(Align.center);
        group.addActor(label);
        group.addActor(abilities);
        rewardList.add(group).padTop(10).row();
    }
    return rewardList;
}