diff --git a/core/src/main/java/ru/trader/analysis/FilteredVendor.java b/core/src/main/java/ru/trader/analysis/FilteredVendor.java index bbe1685..4d42d73 100644 --- a/core/src/main/java/ru/trader/analysis/FilteredVendor.java +++ b/core/src/main/java/ru/trader/analysis/FilteredVendor.java @@ -3,6 +3,7 @@ package ru.trader.analysis; import ru.trader.analysis.graph.Connectable; import ru.trader.core.*; +import java.time.LocalDateTime; import java.util.Collection; import java.util.stream.Collectors; @@ -65,6 +66,46 @@ public class FilteredVendor implements Vendor { vendor.setGovernment(government); } + @Override + public STATION_TYPE getType() { + return vendor.getType(); + } + + @Override + public void setType(STATION_TYPE type) { + vendor.setType(type); + } + + @Override + public ECONOMIC_TYPE getEconomic() { + return vendor.getEconomic(); + } + + @Override + public void setEconomic(ECONOMIC_TYPE economic) { + vendor.setEconomic(economic); + } + + @Override + public ECONOMIC_TYPE getSubEconomic() { + return vendor.getSubEconomic(); + } + + @Override + public void setSubEconomic(ECONOMIC_TYPE economic) { + vendor.setSubEconomic(economic); + } + + @Override + public LocalDateTime getModifiedTime() { + return vendor.getModifiedTime(); + } + + @Override + public void setModifiedTime(LocalDateTime time) { + vendor.setModifiedTime(time); + } + @Override public void add(SERVICE_TYPE service) { vendor.add(service); diff --git a/core/src/main/java/ru/trader/core/AbstractItemStat.java b/core/src/main/java/ru/trader/core/AbstractItemStat.java index 9048751..7768ca4 100644 --- a/core/src/main/java/ru/trader/core/AbstractItemStat.java +++ b/core/src/main/java/ru/trader/core/AbstractItemStat.java @@ -2,6 +2,7 @@ package ru.trader.core; import ru.trader.analysis.graph.Connectable; +import java.time.LocalDateTime; import java.util.Collection; import java.util.Collections; @@ -95,6 +96,21 @@ public abstract class AbstractItemStat implements ItemStat { throw new UnsupportedOperationException("Is fake place, change unsupported"); } + @Override + public POWER getPower() { + return POWER.NONE; + } + + @Override + public POWER_STATE getPowerState() { + return POWER_STATE.NONE; + } + + @Override + public void setPower(POWER power, POWER_STATE state) { + throw new UnsupportedOperationException("Is fake place, change unsupported"); + } + @Override public double getX() { return 0; @@ -172,6 +188,46 @@ public abstract class AbstractItemStat implements ItemStat { throw new UnsupportedOperationException("Is fake vendor, change unsupported"); } + @Override + public STATION_TYPE getType() { + return STATION_TYPE.STARPORT; + } + + @Override + public void setType(STATION_TYPE type) { + throw new UnsupportedOperationException("Is fake vendor, change unsupported"); + } + + @Override + public ECONOMIC_TYPE getEconomic() { + return ECONOMIC_TYPE.NONE; + } + + @Override + public void setEconomic(ECONOMIC_TYPE economic) { + throw new UnsupportedOperationException("Is fake vendor, change unsupported"); + } + + @Override + public ECONOMIC_TYPE getSubEconomic() { + return ECONOMIC_TYPE.NONE; + } + + @Override + public void setSubEconomic(ECONOMIC_TYPE economic) { + throw new UnsupportedOperationException("Is fake vendor, change unsupported"); + } + + @Override + public LocalDateTime getModifiedTime() { + return LocalDateTime.now(); + } + + @Override + public void setModifiedTime(LocalDateTime time) { + throw new UnsupportedOperationException("Is fake vendor, change unsupported"); + } + @Override public Place getPlace() { return FAKE_PLACE; diff --git a/core/src/main/java/ru/trader/core/AbstractMarket.java b/core/src/main/java/ru/trader/core/AbstractMarket.java index 30aaeb0..0ce25db 100644 --- a/core/src/main/java/ru/trader/core/AbstractMarket.java +++ b/core/src/main/java/ru/trader/core/AbstractMarket.java @@ -122,18 +122,6 @@ public abstract class AbstractMarket implements Market { place.updatePosition(x, y, z); } - protected void updateName(AbstractVendor vendor, String name){ - vendor.updateName(name); - } - - protected void updateFaction(AbstractVendor vendor, FACTION faction){ - vendor.updateFaction(faction); - } - - protected void updateGovernment(AbstractVendor vendor, GOVERNMENT government){ - vendor.updateGovernment(government); - } - protected void updatePrice(AbstractOffer offer, double price){ ItemStat itemStat = getStat(offer); if (itemStat instanceof AbstractItemStat){ diff --git a/core/src/main/java/ru/trader/core/AbstractPlace.java b/core/src/main/java/ru/trader/core/AbstractPlace.java index 7ad9bb6..6b06cb1 100644 --- a/core/src/main/java/ru/trader/core/AbstractPlace.java +++ b/core/src/main/java/ru/trader/core/AbstractPlace.java @@ -15,6 +15,7 @@ public abstract class AbstractPlace implements Place { protected abstract void updateName(String name); protected abstract void updateFaction(FACTION faction); protected abstract void updateGovernment(GOVERNMENT government); + protected abstract void updatePower(POWER power, POWER_STATE state); protected abstract void updatePosition(double x, double y, double z); protected abstract void addVendor(Vendor vendor); protected abstract void removeVendor(Vendor vendor); @@ -72,6 +73,16 @@ public abstract class AbstractPlace implements Place { } } + @Override + public final void setPower(POWER power, POWER_STATE state){ + if (market != null){ + LOG.debug("Change power of place {} to {} of {}", this, state, power); + updatePower(power, state); + market.setChange(true); + } else { + updatePower(power, state); + } + } @Override public final void add(Vendor vendor) { diff --git a/core/src/main/java/ru/trader/core/AbstractVendor.java b/core/src/main/java/ru/trader/core/AbstractVendor.java index dfe79d2..521ea9d 100644 --- a/core/src/main/java/ru/trader/core/AbstractVendor.java +++ b/core/src/main/java/ru/trader/core/AbstractVendor.java @@ -5,6 +5,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import ru.trader.analysis.graph.Connectable; +import java.time.LocalDateTime; import java.util.Objects; public abstract class AbstractVendor implements Vendor { @@ -14,11 +15,15 @@ public abstract class AbstractVendor implements Vendor { protected abstract void updateName(String name); protected abstract void updateFaction(FACTION faction); protected abstract void updateGovernment(GOVERNMENT government); + protected abstract void updateType(STATION_TYPE type); + protected abstract void updateEconomic(ECONOMIC_TYPE economic); + protected abstract void updateSubEconomic(ECONOMIC_TYPE economic); protected abstract void updateDistance(double distance); protected abstract void addService(SERVICE_TYPE service); protected abstract void removeService(SERVICE_TYPE service); protected abstract void addOffer(Offer offer); protected abstract void removeOffer(Offer offer); + protected abstract void updateModifiedTime(LocalDateTime time); protected AbstractMarket getMarket(){ Place place = getPlace(); @@ -30,85 +35,75 @@ public abstract class AbstractVendor implements Vendor { @Override public final void setName(String name) { - AbstractMarket market = getMarket(); - if (market != null){ - LOG.debug("Change name of vendor {} to {}", this, name); - market.updateName(this, name); - market.setChange(true); - } else { - updateName(name); - } + LOG.trace("Change name of vendor {} to {}", this, name); + updateName(name); + changed(); } @Override public final void setFaction(FACTION faction){ - AbstractMarket market = getMarket(); - if (market != null){ - LOG.debug("Change faction of vendor {} to {}", this, faction); - market.updateFaction(this, faction); - market.setChange(true); - } else { - updateFaction(faction); - } + LOG.trace("Change faction of vendor {} to {}", this, faction); + updateFaction(faction); + changed(); } @Override public final void setGovernment(GOVERNMENT government){ - AbstractMarket market = getMarket(); - if (market != null){ - LOG.debug("Change government of vendor {} to {}", this, government); - market.updateGovernment(this, government); - market.setChange(true); - } else { - updateGovernment(government); - } + LOG.trace("Change government of vendor {} to {}", this, government); + updateGovernment(government); + changed(); + } + + @Override + public final void setType(STATION_TYPE type){ + LOG.trace("Change type of vendor {} to {}", this, type); + updateType(type); + changed(); + } + + @Override + public final void setEconomic(ECONOMIC_TYPE economic) { + LOG.trace("Change economic of vendor {} to {}", this, economic); + updateEconomic(economic); + changed(); + } + + @Override + public final void setSubEconomic(ECONOMIC_TYPE economic){ + LOG.trace("Change sub economic of vendor {} to {}", this, economic); + updateSubEconomic(economic); + changed(); } @Override public final void setDistance(double distance) { - AbstractMarket market = getMarket(); - if (market != null){ - LOG.debug("Change distance of vendor {} to {}", this, distance); - updateDistance(distance); - market.setChange(true); - } else { - updateDistance(distance); - } + LOG.trace("Change distance of vendor {} to {}", this, distance); + updateDistance(distance); + changed(); } @Override public final void add(SERVICE_TYPE service) { - AbstractMarket market = getMarket(); - if (market != null){ - LOG.trace("Add service {} to vendor {}", service, this); - addService(service); - market.setChange(true); - } else { - addService(service); - } + LOG.trace("Add service {} to vendor {}", service, this); + addService(service); + changed(); } @Override public final void remove(SERVICE_TYPE service) { - AbstractMarket market = getMarket(); - if (market != null){ - LOG.trace("Remove offer {} from vendor {}", service, this); - removeService(service); - market.setChange(true); - } else { - removeService(service); - } + LOG.trace("Remove offer {} from vendor {}", service, this); + removeService(service); + changed(); } + @Override public final void add(Offer offer){ + LOG.trace("Add offer {} to vendor {}", offer, this); + addOffer(offer); + changed(); AbstractMarket market = getMarket(); if (market != null){ - LOG.trace("Add offer {} to vendor {}", offer, this); - addOffer(offer); - market.setChange(true); market.onAdd(offer); - } else { - addOffer(offer); } } @@ -121,14 +116,30 @@ public abstract class AbstractVendor implements Vendor { public final void remove(Offer offer){ assert this.equals(offer.getVendor()); + LOG.trace("Remove offer {} from vendor {}", offer, this); + removeOffer(offer); + changed(); AbstractMarket market = getMarket(); if (market != null){ - LOG.trace("Remove offer {} from vendor {}", offer, this); - removeOffer(offer); - market.setChange(true); market.onRemove(offer); - } else { - removeOffer(offer); + } + } + + @Override + public final void setModifiedTime(LocalDateTime time) { + LOG.trace("Change modified time of vendor {} to {}", this, time); + changed(time); + } + + private void changed(){ + changed(LocalDateTime.now()); + } + + private void changed(LocalDateTime time) { + updateModifiedTime(time); + AbstractMarket market = getMarket(); + if (market != null){ + market.setChange(true); } } diff --git a/core/src/main/java/ru/trader/core/ECONOMIC_TYPE.java b/core/src/main/java/ru/trader/core/ECONOMIC_TYPE.java new file mode 100644 index 0000000..aae1bd6 --- /dev/null +++ b/core/src/main/java/ru/trader/core/ECONOMIC_TYPE.java @@ -0,0 +1,15 @@ +package ru.trader.core; + +public enum ECONOMIC_TYPE { + AGRICULTURE, + EXTRACTION, + HIGH_TECH, + INDUSTRIAL, + MILITARY, + REFINERY, + SERVICE, + TERRAFORMING, + TOURISM, + COLONY, + NONE +} diff --git a/core/src/main/java/ru/trader/core/POWER.java b/core/src/main/java/ru/trader/core/POWER.java new file mode 100644 index 0000000..30728d0 --- /dev/null +++ b/core/src/main/java/ru/trader/core/POWER.java @@ -0,0 +1,15 @@ +package ru.trader.core; + +public enum POWER { + DUVAL, + DELAINE, + LAVIGNY_DUVAL, + PATREUS, + MAHON, + WINTERS, + YONG_RUI, + ANTAL, + HUDSON, + TORVAL, + NONE +} diff --git a/core/src/main/java/ru/trader/core/POWER_STATE.java b/core/src/main/java/ru/trader/core/POWER_STATE.java new file mode 100644 index 0000000..dc7bcda --- /dev/null +++ b/core/src/main/java/ru/trader/core/POWER_STATE.java @@ -0,0 +1,5 @@ +package ru.trader.core; + +public enum POWER_STATE { + CONTROL, EXPLOITED, EXPANSION, NONE +} diff --git a/core/src/main/java/ru/trader/core/Place.java b/core/src/main/java/ru/trader/core/Place.java index b7b7556..074af0b 100644 --- a/core/src/main/java/ru/trader/core/Place.java +++ b/core/src/main/java/ru/trader/core/Place.java @@ -23,6 +23,10 @@ public interface Place extends Connectable { GOVERNMENT getGovernment(); void setGovernment(GOVERNMENT government); + POWER getPower(); + POWER_STATE getPowerState(); + void setPower(POWER power, POWER_STATE state); + Collection get(); default Collection get(boolean withTransit){ if (withTransit){ diff --git a/core/src/main/java/ru/trader/core/STATION_TYPE.java b/core/src/main/java/ru/trader/core/STATION_TYPE.java new file mode 100644 index 0000000..d1d90fe --- /dev/null +++ b/core/src/main/java/ru/trader/core/STATION_TYPE.java @@ -0,0 +1,38 @@ +package ru.trader.core; + +public enum STATION_TYPE { + STARPORT(true, false), + CORIOLIS_STARPORT(true, false), + OCELLUS_STARPORT(true, false), + ORBIS_STARPORT(true, false), + OUTPOST, + CIVILIAN_OUTPOST, + COMMERCIAL_OUTPOST, + INDUSTRIAL_OUTPOST, + MILITARY_OUTPOST, + MINING_OUTPOST, + SCIENTIFIC_OUTPOST, + UNSANCTIONED_OUTPOST, + PLANETARY_PORT(true, true), + PLANETARY_OUTPOST(true, true); + + private final boolean largeLandpad; + private final boolean planetary; + + STATION_TYPE() { + this(false, false); + } + + STATION_TYPE(boolean largeLandpad, boolean planetary) { + this.largeLandpad = largeLandpad; + this.planetary = planetary; + } + + public boolean hasLargeLandpad() { + return largeLandpad; + } + + public boolean isPlanetary() { + return planetary; + } +} diff --git a/core/src/main/java/ru/trader/core/TransitVendor.java b/core/src/main/java/ru/trader/core/TransitVendor.java index cbe8b8d..b470882 100644 --- a/core/src/main/java/ru/trader/core/TransitVendor.java +++ b/core/src/main/java/ru/trader/core/TransitVendor.java @@ -2,6 +2,7 @@ package ru.trader.core; import ru.trader.analysis.graph.Connectable; +import java.time.LocalDateTime; import java.util.Collection; import java.util.Collections; @@ -42,6 +43,46 @@ public class TransitVendor implements Vendor { throw new UnsupportedOperationException("Is fake vendor, change unsupported"); } + @Override + public STATION_TYPE getType() { + return STATION_TYPE.STARPORT; + } + + @Override + public void setType(STATION_TYPE government) { + throw new UnsupportedOperationException("Is fake vendor, change unsupported"); + } + + @Override + public ECONOMIC_TYPE getEconomic() { + return ECONOMIC_TYPE.NONE; + } + + @Override + public void setEconomic(ECONOMIC_TYPE government) { + throw new UnsupportedOperationException("Is fake vendor, change unsupported"); + } + + @Override + public ECONOMIC_TYPE getSubEconomic() { + return ECONOMIC_TYPE.NONE; + } + + @Override + public void setSubEconomic(ECONOMIC_TYPE government) { + throw new UnsupportedOperationException("Is fake vendor, change unsupported"); + } + + @Override + public LocalDateTime getModifiedTime() { + return LocalDateTime.now(); + } + + @Override + public void setModifiedTime(LocalDateTime time) { + throw new UnsupportedOperationException("Is fake vendor, change unsupported"); + } + @Override public Place getPlace() { return place; diff --git a/core/src/main/java/ru/trader/core/Vendor.java b/core/src/main/java/ru/trader/core/Vendor.java index feba35c..b6d9642 100644 --- a/core/src/main/java/ru/trader/core/Vendor.java +++ b/core/src/main/java/ru/trader/core/Vendor.java @@ -2,6 +2,7 @@ package ru.trader.core; import ru.trader.analysis.graph.Connectable; +import java.time.LocalDateTime; import java.util.ArrayList; import java.util.Collection; @@ -30,6 +31,18 @@ public interface Vendor extends Connectable { boolean has(SERVICE_TYPE service); Collection getServices(); + STATION_TYPE getType(); + void setType(STATION_TYPE type); + + ECONOMIC_TYPE getEconomic(); + void setEconomic(ECONOMIC_TYPE economic); + + ECONOMIC_TYPE getSubEconomic(); + void setSubEconomic(ECONOMIC_TYPE economic); + + LocalDateTime getModifiedTime(); + void setModifiedTime(LocalDateTime time); + void add(Offer offer); Offer addOffer(OFFER_TYPE type, Item item, double price, long count); void remove(Offer offer); diff --git a/core/src/main/java/ru/trader/store/berkeley/PlaceProxy.java b/core/src/main/java/ru/trader/store/berkeley/PlaceProxy.java index f3507de..2f441da 100644 --- a/core/src/main/java/ru/trader/store/berkeley/PlaceProxy.java +++ b/core/src/main/java/ru/trader/store/berkeley/PlaceProxy.java @@ -56,6 +56,12 @@ public class PlaceProxy extends AbstractPlace { store.getPlaceAccessor().update(place); } + @Override + protected void updatePower(POWER power, POWER_STATE state) { + place.setPower(power, state); + store.getPlaceAccessor().update(place); + } + @Override protected void updatePosition(double x, double y, double z) { place.setPosition(x, y, z); @@ -101,6 +107,16 @@ public class PlaceProxy extends AbstractPlace { return place.getGovernment(); } + @Override + public POWER getPower() { + return place.getPower(); + } + + @Override + public POWER_STATE getPowerState() { + return place.getPowerState(); + } + @Override public double getX() { return place.getX(); diff --git a/core/src/main/java/ru/trader/store/berkeley/VendorProxy.java b/core/src/main/java/ru/trader/store/berkeley/VendorProxy.java index ada24d3..d4e1f99 100644 --- a/core/src/main/java/ru/trader/store/berkeley/VendorProxy.java +++ b/core/src/main/java/ru/trader/store/berkeley/VendorProxy.java @@ -4,6 +4,8 @@ import ru.trader.core.*; import ru.trader.store.berkeley.entities.BDBOffer; import ru.trader.store.berkeley.entities.BDBVendor; +import java.time.LocalDateTime; +import java.time.ZoneOffset; import java.util.Collection; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; @@ -98,6 +100,30 @@ public class VendorProxy extends AbstractVendor { store.getVendorAccessor().update(vendor); } + @Override + protected void updateType(STATION_TYPE type) { + vendor.setType(type); + store.getVendorAccessor().update(vendor); + } + + @Override + protected void updateEconomic(ECONOMIC_TYPE economic) { + vendor.setEconomic(economic); + store.getVendorAccessor().update(vendor); + } + + @Override + protected void updateSubEconomic(ECONOMIC_TYPE economic) { + vendor.setSubEconomic(economic); + store.getVendorAccessor().update(vendor); + } + + @Override + protected void updateModifiedTime(LocalDateTime time) { + vendor.setModified(time.toEpochSecond(ZoneOffset.UTC)); + store.getVendorAccessor().update(vendor); + } + @Override protected void updateDistance(double distance) { vendor.setDistance(distance); @@ -152,6 +178,26 @@ public class VendorProxy extends AbstractVendor { return vendor.getGovernment(); } + @Override + public STATION_TYPE getType() { + return vendor.getType(); + } + + @Override + public ECONOMIC_TYPE getEconomic() { + return vendor.getEconomic(); + } + + @Override + public ECONOMIC_TYPE getSubEconomic() { + return vendor.getSubEconomic(); + } + + @Override + public LocalDateTime getModifiedTime() { + return LocalDateTime.ofEpochSecond(vendor.getModified(), 0, ZoneOffset.UTC); + } + @Override public Place getPlace() { if (place == null){ diff --git a/core/src/main/java/ru/trader/store/berkeley/entities/BDBPlace.java b/core/src/main/java/ru/trader/store/berkeley/entities/BDBPlace.java index e2152fd..affa105 100644 --- a/core/src/main/java/ru/trader/store/berkeley/entities/BDBPlace.java +++ b/core/src/main/java/ru/trader/store/berkeley/entities/BDBPlace.java @@ -6,8 +6,12 @@ import com.sleepycat.persist.model.Relationship; import com.sleepycat.persist.model.SecondaryKey; import ru.trader.core.FACTION; import ru.trader.core.GOVERNMENT; +import ru.trader.core.POWER; +import ru.trader.core.POWER_STATE; -@Entity(version = 3) +import java.util.Objects; + +@Entity(version = 4) public class BDBPlace { @PrimaryKey(sequence = "P_ID") @@ -24,6 +28,8 @@ public class BDBPlace { private FACTION faction; private GOVERNMENT government; + private POWER power; + private POWER_STATE powerState; private BDBPlace() { } @@ -61,6 +67,19 @@ public class BDBPlace { this.government = government; } + public POWER getPower() { + return power; + } + + public POWER_STATE getPowerState() { + return powerState; + } + + public void setPower(POWER power, POWER_STATE state) { + this.power = power; + this.powerState = state; + } + public double getX() { return x; } @@ -93,8 +112,10 @@ public class BDBPlace { if (Double.compare(bdbPlace.y, y) != 0) return false; if (Double.compare(bdbPlace.z, z) != 0) return false; if (!name.equals(bdbPlace.name)) return false; - - return true; + return Objects.equals(faction, bdbPlace.faction) + && Objects.equals(government, bdbPlace.government) + && Objects.equals(power, bdbPlace.power) + && Objects.equals(powerState, bdbPlace.powerState); } @Override diff --git a/core/src/main/java/ru/trader/store/berkeley/entities/BDBVendor.java b/core/src/main/java/ru/trader/store/berkeley/entities/BDBVendor.java index a686f39..d378b4b 100644 --- a/core/src/main/java/ru/trader/store/berkeley/entities/BDBVendor.java +++ b/core/src/main/java/ru/trader/store/berkeley/entities/BDBVendor.java @@ -1,14 +1,13 @@ package ru.trader.store.berkeley.entities; import com.sleepycat.persist.model.*; -import ru.trader.core.FACTION; -import ru.trader.core.GOVERNMENT; -import ru.trader.core.SERVICE_TYPE; +import ru.trader.core.*; import java.util.Collection; import java.util.HashSet; +import java.util.Objects; -@Entity(version = 2) +@Entity(version = 3) public class BDBVendor { @PrimaryKey(sequence = "V_ID") @@ -20,6 +19,10 @@ public class BDBVendor { private String name; private FACTION faction; private GOVERNMENT government; + private STATION_TYPE type; + private ECONOMIC_TYPE economic; + private ECONOMIC_TYPE subEconomic; + private long modified; private double distance; @SecondaryKey(relate=Relationship.MANY_TO_MANY) @@ -61,6 +64,30 @@ public class BDBVendor { this.government = government; } + public STATION_TYPE getType() { + return type; + } + + public void setType(STATION_TYPE type) { + this.type = type; + } + + public ECONOMIC_TYPE getEconomic() { + return economic; + } + + public void setEconomic(ECONOMIC_TYPE economic) { + this.economic = economic; + } + + public ECONOMIC_TYPE getSubEconomic() { + return subEconomic; + } + + public void setSubEconomic(ECONOMIC_TYPE subEconomic) { + this.subEconomic = subEconomic; + } + public long getPlaceId() { return placeId; } @@ -93,6 +120,14 @@ public class BDBVendor { return services; } + public long getModified() { + return modified; + } + + public void setModified(long modified) { + this.modified = modified; + } + @Override public boolean equals(Object o) { if (this == o) return true; @@ -106,7 +141,12 @@ public class BDBVendor { if (!name.equals(bdbVendor.name)) return false; if (!services.equals(bdbVendor.services)) return false; - return true; + return Objects.equals(faction, bdbVendor.faction) + && Objects.equals(government, bdbVendor.government) + && Objects.equals(type, bdbVendor.type) + && Objects.equals(economic, bdbVendor.economic) + && Objects.equals(subEconomic, bdbVendor.subEconomic) + && Objects.equals(modified, bdbVendor.modified); } @Override diff --git a/core/src/main/java/ru/trader/store/simple/MarketDocHandler.java b/core/src/main/java/ru/trader/store/simple/MarketDocHandler.java index 4f39d6b..5dd77b9 100644 --- a/core/src/main/java/ru/trader/store/simple/MarketDocHandler.java +++ b/core/src/main/java/ru/trader/store/simple/MarketDocHandler.java @@ -8,6 +8,9 @@ import org.xml.sax.SAXParseException; import org.xml.sax.helpers.DefaultHandler; import ru.trader.core.*; +import java.time.LocalDateTime; +import java.util.Collection; +import java.util.EnumSet; import java.util.HashMap; public class MarketDocHandler extends DefaultHandler { @@ -30,17 +33,25 @@ public class MarketDocHandler extends DefaultHandler { protected final static String PRICE_ATTR = "price"; protected final static String COUNT_ATTR = "count"; protected final static String ITEM_ATTR = "item"; + protected final static String ILLEGAL_FACTION_ATTR = "illegalf"; + protected final static String ILLEGAL_GOVERNMENT__ATTR = "illegalg"; protected final static String DISTANCE_ATTR = "distance"; protected final static String X_ATTR = "x"; protected final static String Y_ATTR = "y"; protected final static String Z_ATTR = "z"; protected final static String FACTION_ATTR = "faction"; protected final static String GOVERNMENT_ATTR = "government"; + protected final static String POWER_ATTR = "power"; + protected final static String POWER_STATE_ATTR = "control"; + protected final static String ECONOMIC_ATTR = "economic1"; + protected final static String SUB_ECONOMIC_ATTR = "economic2"; + protected final static String MODIFIED_ATTR = "modified"; protected SimpleMarket world; protected Vendor curVendor; protected Place curPlace; protected Group curGroup; + protected LocalDateTime modified; protected final HashMap items = new HashMap<>(); @Override @@ -71,7 +82,9 @@ public class MarketDocHandler extends DefaultHandler { switch (qName){ case PLACE: curPlace = null; break; - case VENDOR: curVendor = null; + case VENDOR: + curVendor.setModifiedTime(modified); + curVendor = null; break; case GROUP: curGroup = null; break; @@ -94,16 +107,27 @@ public class MarketDocHandler extends DefaultHandler { onPlace(name, x != null ? Double.valueOf(x) : 0, y != null ? Double.valueOf(y) : 0, z != null ? Double.valueOf(z) : 0, faction != null ? FACTION.valueOf(faction) : null, government != null ? GOVERNMENT.valueOf(government) : null ); + String power = attributes.getValue(POWER_ATTR); + String powerState = attributes.getValue(POWER_STATE_ATTR); + if (powerState != null && power != null){ + updatePlace(POWER.valueOf(power), POWER_STATE.valueOf(powerState)); + } } protected void parseVendor(Attributes attributes) throws SAXException { String name = attributes.getValue(NAME_ATTR); + String type = attributes.getValue(TYPE_ATTR); String distance = attributes.getValue(DISTANCE_ATTR); String faction = attributes.getValue(FACTION_ATTR); String government = attributes.getValue(GOVERNMENT_ATTR); - LOG.debug("parse vendor {}, distance {}, faction {}, government {}", name, distance, faction, government); - onVendor(name, distance != null ? Double.valueOf(distance) : 0, - faction != null ? FACTION.valueOf(faction) : null, government != null ? GOVERNMENT.valueOf(government) : null); + String economic = attributes.getValue(ECONOMIC_ATTR); + String subEconomic = attributes.getValue(SUB_ECONOMIC_ATTR); + String modifiedTime = attributes.getValue(MODIFIED_ATTR); + modified = modifiedTime != null ? LocalDateTime.parse(modifiedTime) : null; + LOG.debug("parse vendor {}, type {}, distance {}, faction {}, government {}", name, type, distance, faction, government); + onVendor(name, type != null ? STATION_TYPE.valueOf(type) : null, distance != null ? Double.valueOf(distance) : 0, + faction != null ? FACTION.valueOf(faction) : null, government != null ? GOVERNMENT.valueOf(government) : null); + updateVendor(economic != null ? ECONOMIC_TYPE.valueOf(economic) : null, subEconomic != null ? ECONOMIC_TYPE.valueOf(subEconomic) : null); } protected void parseService(Attributes attributes) throws SAXException { @@ -116,8 +140,23 @@ public class MarketDocHandler extends DefaultHandler { protected void parseItem(Attributes attributes) throws SAXException { String name = attributes.getValue(NAME_ATTR); String id = attributes.getValue(ID_ATTR); - LOG.debug("parse item {} ({})", name, id); - onItem(name, id); + String illegalFactions = attributes.getValue(ILLEGAL_FACTION_ATTR); + String illegalGovernments = attributes.getValue(ILLEGAL_GOVERNMENT__ATTR); + EnumSet factions = EnumSet.noneOf(FACTION.class); + if (illegalFactions != null){ + for (String f : illegalFactions.split(",")) { + factions.add(FACTION.valueOf(f)); + } + } + EnumSet governments = EnumSet.noneOf(GOVERNMENT.class); + if (illegalGovernments != null){ + for (String f : illegalGovernments.split(",")) { + governments.add(GOVERNMENT.valueOf(f)); + } + } + + LOG.debug("parse item {} ({}), illegal - {}, {}", name, id, factions, governments); + onItem(name, id, factions, governments); } protected void parseOffer(Attributes attributes) throws SAXException { @@ -148,19 +187,36 @@ public class MarketDocHandler extends DefaultHandler { curPlace.setGovernment(government); } - protected void onVendor(String name, double distance, FACTION faction, GOVERNMENT government){ + protected void updatePlace(POWER power, POWER_STATE powerState){ + curPlace.setPower(power, powerState); + } + + protected void onVendor(String name, STATION_TYPE type, double distance, FACTION faction, GOVERNMENT government){ curVendor = curPlace.addVendor(name); + curVendor.setType(type); curVendor.setDistance(distance); curVendor.setFaction(faction); curVendor.setGovernment(government); } + protected void updateVendor(ECONOMIC_TYPE economic, ECONOMIC_TYPE subEconomic){ + curVendor.setEconomic(economic); + curVendor.setSubEconomic(subEconomic); + curVendor.setModifiedTime(modified); + } + protected void onService(SERVICE_TYPE type){ curVendor.add(type); } - protected void onItem(String name, String id) { + protected void onItem(String name, String id, Collection illegalFactions, Collection illegalGovernment) { Item item = world.addItem(name, curGroup); + for (FACTION faction : illegalFactions) { + item.setIllegal(faction, true); + } + for (GOVERNMENT government : illegalGovernment) { + item.setIllegal(government, true); + } items.put(id, item); } diff --git a/core/src/main/java/ru/trader/store/simple/MarketStreamWriter.java b/core/src/main/java/ru/trader/store/simple/MarketStreamWriter.java index ba9dfef..c1e6335 100644 --- a/core/src/main/java/ru/trader/store/simple/MarketStreamWriter.java +++ b/core/src/main/java/ru/trader/store/simple/MarketStreamWriter.java @@ -8,9 +8,11 @@ import javax.xml.stream.XMLOutputFactory; import javax.xml.stream.XMLStreamException; import javax.xml.stream.XMLStreamWriter; import java.io.*; +import java.time.format.DateTimeFormatter; import java.util.Collection; import java.util.HashMap; import java.util.Map; +import java.util.stream.Collectors; public class MarketStreamWriter { private final static Logger LOG = LoggerFactory.getLogger(MarketStreamWriter.class); @@ -66,6 +68,16 @@ public class MarketStreamWriter { out.writeEmptyElement(MarketDocHandler.ITEM); out.writeAttribute(MarketDocHandler.NAME_ATTR, item.getName()); out.writeAttribute(MarketDocHandler.ID_ATTR, id); + Collection factions = item.getIllegalFactions(); + if (!factions.isEmpty()) { + String str = factions.stream().map(FACTION::toString).collect(Collectors.joining(",")); + out.writeAttribute(MarketDocHandler.ILLEGAL_FACTION_ATTR, str); + } + Collection governments = item.getIllegalGovernments(); + if (!governments.isEmpty()) { + String str = governments.stream().map(GOVERNMENT::toString).collect(Collectors.joining(",")); + out.writeAttribute(MarketDocHandler.ILLEGAL_GOVERNMENT__ATTR, str); + } } protected void writePlaces() throws XMLStreamException { @@ -85,6 +97,12 @@ public class MarketStreamWriter { if (place.getGovernment() != null) { out.writeAttribute(MarketDocHandler.GOVERNMENT_ATTR, String.valueOf(place.getGovernment())); } + if (place.getPower() != null){ + out.writeAttribute(MarketDocHandler.POWER_ATTR, String.valueOf(place.getPower())); + } + if (place.getPowerState() != null){ + out.writeAttribute(MarketDocHandler.POWER_STATE_ATTR, String.valueOf(place.getPowerState())); + } out.writeAttribute(MarketDocHandler.X_ATTR, String.valueOf(place.getX())); out.writeAttribute(MarketDocHandler.Y_ATTR, String.valueOf(place.getY())); out.writeAttribute(MarketDocHandler.Z_ATTR, String.valueOf(place.getZ())); @@ -97,13 +115,25 @@ public class MarketStreamWriter { protected void writeVendor(Vendor vendor) throws XMLStreamException { out.writeStartElement(MarketDocHandler.VENDOR); out.writeAttribute(MarketDocHandler.NAME_ATTR, vendor.getName()); + if (vendor.getType() != null){ + out.writeAttribute(MarketDocHandler.TYPE_ATTR, String.valueOf(vendor.getType())); + } if (vendor.getFaction() != null) { out.writeAttribute(MarketDocHandler.FACTION_ATTR, String.valueOf(vendor.getFaction())); } if (vendor.getGovernment() != null) { out.writeAttribute(MarketDocHandler.GOVERNMENT_ATTR, String.valueOf(vendor.getGovernment())); } + if (vendor.getEconomic() != null){ + out.writeAttribute(MarketDocHandler.ECONOMIC_ATTR, String.valueOf(vendor.getEconomic())); + } + if (vendor.getSubEconomic() != null){ + out.writeAttribute(MarketDocHandler.SUB_ECONOMIC_ATTR, String.valueOf(vendor.getSubEconomic())); + } out.writeAttribute(MarketDocHandler.DISTANCE_ATTR, String.valueOf(vendor.getDistance())); + if (vendor.getModifiedTime() != null){ + out.writeAttribute(MarketDocHandler.MODIFIED_ATTR, vendor.getModifiedTime().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME)); + } out.writeStartElement(MarketDocHandler.SERVICES_LIST); for (SERVICE_TYPE service_type : vendor.getServices()) { out.writeEmptyElement(MarketDocHandler.SERVICE); diff --git a/core/src/main/java/ru/trader/store/simple/SimplePlace.java b/core/src/main/java/ru/trader/store/simple/SimplePlace.java index c411bb2..0060129 100644 --- a/core/src/main/java/ru/trader/store/simple/SimplePlace.java +++ b/core/src/main/java/ru/trader/store/simple/SimplePlace.java @@ -1,9 +1,6 @@ package ru.trader.store.simple; -import ru.trader.core.AbstractPlace; -import ru.trader.core.FACTION; -import ru.trader.core.GOVERNMENT; -import ru.trader.core.Vendor; +import ru.trader.core.*; import java.util.Collection; import java.util.List; @@ -19,6 +16,9 @@ public class SimplePlace extends AbstractPlace { private FACTION faction; private GOVERNMENT government; + private POWER power; + private POWER_STATE powerState; + public SimplePlace(String name) { this.name = name; @@ -55,6 +55,16 @@ public class SimplePlace extends AbstractPlace { return government; } + @Override + public POWER getPower() { + return power; + } + + @Override + public POWER_STATE getPowerState() { + return powerState; + } + @Override public double getX() { return x; @@ -90,6 +100,12 @@ public class SimplePlace extends AbstractPlace { this.government = government; } + @Override + protected void updatePower(POWER power, POWER_STATE state) { + this.power = power; + this.powerState = state; + } + @Override protected void updatePosition(double x, double y, double z) { this.x = x; diff --git a/core/src/main/java/ru/trader/store/simple/SimpleVendor.java b/core/src/main/java/ru/trader/store/simple/SimpleVendor.java index 0fe37f4..a4ad2ad 100644 --- a/core/src/main/java/ru/trader/store/simple/SimpleVendor.java +++ b/core/src/main/java/ru/trader/store/simple/SimpleVendor.java @@ -2,6 +2,7 @@ package ru.trader.store.simple; import ru.trader.core.*; +import java.time.LocalDateTime; import java.util.Collection; import java.util.EnumSet; import java.util.Map; @@ -14,6 +15,10 @@ public class SimpleVendor extends AbstractVendor { private EnumSet services = EnumSet.noneOf(SERVICE_TYPE.class); private FACTION faction; private GOVERNMENT government; + private STATION_TYPE type; + private ECONOMIC_TYPE economic; + private ECONOMIC_TYPE subEconomic; + private LocalDateTime modified; protected Map sell; protected Map buy; @@ -73,6 +78,36 @@ public class SimpleVendor extends AbstractVendor { this.government = government; } + @Override + public STATION_TYPE getType() { + return type; + } + + @Override + protected void updateType(STATION_TYPE type) { + this.type = type; + } + + @Override + public ECONOMIC_TYPE getEconomic() { + return economic; + } + + @Override + protected void updateEconomic(ECONOMIC_TYPE economic) { + this.economic = economic; + } + + @Override + public ECONOMIC_TYPE getSubEconomic() { + return subEconomic; + } + + @Override + protected void updateSubEconomic(ECONOMIC_TYPE economic) { + this.subEconomic = economic; + } + @Override public Place getPlace() { return place; @@ -163,4 +198,13 @@ public class SimpleVendor extends AbstractVendor { } } + @Override + public LocalDateTime getModifiedTime() { + return modified; + } + + @Override + protected void updateModifiedTime(LocalDateTime time) { + this.modified = time; + } } diff --git a/core/src/main/resources/store/trader.xsd b/core/src/main/resources/store/trader.xsd index 5597c4c..9872145 100644 --- a/core/src/main/resources/store/trader.xsd +++ b/core/src/main/resources/store/trader.xsd @@ -48,6 +48,8 @@ + + @@ -57,6 +59,8 @@ + + @@ -70,7 +74,11 @@ + + + + @@ -133,4 +141,64 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/core/src/test/java/ru/trader/store/LoadTest.java b/core/src/test/java/ru/trader/store/LoadTest.java index 8c94c24..1f4430f 100644 --- a/core/src/test/java/ru/trader/store/LoadTest.java +++ b/core/src/test/java/ru/trader/store/LoadTest.java @@ -12,6 +12,7 @@ import ru.trader.store.simple.Store; import javax.xml.parsers.ParserConfigurationException; import javax.xml.stream.XMLStreamException; import java.io.*; +import java.time.LocalDateTime; import java.util.Collection; public class LoadTest extends Assert { @@ -38,6 +39,8 @@ public class LoadTest extends Assert { private void assertItem(Item item1, Item item2){ assertEquals(item1.getName(), item2.getName()); assertGroup(item1.getGroup(), item2.getGroup()); + assertEquals(item1.getIllegalFactions(), item2.getIllegalFactions()); + assertEquals(item1.getIllegalGovernments(), item2.getIllegalGovernments()); } private void assertPlace(Place place1, Place place2){ @@ -47,13 +50,19 @@ public class LoadTest extends Assert { assertEquals(place1.getZ(), place2.getZ(), 0.00001); assertEquals(place1.getFaction(), place2.getFaction()); assertEquals(place1.getGovernment(), place2.getGovernment()); + assertEquals(place1.getPower(), place2.getPower()); + assertEquals(place1.getPowerState(), place2.getPowerState()); } private void assertVendor(Vendor vendor1, Vendor vendor2){ assertEquals(vendor1.getName(), vendor2.getName()); + assertEquals(vendor1.getType(), vendor2.getType()); assertEquals(vendor1.getDistance(), vendor2.getDistance(), 0.00001); assertEquals(vendor1.getFaction(), vendor2.getFaction()); assertEquals(vendor1.getGovernment(), vendor2.getGovernment()); + assertEquals(vendor1.getEconomic(), vendor2.getEconomic()); + assertEquals(vendor1.getSubEconomic(), vendor2.getSubEconomic()); + assertEquals(vendor1.getModifiedTime(), vendor2.getModifiedTime()); } private void assertOffer(Offer offer1, Offer offer2){ @@ -76,17 +85,26 @@ public class LoadTest extends Assert { Item item3 = market.addItem("Item 3", group2); Item item4 = market.addItem("Item 4", group2); Item item5 = market.addItem("Item 5", group3); + item1.setIllegal(FACTION.FEDERATION, true); + item2.setIllegal(FACTION.EMPIRE, true); + item2.setIllegal(GOVERNMENT.DEMOCRACY, true); + item3.setIllegal(GOVERNMENT.CORPORATE, true); Place place1 = market.addPlace("Place 1", 0, 1, 3); place1.setFaction(FACTION.ALLIANCE); place1.setGovernment(GOVERNMENT.PRISON_COLONY); + place1.setPower(POWER.LAVIGNY_DUVAL, POWER_STATE.EXPLOITED); Place place2 = market.addPlace("Place 2",4,0,5); + place2.setPower(POWER.DELAINE, POWER_STATE.CONTROL); Place place3 = market.addPlace("Place 3",0,0,0); Vendor vendor1 = place1.addVendor("Vendor 1"); Vendor vendor2 = place1.addVendor("Vendor 2"); Vendor vendor3 = place2.addVendor("Vendor 3"); + vendor1.setType(STATION_TYPE.CORIOLIS_STARPORT); vendor1.setDistance(10); vendor1.setFaction(FACTION.ALLIANCE); vendor1.setGovernment(GOVERNMENT.ANARCHY); + vendor1.setEconomic(ECONOMIC_TYPE.EXTRACTION); + vendor1.setSubEconomic(ECONOMIC_TYPE.REFINERY); vendor1.add(SERVICE_TYPE.MARKET); vendor1.add(SERVICE_TYPE.OUTFIT); vendor1.add(SERVICE_TYPE.REFUEL); @@ -98,9 +116,12 @@ public class LoadTest extends Assert { Offer offer6 = vendor1.addOffer(OFFER_TYPE.BUY, item5, 11,10); vendor2.setDistance(100.4); vendor2.setGovernment(GOVERNMENT.NONE); + vendor2.setEconomic(ECONOMIC_TYPE.HIGH_TECH); + vendor2.setType(STATION_TYPE.PLANETARY_PORT); vendor3.setDistance(200000.4); vendor3.add(SERVICE_TYPE.OUTFIT); vendor3.add(SERVICE_TYPE.REFUEL); + vendor3.setModifiedTime(LocalDateTime.of(2016,10,2,10,20,0)); LOG.info("save market"); File xml = new File("save_load_test.xml");