Merge branch 'v2' of https://github.com/iMoHax/Trader into v2

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
     }
 

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<Vendor> getMarkets(){
         return getMarkets(false);
     }
 
     public Stream<Vendor> getMarkets(boolean withTransit){
-        Predicate<Vendor> transitOrMarket = v -> withTransit && isTransit(v) || isMarket(v);
+        Predicate<Vendor> 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));
+    }
 
 }

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<SERVICE_TYPE> 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<Offer> 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<Offer> getAllSellOffers() {
+        if (vendor.isTransit()) return vendor.getAllSellOffers();
+        return vendor.getAllSellOffers().stream().filter(o -> !filter.isFiltered(o)).collect(Collectors.toList());
+    }
+
+    @Override
+    public Collection<Offer> 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<Vendor> o) {
+        return vendor.compareTo(o);
+    }
+
+    @Override
+    public String toString() {
+        return vendor.toString();
+    }
+
+    public Vendor unwrap(){
+        return vendor;
+    }
+}

core/src/main/java/ru/trader/analysis/MarketUtils.java

@@ -46,6 +46,7 @@ public class MarketUtils {
     public static List<Order> getOrders(Vendor seller, Vendor buyer){
         LOG.trace("Get orders from {}, to {}", seller, buyer);
         List<Order> orders = new ArrayList<>();
+        if (seller.isTransit() || buyer.isTransit()) return orders;
         for (Offer sell : seller.getAllSellOffers()) {
             Offer buy = buyer.getBuy(sell.getItem());
             if (buy != null) {

core/src/main/java/ru/trader/analysis/Route.java

@@ -308,6 +308,7 @@ public class Route implements Comparable<Route> {
     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<Route> {
 
             @Override
             public boolean hasNext() {
-                return i < size-1;
+                return i < maxIndex;
             }
 
             @Override
@@ -337,7 +338,7 @@ public class Route implements Comparable<Route> {
 
     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);

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(){

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<Place> edge = (ConnectibleEdge<Place>) 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);

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<Order> getOrders(Vendor seller, Vendor buyer){
+        FilteredVendor fSeller = market.getFiltered(seller);
+        FilteredVendor fBuyer = market.getFiltered(buyer);
+        return MarketUtils.getOrders(fSeller, fBuyer);
+    }
 }

core/src/main/java/ru/trader/analysis/VendorsCrawler.java

@@ -87,7 +87,7 @@ public class VendorsCrawler extends Crawler<Vendor> {
             } 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<Vendor> {
             if (orders == null){
                 Vendor seller = source.getEntry();
                 Vendor buyer = target.getEntry();
-                orders = MarketUtils.getOrders(seller, buyer);
+                orders = getScorer().getOrders(seller, buyer);
             }
             return orders;
         }

core/src/main/java/ru/trader/analysis/VendorsGraph.java

@@ -75,7 +75,7 @@ public class VendorsGraph extends ConnectibleGraph<Vendor> {
     }
 
     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<Vendor> {
             BuildHelper<Vendor> 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<Vendor> {
         @Override
         protected BuildEdge createEdge(BuildHelper<Vendor> helper, Vertex<Vendor> 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<Vendor> {
 
         private void addEdgesToHead(BuildEdge lastEdge){
             Vertex<Vendor> target = lastEdge.getTarget();
-            assert vertex.getEntry() instanceof TransitVendor && !(target.getEntry() instanceof TransitVendor);
+            assert vertex.getEntry().isTransit() && !target.getEntry().isTransit();
             VendorsGraphBuilder h = this;
             Path<Vendor> path = new Path<>(Collections.singleton(lastEdge));
             while (h != null && h.edge != null){
@@ -177,7 +177,7 @@ public class VendorsGraph extends ConnectibleGraph<Vendor> {
                 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<Vendor> {
                 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<Vendor> {
 
         private void addCheckedEdgesToHead(VendorsBuildEdge lastEdge){
             Vertex<Vendor> target = lastEdge.getTarget();
-            assert vertex.getEntry() instanceof TransitVendor && !(target.getEntry() instanceof TransitVendor);
+            assert vertex.getEntry().isTransit() && !target.getEntry().isTransit();
             List<Path<Vendor>> paths = lastEdge.paths;
             int i = 1;
             Path<Vendor> path = paths != null ? paths.get(0) : new Path<>(Collections.singleton((BuildEdge)lastEdge));
@@ -232,7 +232,7 @@ public class VendorsGraph extends ConnectibleGraph<Vendor> {
                         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<Vendor> {
         @Override
         protected void addSubTask(Edge<Vendor> edge, double nextLimit) {
             Vertex<Vendor> 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;
@@ -297,7 +297,7 @@ public class VendorsGraph extends ConnectibleGraph<Vendor> {
             if (orders == null){
                 Vendor seller = source.getEntry();
                 Vendor buyer = target.getEntry();
-                orders = MarketUtils.getOrders(seller, buyer);
+                orders = getScorer().getOrders(seller, buyer);
             }
             return orders;
         }

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();

core/src/main/java/ru/trader/core/Item.java

@@ -2,12 +2,25 @@ package ru.trader.core;
 
 import org.jetbrains.annotations.NotNull;
 
+import java.util.Collection;
 import java.util.Objects;
 
 public interface Item extends Comparable<Item> {
     String getName();
     void setName(String name);
 
+    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<FACTION> getIllegalFactions();
+    void setIllegal(FACTION faction, boolean illegal);
+    Collection<GOVERNMENT> getIllegalGovernments();
+    void setIllegal(GOVERNMENT government, boolean illegal);
+
     Group getGroup();
 
     @Override

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.*;
-import java.util.Collection;
-import java.util.EnumSet;
-import java.util.Properties;
 
 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<SERVICE_TYPE> services;
     private final Collection<Vendor> excludes;
+    private final VendorFilter defaultVendorFilter;
+    private final HashMap<String, VendorFilter> customFilteredVendors;
 
     public MarketFilter() {
-        services = EnumSet.noneOf(SERVICE_TYPE.class);
+        this(new VendorFilter());
-        excludes = new ArrayList<>();
+    }
+
+    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);

core/src/main/java/ru/trader/core/Offer.java

@@ -24,6 +24,12 @@ public interface Offer extends Comparable<Offer> {
         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");

core/src/main/java/ru/trader/core/Vendor.java

@@ -85,4 +85,8 @@ public interface Vendor extends Connectable<Vendor> {
             remove(offer);
         }
     }
+
+    default boolean isTransit(){
+        return this instanceof TransitVendor;
+    }
 }

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<Item> buyExcludes;
+    private final Collection<Item> 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<Item> 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<Item> 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;
+    }
+
+}

core/src/main/java/ru/trader/store/berkeley/ItemProxy.java

@@ -1,9 +1,13 @@
 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;
 
+import java.util.Collection;
+
 public class ItemProxy extends AbstractItem {
     private final BDBItem item;
     private final BDBStore store;
@@ -33,6 +37,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 Collection<FACTION> getIllegalFactions() {
+        return item.getIllegalFactions();
+    }
+
+    @Override
+    protected void updateIllegalState(GOVERNMENT government, boolean illegal) {
+        item.setIllegal(government, illegal);
+        store.getItemAccessor().update(item);
+    }
+
+    @Override
+    public Collection<GOVERNMENT> getIllegalGovernments() {
+        return item.getIllegalGovernments();
+    }
+
     @Override
     public Group getGroup() {
         if (group == null){

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<FACTION> fIllegals = new HashSet<>();
+    @SecondaryKey(relate=Relationship.MANY_TO_MANY)
+    Collection<GOVERNMENT> 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 Collection<FACTION> getIllegalFactions() {
+        return fIllegals;
+    }
+
+    public void setIllegal(GOVERNMENT government, boolean illegal) {
+        if (illegal) gIllegals.add(government);
+        else gIllegals.remove(government);
+    }
+
+    public Collection<GOVERNMENT> getIllegalGovernments() {
+        return gIllegals;
+    }
+
     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;
     }

core/src/main/java/ru/trader/store/simple/SimpleItem.java

@@ -1,11 +1,18 @@
 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.Collection;
+import java.util.EnumSet;
+
 public class SimpleItem extends AbstractItem {
     private String name;
     private Group group;
+    private final EnumSet<GOVERNMENT> gIllegals = EnumSet.noneOf(GOVERNMENT.class);
+    private final EnumSet<FACTION> fIllegals = EnumSet.noneOf(FACTION.class);
 
     public SimpleItem(String name) {
         this.name = name;
@@ -26,6 +33,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 Collection<FACTION> getIllegalFactions() {
+        return fIllegals;
+    }
+
+    @Override
+    protected void updateIllegalState(GOVERNMENT government, boolean illegal) {
+        if (illegal) gIllegals.add(government);
+            else gIllegals.remove(government);
+    }
+
+    @Override
+    public Collection<GOVERNMENT> getIllegalGovernments() {
+        return gIllegals;
+    }
+
     @Override
     public Group getGroup() {
         return group;