SalvageEntityGenDataSpec.java

Go to the documentation of this file.

package com.fs.starfarer.api.impl.campaign.procgen;
 
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
 
import org.json.JSONException;
import org.json.JSONObject;
 
import com.fs.starfarer.api.util.Misc;
import com.fs.starfarer.api.util.WeightedRandomPicker;
 
public class SalvageEntityGenDataSpec {
    
    public static enum DiscoverabilityType {
        DISCOVERABLE,
        NOT_DISCOVERABLE,
        ALWAYS_VISIBLE,
    }
    
    public static class DropData implements Cloneable {
        transient public String group;
        transient public int chances = -1;
        transient public int maxChances = -1;
        transient public int value = -1;
        transient public float valueMult = 1f;
        private WeightedRandomPicker<DropGroupRow> custom = null;
        
        private String j = null;
//      public DropData(String group) {
//          this.group = group;
//      }
        Object readResolve() {
            if (j != null) {
                try {
                    JSONObject json = new JSONObject(j);
                    if (json.has("g")) group = json.getString("g");
                    if (json.has("c")) {
                        chances = json.getInt("c");
                    } else {
                        chances = -1;
                    }
                    if (json.has("mC")) {
                        maxChances = json.getInt("mC");
                    } else {
                        maxChances = -1;
                    }
                    if (json.has("v")) {
                        value = json.getInt("v");
                    } else {
                        value = -1;
                    }
                    if (json.has("vM")) {
                        valueMult = (float) json.getDouble("vM");
                    } else {
                        valueMult = 1f;
                    }
                } catch (JSONException e) {
                    throw new RuntimeException(e);
                }
            }
            return this;
        }
        
        Object writeReplace() {
            try {
                JSONObject json = new JSONObject();
                if (group != null) json.put("g", group);
                if (chances > 0) json.put("c", chances);
                if (maxChances > 0) json.put("mC", maxChances);
                if (value > 0) json.put("v", value);
                if (valueMult != 1) json.put("vM", valueMult);
                j = json.toString();
            } catch (JSONException e) {
                throw new RuntimeException(e);
            }
            return this;
        }
        
        
        public void addWeapon(String id, float weight) {
            addCustom(DropGroupRow.WEAPON_PREFIX + id, weight);
        }
        public void addHullMod(String id, float weight) {
            //addCustom(DropGroupRow.MOD_PREFIX + id, weight);
            addCustom("item_modspec:" + id, weight);
        }
        public void addFighterChip(String id, float weight) {
            addCustom(DropGroupRow.FIGHTER_PREFIX + id, weight);
        }
        public void addNothing(float weight) {
            addCustom(DropGroupRow.NOTHING, weight);
        }
        public void addCommodity(String id, float weight) {
            addCustom(id, weight);
        }
        public void addSpecialItem(String data, float weight) {
            addCustom(DropGroupRow.ITEM_PREFIX + data, weight);
        }
        public void addCustom(String data, float weight) {
            initCustom();
            for (int i = 0; i < custom.getItems().size(); i++) {
                DropGroupRow row = custom.getItems().get(i);
                if (row.getCommodity() != null && row.getCommodity().equals(data)) {
                    float w = custom.getWeight(i);
                    w += weight;
                    custom.setWeight(i, w);
                    return;
                }
            }
            DropGroupRow row = new DropGroupRow(data, "custom", weight);
            custom.add(row, weight);
        }
        
        public void addRandomWeapons(int tier, float weight) {
            addCustom(DropGroupRow.WEAPON_PREFIX, tier, weight, (String []) null);
        }
        public void addRandomWeapons(int tier, float weight, String ... tags) {
            addCustom(DropGroupRow.WEAPON_PREFIX, tier, weight, tags);
        }
        
        public void addRandomHullmods(int tier, float weight) {
            //addCustom(DropGroupRow.MOD_PREFIX, tier, weight, (String []) null);
            addCustom("item_modspec:", tier, weight, (String []) null);
        }
        public void addRandomHullmods(int tier, float weight, String ... tags) {
            //addCustom(DropGroupRow.MOD_PREFIX, tier, weight, tags);
            addCustom("item_modspec:", tier, weight, tags);
        }
        
        public void addRandomFighters(int tier, float weight) {
            addCustom(DropGroupRow.FIGHTER_PREFIX, tier, weight, (String []) null);
        }
        public void addRandomFighters(int tier, float weight, String ... tags) {
            addCustom(DropGroupRow.FIGHTER_PREFIX, tier, weight, tags);
        }
        
