From d113caf564e90d151474a71ae27f0e66f1ef2696 Mon Sep 17 00:00:00 2001 From: iMoHax Date: Wed, 9 Dec 2015 17:08:10 +0300 Subject: [PATCH 1/5] implement illegal state for items --- .../java/ru/trader/core/AbstractItem.java | 24 ++++++++++++++ core/src/main/java/ru/trader/core/Item.java | 5 +++ .../ru/trader/store/berkeley/ItemProxy.java | 24 ++++++++++++++ .../store/berkeley/entities/BDBItem.java | 32 ++++++++++++++++++- .../ru/trader/store/simple/SimpleItem.java | 28 ++++++++++++++++ 5 files changed, 112 insertions(+), 1 deletion(-) diff --git a/core/src/main/java/ru/trader/core/AbstractItem.java b/core/src/main/java/ru/trader/core/AbstractItem.java index 5484c54..72e7c6b 100644 --- a/core/src/main/java/ru/trader/core/AbstractItem.java +++ b/core/src/main/java/ru/trader/core/AbstractItem.java @@ -11,6 +11,8 @@ public abstract class AbstractItem implements Item { private AbstractMarket market; protected abstract void updateName(String name); + protected abstract void updateIllegalState(FACTION faction, boolean illegal); + protected abstract void updateIllegalState(GOVERNMENT government, boolean illegal); protected final void setMarket(AbstractMarket market){ assert this.market == null; @@ -28,6 +30,28 @@ public abstract class AbstractItem implements Item { } } + @Override + public final void setIllegal(FACTION faction, boolean illegal){ + if (market != null){ + LOG.debug("Change illegal state of item {} for faction {} to {}", this, faction, illegal); + updateIllegalState(faction, illegal); + market.setChange(true); + } else { + updateIllegalState(faction, illegal); + } + } + + @Override + public final void setIllegal(GOVERNMENT government, boolean illegal){ + if (market != null){ + LOG.debug("Change illegal state of item {} for government {} to {}", this, government, illegal); + updateIllegalState(government, illegal); + market.setChange(true); + } else { + updateIllegalState(government, illegal); + } + } + @Override public String toString(){ return getName(); diff --git a/core/src/main/java/ru/trader/core/Item.java b/core/src/main/java/ru/trader/core/Item.java index ec8f9c4..f7805ca 100644 --- a/core/src/main/java/ru/trader/core/Item.java +++ b/core/src/main/java/ru/trader/core/Item.java @@ -8,6 +8,11 @@ public interface Item extends Comparable { String getName(); void setName(String name); + boolean isIllegal(FACTION faction); + void setIllegal(FACTION faction, boolean illegal); + boolean isIllegal(GOVERNMENT government); + void setIllegal(GOVERNMENT government, boolean illegal); + Group getGroup(); @Override diff --git a/core/src/main/java/ru/trader/store/berkeley/ItemProxy.java b/core/src/main/java/ru/trader/store/berkeley/ItemProxy.java index b44f84d..e6f3ea1 100644 --- a/core/src/main/java/ru/trader/store/berkeley/ItemProxy.java +++ b/core/src/main/java/ru/trader/store/berkeley/ItemProxy.java @@ -1,6 +1,8 @@ package ru.trader.store.berkeley; import ru.trader.core.AbstractItem; +import ru.trader.core.FACTION; +import ru.trader.core.GOVERNMENT; import ru.trader.core.Group; import ru.trader.store.berkeley.entities.BDBItem; @@ -33,6 +35,28 @@ public class ItemProxy extends AbstractItem { return item.getName(); } + @Override + protected void updateIllegalState(FACTION faction, boolean illegal) { + item.setIllegal(faction, illegal); + store.getItemAccessor().update(item); + } + + @Override + public boolean isIllegal(FACTION faction) { + return item.isIllegal(faction); + } + + @Override + protected void updateIllegalState(GOVERNMENT government, boolean illegal) { + item.setIllegal(government, illegal); + store.getItemAccessor().update(item); + } + + @Override + public boolean isIllegal(GOVERNMENT government) { + return item.isIllegal(government); + } + @Override public Group getGroup() { if (group == null){ diff --git a/core/src/main/java/ru/trader/store/berkeley/entities/BDBItem.java b/core/src/main/java/ru/trader/store/berkeley/entities/BDBItem.java index 932d0cc..0ae9a8b 100644 --- a/core/src/main/java/ru/trader/store/berkeley/entities/BDBItem.java +++ b/core/src/main/java/ru/trader/store/berkeley/entities/BDBItem.java @@ -1,8 +1,13 @@ package ru.trader.store.berkeley.entities; import com.sleepycat.persist.model.*; +import ru.trader.core.FACTION; +import ru.trader.core.GOVERNMENT; -@Entity(version = 1) +import java.util.Collection; +import java.util.HashSet; + +@Entity(version = 2) public class BDBItem { @PrimaryKey(sequence="I_ID") private long id; @@ -14,6 +19,11 @@ public class BDBItem { onRelatedEntityDelete = DeleteAction.CASCADE) private String groupId; + @SecondaryKey(relate=Relationship.MANY_TO_MANY) + Collection fIllegals = new HashSet<>(); + @SecondaryKey(relate=Relationship.MANY_TO_MANY) + Collection gIllegals = new HashSet<>(); + private BDBItem() { } @@ -34,6 +44,24 @@ public class BDBItem { this.name = name; } + public void setIllegal(FACTION faction, boolean illegal) { + if (illegal) fIllegals.add(faction); + else fIllegals.remove(faction); + } + + public boolean isIllegal(FACTION faction) { + return fIllegals.contains(faction); + } + + public void setIllegal(GOVERNMENT government, boolean illegal) { + if (illegal) gIllegals.add(government); + else gIllegals.remove(government); + } + + public boolean isIllegal(GOVERNMENT government) { + return gIllegals.contains(government); + } + public String getGroupId() { return groupId; } @@ -48,6 +76,8 @@ public class BDBItem { if (id != bdbItem.id) return false; if (!groupId.equals(bdbItem.groupId)) return false; if (!name.equals(bdbItem.name)) return false; + if (!fIllegals.equals(bdbItem.fIllegals)) return false; + if (!gIllegals.equals(bdbItem.gIllegals)) return false; return true; } diff --git a/core/src/main/java/ru/trader/store/simple/SimpleItem.java b/core/src/main/java/ru/trader/store/simple/SimpleItem.java index edf810c..961555a 100644 --- a/core/src/main/java/ru/trader/store/simple/SimpleItem.java +++ b/core/src/main/java/ru/trader/store/simple/SimpleItem.java @@ -1,11 +1,17 @@ package ru.trader.store.simple; import ru.trader.core.AbstractItem; +import ru.trader.core.FACTION; +import ru.trader.core.GOVERNMENT; import ru.trader.core.Group; +import java.util.EnumSet; + public class SimpleItem extends AbstractItem { private String name; private Group group; + private final EnumSet gIllegals = EnumSet.noneOf(GOVERNMENT.class); + private final EnumSet fIllegals = EnumSet.noneOf(FACTION.class); public SimpleItem(String name) { this.name = name; @@ -26,6 +32,28 @@ public class SimpleItem extends AbstractItem { this.name = name; } + @Override + protected void updateIllegalState(FACTION faction, boolean illegal) { + if (illegal) fIllegals.add(faction); + else fIllegals.remove(faction); + } + + @Override + public boolean isIllegal(FACTION faction) { + return fIllegals.contains(faction); + } + + @Override + protected void updateIllegalState(GOVERNMENT government, boolean illegal) { + if (illegal) gIllegals.add(government); + else gIllegals.remove(government); + } + + @Override + public boolean isIllegal(GOVERNMENT government) { + return gIllegals.contains(government); + } + @Override public Group getGroup() { return group; From 4e3f6ca9d1aabd967014f220d8f62011c66fd6ee Mon Sep 17 00:00:00 2001 From: iMoHax Date: Thu, 10 Dec 2015 15:34:02 +0300 Subject: [PATCH 2/5] add isTransit method to vendor --- .../main/java/ru/trader/analysis/Route.java | 2 +- .../ru/trader/analysis/RouteSearcher.java | 8 +++---- .../java/ru/trader/analysis/VendorsGraph.java | 22 +++++++++---------- core/src/main/java/ru/trader/core/Vendor.java | 4 ++++ 4 files changed, 20 insertions(+), 16 deletions(-) diff --git a/core/src/main/java/ru/trader/analysis/Route.java b/core/src/main/java/ru/trader/analysis/Route.java index a52585f..235fcf0 100644 --- a/core/src/main/java/ru/trader/analysis/Route.java +++ b/core/src/main/java/ru/trader/analysis/Route.java @@ -337,7 +337,7 @@ public class Route implements Comparable { public static Route singletone(Vendor root, double balance, long cargo){ RouteEntry entry = new RouteEntry(root, 0,0,0); - if (!(root instanceof TransitVendor)){ + if (!root.isTransit()){ entry.setLand(true); } Route route = new Route(entry); diff --git a/core/src/main/java/ru/trader/analysis/RouteSearcher.java b/core/src/main/java/ru/trader/analysis/RouteSearcher.java index ce18253..9762c27 100644 --- a/core/src/main/java/ru/trader/analysis/RouteSearcher.java +++ b/core/src/main/java/ru/trader/analysis/RouteSearcher.java @@ -189,7 +189,7 @@ public class RouteSearcher { buyer = orders.get(0).getBuyer(); sellerEntry.addAll(orders); } else { - if (!(vendor instanceof TransitVendor)){ + if (!vendor.isTransit()){ entry.setLand(true); } } @@ -203,7 +203,7 @@ public class RouteSearcher { } if (vEdge != null) { RouteEntry entry = new RouteEntry(vEdge.getTarget().getEntry(), 0, 0, 0); - if (!(entry.getVendor() instanceof TransitVendor)) entry.setLand(true); + if (!entry.getVendor().isTransit()) entry.setLand(true); if (prev != null){ prev.setTime(scorer.getTime(entry, prev)); } @@ -230,7 +230,7 @@ public class RouteSearcher { ConnectibleEdge edge = (ConnectibleEdge) edges.get(i); Vendor vendor = i == 0 ? from : edge.getSource().getEntry().asTransit(); RouteEntry entry = new RouteEntry(vendor, edge.getRefill(), edge.getFuelCost(), 0); - if (i == 0) entry.setLand(!(vendor instanceof TransitVendor)); + if (i == 0) entry.setLand(!vendor.isTransit()); if (prev != null){ prev.setTime(scorer.getTime(entry, prev)); prev.setFullTime(prev.getTime()); @@ -239,7 +239,7 @@ public class RouteSearcher { prev = entry; if (i == edges.size()-1){ entry = new RouteEntry(to, 0, 0, 0); - entry.setLand(!(to instanceof TransitVendor)); + entry.setLand(!to.isTransit()); prev.setTime(scorer.getTime(entry, prev)); prev.setFullTime(prev.getTime()); entries.add(entry); diff --git a/core/src/main/java/ru/trader/analysis/VendorsGraph.java b/core/src/main/java/ru/trader/analysis/VendorsGraph.java index 492c482..c34693b 100644 --- a/core/src/main/java/ru/trader/analysis/VendorsGraph.java +++ b/core/src/main/java/ru/trader/analysis/VendorsGraph.java @@ -75,7 +75,7 @@ public class VendorsGraph extends ConnectibleGraph { } private void updateVertexes(){ - vertexes.removeIf(v -> v.getEntry() instanceof TransitVendor); + vertexes.removeIf(v -> v.getEntry().isTransit()); updateLevels(root); } @@ -124,11 +124,11 @@ public class VendorsGraph extends ConnectibleGraph { BuildHelper helper = super.createHelper(buyer); if (helper.isConnected()){ Vendor seller = vertex.getEntry(); - if (buyer instanceof TransitVendor && (deep == 0 || seller.getPlace().equals(buyer.getPlace()))){ + if (buyer.isTransit() && (deep == 0 || seller.getPlace().equals(buyer.getPlace()))){ LOG.trace("Buyer is transit of seller or is end, skipping"); return new BuildHelper<>(buyer, -1); } - if (seller instanceof TransitVendor && seller.getPlace().equals(buyer.getPlace())){ + if (seller.isTransit() && seller.getPlace().equals(buyer.getPlace())){ LOG.trace("Seller is transit of buyer, skipping"); return new BuildHelper<>(buyer, -1); } @@ -147,10 +147,10 @@ public class VendorsGraph extends ConnectibleGraph { @Override protected BuildEdge createEdge(BuildHelper helper, Vertex next) { BuildEdge cEdge = super.createEdge(helper, next); - if (next.getEntry() instanceof TransitVendor){ + if (next.getEntry().isTransit()){ return cEdge; } - if (vertex.getEntry() instanceof TransitVendor){ + if (vertex.getEntry().isTransit()){ addEdgesToHead(cEdge); } return new VendorsBuildEdge(cEdge); @@ -158,7 +158,7 @@ public class VendorsGraph extends ConnectibleGraph { private void addEdgesToHead(BuildEdge lastEdge){ Vertex target = lastEdge.getTarget(); - assert vertex.getEntry() instanceof TransitVendor && !(target.getEntry() instanceof TransitVendor); + assert vertex.getEntry().isTransit() && !target.getEntry().isTransit(); VendorsGraphBuilder h = this; Path path = new Path<>(Collections.singleton(lastEdge)); while (h != null && h.edge != null){ @@ -177,7 +177,7 @@ public class VendorsGraph extends ConnectibleGraph { if (!source.equals(target)){ addEdge(source, target, path); } - if (!(source.getEntry() instanceof TransitVendor)){ + if (!source.getEntry().isTransit()){ break; } h = h.head; @@ -199,7 +199,7 @@ public class VendorsGraph extends ConnectibleGraph { LOG.trace("Check {}", entry); if (limit >= e.getMinFuel() && limit <= e.getMaxFuel()) { LOG.trace("Connect {} to {}", entry, vertex); - if (vertex.getEntry() instanceof TransitVendor && !(entry instanceof TransitVendor)) { + if (vertex.getEntry().isTransit() && !entry.isTransit()) { addCheckedEdgesToHead(e); } } @@ -208,7 +208,7 @@ public class VendorsGraph extends ConnectibleGraph { private void addCheckedEdgesToHead(VendorsBuildEdge lastEdge){ Vertex target = lastEdge.getTarget(); - assert vertex.getEntry() instanceof TransitVendor && !(target.getEntry() instanceof TransitVendor); + assert vertex.getEntry().isTransit() && !target.getEntry().isTransit(); List> paths = lastEdge.paths; int i = 1; Path path = paths != null ? paths.get(0) : new Path<>(Collections.singleton((BuildEdge)lastEdge)); @@ -232,7 +232,7 @@ public class VendorsGraph extends ConnectibleGraph { if (!source.equals(target)){ addEdge(source, target, path); } - if (!(source.getEntry() instanceof TransitVendor)){ + if (!source.getEntry().isTransit()){ break; } h = h.head; @@ -256,7 +256,7 @@ public class VendorsGraph extends ConnectibleGraph { @Override protected void addSubTask(Edge edge, double nextLimit) { Vertex next = edge.getTarget(); - if (next.getLevel() >= deep && next.getEntry() instanceof TransitVendor) { + if (next.getLevel() >= deep && next.getEntry().isTransit()) { if (deep > 0){ VendorsGraphBuilder task = new VendorsGraphBuilder(this, (BuildEdge) edge, set, deep - 1, nextLimit); task.isAdding = true; diff --git a/core/src/main/java/ru/trader/core/Vendor.java b/core/src/main/java/ru/trader/core/Vendor.java index e908df6..feba35c 100644 --- a/core/src/main/java/ru/trader/core/Vendor.java +++ b/core/src/main/java/ru/trader/core/Vendor.java @@ -85,4 +85,8 @@ public interface Vendor extends Connectable { remove(offer); } } + + default boolean isTransit(){ + return this instanceof TransitVendor; + } } From 44f89e377b7abc98a179f87f824da0a60bcfafa2 Mon Sep 17 00:00:00 2001 From: iMoHax Date: Fri, 11 Dec 2015 13:53:53 +0300 Subject: [PATCH 3/5] implement vendor offers filter --- .../ru/trader/analysis/FilteredMarket.java | 12 +- .../ru/trader/analysis/FilteredVendor.java | 190 ++++++++++++++++++ .../java/ru/trader/analysis/MarketUtils.java | 1 + .../main/java/ru/trader/analysis/Scorer.java | 6 + .../ru/trader/analysis/VendorsCrawler.java | 4 +- .../java/ru/trader/analysis/VendorsGraph.java | 2 +- core/src/main/java/ru/trader/core/Item.java | 12 +- .../java/ru/trader/core/MarketFilter.java | 41 +++- core/src/main/java/ru/trader/core/Offer.java | 6 + .../java/ru/trader/core/VendorFilter.java | 91 +++++++++ .../ru/trader/store/berkeley/ItemProxy.java | 10 +- .../store/berkeley/entities/BDBItem.java | 8 +- .../ru/trader/store/simple/SimpleItem.java | 9 +- 13 files changed, 363 insertions(+), 29 deletions(-) create mode 100644 core/src/main/java/ru/trader/analysis/FilteredVendor.java create mode 100644 core/src/main/java/ru/trader/core/VendorFilter.java diff --git a/core/src/main/java/ru/trader/analysis/FilteredMarket.java b/core/src/main/java/ru/trader/analysis/FilteredMarket.java index 7f9b65d..1be1051 100644 --- a/core/src/main/java/ru/trader/analysis/FilteredMarket.java +++ b/core/src/main/java/ru/trader/analysis/FilteredMarket.java @@ -3,6 +3,7 @@ package ru.trader.analysis; import ru.trader.core.*; import java.util.Collection; +import java.util.HashMap; import java.util.NavigableSet; import java.util.function.Predicate; import java.util.stream.Stream; @@ -52,16 +53,12 @@ public class FilteredMarket { return vendor.has(SERVICE_TYPE.MARKET) || vendor.has(SERVICE_TYPE.BLACK_MARKET); } - private boolean isTransit(Vendor vendor){ - return vendor instanceof TransitVendor; - } - public Stream getMarkets(){ return getMarkets(false); } public Stream getMarkets(boolean withTransit){ - Predicate transitOrMarket = v -> withTransit && isTransit(v) || isMarket(v); + Predicate transitOrMarket = v -> withTransit && v.isTransit() || isMarket(v); if (disableFilter){ return market.getVendors().stream().filter(transitOrMarket); } @@ -91,8 +88,11 @@ public class FilteredMarket { if (disableFilter){ return res; } - return res.filter(o -> !filter.isFiltered(o.getVendor(), true)); + return res.filter(o -> !filter.isFiltered(o)); } + public FilteredVendor getFiltered(Vendor vendor){ + return new FilteredVendor(vendor, filter.getFilter(vendor)); + } } diff --git a/core/src/main/java/ru/trader/analysis/FilteredVendor.java b/core/src/main/java/ru/trader/analysis/FilteredVendor.java new file mode 100644 index 0000000..bbe1685 --- /dev/null +++ b/core/src/main/java/ru/trader/analysis/FilteredVendor.java @@ -0,0 +1,190 @@ +package ru.trader.analysis; + +import ru.trader.analysis.graph.Connectable; +import ru.trader.core.*; + +import java.util.Collection; +import java.util.stream.Collectors; + +public class FilteredVendor implements Vendor { + private final Vendor vendor; + private final VendorFilter filter; + + public FilteredVendor(Vendor vendor, VendorFilter filter) { + this.vendor = vendor; + this.filter = filter; + } + + @Override + public String getName() { + return vendor.getName(); + } + + @Override + public void setName(String name) { + vendor.setName(name); + } + + @Override + public String getFullName() { + return vendor.getFullName(); + } + + @Override + public Place getPlace() { + return vendor.getPlace(); + } + + @Override + public double getDistance() { + return vendor.getDistance(); + } + + @Override + public void setDistance(double distance) { + vendor.setDistance(distance); + } + + @Override + public FACTION getFaction() { + return vendor.getFaction(); + } + + @Override + public void setFaction(FACTION faction) { + vendor.setFaction(faction); + } + + @Override + public GOVERNMENT getGovernment() { + return vendor.getGovernment(); + } + + @Override + public void setGovernment(GOVERNMENT government) { + vendor.setGovernment(government); + } + + @Override + public void add(SERVICE_TYPE service) { + vendor.add(service); + } + + @Override + public void remove(SERVICE_TYPE service) { + vendor.remove(service); + } + + @Override + public boolean has(SERVICE_TYPE service) { + return vendor.has(service); + } + + @Override + public Collection getServices() { + return vendor.getServices(); + } + + @Override + public void add(Offer offer) { + vendor.add(offer); + } + + @Override + public Offer addOffer(OFFER_TYPE type, Item item, double price, long count) { + return vendor.addOffer(type, item, price, count); + } + + @Override + public void remove(Offer offer) { + vendor.remove(offer); + } + + @Override + public Collection get(OFFER_TYPE type) { + if (vendor.isTransit()) return vendor.get(type); + return vendor.get(type).stream().filter(o -> !filter.isFiltered(o)).collect(Collectors.toList()); + } + + @Override + public Offer get(OFFER_TYPE type, Item item) { + Offer offer = vendor.get(type, item); + if (offer == null || filter.isFiltered(offer)) return null; + return offer; + } + + @Override + public boolean has(OFFER_TYPE type, Item item) { + return vendor.has(type, item) && !filter.isFiltered(vendor, item, type); + } + + @Override + public Collection getAllSellOffers() { + if (vendor.isTransit()) return vendor.getAllSellOffers(); + return vendor.getAllSellOffers().stream().filter(o -> !filter.isFiltered(o)).collect(Collectors.toList()); + } + + @Override + public Collection getAllBuyOffers() { + if (vendor.isTransit()) return vendor.getAllBuyOffers(); + return vendor.getAllBuyOffers().stream().filter(o -> !filter.isFiltered(o)).collect(Collectors.toList()); + } + + @Override + public Offer getSell(Item item) { + Offer offer = vendor.getSell(item); + if (offer == null || filter.isFiltered(offer)) return null; + return offer; + } + + @Override + public Offer getBuy(Item item) { + Offer offer = vendor.getBuy(item); + if (offer == null || filter.isFiltered(offer)) return null; + return offer; + } + + @Override + public boolean hasSell(Item item) { + return vendor.hasSell(item) && !filter.isFiltered(vendor, item, OFFER_TYPE.SELL); + } + + @Override + public boolean hasBuy(Item item) { + return vendor.hasBuy(item) && !filter.isFiltered(vendor, item, OFFER_TYPE.BUY); + } + + @Override + public double getDistance(Vendor other) { + return vendor.getDistance(other); + } + + @Override + public boolean canRefill() { + return vendor.canRefill(); + } + + @Override + public void clear() { + vendor.clear(); + } + + @Override + public boolean isTransit() { + return vendor.isTransit(); + } + + @Override + public int compareTo(Connectable o) { + return vendor.compareTo(o); + } + + @Override + public String toString() { + return vendor.toString(); + } + + public Vendor unwrap(){ + return vendor; + } +} diff --git a/core/src/main/java/ru/trader/analysis/MarketUtils.java b/core/src/main/java/ru/trader/analysis/MarketUtils.java index 6c4dc1c..8ea6229 100644 --- a/core/src/main/java/ru/trader/analysis/MarketUtils.java +++ b/core/src/main/java/ru/trader/analysis/MarketUtils.java @@ -46,6 +46,7 @@ public class MarketUtils { public static List getOrders(Vendor seller, Vendor buyer){ LOG.trace("Get orders from {}, to {}", seller, buyer); List orders = new ArrayList<>(); + if (seller.isTransit() || buyer.isTransit()) return orders; for (Offer sell : seller.getAllSellOffers()) { Offer buy = buyer.getBuy(sell.getItem()); if (buy != null) { diff --git a/core/src/main/java/ru/trader/analysis/Scorer.java b/core/src/main/java/ru/trader/analysis/Scorer.java index ef0a88e..e1d14c3 100644 --- a/core/src/main/java/ru/trader/analysis/Scorer.java +++ b/core/src/main/java/ru/trader/analysis/Scorer.java @@ -165,4 +165,10 @@ public class Scorer { if (order.getProfit() <= 0) return Stream.empty(); return Stream.of(order); } + + public List getOrders(Vendor seller, Vendor buyer){ + FilteredVendor fSeller = market.getFiltered(seller); + FilteredVendor fBuyer = market.getFiltered(buyer); + return MarketUtils.getOrders(fSeller, fBuyer); + } } diff --git a/core/src/main/java/ru/trader/analysis/VendorsCrawler.java b/core/src/main/java/ru/trader/analysis/VendorsCrawler.java index 102d7b8..8a7b73d 100644 --- a/core/src/main/java/ru/trader/analysis/VendorsCrawler.java +++ b/core/src/main/java/ru/trader/analysis/VendorsCrawler.java @@ -87,7 +87,7 @@ public class VendorsCrawler extends Crawler { } else { Vendor seller = findMarket(); if (seller != null) { - orders = MarketUtils.getOrders(seller, edge.getTarget().getEntry()); + orders = getScorer().getOrders(seller, edge.getTarget().getEntry()); } } res.setOrders(MarketUtils.getStack(orders, balance, getScorer().getProfile().getShip().getCargo())); @@ -146,7 +146,7 @@ public class VendorsCrawler extends Crawler { if (orders == null){ Vendor seller = source.getEntry(); Vendor buyer = target.getEntry(); - orders = MarketUtils.getOrders(seller, buyer); + orders = getScorer().getOrders(seller, buyer); } return orders; } diff --git a/core/src/main/java/ru/trader/analysis/VendorsGraph.java b/core/src/main/java/ru/trader/analysis/VendorsGraph.java index c34693b..13b768e 100644 --- a/core/src/main/java/ru/trader/analysis/VendorsGraph.java +++ b/core/src/main/java/ru/trader/analysis/VendorsGraph.java @@ -297,7 +297,7 @@ public class VendorsGraph extends ConnectibleGraph { if (orders == null){ Vendor seller = source.getEntry(); Vendor buyer = target.getEntry(); - orders = MarketUtils.getOrders(seller, buyer); + orders = getScorer().getOrders(seller, buyer); } return orders; } diff --git a/core/src/main/java/ru/trader/core/Item.java b/core/src/main/java/ru/trader/core/Item.java index f7805ca..c6fff26 100644 --- a/core/src/main/java/ru/trader/core/Item.java +++ b/core/src/main/java/ru/trader/core/Item.java @@ -2,15 +2,23 @@ package ru.trader.core; import org.jetbrains.annotations.NotNull; +import java.util.Collection; import java.util.Objects; public interface Item extends Comparable { String getName(); void setName(String name); - boolean isIllegal(FACTION faction); + default boolean isIllegal(Vendor vendor){ + FACTION faction = vendor.getFaction(); + GOVERNMENT government = vendor.getGovernment(); + return faction != null && getIllegalFactions().contains(vendor.getFaction()) + || government != null && getIllegalGovernments().contains(government); + } + + Collection getIllegalFactions(); void setIllegal(FACTION faction, boolean illegal); - boolean isIllegal(GOVERNMENT government); + Collection getIllegalGovernments(); void setIllegal(GOVERNMENT government, boolean illegal); Group getGroup(); diff --git a/core/src/main/java/ru/trader/core/MarketFilter.java b/core/src/main/java/ru/trader/core/MarketFilter.java index 70a1e80..132d911 100644 --- a/core/src/main/java/ru/trader/core/MarketFilter.java +++ b/core/src/main/java/ru/trader/core/MarketFilter.java @@ -2,11 +2,9 @@ package ru.trader.core; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import ru.trader.analysis.FilteredVendor; -import java.util.ArrayList; -import java.util.Collection; -import java.util.EnumSet; -import java.util.Properties; +import java.util.*; public class MarketFilter { private final static Logger LOG = LoggerFactory.getLogger(MarketFilter.class); @@ -16,10 +14,18 @@ public class MarketFilter { private double distance; private final EnumSet services; private final Collection excludes; + private final VendorFilter defaultVendorFilter; + private final HashMap customFilteredVendors; public MarketFilter() { - services = EnumSet.noneOf(SERVICE_TYPE.class); - excludes = new ArrayList<>(); + this(new VendorFilter()); + } + + public MarketFilter(VendorFilter defaultVendorFilter) { + this.services = EnumSet.noneOf(SERVICE_TYPE.class); + this.excludes = new ArrayList<>(); + this.customFilteredVendors = new HashMap<>(); + this.defaultVendorFilter = defaultVendorFilter; } public Place getCenter() { @@ -78,6 +84,23 @@ public class MarketFilter { return excludes; } + private String getVendorKey(Vendor vendor){ + return vendor == null ? null : vendor.getFullName(); + } + + public void addFilter(Vendor vendor, VendorFilter vendorFilter){ + customFilteredVendors.put(getVendorKey(vendor), vendorFilter); + } + + public void removeFilter(Vendor vendor){ + customFilteredVendors.remove(getVendorKey(vendor)); + } + + public VendorFilter getFilter(Vendor vendor){ + VendorFilter filter = customFilteredVendors.get(getVendorKey(vendor)); + return filter != null ? filter : defaultVendorFilter; + } + public boolean isFiltered(Place place){ return center != null && center.getDistance(place) > radius; } @@ -96,6 +119,12 @@ public class MarketFilter { return false; } + public boolean isFiltered(Offer offer){ + if (isFiltered(offer.getVendor(), true)) return true; + VendorFilter filter = getFilter(offer.getVendor()); + return filter.isFiltered(offer); + } + public static MarketFilter buildFilter(Properties values, Market market){ MarketFilter filter = new MarketFilter(); String v = values.getProperty("filter.center", null); diff --git a/core/src/main/java/ru/trader/core/Offer.java b/core/src/main/java/ru/trader/core/Offer.java index a56c96f..a76757d 100644 --- a/core/src/main/java/ru/trader/core/Offer.java +++ b/core/src/main/java/ru/trader/core/Offer.java @@ -24,6 +24,12 @@ public interface Offer extends Comparable { return getItem().equals(item); } + default boolean isIllegal(){ + Vendor vendor = getVendor(); + Item item = getItem(); + return item.isIllegal(vendor); + } + @Override default int compareTo(@NotNull Offer other) { Objects.requireNonNull(other, "Not compare with null"); diff --git a/core/src/main/java/ru/trader/core/VendorFilter.java b/core/src/main/java/ru/trader/core/VendorFilter.java new file mode 100644 index 0000000..edb5bc2 --- /dev/null +++ b/core/src/main/java/ru/trader/core/VendorFilter.java @@ -0,0 +1,91 @@ +package ru.trader.core; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.ArrayList; +import java.util.Collection; + +public class VendorFilter { + private final static Logger LOG = LoggerFactory.getLogger(VendorFilter.class); + + private boolean disable; + private boolean skipIllegal; + private final Collection buyExcludes; + private final Collection sellExcludes; + + public VendorFilter() { + buyExcludes = new ArrayList<>(); + sellExcludes = new ArrayList<>(); + skipIllegal = false; + } + + public boolean isDisable() { + return disable; + } + + public void setDisable(boolean disable) { + this.disable = disable; + } + + public boolean isSkipIllegal() { + return skipIllegal; + } + + public void setSkipIllegal(boolean skipIllegal) { + this.skipIllegal = skipIllegal; + } + + public void addBuyExclude(Item item){ + buyExcludes.add(item); + } + + public void removeBuyExclude(Item item){ + buyExcludes.remove(item); + } + + public void clearBuyExcludes(){ + buyExcludes.clear(); + } + + public Collection getBuyExcludes(){ + return buyExcludes; + } + + public void addSellExclude(Item item){ + sellExcludes.add(item); + } + + public void removeSellExclude(Item item){ + sellExcludes.remove(item); + } + + public void clearSellExcludes(){ + sellExcludes.clear(); + } + + public Collection getSellExcludes(){ + return sellExcludes; + } + + public boolean isFiltered(Offer offer){ + if (disable) return false; + if (skipIllegal && offer.isIllegal()) return true; + switch (offer.getType()) { + case SELL: return sellExcludes.contains(offer.getItem()); + case BUY: return buyExcludes.contains(offer.getItem()); + } + return false; + } + + public boolean isFiltered(Vendor vendor, Item item, OFFER_TYPE offerType){ + if (disable) return false; + if (skipIllegal && (item.isIllegal(vendor))) return true; + switch (offerType) { + case SELL: return sellExcludes.contains(item); + case BUY: return buyExcludes.contains(item); + } + return false; + } + +} diff --git a/core/src/main/java/ru/trader/store/berkeley/ItemProxy.java b/core/src/main/java/ru/trader/store/berkeley/ItemProxy.java index e6f3ea1..cd7a0e4 100644 --- a/core/src/main/java/ru/trader/store/berkeley/ItemProxy.java +++ b/core/src/main/java/ru/trader/store/berkeley/ItemProxy.java @@ -6,6 +6,8 @@ import ru.trader.core.GOVERNMENT; import ru.trader.core.Group; import ru.trader.store.berkeley.entities.BDBItem; +import java.util.Collection; + public class ItemProxy extends AbstractItem { private final BDBItem item; private final BDBStore store; @@ -42,8 +44,8 @@ public class ItemProxy extends AbstractItem { } @Override - public boolean isIllegal(FACTION faction) { - return item.isIllegal(faction); + public Collection getIllegalFactions() { + return item.getIllegalFactions(); } @Override @@ -53,8 +55,8 @@ public class ItemProxy extends AbstractItem { } @Override - public boolean isIllegal(GOVERNMENT government) { - return item.isIllegal(government); + public Collection getIllegalGovernments() { + return item.getIllegalGovernments(); } @Override diff --git a/core/src/main/java/ru/trader/store/berkeley/entities/BDBItem.java b/core/src/main/java/ru/trader/store/berkeley/entities/BDBItem.java index 0ae9a8b..bd2bbf2 100644 --- a/core/src/main/java/ru/trader/store/berkeley/entities/BDBItem.java +++ b/core/src/main/java/ru/trader/store/berkeley/entities/BDBItem.java @@ -49,8 +49,8 @@ public class BDBItem { else fIllegals.remove(faction); } - public boolean isIllegal(FACTION faction) { - return fIllegals.contains(faction); + public Collection getIllegalFactions() { + return fIllegals; } public void setIllegal(GOVERNMENT government, boolean illegal) { @@ -58,8 +58,8 @@ public class BDBItem { else gIllegals.remove(government); } - public boolean isIllegal(GOVERNMENT government) { - return gIllegals.contains(government); + public Collection getIllegalGovernments() { + return gIllegals; } public String getGroupId() { diff --git a/core/src/main/java/ru/trader/store/simple/SimpleItem.java b/core/src/main/java/ru/trader/store/simple/SimpleItem.java index 961555a..f41e84a 100644 --- a/core/src/main/java/ru/trader/store/simple/SimpleItem.java +++ b/core/src/main/java/ru/trader/store/simple/SimpleItem.java @@ -5,6 +5,7 @@ import ru.trader.core.FACTION; import ru.trader.core.GOVERNMENT; import ru.trader.core.Group; +import java.util.Collection; import java.util.EnumSet; public class SimpleItem extends AbstractItem { @@ -39,8 +40,8 @@ public class SimpleItem extends AbstractItem { } @Override - public boolean isIllegal(FACTION faction) { - return fIllegals.contains(faction); + public Collection getIllegalFactions() { + return fIllegals; } @Override @@ -50,8 +51,8 @@ public class SimpleItem extends AbstractItem { } @Override - public boolean isIllegal(GOVERNMENT government) { - return gIllegals.contains(government); + public Collection getIllegalGovernments() { + return gIllegals; } @Override From e0c62d9ffb96ac8b0c58b4499ed44834b236213f Mon Sep 17 00:00:00 2001 From: iMoHax Date: Fri, 11 Dec 2015 14:48:06 +0300 Subject: [PATCH 4/5] remove old controller --- client/src/main/java/ru/trader/controllers/MainController.java | 3 --- 1 file changed, 3 deletions(-) diff --git a/client/src/main/java/ru/trader/controllers/MainController.java b/client/src/main/java/ru/trader/controllers/MainController.java index d4394eb..c956704 100644 --- a/client/src/main/java/ru/trader/controllers/MainController.java +++ b/client/src/main/java/ru/trader/controllers/MainController.java @@ -48,8 +48,6 @@ public class MainController { @FXML private ItemsController itemsController; @FXML - private RouterController routerController; - @FXML private TabPane tabs; @FXML private Tab track; @@ -111,7 +109,6 @@ public class MainController { void init(){ itemsController.init(); offersController.init(); - routerController.init(); //TODO: add init all controllers } From 1f43571e37047080b7c11606035f4fd4e0d213d5 Mon Sep 17 00:00:00 2001 From: iMoHax Date: Mon, 14 Dec 2015 14:25:37 +0300 Subject: [PATCH 5/5] fix reserves for not looped routes --- core/src/main/java/ru/trader/analysis/Route.java | 3 ++- .../src/main/java/ru/trader/analysis/RouteFiller.java | 11 +++++++---- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/core/src/main/java/ru/trader/analysis/Route.java b/core/src/main/java/ru/trader/analysis/Route.java index 235fcf0..173067e 100644 --- a/core/src/main/java/ru/trader/analysis/Route.java +++ b/core/src/main/java/ru/trader/analysis/Route.java @@ -308,6 +308,7 @@ public class Route implements Comparable { public LoopIterator loopIterator(int from){ return new LoopIterator() { private final int size = entries.size() - (isLoop() ? 1 : 0); + private final int maxIndex = isLoop() ? size - 1 : size - from; private int i = -1; @Override @@ -324,7 +325,7 @@ public class Route implements Comparable { @Override public boolean hasNext() { - return i < size-1; + return i < maxIndex; } @Override diff --git a/core/src/main/java/ru/trader/analysis/RouteFiller.java b/core/src/main/java/ru/trader/analysis/RouteFiller.java index 60ae6e3..d7a5edc 100644 --- a/core/src/main/java/ru/trader/analysis/RouteFiller.java +++ b/core/src/main/java/ru/trader/analysis/RouteFiller.java @@ -421,11 +421,14 @@ public class RouteFiller { return res; } - private static int getLastIndex(final int fromIndex, final Offer buyOffer, final Order[] sells){ + private static int getLastIndex(final int fromIndex, final Offer buyOffer, final Order[] sells, boolean isLoop){ long need = buyOffer.getCount(); for (int i = 0; i < sells.length; i++) { int index = i + fromIndex; - if (index >= sells.length) index -= sells.length; + if (index >= sells.length){ + if (isLoop) index -= sells.length; + else break; + } Order sell = sells[index]; if (sell == null) continue; if (sell.getCount() >= need) { @@ -465,7 +468,7 @@ public class RouteFiller { this.entry = entry; this.index = index; this.sell = orders[index]; - int lastIndex = getLastIndex(index, buyOffer, orders); + int lastIndex = getLastIndex(index, buyOffer, orders, route.isLoop()); if (lastIndex != -1) { endIndex = route.find(buyOffer.getVendor(), lastIndex+1); if (endIndex != -1) { @@ -481,7 +484,7 @@ public class RouteFiller { } private boolean isSeller(){ - return sell != null && endIndex != -1; + return sell != null && endIndex != -1 && (endIndex >= index || route.isLoop()); } private double getProfit(){