package com.github.clentfort.dota2.parser;
import java.util.Iterator;
import java.util.List;
import com.github.clentfort.dota2.dota.Abilities;
import com.github.clentfort.dota2.dota.Ability;
import com.github.clentfort.dota2.dota.AbilityLevelBasedType;
import com.github.clentfort.dota2.dota.Hero;
import com.github.clentfort.dota2.dota.HeroRole;
import com.github.clentfort.dota2.dota.Heroes;
import com.github.clentfort.dota2.dota.Unit;
import com.github.clentfort.dota2.dota.UnitAttribute;
import com.github.clentfort.dota2.dota.UnitStatus;
import com.github.clentfort.dota2.dota.Units;
public class ParserConverter {
public static final String BASE_UNIT = "npc_dota_units_base";
public static final String BASE_HERO = "npc_dota_hero_base";
public static final String BASE_ABILITY = "ability_base";
protected static Unit baseUnit(ParserObject baseObject) throws ParserException {
Unit baseUnit = new Unit();
baseUnit.setName("base");
baseUnit.setLevel(baseObject.getInt("Level"));
baseUnit.setAncient(baseObject.optBoolean("IsAncient"));
baseUnit.setNeutral(baseObject.optBoolean("IsNeutralUnitType"));
Unit.Abilities abilities = new Unit.Abilities();
baseUnit.setAbilities(abilities);
Unit.Armor armor = new Unit.Armor();
armor.setPhysical(baseObject.getDouble("ArmorPhysical"));
armor.setMagical(baseObject.getDouble("ArmorMagical"));
baseUnit.setArmor(armor);
Unit.Attack attack = new Unit.Attack();
attack.setAttackCapabilities(baseObject.getString("AttackCapabilities"));
Unit.Attack.Damage damage = new Unit.Attack.Damage();
damage.setDamageType(baseObject.getString("AttackDamageType"));
damage.setMin(baseObject.getInt("AttackDamageMin"));
damage.setMax(baseObject.getInt("AttackDamageMax"));
attack.setDamage(damage);
attack.setRate(baseObject.getDouble("AttackRate"));
attack.setRange(baseObject.getInt("AttackRange"));
attack.setProjectileSpeed(baseObject.getInt("ProjectileSpeed"));
baseUnit.setAttack(attack);
Unit.Attributes attributes = new Unit.Attributes();
attributes.setPrimary(baseObject.getString("AttributePrimary"));
UnitAttribute strength = new UnitAttribute();
strength.setBase(baseObject.getInt("AttributeBaseStrength"));
strength.setGain(baseObject.getDouble("AttributeStrengthGain"));
attributes.setStrength(strength);
UnitAttribute intelligence = new UnitAttribute();
intelligence.setBase(baseObject.getInt("AttributeBaseIntelligence"));
intelligence.setGain(baseObject.getDouble("AttributeIntelligenceGain"));
attributes.setIntelligence(intelligence);
UnitAttribute agility = new UnitAttribute();
agility.setBase(baseObject.getInt("AttributeBaseAgility"));
agility.setGain(baseObject.getDouble("AttributeAgilityGain"));
attributes.setAgility(agility);
baseUnit.setAttributes(attributes);
Unit.Bounty bounty = new Unit.Bounty();
bounty.setXp(baseObject.getInt("BountyXP"));
Unit.Bounty.Gold gold = new Unit.Bounty.Gold();
gold.setMin(baseObject.getInt("BountyGoldMin"));
gold.setMax(baseObject.getInt("BountyGoldMax"));
bounty.setGold(gold);
baseUnit.setBounty(bounty);
Unit.Movement movement = new Unit.Movement();
movement.setMovementCapabilities(baseObject.getString("MovementCapabilities"));
movement.setSpeed(baseObject.getInt("MovementSpeed"));
movement.setTurnRate(baseObject.getDouble("MovementTurnRate"));
baseUnit.setMovement(movement);
Unit.Stats stats = new Unit.Stats();
UnitStatus health = new UnitStatus();
health.setBase(baseObject.getInt("StatusHealth"));
health.setRegeneration(baseObject.getDouble("StatusHealthRegen"));
stats.setHealth(health);
UnitStatus mana = new UnitStatus();
mana.setBase(baseObject.getInt("StatusMana"));
mana.setRegeneration(baseObject.getDouble("StatusManaRegen"));
stats.setMana(mana);
baseUnit.setStats(stats);
Unit.Vision vision = new Unit.Vision();
vision.setDay(baseObject.getInt("VisionDaytimeRange"));
vision.setNight(baseObject.getInt("VisionNighttimeRange"));
baseUnit.setVision(vision);
return baseUnit;
}
public static Units toUnits(ParserObject object) throws ParserException {
ParserObject baseObject;
if (object.has(BASE_UNIT)) {
baseObject = object.getParserObject(BASE_UNIT);
object.remove(BASE_UNIT);
}
else if (object.has(BASE_HERO)) {
baseObject = object.getParserObject(BASE_HERO);
object.remove(BASE_HERO);
}
else throw new ParserException("The ParserObject is not a valid units object!");
Unit baseUnit = baseUnit(baseObject);
Units u = new Units();
List<Unit> units = u.getUnit();
for (Iterator i = object.keys(); i.hasNext();) {
String name = (String)i.next();
if (!name.startsWith("npc_dota_")) continue;
ParserObject unitObject = object.getParserObject(name);
Unit unit = new Unit(baseUnit);
unit.setName(name);
// Level
if (unitObject.has("Level"))
unit.setLevel(unitObject.getInt("Level"));
// Is ancient
if (unitObject.has("IsAncient"))
unit.setAncient(unitObject.getBoolean("IsAncient"));
// Is neutral
if (unitObject.has("IsNeutralUnitType"))
unit.setNeutral(unitObject.getBoolean("IsNeutralUnitType"));
// Abilities
for (Iterator j = unitObject.keys(); j.hasNext();) {
String key = (String)j.next();
if (key.startsWith("Ability") && !key.endsWith("Preview") && !unitObject.getString(key).isEmpty()) {
unit.getAbilities().getAbility().add(unitObject.getString(key));
}
}
// Armor
// Physical
if (unitObject.has("ArmorPhysical"))
unit.getArmor().setPhysical(unitObject.getDouble("ArmorPhysical"));
// Magical
if (unitObject.has("ArmorMagical"))
unit.getArmor().setMagical(unitObject.getDouble("ArmorMagical"));
// Attack
// AttackCapabilities
if (unitObject.has("AttackCapabilities"))
unit.getAttack().setAttackCapabilities(unitObject.getString("AttackCapabilities"));
// Damage
// Damage Type
if (unitObject.has("AttackDamageType"))
unit.getAttack().getDamage().setDamageType(unitObject.getString("AttackDamageType"));
// Min Damage
if (unitObject.has("AttackDamageMin"))
unit.getAttack().getDamage().setMin(unitObject.getInt("AttackDamageMin"));
// Max Damage
if (unitObject.has("AttackDamageMax"))
unit.getAttack().getDamage().setMax(unitObject.getInt("AttackDamageMax"));
// - End Damage
// Attack Rate
if (unitObject.has("AttackRate"))
unit.getAttack().setRate(unitObject.getDouble("AttackRate"));
// Attack Range
if (unitObject.has("AttackRange"))
unit.getAttack().setRange(unitObject.getInt("AttackRange"));
// Projectile Speed
if (unitObject.has("ProjectileSpeed"))
unit.getAttack().setProjectileSpeed(unitObject.getInt("ProjectileSpeed"));
// Attributes
// Primary
if (unitObject.has("AttributePrimary"))
unit.getAttributes().setPrimary(unitObject.getString("AttributePrimary"));
// Strength
if (unitObject.has("AttributeBaseStrength"))
unit.getAttributes().getStrength().setBase(unitObject.getInt("AttributeBaseStrength"));
if (unitObject.has("AttributeStrengthGain"))
unit.getAttributes().getStrength().setGain(unitObject.getDouble("AttributeStrengthGain"));
// Intelligence
if (unitObject.has("AttributeBaseIntelligence"))
unit.getAttributes().getIntelligence().setBase(unitObject.getInt("AttributeBaseIntelligence"));
if (unitObject.has("AttributeIntelligenceGain"))
unit.getAttributes().getIntelligence().setGain(unitObject.getDouble("AttributeIntelligenceGain"));
// Agility
if (unitObject.has("AttributeBaseAgility"))
unit.getAttributes().getAgility().setBase(unitObject.getInt("AttributeBaseAgility"));
if (unitObject.has("AttributeAgilityGain"))
unit.getAttributes().getAgility().setGain(unitObject.getDouble("AttributeAgilityGain"));
// Bounty
// XP
if (unitObject.has("BountyXP"))
unit.getBounty().setXp(unitObject.getInt("BountyXP"));
// Gold
if (unitObject.has("BountyGoldMin"))
unit.getBounty().getGold().setMin(unitObject.getInt("BountyGoldMin"));
if (unitObject.has("BountyGoldMax"))
unit.getBounty().getGold().setMax(unitObject.getInt("BountyGoldMax"));
// Movement
// Capabilities
if (unitObject.has("MovementCapabilities"))
unit.getMovement().setMovementCapabilities(unitObject.getString("MovementCapabilities"));
// Speed
if (unitObject.has("MovementSpeed"))
unit.getMovement().setSpeed(unitObject.getInt("MovementSpeed"));
// Turn rate
if (unitObject.has("MovementTurnRate"))
unit.getMovement().setTurnRate(unitObject.getDouble("MovementTurnRate"));
// Stats
// Health
if (unitObject.has("StatusHealth"))
unit.getStats().getHealth().setBase(unitObject.getInt("StatusHealth"));
// Health Regen
if (unitObject.has("StatusHealthRegen"))
unit.getStats().getHealth().setRegeneration(unitObject.getDouble("StatusHealthRegen"));
// Mana
if (unitObject.has("StatusMana"))
unit.getStats().getMana().setBase(unitObject.getInt("StatusMana"));
// Mana Regen
if (unitObject.has("StatusMana"))
unit.getStats().getMana().setRegeneration(unitObject.getDouble("StatusManaRegen"));
// Vision
// Day
if (unitObject.has("VisionDaytimeRange"))
unit.getVision().setDay(unitObject.getInt("VisionDaytimeRange"));
if (unitObject.has("VisionNighttimeRange"))
unit.getVision().setNight(unitObject.getInt("VisionNighttimeRange"));
units.add(unit);
}
return u;
}
public static Heroes toHeroes(ParserObject object) throws ParserException {
Units u = toUnits(object);
List<Unit> units = u.getUnit();
Heroes h = new Heroes();
List<Hero> heroes = h.getHero();
for (Unit unit : units) {
//Hero hero = (Hero)unit;
Hero hero = new Hero(unit);
ParserObject heroObject = object.getParserObject(hero.getName());
if (heroObject.has("HeroID"))
hero.setId(heroObject.getInt("HeroID"));
if (heroObject.has("Role"))
hero.setRole(HeroRole.fromValue(heroObject.getString("Role")));
if (heroObject.has("NameAliases"))
hero.setAlias(heroObject.getString("NameAliases"));
heroes.add(hero);
}
return h;
}
protected static void fillAbilityLevelBasedList(List<AbilityLevelBasedType> list, String string) {
String[] values = string.split(" ");
list.clear();
for (int i = 0; i < values.length; i++) {
AbilityLevelBasedType type = new AbilityLevelBasedType();
type.setLevel(i);
type.setValue(Double.parseDouble((String)values[i]));
list.add(type);
}
return;
}
protected static Ability baseAbility(ParserObject baseObject) throws ParserException {
Ability baseAbility = new Ability();
baseAbility.setId(baseObject.getInt("ID"));
baseAbility.setName(baseObject.getString("AbilityName"));
baseAbility.setType(baseObject.getString("AbilityType"));
baseAbility.setBehavior(baseObject.getString("AbilityBehavior"));
fillAbilityLevelBasedList(baseAbility.getCastRange(), baseObject.getString("AbilityCastRange"));
fillAbilityLevelBasedList(baseAbility.getChannelTime(), baseObject.getString("AbilityChannelTime"));
fillAbilityLevelBasedList(baseAbility.getCooldown(), baseObject.getString("AbilityCooldown"));
fillAbilityLevelBasedList(baseAbility.getDuration(), baseObject.getString("AbilityDuration"));
fillAbilityLevelBasedList(baseAbility.getDamage(), baseObject.getString("AbilityDamage"));
fillAbilityLevelBasedList(baseAbility.getManacost(), baseObject.getString("AbilityManaCost"));
return baseAbility;
}
public static Abilities toAbilities(ParserObject object) throws ParserException {
ParserObject baseObject;
if (object.has(BASE_ABILITY)) {
baseObject = object.getParserObject(BASE_ABILITY);
object.remove(BASE_ABILITY);
}
else throw new ParserException("The ParserObject is not a valid items object!");
Ability baseAbility = baseAbility(baseObject);
Abilities a = new Abilities();
List<Ability> abilities = a.getAbility();
for (Iterator i = object.keys(); i.hasNext();) {
String key = (String)i.next();
if (!(object.get(key) instanceof ParserObject)) continue;
ParserObject abilityObject = object.getParserObject(key);
Ability ability = new Ability(baseAbility);
if (abilityObject.has("ID"))
ability.setId(abilityObject.getInt("ID"));
if (abilityObject.has("AbilityName"))
ability.setName(abilityObject.getString("AbilityName"));
if (abilityObject.has("AbilityType"))
ability.setType(abilityObject.getString("AbilityType"));
if (abilityObject.has("AbilityBehavior"))
ability.setBehavior("AbilityBehavior");
if (abilityObject.has("AbilityCastRange"))
fillAbilityLevelBasedList(ability.getCastRange(), abilityObject.getString("AbilityCastRange"));
if (abilityObject.has("AbilityChannelTime"))
fillAbilityLevelBasedList(ability.getChannelTime(), abilityObject.getString("AbilityChannelTime"));
if (abilityObject.has("AbilityCooldown"))
fillAbilityLevelBasedList(ability.getCooldown(), abilityObject.getString("AbilityCooldown"));
if (abilityObject.has("AbilityDuration"))
fillAbilityLevelBasedList(ability.getDuration(), abilityObject.getString("AbilityDuration"));
if (abilityObject.has("AbilityDamage"))
fillAbilityLevelBasedList(ability.getDamage(), abilityObject.getString("AbilityDamage"));
if (abilityObject.has("AbilityManaCost"))
fillAbilityLevelBasedList(ability.getManacost(), abilityObject.getString("AbilityManaCost"));
abilities.add(ability);
}
return a;
}
}