        private void addCustom(String prefix, int tier, float weight, String ... tags) {
            initCustom();
            
            String data = prefix;
            data += "{";
            if (tier >= 0) {
                data += "tier:" + tier + ",";
            }
            if (tags != null && tags.length > 0) {
                data += "tags:[";
                for (String tag : tags) {
                    data += tag + ",";
                }
                data += "]";
            }
            data += "}";
            DropGroupRow row = new DropGroupRow(data, "custom", weight);
            custom.add(row, weight);
        }
        
        public void initCustom() {
            if (custom == null) {
                custom = new WeightedRandomPicker<DropGroupRow>();
            }
        }
        
        public void clearCustom() {
            custom = null;
        }
        
        public WeightedRandomPicker<DropGroupRow> getCustom() {
            return custom;
        }
 
        @Override
        public DropData clone() {
            try {
                DropData copy = (DropData) super.clone();
                
                if (custom != null) {
                    copy.custom = new WeightedRandomPicker<DropGroupRow>();
                    for (int i = 0; i < custom.getItems().size(); i++) {
                        copy.custom.add(custom.getItems().get(i), custom.getWeight(i));
                    }
                }
                return copy;
            } catch (CloneNotSupportedException e) {
                throw new RuntimeException(e);
            }
        }
    }
 
//  id,rating,detection_range,xpGain,drop_value,drop_random
//  derelict_probe,0,2000,500,"basic:2000, extended:500",ai_cores1:1
//  probDefenders   minStr  maxStr  maxSize
    // probStation  stationRole
    private String id;
    private String nameOverride;
    private float salvageRating, detectionRange, xpDiscover, xpSalvage, radiusOverride = -1f;
    private DiscoverabilityType type;
    private float probDefenders, defQuality, minStr, maxStr, maxDefenderSize, minDefenderSize, probStation;
    private String stationRole;
    private String defFaction;
    
//  private Map<String, Float> dropValue = new HashMap<String, Float>();
//  private Map<String, Float> dropRandom = new HashMap<String, Float>();
    private List<DropData> dropValue = new ArrayList<DropData>();
    private List<DropData> dropRandom = new ArrayList<DropData>();
 
    private Set<String> tags = new HashSet<String>();
    
    public SalvageEntityGenDataSpec(JSONObject row) throws JSONException {
        id = row.getString("id");
        
        stationRole = row.getString("stationRole");
        
        nameOverride = row.optString("name");
        if (nameOverride != null && nameOverride.isEmpty()) nameOverride = null;
        
        salvageRating = (float) row.optDouble("rating", 0);
        detectionRange = (float) row.optDouble("detection_range", 0);
        
        float baseXP = 200 + 1 * (salvageRating * 20f);
        //baseXP /= 3f;
        baseXP = Misc.getRounded(baseXP);
//      if (id.equals("ruins_vast")) {
//          System.out.println("wefwefe");
//      }
        xpDiscover = (float) row.optDouble("xpDiscover", baseXP);
        xpSalvage = (float) row.optDouble("xpSalvage", baseXP * 3f);
        
        radiusOverride = (float) row.optDouble("radius", -1);
        
        defQuality = (float) row.optDouble("defQuality", 1f);
        
        probDefenders = (float) row.optDouble("probDefenders", 0);
        minStr = (float) row.optDouble("minStr", 0);
        maxStr = (float) row.optDouble("maxStr", 0);
        maxDefenderSize = (float) row.optDouble("maxSize", 4);
        minDefenderSize = (float) row.optDouble("minSize", 0);
        
        defFaction = row.optString("defFaction", null);
        if (defFaction != null && defFaction.isEmpty()) defFaction = null;
        
        probStation = (float) row.optDouble("probStation", 0);
        
        type = Misc.mapToEnum(row, "type", DiscoverabilityType.class, DiscoverabilityType.DISCOVERABLE);
        
        if (row.has("drop_value") && !row.getString("drop_value").isEmpty()) {
            //readToMap(row.getString("drop_value"), dropValue);
            String [] parts = row.getString("drop_value").split(",");
            for (String part : parts) {
                part = part.trim();
                String [] pair = part.split(":");
                String key = pair[0].trim();
                String value = pair[1].trim();
                
                DropData data = new DropData();
                data.group = key;
                data.value = Integer.valueOf(value);
                data.chances = -1;
                
                dropValue.add(data);
            }
        }
        
        if (row.has("drop_random") && !row.getString("drop_random").isEmpty()) {
            //readToMap(row.getString("drop_random"), dropRandom);
            String [] parts = row.getString("drop_random").split(",");
            for (String part : parts) {
                part = part.trim();
                String [] pair = part.split(":");
                String key = pair[0].trim();
                String value = pair[1].trim();
                
                DropData data = new DropData();
                data.group = key;
                
                if (value.contains("x")) {
                    String [] chancesXValue = value.split("x");
                    if (chancesXValue[0].trim().contains("-")) {
                        data.chances = Integer.valueOf(chancesXValue[0].trim().split("-")[0]);
                        data.maxChances = Integer.valueOf(chancesXValue[0].trim().split("-")[1]);
                    } else {
                        data.chances = Integer.valueOf(chancesXValue[0].trim());
                    }
                    data.value = Integer.valueOf(chancesXValue[1].trim()); 
                } else {
                    data.value = -1;
                    
                    if (value.contains("-")) {
                        data.chances = Integer.valueOf(value.trim().split("-")[0]);
                        data.maxChances = Integer.valueOf(value.trim().split("-")[1]);
                    } else {
                        float c = Float.valueOf(value); 
                        data.chances = (int) Math.max(c, 1);
                        if (c < 1) data.valueMult = c;
                    }
                    //data.chances = Integer.valueOf(value);
                }
                
                dropRandom.add(data);
            }
        }
        
        String tags = row.optString("tags", null);
        if (tags != null) {
            String [] split = tags.split(",");
            for (String tag : split) {
                tag = tag.trim();
                if (tag.isEmpty()) continue;
                addTag(tag);
            }
        }
    }
    
    public String getDefFaction() {
        return defFaction;
    }
 
    public void setDefFaction(String defFaction) {
        this.defFaction = defFaction;
    }
 
 
    public Set<String> getTags() {
        return tags;
    }
    
    public void addTag(String tag) {
        tags.add(tag);
    }
 
    public boolean hasTag(String tag) {
        return tags.contains(tag);
    }
    
    public float getRadiusOverride() {
        return radiusOverride;
    }
 
    public void setRadiusOverride(float radiusOverride) {
        this.radiusOverride = radiusOverride;
    }
 
    public String getNameOverride() {
        return nameOverride;
    }
 
    public void setNameOverride(String nameOverride) {
        this.nameOverride = nameOverride;
    }
 
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public float getSalvageRating() {
        return salvageRating;
    }
    public void setSalvageRating(float salvageRating) {
        this.salvageRating = salvageRating;
    }
    public float getDetectionRange() {
        return detectionRange;
    }
    public void setDetectionRange(float detectionRange) {
        this.detectionRange = detectionRange;
    }
    public float getXpDiscover() {
        return xpDiscover;
    }
    public void setXpDiscover(float xpDiscover) {
        this.xpDiscover = xpDiscover;
    }
    public float getXpSalvage() {
        return xpSalvage;
    }
    public void setXpSalvage(float xpSalvage) {
        this.xpSalvage = xpSalvage;
    }
 
 
    public List<DropData> getDropValue() {
        return dropValue;
    }
    public List<DropData> getDropRandom() {
        return dropRandom;
    }
    public DiscoverabilityType getType() {
        return type;
    }
    public void setType(DiscoverabilityType type) {
        this.type = type;
    }
    public float getProbDefenders() {
        return probDefenders;
    }
    public void setProbDefenders(float probDefenders) {
        this.probDefenders = probDefenders;
    }
    public float getMinStr() {
        return minStr;
    }
    public void setMinStr(float minStr) {
        this.minStr = minStr;
    }
    public float getMaxStr() {
        return maxStr;
    }
    public void setMaxStr(float maxStr) {
        this.maxStr = maxStr;
    }
    public float getMaxDefenderSize() {
        return maxDefenderSize;
    }
    public void setMaxDefenderSize(float maxSize) {
        this.maxDefenderSize = maxSize;
    }
    
    public float getMinDefenderSize() {
        return minDefenderSize;
    }
 
    public void setMinDefenderSize(float minDefenderSize) {
        this.minDefenderSize = minDefenderSize;
    }
 
    public float getDefQuality() {
        return defQuality;
    }
 
    public void setDefQuality(float defQuality) {
        this.defQuality = defQuality;
    }
 
    public float getProbStation() {
        return probStation;
    }
 
    public void setProbStation(float probStation) {
        this.probStation = probStation;
    }
 
    public String getStationRole() {
        return stationRole;
    }
 
    public void setStationRole(String stationRole) {
        this.stationRole = stationRole;
    }
 
 
//  public static void readToMap(String input, Map<String, Float> map) {
//      String [] parts = input.split(",");
//      for (String part : parts) {
//          part = part.trim();
//          String [] pair = part.split(":");
//          String key = pair[0].trim();
//          float value = Float.valueOf(pair[1].trim());
//          map.put(key, value);
//      }
//  }
    
//  public static void verifySpecsExist(Class clazz, List<String> specs, String desc) {
//      for (String id : specs) {
//          Object spec = Global.getSettings().getSpec(clazz, id, true);
//          if (spec == null) {
//              throw new RuntimeException("Spec of class " + clazz.getName() +
//                                         " with id [" + id + "] not found while verifying [" + 
//                                         desc + "]");
//          }
//      }
//  }
    
    
}