Voomra/trader
Archived
0
Fork 0
Code Activity

Refactoring core module

Browse Source
This commit is contained in:
iMoHax
2014-11-08 18:37:12 +03:00
parent 1e1e41595d
commit b1a585bbc0
43 changed files with 1440 additions and 1021 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
core/src/main/java/ru/trader/core/AbstractItem.java Normal file
View File

@@ -0,0 +1,45 @@
package ru.trader.core;
import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Objects;
public abstract class AbstractItem implements Item {
private final static Logger LOG = LoggerFactory.getLogger(AbstractItem.class);
private AbstractMarket market;
protected abstract void updateName(String name);
protected final void setMarket(AbstractMarket market){
assert this.market == null;
this.market = market;
}
@Override
public final void setName(String name){
if (market != null){
LOG.debug("Change name of item {} to {}", this, name);
market.updateName(this, name);
market.setChange(true);
} else {
updateName(name);
}
}
@Override
public String toString(){
return getName();
}
@Override
public int compareTo(@NotNull Item other){
Objects.requireNonNull(other, "Not compare with null");
if (this == other) return 0;
String name = getName();
String otherName = other.getName();
return name != null ? otherName != null ? name.compareTo(otherName) : -1 : 0;
}
}

188
core/src/main/java/ru/trader/core/AbstractItemStat.java Normal file
View File

@@ -0,0 +1,188 @@
package ru.trader.core;
import java.util.Collection;
import java.util.Collections;
public abstract class AbstractItemStat implements ItemStat {
protected void updatePrice(AbstractOffer offer, double price){
offer.updatePrice(price);
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("{");
sb.append(getItem());
sb.append(", ").append(getType());
sb.append(", avg=").append(getAvg());
sb.append(", best=").append(getBest());
sb.append(", min=").append(getMin());
sb.append(", max=").append(getMax());
sb.append("}");
return sb.toString();
}
protected Offer getFake() {
return new Offer() {
@Override
public Item getItem() {
return AbstractItemStat.this.getItem();
}
@Override
public OFFER_TYPE getType() {
return AbstractItemStat.this.getType();
}
@Override
public Vendor getVendor() {
return NONE_VENDOR;
}
@Override
public double getPrice() {
return Double.NaN;
}
@Override
public void setPrice(double price) {
throw new UnsupportedOperationException("Is fake offer, change unsupported");
}
@Override
public long getCount() {
return 0;
}
@Override
public void setCount(long count) {
throw new UnsupportedOperationException("Is fake offer, change unsupported");
}
};
}
private static Place FAKE_PLACE = new Place() {
@Override
public String getName() {
return "None";
}
@Override
public void setName(String name) {
throw new UnsupportedOperationException("Is fake place, change unsupported");
}
@Override
public double getX() {
return 0;
}
@Override
public double getY() {
return 0;
}
@Override
public double getZ() {
return 0;
}
@Override
public void setPosition(double x, double y, double z) {
throw new UnsupportedOperationException("Is fake place, change unsupported");
}
@Override
public Collection<Vendor> get() {
return Collections.singleton(NONE_VENDOR);
}
@Override
public Vendor addVendor(String name) {
throw new UnsupportedOperationException("Is fake place, change unsupported");
}
@Override
public void add(Vendor vendor) {
throw new UnsupportedOperationException("Is fake place, change unsupported");
}
@Override
public void remove(Vendor vendor) {
throw new UnsupportedOperationException("Is fake place, change unsupported");
}
};
private static Vendor NONE_VENDOR = new Vendor() {
@Override
public String getName() {
return "None";
}
@Override
public void setName(String name) {
throw new UnsupportedOperationException("Is fake vendor, change unsupported");
}
@Override
public Place getPlace() {
return FAKE_PLACE;
}
@Override
public double getDistance() {
return 0;
}
@Override
public void setDistance(double distance) {
throw new UnsupportedOperationException("Is fake vendor, change unsupported");
}
@Override
public void add(SERVICE_TYPE service) {
throw new UnsupportedOperationException("Is fake vendor, change unsupported");
}
@Override
public void remove(SERVICE_TYPE service) {
throw new UnsupportedOperationException("Is fake vendor, change unsupported");
}
@Override
public boolean has(SERVICE_TYPE service) {
return false;
}
@Override
public Offer addOffer(OFFER_TYPE type, Item item, double price, long count) {
throw new UnsupportedOperationException("Is fake vendor, change unsupported");
}
@Override
public void add(Offer offer) {
throw new UnsupportedOperationException("Is fake vendor, change unsupported");
}
@Override
public void remove(Offer offer) {
throw new UnsupportedOperationException("Is fake vendor, change unsupported");
}
@Override
public Collection<Offer> get(OFFER_TYPE type) {
return null;
}
@Override
public Offer get(OFFER_TYPE type, Item item) {
return null;
}
@Override
public boolean has(OFFER_TYPE type, Item item) {
return false;
}
};
}

134
core/src/main/java/ru/trader/core/AbstractMarket.java Normal file
View File

@@ -0,0 +1,134 @@
package ru.trader.core;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public abstract class AbstractMarket implements Market {
private final static Logger LOG = LoggerFactory.getLogger(AbstractMarket.class);
private boolean change;
protected abstract Place createPlace(String name, double x, double y, double z);
protected abstract Group createGroup(String name, GROUP_TYPE type);
protected abstract Item createItem(String name, Group group);
protected abstract void addGroup(Group group);
protected abstract void removeGroup(Group group);
protected abstract void addPlace(Place place);
protected abstract void removePlace(Place place);
protected abstract void addItem(Item item);
protected abstract void removeItem(Item item);
@Override
public final void add(Place place){
LOG.debug("Add place {} to market {}", place, this);
change = true;
if (place instanceof AbstractPlace){
((AbstractPlace) place).setMarket(this);
}
addPlace(place);
}
@Override
public Place addPlace(String name, double x, double y, double z) {
Place place = createPlace(name, x, y, z);
add(place);
return place;
}
@Override
public final void remove(Place place){
LOG.debug("Remove place {} from market {}", place, this);
change = true;
removePlace(place);
}
@Override
public final void add(Group group){
LOG.debug("Add group {} to market {}", group, this);
change = true;
addGroup(group);
}
@Override
public Group addGroup(String name, GROUP_TYPE type) {
Group group = createGroup(name, type);
add(group);
return group;
}
@Override
public void remove(Group group) {
LOG.debug("Remove group {} from market {}", group, this);
change = true;
removeGroup(group);
}
@Override
public final void add(Item item){
LOG.debug("Add item {} to market {}", item, this);
change = true;
if (item instanceof AbstractItem){
((AbstractItem) item).setMarket(this);
}
addItem(item);
}
@Override
public Item addItem(String name, Group group) {
Item item = createItem(name, group);
add(item);
return item;
}
@Override
public final void remove(Item item){
LOG.debug("Remove item {} from market {}", item, this);
change = true;
removeItem(item);
}
@Override
public boolean isChange() {
return change;
}
@Override
public void commit() {
change = false;
}
protected final void setChange(boolean change) {
this.change = change;
}
protected void onAdd(Vendor vendor){}
protected void onRemove(Vendor vendor){}
protected void onAdd(Offer offer){}
protected void onRemove(Offer offer){}
protected void updateName(AbstractPlace place, String name){
place.updateName(name);
}
protected void updatePosition(AbstractPlace place, double x, double y, double z){
place.updatePosition(x, y, z);
}
protected void updateName(AbstractVendor vendor, String name){
vendor.updateName(name);
}
protected void updatePrice(AbstractOffer offer, double price){
ItemStat itemStat = getStat(offer);
if (itemStat instanceof AbstractItemStat){
((AbstractItemStat)itemStat).updatePrice(offer, price);
}
}
protected void updateName(AbstractItem item, String name){
item.updateName(name);
}
}

45
core/src/main/java/ru/trader/core/AbstractOffer.java Normal file
View File

@@ -0,0 +1,45 @@
package ru.trader.core;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public abstract class AbstractOffer implements Offer {
private final static Logger LOG = LoggerFactory.getLogger(AbstractOffer.class);
protected abstract void updatePrice(double price);
protected abstract void updateCount(long count);
protected AbstractMarket getMarket(){
Vendor vendor = getVendor();
if (vendor != null && vendor instanceof AbstractVendor){
return ((AbstractVendor) vendor).getMarket();
}
return null;
}
@Override
public final void setPrice(double price) {
AbstractMarket market = getMarket();
if (market != null){
LOG.debug("Change price of offer {} to {}", this, price);
market.updatePrice(this, price);
market.setChange(true);
} else {
updatePrice(price);
}
}
@Override
public final void setCount(long count) {
AbstractMarket market = getMarket();
if (market != null){
LOG.debug("Change count of offer {} to {}", this, count);
updateCount(count);
market.setChange(true);
} else {
updateCount(count);
}
}
}

95
core/src/main/java/ru/trader/core/AbstractPlace.java Normal file
View File

@@ -0,0 +1,95 @@
package ru.trader.core;
import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Objects;
public abstract class AbstractPlace implements Place, Comparable<Place> {
private final static Logger LOG = LoggerFactory.getLogger(AbstractPlace.class);
private AbstractMarket market;
protected abstract Vendor createVendor(String name);
protected abstract void updateName(String name);
protected abstract void updatePosition(double x, double y, double z);
protected abstract void addVendor(Vendor vendor);
protected abstract void removeVendor(Vendor vendor);
protected final void setMarket(AbstractMarket market){
assert this.market == null;
this.market = market;
}
protected final AbstractMarket getMarket(){
return market;
}
@Override
public final void setName(String name){
if (market != null){
LOG.debug("Change name of place {} to {}", this, name);
market.updateName(this, name);
market.setChange(true);
} else {
updateName(name);
}
}
@Override
public final void setPosition(double x, double y, double z) {
if (market != null){
LOG.debug("Change position of place {} to {},{},{}", this, x, y, z);
market.updatePosition(this, x, y, z);
market.setChange(true);
} else {
updatePosition(x, y, z);
}
}
@Override
public final void add(Vendor vendor) {
if (market != null){
LOG.debug("Add vendor {} to place {}", vendor, this);
addVendor(vendor);
market.setChange(true);
market.onAdd(vendor);
} else {
addVendor(vendor);
}
}
@Override
public Vendor addVendor(String name) {
Vendor vendor = createVendor(name);
add(vendor);
return vendor;
}
@Override
public final void remove(Vendor vendor) {
if (market != null){
LOG.debug("Remove vendor {} from place {}", vendor, this);
removeVendor(vendor);
market.setChange(true);
market.onRemove(vendor);
} else {
removeVendor(vendor);
}
}
@Override
public String toString() {
return getName();
}
@Override
public int compareTo(@NotNull Place other) {
Objects.requireNonNull(other, "Not compare with null");
if (this == other) return 0;
String name = getName();
String otherName = other.getName();
return name != null ? otherName != null ? name.compareTo(otherName) : -1 : 0;
}
}

110
core/src/main/java/ru/trader/core/AbstractVendor.java Normal file
View File

@@ -0,0 +1,110 @@
package ru.trader.core;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public abstract class AbstractVendor implements Vendor {
private final static Logger LOG = LoggerFactory.getLogger(AbstractVendor.class);
protected abstract Offer createOffer(OFFER_TYPE type, Item item, double price, long count);
protected abstract void updateName(String name);
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 AbstractMarket getMarket(){
Place place = getPlace();
if (place != null && place instanceof AbstractPlace){
return ((AbstractPlace) place).getMarket();
}
return null;
}
@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);
}
}
@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);
}
}
@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);
}
}
@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);
}
}
public final void add(Offer offer){
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);
}
}
@Override
public Offer addOffer(OFFER_TYPE type, Item item, double price, long count) {
Offer offer = createOffer(type, item, price, count);
add(offer);
return offer;
}
public final void remove(Offer offer){
assert this.equals(offer.getVendor());
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 String toString() {
return getName();
}
}

12
core/src/main/java/ru/trader/core/Group.java
View File

@@ -1,18 +1,18 @@
package ru.trader.core;
public abstract class Group {
public abstract String getName();
public abstract GROUP_TYPE getType();
public interface Group {
public String getName();
public GROUP_TYPE getType();
public boolean isMarket(){
public default boolean isMarket(){
return GROUP_TYPE.MARKET.equals(getType());
}
public boolean isShip(){
public default boolean isShip(){
return GROUP_TYPE.SHIP.equals(getType());
}
public boolean isOutfit(){
public default boolean isOutfit(){
return GROUP_TYPE.OUTFIT.equals(getType());
}

17
core/src/main/java/ru/trader/core/Item.java
View File

@@ -4,21 +4,14 @@ import org.jetbrains.annotations.NotNull;
import java.util.Objects;
public abstract class Item implements Comparable<Item> {
public interface Item extends Comparable<Item> {
String getName();
void setName(String name);
public abstract String getName();
protected abstract void setName(String name);
public abstract Group getGroup();
public abstract void setGroup(Group group);
Group getGroup();
@Override
public String toString(){
return getName();
}
@Override
public int compareTo(@NotNull Item other){
default int compareTo(@NotNull Item other){
Objects.requireNonNull(other, "Not compare with null");
if (this == other) return 0;
String name = getName();

177
core/src/main/java/ru/trader/core/ItemStat.java
View File

@@ -1,176 +1,17 @@
package ru.trader.core;
import java.util.ArrayList;
import java.util.Collection;
import java.util.NavigableSet;
public abstract class ItemStat {
public interface ItemStat {
protected abstract void update(Offer offer, double price);
OFFER_TYPE getType();
Item getItem();
public abstract OFFER_TYPE getType();
Offer getMin();
double getAvg();
Offer getMax();
public abstract Item getItem();
public abstract double getAvg();
public abstract Offer getBest();
public abstract int getOffersCount();
public abstract NavigableSet<Offer> getOffers();
public abstract Offer getMin();
public abstract Offer getMax();
public abstract boolean isEmpty();
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof ItemStat)) return false;
ItemStat itemStat = (ItemStat) o;
return getType() == itemStat.getType() && getItem().equals(itemStat.getItem());
}
@Override
public int hashCode() {
int result = getItem().hashCode();
result = 31 * result + getType().hashCode();
return result;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("{");
sb.append(getItem());
sb.append(", ").append(getType());
sb.append(", avg=").append(getAvg());
sb.append(", best=").append(getBest());
sb.append(", min=").append(getMin());
sb.append(", max=").append(getMax());
sb.append("}");
return sb.toString();
}
protected Offer getFake() {
return new Offer() {
@Override
public Item getItem() {
return getItem();
}
@Override
public OFFER_TYPE getType() {
return getType();
}
@Override
public double getPrice() {
return Double.NaN;
}
@Override
public Vendor getVendor() {
return NONE_VENDOR;
}
@Override
public boolean hasType(OFFER_TYPE offerType) {
return false;
}
@Override
public boolean hasItem(Item item) {
return false;
}
@Override
protected void setPrice(double price) {
throw new UnsupportedOperationException("Is fake offer, change unsupported");
}
@Override
protected void setVendor(Vendor vendor) {
throw new UnsupportedOperationException("Is fake offer, change unsupported");
}
};
}
private static Vendor NONE_VENDOR = new Vendor() {
@Override
public String getName() {
return "None";
}
@Override
protected Collection<Offer> getOffers() {
return new ArrayList<>();
}
@Override
protected Collection<Item> getItems(OFFER_TYPE offerType) {
return new ArrayList<>();
}
@Override
protected Offer getOffer(OFFER_TYPE offerType, Item item) {
return null;
}
@Override
protected boolean hasOffer(OFFER_TYPE offerType, Item item) {
return false;
}
@Override
protected void addOffer(Offer offer) {
throw new UnsupportedOperationException("Is fake vendor, change unsupported");
}
@Override
protected void removeOffer(Offer offer) {
throw new UnsupportedOperationException("Is fake vendor, change unsupported");
}
@Override
public void setName(String name) {
throw new UnsupportedOperationException("Is fake vendor, change unsupported");
}
@Override
public double getX() {
return 0;
}
@Override
public void setX(double x) {
throw new UnsupportedOperationException("Is fake vendor, change unsupported");
}
@Override
public double getY() {
return 0;
}
@Override
public void setY(double y) {
throw new UnsupportedOperationException("Is fake vendor, change unsupported");
}
@Override
public double getZ() {
return 0;
}
@Override
public void setZ(double z) {
throw new UnsupportedOperationException("Is fake vendor, change unsupported");
}
};
Offer getBest();
NavigableSet<Offer> getOffers();
boolean isEmpty();
}

58
core/src/main/java/ru/trader/core/Market.java
View File

@@ -2,49 +2,45 @@ package ru.trader.core;
import java.util.Collection;
public interface Market {
boolean isChange();
ItemStat getStat(Offer offer);
void add(Place place);
Place addPlace(String name, double x, double y, double z);
void remove(Place place);
ItemStat getStat(OFFER_TYPE type, Item item);
ItemStat getStatSell(Item item);
ItemStat getStatBuy(Item item);
Collection<Offer> getSell(Item item);
Collection<Offer> getBuy(Item item);
void add(Vendor vendor);
void add(Group group);
Group addGroup(String name, GROUP_TYPE type);
void remove(Group group);
void add(Item item);
void remove(Vendor vendor);
Item addItem(String name, Group group);
void remove(Item item);
Collection<Vendor> get();
void add(Vendor vendor, Offer offer);
void remove(Vendor vendor, Offer offer);
Collection<Place> get();
Collection<Group> getGroups();
Collection<Item> getItems();
ItemStat getStat(OFFER_TYPE type, Item item);
void addVendors(Collection<? extends Vendor> vendors);
boolean isChange();
void commit();
void addItems(Collection<? extends Item> items);
default ItemStat getStat(Offer offer){
return getStat(offer.getType(), offer.getItem());
}
void updatePrice(Offer offer, double price);
default ItemStat getStatSell(Item item){
return getStat(OFFER_TYPE.SELL, item);
}
void setChange(boolean change);
default ItemStat getStatBuy(Item item){
return getStat(OFFER_TYPE.BUY, item);
}
void updateName(Vendor vendor, String name);
default Collection<Offer> getSell(Item item){
return getStatSell(item).getOffers();
}
void updateName(Item item, String name);
void updatePosition(Vendor vendor, double x, double y, double z);
default Collection<Offer> getBuy(Item item){
return getStatBuy(item).getOffers();
}
}

105
core/src/main/java/ru/trader/core/MarketAnalyzer.java
View File

@@ -27,58 +27,89 @@ public class MarketAnalyzer {
public Collection<Order> getTop(double balance){
LOG.debug("Get top {}", limit);
Collection<Vendor> vendors = market.get();
Iterable<Place> places = market.get();
List<Order> top = new ArrayList<>(limit);
for (Vendor vendor : vendors) {
LOG.trace("Check vendor {}", vendor);
Collection<Order> orders = getOrders(vendor, balance, top.isEmpty() ? 0 : top.get(top.size()-1).getProfit());
TopList.addAllToTop(top, orders, limit, orderComparator);
for (Place place : places) {
LOG.trace("Check place {}", place);
Collection<Order> orders = getOrders(place, balance, top.isEmpty() ? 0 : top.get(top.size()-1).getProfit());
TopList.addAllToTop(top, orders, limit, orderComparator);
}
return top;
}
public Collection<Order> getOrders(Vendor vendor, double balance) {
return getOrders(vendor, balance, 0);
public Collection<Order> getOrders(Place place, double balance) {
return getOrders(place, balance, 0);
}
private Collection<Order> getOrders(Vendor vendor, double balance, double lowProfit) {
private Collection<Order> getOrders(Place place, double balance, double lowProfit) {
List<Order> res = new ArrayList<>(20);
Collection<Vendor> vendors = market.get();
RouteGraph graph = new RouteGraph(vendor, vendors, tank, maxDistance, true, jumps);
for (Offer sell : vendor.getAllSellOffers()) {
long count = Math.min(cargo, (long) Math.floor(balance / sell.getPrice()));
LOG.trace("Sell offer {}, count = {}", sell, count);
if (count == 0) continue;
Iterator<Offer> buyers = market.getStatBuy(sell.getItem()).getOffers().descendingIterator();
while (buyers.hasNext()){
Offer buy = buyers.next();
if (!graph.isAccessible(buy.getVendor())){
LOG.trace("Is inaccessible buyer, skip");
continue;
Collection<Place> places = market.get();
RouteGraph graph = new RouteGraph(place, places, tank, maxDistance, true, jumps);
for (Vendor vendor : place.get()) {
for (Offer sell : vendor.getAllSellOffers()) {
LOG.trace("Sell offer {}", sell);
if (sell.getCount() == 0) continue;
long count = Math.min(sell.getCount(), Math.min(cargo, (long) Math.floor(balance / sell.getPrice())));
LOG.trace("count = {}", count);
if (count == 0) continue;
Iterator<Offer> buyers = market.getStatBuy(sell.getItem()).getOffers().descendingIterator();
while (buyers.hasNext()){
Offer buy = buyers.next();
if (!graph.isAccessible(buy.getVendor().getPlace())){
LOG.trace("Is inaccessible buyer, skip");
continue;
}
Order order = new Order(sell, buy, count);
LOG.trace("Buy offer {} profit = {}", buy, order.getProfit());
if (order.getProfit() <= 0 && order.getCount() > 0) break;
if (order.getProfit() < lowProfit && order.getCount() == count) {
LOG.trace("Is low profit, skip");
break;
}
res.add(order);
}
Order order = new Order(sell, buy, count);
LOG.trace("Buy offer {} profit = {}", buy, order.getProfit());
if (order.getProfit() <= 0 ) break;
if (order.getProfit() < lowProfit) {
LOG.trace("Is low profit, skip");
break;
}
res.add(order);
}
}
res.sort(orderComparator);
return res;
}
public Collection<Order> getOrders(Vendor from, Vendor to, double balance) {
public Collection<Order> getOrders(Place from, Place to, double balance) {
Collection<Order> res = new ArrayList<>();
RouteGraph graph = new RouteGraph(from, market.get(), tank, maxDistance, true, jumps);
if (!graph.isAccessible(to)){
LOG.trace("Is inaccessible buyer");
return res;
}
for (Vendor seller : from.get()) {
for (Offer sell : seller.getAllSellOffers()) {
if (sell.getCount() == 0) continue;
long count = Math.min(sell.getCount(), Math.min(cargo, (long) Math.floor(balance / sell.getPrice())));
LOG.trace("Sell offer {}, count = {}", sell, count);
if (count == 0) continue;
for (Vendor buyer : to.get()) {
Offer buy = buyer.getBuy(sell.getItem());
if (buy != null){
Order order = new Order(sell, buy, count);
LOG.trace("Buy offer {} profit = {}", buy, order.getProfit());
res.add(order);
}
}
}
}
return res;
}
public Collection<Order> getOrders(Vendor from, Vendor to, double balance) {
Collection<Order> res = new ArrayList<>();
RouteGraph graph = new RouteGraph(from.getPlace(), market.get(), tank, maxDistance, true, jumps);
if (!graph.isAccessible(to.getPlace())){
LOG.trace("Is inaccessible buyer");
return res;
}
for (Offer sell : from.getAllSellOffers()) {
long count = Math.min(cargo, (long) Math.floor(balance / sell.getPrice()));
if (sell.getCount() == 0) continue;
long count = Math.min(sell.getCount(), Math.min(cargo, (long) Math.floor(balance / sell.getPrice())));
LOG.trace("Sell offer {}, count = {}", sell, count);
if (count == 0) continue;
@@ -92,22 +123,22 @@ public class MarketAnalyzer {
return res;
}
public Collection<Path<Vendor>> getPaths(Vendor from, Vendor to){
public Collection<Path<Place>> getPaths(Place from, Place to){
RouteGraph graph = new RouteGraph(from, market.get(), tank, maxDistance, true, jumps);
return graph.getPathsTo(to);
}
public PathRoute getPath(Vendor from, Vendor to){
public PathRoute getPath(Place from, Place to){
RouteGraph graph = new RouteGraph(from, market.get(), tank, maxDistance, true, jumps);
return (PathRoute) graph.getFastPathTo(to);
}
public Collection<PathRoute> getPaths(Vendor from, double balance){
public Collection<PathRoute> getPaths(Place from, double balance){
RouteSearcher searcher = new RouteSearcher(maxDistance, tank, segmentSize);
return searcher.getPaths(from, market.get(), jumps, balance, cargo, limit);
}
public Collection<PathRoute> getPaths(Vendor from, Vendor to, double balance){
public Collection<PathRoute> getPaths(Place from, Place to, double balance){
RouteSearcher searcher = new RouteSearcher(maxDistance, tank, segmentSize);
return searcher.getPaths(from, to, market.get(), jumps, balance, cargo, limit);
}
@@ -115,9 +146,9 @@ public class MarketAnalyzer {
public Collection<PathRoute> getTopPaths(double balance){
List<PathRoute> top = new ArrayList<>(limit);
RouteSearcher searcher = new RouteSearcher(maxDistance, tank, segmentSize);
Collection<Vendor> vendors = market.get();
for (Vendor vendor : vendors) {
Collection<PathRoute> paths = searcher.getPaths(vendor, vendor, vendors, jumps, balance, cargo, 3);
Collection<Place> places = market.get();
for (Place place : places) {
Collection<PathRoute> paths = searcher.getPaths(place, place, places, jumps, balance, cargo, 3);
TopList.addAllToTop(top, paths, limit, RouteGraph.byProfitComparator);
}
return top;

173
core/src/main/java/ru/trader/core/MarketSupport.java
View File

@@ -1,173 +0,0 @@
package ru.trader.core;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import java.util.stream.Collectors;
public abstract class MarketSupport implements Market {
private final static Logger LOG = LoggerFactory.getLogger(MarketSupport.class);
protected abstract void addVendor(Vendor vendor);
protected abstract void removeVendor(Vendor vendor);
protected abstract void addItem(Item item);
protected abstract void removeItem(Item item);
protected abstract Collection<Vendor> getVendors();
protected abstract Collection<Item> getItemList();
@Override
public abstract ItemStat getStat(OFFER_TYPE offerType, Item item);
private boolean change;
@Override
public boolean isChange() {
return change;
}
protected Collection<Vendor> getVendors(OFFER_TYPE offerType, Item item){
List<Vendor> offers = getVendors()
.stream()
.filter(vendor -> vendor.hasOffer(offerType, item))
.collect(Collectors.toList());
return Collections.unmodifiableCollection(offers);
}
protected Collection<Offer> getOffers(OFFER_TYPE offerType, Item item){
ItemStat entry = getStat(offerType, item);
return entry!=null ? Collections.unmodifiableCollection(entry.getOffers()) : null;
}
@Override
public final ItemStat getStat(Offer offer){
return getStat(offer.getType(), offer.getItem());
}
@Override
public final ItemStat getStatSell(Item item){
return getStat(OFFER_TYPE.SELL, item);
}
@Override
public final ItemStat getStatBuy(Item item){
return getStat(OFFER_TYPE.BUY, item);
}
@Override
public final Collection<Offer> getSell(Item item){
return getOffers(OFFER_TYPE.SELL,item);
}
@Override
public final Collection<Offer> getBuy(Item item){
return getOffers(OFFER_TYPE.BUY,item);
}
@Override
public final void add(Vendor vendor){
LOG.debug("Add vendor {} to market {}", vendor, this);
change = true;
addVendor(vendor);
}
@Override
public final void add(Item item){
LOG.debug("Add item {} to market {}", item, this);
change = true;
addItem(item);
}
@Override
public final void remove(Vendor vendor){
LOG.debug("Remove vendor {} from market {}", vendor, this);
change = true;
removeVendor(vendor);
}
@Override
public final void remove(Item item){
LOG.debug("Remove item {} from market {}", item, this);
change = true;
removeItem(item);
}
@Override
public final Collection<Vendor> get(){
return Collections.unmodifiableCollection(getVendors());
}
// Execute on add or remove offer
protected void onAdd(Offer offer){}
protected void onRemove(Offer offer){}
@Override
public final void add(Vendor vendor, Offer offer){
LOG.debug("Add offer {} to vendor {}", offer, vendor);
change = true;
vendor.add(offer);
onAdd(offer);
}
@Override
public final void remove(Vendor vendor, Offer offer){
LOG.debug("Remove offer {} from vendor {}", offer, vendor);
change = true;
vendor.remove(offer);
onRemove(offer);
}
@Override
public final Collection<Item> getItems(){
return Collections.unmodifiableCollection(getItemList());
}
@Override
public void addVendors(Collection<? extends Vendor> vendors) {
change = true;
for (Vendor vendor : vendors) {
add(vendor);
}
}
@Override
public void addItems(Collection<? extends Item> items) {
change = true;
for (Item item : items) {
add(item);
}
}
@Override
public void updateName(Vendor vendor, String name){
change = true;
vendor.setName(name);
}
@Override
public void updatePosition(Vendor vendor, double x, double y, double z){
change = true;
vendor.setX(x);
vendor.setY(y);
vendor.setZ(z);
}
@Override
public void updateName(Item item, String name){
change = true;
item.setName(name);
}
@Override
public void updatePrice(Offer offer, double price){
change = true;
getStat(offer).update(offer, price);
}
@Override
public void setChange(boolean change) {
this.change = change;
}
}

55
core/src/main/java/ru/trader/core/Offer.java
View File

@@ -1,44 +1,31 @@
package ru.trader.core;
import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Objects;
public abstract class Offer implements Comparable<Offer> {
private final static Logger LOG = LoggerFactory.getLogger(Offer.class);
public interface Offer extends Comparable<Offer> {
public abstract Item getItem();
Item getItem();
OFFER_TYPE getType();
Vendor getVendor();
public abstract OFFER_TYPE getType();
double getPrice();
void setPrice(double price);
public abstract double getPrice();
protected abstract void setPrice(double price);
long getCount();
void setCount(long count);
public abstract Vendor getVendor();
protected abstract void setVendor(Vendor vendor);
public boolean hasType(OFFER_TYPE offerType) {
default boolean hasType(OFFER_TYPE offerType) {
return getType().equals(offerType);
}
public boolean hasItem(Item item) {
default boolean hasItem(Item item) {
return getItem().equals(item);
}
public boolean equalsPrice(Offer offer){
return equalsType(offer) && getPrice() == offer.getPrice();
}
public boolean equalsType(Offer offer){
return offer != null &&
getType().equals(offer.getType()) &&
getItem().equals(offer.getItem());
}
@Override
public int compareTo(@NotNull Offer other) {
default int compareTo(@NotNull Offer other) {
Objects.requireNonNull(other, "Not compare with null");
if (this == other) return 0;
int cmp = getType().compareTo(other.getType());
@@ -50,26 +37,12 @@ public abstract class Offer implements Comparable<Offer> {
return getItem().compareTo(other.getItem());
}
public String toVString(){
return String.format("%s (%.0f)", getVendor().getName(), getPrice());
default String toPString(){
return String.format("%s (%.0f)", getVendor().getPlace().getName(), getPrice());
}
public String toIString(){
default String toIString(){
return String.format("%s (%.0f)", getItem().getName(), getPrice());
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("{");
sb.append("").append(getVendor());
sb.append(", ").append(getItem());
sb.append(", ").append(getType());
if (LOG.isTraceEnabled()){
sb.append(", ").append(getPrice());
} else {
sb.append(", ").append(getPrice());
}
sb.append('}');
return sb.toString();
}
}

10
core/src/main/java/ru/trader/core/Order.java
View File

@@ -19,7 +19,7 @@ public class Order implements Comparable<Order> {
public Order(Offer sell, Offer buy, long count) {
this.sell = sell;
this.buy = buy;
this.count = count;
this.count = Math.min(Math.min(buy.getCount(), sell.getCount()), count);
this.profit = (buy.getPrice() - sell.getPrice()) * count;
}
@@ -32,7 +32,7 @@ public class Order implements Comparable<Order> {
}
public void setCount(long count){
this.count = count;
this.count = Math.min(Math.min(buy.getCount(), sell.getCount()), count);
this.profit = (buy.getPrice() - sell.getPrice()) * count;
}
@@ -45,7 +45,11 @@ public class Order implements Comparable<Order> {
}
public double getDistance() {
return sell.getVendor().getDistance(buy.getVendor());
return sell.getVendor().getPlace().getDistance(buy.getVendor().getPlace()) + buy.getVendor().getDistance() * 3.17e-8;
}
public boolean isBuyer(Place buyer) {
return buy.getVendor().getPlace().equals(buyer);
}
public boolean isBuyer(Vendor buyer) {

40
core/src/main/java/ru/trader/core/Place.java Normal file
View File

@@ -0,0 +1,40 @@
package ru.trader.core;
import ru.trader.graph.Connectable;
import java.util.Collection;
public interface Place extends Connectable<Place> {
String getName();
void setName(String name);
double getX();
double getY();
double getZ();
void setPosition(double x, double y, double z);
Collection<Vendor> get();
void add(Vendor vendor);
Vendor addVendor(String name);
void remove(Vendor vendor);
default boolean isEmpty(){
return get().isEmpty();
}
@Override
default boolean canRefill() {
return !isEmpty();
}
@Override
default double getDistance(Place other){
return getDistance(other.getX(), other.getY(), other.getZ());
}
default double getDistance(double x, double y, double z){
return Math.sqrt(Math.pow(x - getX(), 2) + Math.pow(y - getY(), 2) + Math.pow(z - getZ(), 2));
}
}

25
core/src/main/java/ru/trader/core/Route.java
View File

@@ -1,25 +0,0 @@
package ru.trader.core;
import ru.trader.graph.Path;
import java.util.LinkedList;
public class Route {
private double profit;
private double distance;
private final LinkedList<Order> orders = new LinkedList<>();
public Route() {
profit = 0;
distance = 0;
}
public void add(Order order){
orders.add(order);
profit += order.getProfit();
distance += order.getDistance();
}
}

5
core/src/main/java/ru/trader/core/SERVICE_TYPE.java Normal file
View File

@@ -0,0 +1,5 @@
package ru.trader.core;
public enum SERVICE_TYPE {
MARKET, BLACK_MARKET, REPAIR, MUNITION, OUTFIT, SHIPYARD
}

118
core/src/main/java/ru/trader/core/Vendor.java
View File

@@ -1,123 +1,65 @@
package ru.trader.core;
import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.trader.graph.Connectable;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
public abstract class Vendor implements Comparable<Vendor>, Connectable<Vendor> {
private final static Logger LOG = LoggerFactory.getLogger(Vendor.class);
public interface Vendor extends Comparable<Vendor> {
public abstract String getName();
public abstract void setName(String name);
String getName();
void setName(String name);
public abstract double getX();
public abstract void setX(double x);
Place getPlace();
public abstract double getY();
public abstract void setY(double y);
double getDistance();
void setDistance(double distance);
public abstract double getZ();
public abstract void setZ(double z);
void add(SERVICE_TYPE service);
void remove(SERVICE_TYPE service);
boolean has(SERVICE_TYPE service);
void add(Offer offer);
Offer addOffer(OFFER_TYPE type, Item item, double price, long count);
void remove(Offer offer);
protected abstract Collection<Offer> getOffers();
protected abstract Collection<Item> getItems(OFFER_TYPE offerType);
protected abstract Offer getOffer(OFFER_TYPE offerType, Item item);
protected abstract boolean hasOffer(OFFER_TYPE offerType, Item item);
protected abstract void addOffer(Offer offer);
protected abstract void removeOffer(Offer offer);
Collection<Offer> get(OFFER_TYPE type);
Offer get(OFFER_TYPE type, Item item);
boolean has(OFFER_TYPE type, Item item);
protected Collection<Offer> getOffers(OFFER_TYPE offerType){
List<Offer> offers = getOffers()
.stream()
.filter(offer -> offer.hasType(offerType))
.sorted()
.collect(Collectors.toList());
return Collections.unmodifiableCollection(offers);
default Collection<Offer> getAllSellOffers(){
return get(OFFER_TYPE.SELL);
}
public final Collection<Offer> getAllOffers(){
return Collections.unmodifiableCollection(getOffers());
default Collection<Offer> getAllBuyOffers(){
return get(OFFER_TYPE.BUY);
}
public final Collection<Offer> getAllSellOffers(){
return Collections.unmodifiableCollection(getOffers(OFFER_TYPE.SELL));
default Offer getSell(Item item){
return get(OFFER_TYPE.SELL, item);
}
public final Collection<Offer> getAllBuyOffers(){
return Collections.unmodifiableCollection(getOffers(OFFER_TYPE.BUY));
default Offer getBuy(Item item){
return get(OFFER_TYPE.BUY, item);
}
public final Offer getSell(Item item){
return getOffer(OFFER_TYPE.SELL, item);
default boolean hasSell(Item item){
return has(OFFER_TYPE.SELL, item);
}
public final Offer getBuy(Item item){
return getOffer(OFFER_TYPE.BUY, item);
default boolean hasBuy(Item item){
return has(OFFER_TYPE.BUY, item);
}
public final boolean hasSell(Item item){
return hasOffer(OFFER_TYPE.SELL, item);
}
public final boolean hasBuy(Item item){
return hasOffer(OFFER_TYPE.BUY, item);
}
public final void add(Offer offer){
LOG.trace("Add offer {} to vendor {}", offer, this);
offer.setVendor(this);
addOffer(offer);
}
public final void remove(Offer offer){
LOG.trace("Remove offer {} from vendor {}", offer, this);
assert this.equals(offer.getVendor());
removeOffer(offer);
}
public final Collection<Item> getSellItems() {
return getItems(OFFER_TYPE.SELL);
}
public final Collection<Item> getBuyItems() {
return getItems(OFFER_TYPE.BUY);
}
@Override
public String toString() {
return getName();
}
@Override
public int compareTo(@NotNull Vendor other) {
default int compareTo(@NotNull Vendor other) {
Objects.requireNonNull(other, "Not compare with null");
if (this == other) return 0;
int cmp = Double.compare(getDistance(), other.getDistance());
if (cmp!=0) return cmp;
String name = getName();
String otherName = other.getName();
return name != null ? otherName != null ? name.compareTo(otherName) : -1 : 0;
}
@Override
public double getDistance(Vendor other){
return getDistance(other.getX(), other.getY(), other.getZ());
}
@Override
public boolean canRefill() {
return !getAllSellOffers().isEmpty() || !getAllBuyOffers().isEmpty();
}
public double getDistance(double x, double y, double z){
return Math.sqrt(Math.pow(x - getX(), 2) + Math.pow(y - getY(), 2) + Math.pow(z - getZ(), 2));
}
}

53
core/src/main/java/ru/trader/graph/PathRoute.java
View File

@@ -4,11 +4,12 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.trader.core.Offer;
import ru.trader.core.Order;
import ru.trader.core.Place;
import ru.trader.core.Vendor;
import java.util.*;
public class PathRoute extends Path<Vendor> {
public class PathRoute extends Path<Place> {
private final static Logger LOG = LoggerFactory.getLogger(PathRoute.class);
private final ArrayList<Order> orders = new ArrayList<>();
@@ -20,21 +21,21 @@ public class PathRoute extends Path<Vendor> {
private PathRoute tail;
public final static Order TRANSIT = null;
public PathRoute(Vertex<Vendor> source) {
public PathRoute(Vertex<Place> source) {
this(source, false);
}
public static PathRoute buildAvg(Vertex<Vendor> source){
public static PathRoute buildAvg(Vertex<Place> source){
return new PathRoute(source, true);
}
private PathRoute(Vertex<Vendor> source, boolean byAvg) {
private PathRoute(Vertex<Place> source, boolean byAvg) {
super(source);
this.byAvg = byAvg;
}
private PathRoute(PathRoute head, Vertex<Vendor> vertex, boolean refill) {
private PathRoute(PathRoute head, Vertex<Place> vertex, boolean refill) {
super(head, vertex, refill);
assert head.tail == null;
head.tail = this;
@@ -44,7 +45,7 @@ public class PathRoute extends Path<Vendor> {
}
@Override
public Path<Vendor> connectTo(Vertex<Vendor> vertex, boolean refill) {
public Path<Place> connectTo(Vertex<Place> vertex, boolean refill) {
LOG.trace("Connect path {} to {}", this, vertex);
return new PathRoute(this.getCopy(), vertex, refill);
}
@@ -126,13 +127,27 @@ public class PathRoute extends Path<Vendor> {
orders.clear();
orders.add(TRANSIT);
LOG.trace("Fill orders of path {}", this);
Vendor seller = getPrevious().get();
for (Offer sell : seller.getAllSellOffers()) {
PathRoute p = this;
while (p != null) {
Offer buy = p.get().getBuy(sell.getItem());
if (buy != null) addOrder(new Order(sell, buy));
p = p.getNext();
Place placeSeller = getPrevious().get();
for (Vendor seller : placeSeller.get()) {
for (Offer sell : seller.getAllSellOffers()) {
PathRoute p = this;
while (p != null) {
Place placeBuyer = p.get();
Order best = null;
for (Vendor buyer : placeBuyer.get()) {
Offer buy = buyer.getBuy(sell.getItem());
if (buy != null){
Order order = new Order(sell, buy);
if (best == null || best.compareTo(order) < 0){
best = order;
}
}
}
if (best != null){
addOrder(best);
}
p = p.getNext();
}
}
}
}
@@ -210,7 +225,7 @@ public class PathRoute extends Path<Vendor> {
PathRoute p = getPrevious();
balance = p.balance;
if (!p.isRoot()) {
Vendor buyer = p.get();
Place buyer = p.get();
while (!p.isRoot()){
for (Order order : p.orders) {
if (order == TRANSIT) continue;
@@ -252,7 +267,7 @@ public class PathRoute extends Path<Vendor> {
public double getProfit(Order order){
if (order == TRANSIT) return getTransitProfit();
if (isPathFrom(order.getBuyer())) return order.getProfit() + profit;
if (isPathFrom(order.getBuyer().getPlace())) return order.getProfit() + profit;
return hasNext() ? getNext().getProfit(order) : order.getProfit();
}
@@ -325,7 +340,7 @@ public class PathRoute extends Path<Vendor> {
while (p.hasNext()){
p = p.getNext();
// lands for sell
if (order != null && p.isPathFrom(order.getBuyer())){
if (order != null && p.isPathFrom(order.getBuyer().getPlace())){
LOG.trace("{} is lands for sell by order {}", p, order);
return res + p.getLandsCount() + 1;
} else {
@@ -388,15 +403,15 @@ public class PathRoute extends Path<Vendor> {
public PathRoute dropTo(Vendor vendor){
PathRoute p = getCopy(true).getEnd();
while (!p.isRoot() && !p.get().equals(vendor)){
while (!p.isRoot() && !p.get().equals(vendor.getPlace())){
p = p.getPrevious();
}
p.tail = null;
return p;
}
public static PathRoute toPathRoute(Vendor... items){
Vendor t = items[0];
public static PathRoute toPathRoute(Place... items){
Place t = items[0];
PathRoute path = new PathRoute(new Vertex<>(t));
for (int i = 1; i < items.length; i++) {
t = items[i];

14
core/src/main/java/ru/trader/graph/RouteGraph.java
View File

@@ -1,10 +1,10 @@
package ru.trader.graph;
import ru.trader.core.Vendor;
import ru.trader.core.Place;
import java.util.*;
public class RouteGraph extends Graph<Vendor> {
public class RouteGraph extends Graph<Place> {
private double balance;
private int cargo;
@@ -28,11 +28,11 @@ public class RouteGraph extends Graph<Vendor> {
return byProfitComparator.compare(p1, p2);
};
public RouteGraph(Vendor start, Collection<Vendor> set, double stock, double maxDistance, boolean withRefill, int maxDeep) {
public RouteGraph(Place start, Collection<Place> set, double stock, double maxDistance, boolean withRefill, int maxDeep) {
this(start, set, stock, maxDistance, withRefill, maxDeep, false);
}
public RouteGraph(Vendor start, Collection<Vendor> set, double stock, double maxDistance, boolean withRefill, int maxDeep, boolean groupRes) {
public RouteGraph(Place start, Collection<Place> set, double stock, double maxDistance, boolean withRefill, int maxDeep, boolean groupRes) {
super(start, set, stock, maxDistance, withRefill, maxDeep, groupRes ? PathRoute::buildAvg : PathRoute::new);
if (groupRes){
this.groupRes = maxDeep > minJumps;
@@ -48,7 +48,7 @@ public class RouteGraph extends Graph<Vendor> {
}
@Override
protected TopList<Path<Vendor>> newTopList(int count) {
protected TopList<Path<Place>> newTopList(int count) {
int groupSize = 0;
if (groupRes && getMinJumps() > 1){
groupSize = Math.floorDiv(count, root.getLevel());
@@ -56,7 +56,7 @@ public class RouteGraph extends Graph<Vendor> {
return new TopRoutes(count, groupSize);
}
private class TopRoutes extends TopList<Path<Vendor>> {
private class TopRoutes extends TopList<Path<Place>> {
private final int groupSize;
public TopRoutes(int limit, int groupSize) {
@@ -65,7 +65,7 @@ public class RouteGraph extends Graph<Vendor> {
}
@Override
public boolean add(Path<Vendor> entry) {
public boolean add(Path<Place> entry) {
if (comparator != null){
((PathRoute)entry).sort(balance, cargo);
}

30
core/src/main/java/ru/trader/graph/RouteSearcher.java
View File

@@ -3,7 +3,7 @@ package ru.trader.graph;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.trader.core.Vendor;
import ru.trader.core.Place;
import java.util.ArrayList;
import java.util.Collection;
@@ -29,27 +29,27 @@ public class RouteSearcher {
this.segmentSize = segmentSize;
}
public List<PathRoute> getPaths(Vendor from, Vendor to, Collection<Vendor> vendors, int jumps, double balance, int cargo, int limit){
return POOL.invoke(new SegmentSearcher(from, to, vendors, jumps, balance, cargo, limit));
public List<PathRoute> getPaths(Place from, Place to, Collection<Place> places, int jumps, double balance, int cargo, int limit){
return POOL.invoke(new SegmentSearcher(from, to, places, jumps, balance, cargo, limit));
}
public List<PathRoute> getPaths(Vendor from, Collection<Vendor> vendors, int jumps, double balance, int cargo, int limit){
return POOL.invoke(new SegmentSearcher(from, null, vendors, jumps, balance, cargo, limit));
public List<PathRoute> getPaths(Place from, Collection<Place> places, int jumps, double balance, int cargo, int limit){
return POOL.invoke(new SegmentSearcher(from, null, places, jumps, balance, cargo, limit));
}
public class SegmentSearcher extends RecursiveTask<List<PathRoute>> {
protected final Vendor source;
protected final Vendor target;
protected final Collection<Vendor> vendors;
protected final Place source;
protected final Place target;
protected final Collection<Place> places;
protected final int jumps;
protected final double balance;
protected final int cargo;
protected int limit;
public SegmentSearcher(Vendor source, Vendor target, Collection<Vendor> vendors, int jumps, double balance, int cargo, int limit) {
public SegmentSearcher(Place source, Place target, Collection<Place> places, int jumps, double balance, int cargo, int limit) {
this.source = source;
this.target = target;
this.vendors = vendors;
this.places = places;
this.jumps = jumps;
this.balance = balance;
this.cargo = cargo;
@@ -59,7 +59,7 @@ public class RouteSearcher {
@Override
protected List<PathRoute> compute() {
LOG.trace("Start search route to {} from {}, jumps {}", source, target, jumps);
RouteGraph sGraph = new RouteGraph(source, vendors, stock, maxDistance, true, jumps, true);
RouteGraph sGraph = new RouteGraph(source, places, stock, maxDistance, true, jumps, true);
int jumpsToAll = sGraph.getMinJumps();
LOG.trace("Segment jumps {}", jumpsToAll);
sGraph.setCargo(cargo);
@@ -67,18 +67,18 @@ public class RouteSearcher {
List<PathRoute> res = new ArrayList<>(limit);
if (jumps <= jumpsToAll){
LOG.trace("Is last segment");
List<Path<Vendor>> paths;
List<Path<Place>> paths;
if (target == null){
paths = sGraph.getPaths(limit);
} else {
paths = sGraph.getPathsTo(target, limit);
}
for (Path<Vendor> path : paths) {
for (Path<Place> path : paths) {
res.add((PathRoute) path);
}
} else {
LOG.trace("Split to segments");
List<Path<Vendor>> paths = sGraph.getPaths(getPathsOnSegmentCount(sGraph), jumpsToAll-1).getList();
List<Path<Place>> paths = sGraph.getPaths(getPathsOnSegmentCount(sGraph), jumpsToAll-1).getList();
int i = 0;
ArrayList<SegmentSearcher> subTasks = new ArrayList<>(THRESHOLD);
while (i < paths.size()) {
@@ -86,7 +86,7 @@ public class RouteSearcher {
for (int taskIndex = 0; taskIndex < THRESHOLD && i+taskIndex < paths.size(); taskIndex++) {
PathRoute path = (PathRoute) paths.get(i+taskIndex);
double newBalance = balance + path.getRoot().getProfit();
SegmentSearcher task = new SegmentSearcher(path.get(), target, vendors, jumps - path.getLength(), newBalance, cargo, 1);
SegmentSearcher task = new SegmentSearcher(path.get(), target, places, jumps - path.getLength(), newBalance, cargo, 1);
task.fork();
subTasks.add(task);
}

27
core/src/main/java/ru/trader/store/simple/MarketDocHandler.java
View File

@@ -16,7 +16,7 @@ public class MarketDocHandler extends DefaultHandler {
protected final static String MARKET = "market";
protected final static String ITEM_LIST = "items";
protected final static String ITEM = "item";
protected final static String VENDOR_LIST = "vendors";
protected final static String VENDOR_LIST = "places";
protected final static String VENDOR = "vendor";
protected final static String OFFER = "offer";
protected final static String GROUP = "group";
@@ -30,8 +30,9 @@ public class MarketDocHandler extends DefaultHandler {
protected final static String Y_ATTR = "y";
protected final static String Z_ATTR = "z";
protected Market world;
protected SimpleMarket world;
protected Vendor curVendor;
protected Place curSystem;
protected Group curGroup;
protected final HashMap<String,Item> items = new HashMap<>();
@@ -57,7 +58,7 @@ public class MarketDocHandler extends DefaultHandler {
@Override
public void endElement(String uri, String localName, String qName) throws SAXException {
switch (qName){
case VENDOR: world.add(curVendor);
case VENDOR: curVendor = null; curSystem = null;
break;
case GROUP: curGroup = null;
break;
@@ -66,7 +67,7 @@ public class MarketDocHandler extends DefaultHandler {
@Override
public void endDocument() throws SAXException {
world.setChange(false);
world.commit();
}
protected void parseVendor(Attributes attributes) throws SAXException {
@@ -103,26 +104,24 @@ public class MarketDocHandler extends DefaultHandler {
}
protected void onOffer(OFFER_TYPE offerType, Item item, double price){
Offer offer = new SimpleOffer(offerType, item, price);
curVendor.add(offer);
if (curVendor == null){
curVendor = curSystem.addVendor("STATION OF "+curSystem.getName());
curVendor.add(SERVICE_TYPE.MARKET);
}
curVendor.addOffer(offerType, item, price, 1000);
}
protected void onVendor(String name, double x, double y, double z){
curVendor = new SimpleVendor(name);
curVendor.setX(x);
curVendor.setY(y);
curVendor.setZ(z);
curSystem = world.addPlace(name, x, y, z);
}
protected void onItem(String name, String id) {
Item item = new SimpleItem(name);
item.setGroup(curGroup);
world.add(item);
Item item = world.addItem(name, curGroup);
items.put(id, item);
}
protected void onGroup(String name, GROUP_TYPE type) {
curGroup = new SimpleGroup(name, type);
curGroup = world.addGroup(name, type);
}
public Market getWorld(){

23
core/src/main/java/ru/trader/store/simple/MarketStreamWriter.java
View File

@@ -42,7 +42,7 @@ public class MarketStreamWriter {
protected void writeMarket() throws XMLStreamException {
out.writeStartElement(MarketDocHandler.MARKET);
writeItems();
writeVendors(market.get());
writeVendors();
out.writeEndElement();
}
@@ -68,10 +68,12 @@ public class MarketStreamWriter {
out.writeAttribute(MarketDocHandler.ID_ATTR, id);
}
protected void writeVendors(Collection<Vendor> vendors) throws XMLStreamException {
protected void writeVendors() throws XMLStreamException {
out.writeStartElement(MarketDocHandler.VENDOR_LIST);
for (Vendor vendor : vendors) {
writeVendor(vendor);
for (Place place : market.get()) {
for (Vendor vendor : place.get()) {
writeVendor(vendor);
}
}
out.writeEndElement();
}
@@ -79,11 +81,14 @@ public class MarketStreamWriter {
protected void writeVendor(Vendor vendor) throws XMLStreamException {
out.writeStartElement(MarketDocHandler.VENDOR);
out.writeAttribute(MarketDocHandler.NAME_ATTR, vendor.getName());
out.writeAttribute(MarketDocHandler.X_ATTR, String.valueOf(vendor.getX()));
out.writeAttribute(MarketDocHandler.Y_ATTR, String.valueOf(vendor.getY()));
out.writeAttribute(MarketDocHandler.Z_ATTR, String.valueOf(vendor.getZ()));
for (Offer offer : vendor.getAllOffers()) {
Place place = vendor.getPlace();
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()));
for (Offer offer : vendor.getAllSellOffers()) {
writeOffer(offer);
}
for (Offer offer : vendor.getAllBuyOffers()) {
writeOffer(offer);
}
out.writeEndElement();

2
core/src/main/java/ru/trader/store/simple/SimpleGroup.java
View File

@@ -3,7 +3,7 @@ package ru.trader.store.simple;
import ru.trader.core.GROUP_TYPE;
import ru.trader.core.Group;
public class SimpleGroup extends Group {
public class SimpleGroup implements Group {
private final String name;
private final GROUP_TYPE type;

14
core/src/main/java/ru/trader/store/simple/SimpleItem.java
View File

@@ -1,9 +1,9 @@
package ru.trader.store.simple;
import ru.trader.core.AbstractItem;
import ru.trader.core.Group;
import ru.trader.core.Item;
public class SimpleItem extends Item {
public class SimpleItem extends AbstractItem {
private String name;
private Group group;
@@ -11,13 +11,18 @@ public class SimpleItem extends Item {
this.name = name;
}
public SimpleItem(String name, Group group) {
this.name = name;
setGroup(group);
}
@Override
public String getName() {
return name;
}
@Override
protected void setName(String name) {
public void updateName(String name) {
this.name = name;
}
@@ -26,8 +31,7 @@ public class SimpleItem extends Item {
return group;
}
@Override
public void setGroup(Group group) {
protected void setGroup(Group group) {
this.group = group;
}
}

69
core/src/main/java/ru/trader/store/simple/SimpleItemStat.java
View File

@@ -2,15 +2,12 @@ package ru.trader.store.simple;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.trader.core.Item;
import ru.trader.core.ItemStat;
import ru.trader.core.OFFER_TYPE;
import ru.trader.core.Offer;
import ru.trader.core.*;
import java.util.*;
import java.util.concurrent.ConcurrentSkipListSet;
public class SimpleItemStat extends ItemStat {
public class SimpleItemStat extends AbstractItemStat {
private final static Logger LOG = LoggerFactory.getLogger(SimpleItemStat.class);
private final Item item;
@@ -55,12 +52,14 @@ public class SimpleItemStat extends ItemStat {
}
@Override
protected synchronized void update(Offer offer, double price){
protected synchronized void updatePrice(AbstractOffer offer, double price) {
LOG.trace("Update offer {} from item stat {}", offer, this);
assert offer.hasType(type) && offer.hasItem(item) && offers.contains(offer);
double oldPrice = offer.getPrice();
offers.remove(offer);
((SimpleOffer)offer).setPrice(price);
super.updatePrice(offer, price);
offers.add(offer);
sum += price - oldPrice;
avg = sum / offers.size();
@@ -77,33 +76,17 @@ public class SimpleItemStat extends ItemStat {
return item;
}
@Override
public synchronized double getAvg(){
return avg;
}
@Override
public synchronized Offer getBest() {
if (offers.isEmpty()) return getFake();
return type.getOrder() > 0 ? offers.first() : offers.last();
}
@Override
public synchronized int getOffersCount(){
return offers.size();
}
@Override
public synchronized NavigableSet<Offer> getOffers() {
return Collections.unmodifiableNavigableSet(offers);
}
@Override
public synchronized Offer getMin() {
if (offers.isEmpty()) return getFake();
return offers.first();
}
@Override
public synchronized double getAvg(){
return avg;
}
@Override
public synchronized Offer getMax() {
if (offers.isEmpty()) return getFake();
@@ -111,10 +94,38 @@ public class SimpleItemStat extends ItemStat {
}
@Override
public synchronized boolean isEmpty(){
public synchronized Offer getBest() {
if (offers.isEmpty()) return getFake();
return type.getOrder() > 0 ? offers.first() : offers.last();
}
@Override
public synchronized NavigableSet<Offer> getOffers() {
return Collections.unmodifiableNavigableSet(offers);
}
@Override
public synchronized boolean isEmpty() {
return offers.isEmpty();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof SimpleItemStat)) return false;
SimpleItemStat itemStat = (SimpleItemStat) o;
return type == itemStat.type && item.equals(itemStat.item);
}
@Override
public int hashCode() {
int result = item.hashCode();
result = 31 * result + type.hashCode();
return result;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("{");

151
core/src/main/java/ru/trader/store/simple/SimpleMarket.java
View File

@@ -1,13 +1,17 @@
package ru.trader.store.simple;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.trader.core.*;
import java.util.*;
import java.util.stream.Collectors;
public class SimpleMarket extends MarketSupport {
protected Set<Vendor> vendors;
public class SimpleMarket extends AbstractMarket {
private final static Logger LOG = LoggerFactory.getLogger(SimpleMarket.class);
protected Set<Place> systems;
protected List<Item> items;
protected List<Group> groups;
//caching
private final Map<Item,SimpleItemStat> sellItems = new HashMap<>();
@@ -18,8 +22,9 @@ public class SimpleMarket extends MarketSupport {
}
protected void init() {
vendors = new TreeSet<>();
systems = new TreeSet<>();
items = new ArrayList<>();
groups = new ArrayList<>();
}
private Map<Item,SimpleItemStat> getItemCache(OFFER_TYPE offerType){
@@ -46,14 +51,89 @@ public class SimpleMarket extends MarketSupport {
SimpleItemStat entry = cache.get(item);
if (entry!=null){
entry.remove(offer);
if (entry.getOffersCount()==0)
if (entry.isEmpty())
cache.remove(item);
}
}
@Override
public void addVendor(Vendor vendor) {
vendors.add(vendor);
protected Place createPlace(String name, double x, double y, double z) {
return new SimplePlace(name, x, y, z);
}
@Override
protected Group createGroup(String name, GROUP_TYPE type) {
return new SimpleGroup(name, type);
}
@Override
protected Item createItem(String name, Group group) {
return new SimpleItem(name, group);
}
@Override
protected void addPlace(Place place) {
systems.add(place);
for (Vendor vendor : place.get()) {
onAdd(vendor);
}
}
@Override
protected void removePlace(Place place) {
systems.remove(place);
for (Vendor vendor : place.get()) {
onRemove(vendor);
}
}
@Override
protected void addGroup(Group group) {
groups.add(group);
}
@Override
protected void removeGroup(Group group) {
groups.remove(group);
}
@Override
protected void addItem(Item item) {
items.add(item);
}
@Override
protected void removeItem(Item item) {
items.remove(item);
sellItems.remove(item);
buyItems.remove(item);
}
@Override
public Collection<Place> get() {
return systems;
}
@Override
public Collection<Group> getGroups() {
return groups;
}
@Override
public Collection<Item> getItems() {
return items;
}
@Override
public ItemStat getStat(OFFER_TYPE offerType, Item item) {
ItemStat entry = getItemCache(offerType).get(item);
return entry != null ? entry : new SimpleItemStat(item, offerType);
}
@Override
protected void onAdd(Vendor vendor) {
LOG.trace("Cached on add vendor {}", vendor);
Collection<Offer> offers = vendor.getAllSellOffers();
for (Offer offer : offers) {
put(sellItems, offer);
@@ -65,8 +145,8 @@ public class SimpleMarket extends MarketSupport {
}
@Override
public void removeVendor(Vendor vendor) {
vendors.remove(vendor);
protected void onRemove(Vendor vendor) {
LOG.trace("Remove cache of vendor {}", vendor);
Collection<Offer> offers = vendor.getAllSellOffers();
for (Offer offer : offers) {
remove(sellItems, offer);
@@ -77,63 +157,24 @@ public class SimpleMarket extends MarketSupport {
}
}
@Override
protected void addItem(Item item) {
if (!items.contains(item))
items.add(item);
}
@Override
protected void removeItem(Item item) {
items.remove(item);
sellItems.remove(item);
buyItems.remove(item);
}
@Override
protected Collection<Vendor> getVendors() {
return vendors;
}
@Override
protected Collection<Vendor> getVendors(OFFER_TYPE offerType, Item item) {
List<Vendor> result = null;
ItemStat entry = getItemCache(offerType).get(item);
if (entry!=null){
result = entry.getOffers()
.stream()
.map(Offer::getVendor)
.collect(Collectors.toList());
}
return result!=null ? Collections.unmodifiableCollection(result) : null;
}
@Override
public ItemStat getStat(OFFER_TYPE offerType, Item item) {
ItemStat entry = getItemCache(offerType).get(item);
return entry != null ? entry : new SimpleItemStat(item, offerType);
}
@Override
protected Collection<Item> getItemList() {
return items;
}
@Override
protected void onAdd(Offer offer) {
LOG.trace("Cached on add offer {}", offer);
put(getItemCache(offer.getType()), offer);
}
@Override
protected void onRemove(Offer offer) {
LOG.trace("Remove cache of offer {}", offer);
remove(getItemCache(offer.getType()), offer);
}
@Override
public void addItems(Collection<? extends Item> items) {
this.items.addAll(items);
protected void updateName(AbstractPlace place, String name) {
LOG.trace("Replace system {} on change name", place);
systems.remove(place);
super.updateName(place, name);
systems.add(place);
}
}

35
core/src/main/java/ru/trader/store/simple/SimpleOffer.java
View File

@@ -2,23 +2,22 @@ package ru.trader.store.simple;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.trader.core.Item;
import ru.trader.core.OFFER_TYPE;
import ru.trader.core.Offer;
import ru.trader.core.Vendor;
import ru.trader.core.*;
public class SimpleOffer extends Offer {
public class SimpleOffer extends AbstractOffer {
private final static Logger LOG = LoggerFactory.getLogger(SimpleOffer.class);
private Vendor vendor;
private final Item item;
private final OFFER_TYPE type;
private volatile double price;
private volatile long count;
public SimpleOffer(OFFER_TYPE type, Item item, double price) {
public SimpleOffer(OFFER_TYPE type, Item item, double price, long count) {
this.item = item;
this.type = type;
setPrice(price);
this.price = price;
this.count = count;
}
@Override
@@ -31,25 +30,35 @@ public class SimpleOffer extends Offer {
return type;
}
@Override
public Vendor getVendor() {
return vendor;
}
protected void setVendor(Vendor vendor) {
assert this.vendor == null;
LOG.trace("Set vendor {} to offer {}", vendor, this);
this.vendor = vendor;
}
@Override
public double getPrice() {
return price;
}
@Override
protected void setPrice(double price) {
protected void updatePrice(double price) {
this.price = price;
}
@Override
public Vendor getVendor() {
return vendor;
public long getCount() {
return count;
}
@Override
protected void setVendor(Vendor vendor) {
LOG.trace("Set vendor {} to item {}", vendor, this);
this.vendor = vendor;
public void updateCount(long count) {
this.count = count;
}
}

88
core/src/main/java/ru/trader/store/simple/SimplePlace.java Normal file
View File

@@ -0,0 +1,88 @@
package ru.trader.store.simple;
import ru.trader.core.AbstractPlace;
import ru.trader.core.Vendor;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
public class SimplePlace extends AbstractPlace {
private String name;
private final List<Vendor> vendors;
private double x;
private double y;
private double z;
public SimplePlace(String name) {
this.name = name;
this.vendors = new CopyOnWriteArrayList<>();
}
public SimplePlace(String name, double x, double y, double z) {
this(name);
setPosition(x, y, z);
}
public SimplePlace(String name, double x, double y, double z, Vendor vendor) {
this(name,x,y,z);
vendors.add(vendor);
}
@Override
protected Vendor createVendor(String name) {
return new SimpleVendor(name);
}
@Override
public String getName() {
return name;
}
@Override
public double getX() {
return x;
}
@Override
public double getY() {
return y;
}
@Override
public double getZ() {
return z;
}
@Override
public Collection<Vendor> get() {
return vendors;
}
@Override
protected void updateName(String name) {
this.name = name;
}
@Override
protected void updatePosition(double x, double y, double z) {
this.x = x;
this.y = y;
this.z = z;
}
@Override
protected void addVendor(Vendor vendor) {
if (vendor instanceof SimpleVendor){
((SimpleVendor) vendor).setPlace(this);
}
vendors.add(vendor);
}
@Override
protected void removeVendor(Vendor vendor) {
vendors.remove(vendor);
}
}

79
core/src/main/java/ru/trader/store/simple/SimpleVendor.java
View File

@@ -1,18 +1,15 @@
package ru.trader.store.simple;
import ru.trader.core.Item;
import ru.trader.core.OFFER_TYPE;
import ru.trader.core.Offer;
import ru.trader.core.Vendor;
import ru.trader.core.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
public class SimpleVendor extends Vendor {
public class SimpleVendor extends AbstractVendor {
private String name;
private double x;
private double y;
private double z;
private Place place;
private double distance;
private EnumSet<SERVICE_TYPE> services = EnumSet.noneOf(SERVICE_TYPE.class);
protected Map<Item, Offer> sell;
protected Map<Item, Offer> buy;
@@ -26,53 +23,68 @@ public class SimpleVendor extends Vendor {
initOffers();
}
public SimpleVendor(String name, double x, double y, double z) {
this(name);
place = new SimplePlace(name, x, y, z, this);
}
protected void initOffers(){
sell = new ConcurrentHashMap<>(20, 0.9f, 2);
buy = new ConcurrentHashMap<>(20, 0.9f, 2);
}
@Override
protected Offer createOffer(OFFER_TYPE type, Item item, double price, long count) {
return new SimpleOffer(type, item, price, count);
}
@Override
public String getName() {
return name;
}
@Override
public void setName(String name) {
protected void updateName(String name) {
this.name = name;
}
@Override
public double getX() {
return x;
public Place getPlace() {
return place;
}
protected void setPlace(Place place){
assert this.place == null;
this.place = place;
}
@Override
public void setX(double x) {
this.x = x;
public double getDistance() {
return distance;
}
@Override
public double getY() {
return y;
public void updateDistance(double distance) {
this.distance = distance;
}
@Override
public void setY(double y) {
this.y = y;
public void addService(SERVICE_TYPE service) {
services.add(service);
}
@Override
public double getZ() {
return z;
public void removeService(SERVICE_TYPE service) {
services.remove(service);
}
@Override
public void setZ(double z) {
this.z = z;
public boolean has(SERVICE_TYPE service) {
return services.contains(service);
}
@Override
protected Collection<Offer> getOffers(OFFER_TYPE offerType) {
public Collection<Offer> get(OFFER_TYPE offerType) {
switch (offerType) {
case SELL: return sell.values();
case BUY: return buy.values();
@@ -81,23 +93,7 @@ public class SimpleVendor extends Vendor {
}
@Override
protected Collection<Offer> getOffers() {
ArrayList<Offer> offers = new ArrayList<>(sell.values());
offers.addAll(buy.values());
return offers;
}
@Override
protected Collection<Item> getItems(OFFER_TYPE offerType) {
switch (offerType) {
case SELL: return sell.keySet();
case BUY: return buy.keySet();
}
throw new IllegalArgumentException("Wrong offer type: "+offerType);
}
@Override
protected Offer getOffer(OFFER_TYPE offerType, Item item) {
public Offer get(OFFER_TYPE offerType, Item item) {
switch (offerType) {
case SELL: return sell.get(item);
case BUY: return buy.get(item);
@@ -106,7 +102,7 @@ public class SimpleVendor extends Vendor {
}
@Override
protected boolean hasOffer(OFFER_TYPE offerType, Item item) {
public boolean has(OFFER_TYPE offerType, Item item) {
switch (offerType) {
case SELL: return sell.containsKey(item);
case BUY: return buy.containsKey(item);
@@ -116,6 +112,9 @@ public class SimpleVendor extends Vendor {
@Override
protected void addOffer(Offer offer) {
if (offer instanceof SimpleOffer){
((SimpleOffer) offer).setVendor(this);
}
switch (offer.getType()) {
case SELL: sell.put(offer.getItem(), offer);
break;

2
core/src/main/resources/store/trader.xsd
View File

@@ -6,7 +6,7 @@
<xs:complexType name="marketType">
<xs:sequence>
<xs:element name="items" type="itemsType"/>
<xs:element name="vendors" type="vendorsType"/>
<xs:element name="places" type="vendorsType"/>
</xs:sequence>
</xs:complexType>

103
core/src/test/java/ru/trader/core/MarketAnalyzerTest.java
View File

@@ -8,10 +8,7 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.trader.TestUtil;
import ru.trader.graph.Path;
import ru.trader.store.simple.SimpleItem;
import ru.trader.store.simple.SimpleMarket;
import ru.trader.store.simple.SimpleOffer;
import ru.trader.store.simple.SimpleVendor;
import ru.trader.store.simple.*;
import java.util.Collection;
@@ -19,47 +16,43 @@ public class MarketAnalyzerTest extends Assert {
private final static Logger LOG = LoggerFactory.getLogger(MarketAnalyzerTest.class);
private static Market market = new SimpleMarket();
private static Vendor v1;
private static Vendor v2;
private static Vendor v3;
private static Vendor v4;
private static Vendor v5;
private static Vendor v6;
private static Vendor v7;
private static Vendor v8;
private static Vendor v9;
private static Vendor v10;
private static Vendor v11;
private static Place v1;
private static Place v2;
private static Place v3;
private static Place v4;
private static Place v5;
private static Place v6;
private static Place v7;
private static Place v8;
private static Place v9;
private static Place v10;
private static Place v11;
private static Item ITEM1 = new SimpleItem("ITEM1");
private static Item ITEM2 = new SimpleItem("ITEM2");
private static Item ITEM3 = new SimpleItem("ITEM3");
private void add(Place place, Offer offer){
if (place.isEmpty()){
place.add(new SimpleVendor());
}
Vendor vendor = place.get().iterator().next();
vendor.add(offer);
}
@Before
public void setUp() throws Exception {
v1 = new SimpleVendor("v1_x0y0z0");
v2 = new SimpleVendor("v2_x1y0z0");
v3 = new SimpleVendor("v3_x0y1z0");
v4 = new SimpleVendor("v4_x0y0z1");
v5 = new SimpleVendor("v5_x1y1z0");
v1 = new SimplePlace("v1_x0y0z0",0,0,0);
v2 = new SimplePlace("v2_x1y0z0",1,0,0);
v3 = new SimplePlace("v3_x0y1z0",0,1,0);
v4 = new SimplePlace("v4_x0y0z1",0,0,1);
v5 = new SimplePlace("v5_x1y1z0",1,1,0);
v6 = new SimpleVendor("v6_x110y100z100");
v7 = new SimpleVendor("v7_x115y100z100");
v8 = new SimpleVendor("v8_x105y105z100");
v9 = new SimpleVendor("v9_x100y115z100");
v10 = new SimpleVendor("v10_x100y100z100");
v11 = new SimpleVendor("v11_x105y105z105");
v1.setX(0); v1.setY(0); v1.setZ(0);
v2.setX(1); v2.setY(0); v2.setZ(0);
v3.setX(0); v3.setY(1); v3.setZ(0);
v4.setX(0); v4.setY(0); v4.setZ(1);
v5.setX(1); v5.setY(1); v5.setZ(0);
v6.setX(110); v6.setY(100); v6.setZ(100);
v7.setX(115); v7.setY(100); v7.setZ(100);
v8.setX(105); v8.setY(105); v8.setZ(100);
v9.setX(100); v9.setY(115); v9.setZ(100);
v10.setX(100); v10.setY(100); v10.setZ(100);
v11.setX(105); v11.setY(105); v11.setZ(105);
v6 = new SimplePlace("v6_x110y100z100",110,100,100);
v7 = new SimplePlace("v7_x115y100z100",115,100,100);
v8 = new SimplePlace("v8_x105y105z100",105,105,100);
v9 = new SimplePlace("v9_x100y115z100",100,115,100);
v10 = new SimplePlace("v10_x100y100z100",100,100,100);
v11 = new SimplePlace("v11_x105y105z105",105,105,105);
market.add(v1);
market.add(v2);
@@ -73,19 +66,19 @@ public class MarketAnalyzerTest extends Assert {
market.add(v10);
market.add(v11);
market.add(v6, new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100));
market.add(v7, new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100));
market.add(v9, new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100));
market.add(v10, new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100));
market.add(v6, new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 50));
market.add(v7, new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 120));
market.add(v9, new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200));
market.add(v10, new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 150));
market.add(v9, new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 100));
market.add(v6, new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 140));
market.add(v7, new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 154));
market.add(v10, new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 140));
market.add(v11, new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 500));
add(v6, new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1));
add(v7, new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1));
add(v9, new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1));
add(v10, new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1));
add(v6, new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 50, 1));
add(v7, new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 120, 1));
add(v9, new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200, 1));
add(v10, new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 150, 1));
add(v9, new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 100, 1));
add(v6, new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 140, 1));
add(v7, new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 154, 1));
add(v10, new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 140, 1));
add(v11, new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 500, 1));
}
@@ -96,7 +89,7 @@ public class MarketAnalyzerTest extends Assert {
MarketAnalyzer analyzer = new MarketAnalyzer(market);
analyzer.setJumps(5);analyzer.setMaxDistance(1);analyzer.setTank(1);
Collection<Path<Vendor>> paths = analyzer.getPaths(v1, v2);
Collection<Path<Place>> paths = analyzer.getPaths(v1, v2);
TestUtil.assertCollectionEquals(paths, Path.toPath(v1, v2));
paths = analyzer.getPaths(v1, v3);
@@ -121,7 +114,7 @@ public class MarketAnalyzerTest extends Assert {
MarketAnalyzer analyzer = new MarketAnalyzer(market);
analyzer.setJumps(5);analyzer.setMaxDistance(1);analyzer.setTank(2);
Collection<Path<Vendor>> paths = analyzer.getPaths(v1, v2);
Collection<Path<Place>> paths = analyzer.getPaths(v1, v2);
TestUtil.assertCollectionContainAll(paths, Path.toPath(v1, v2));
paths = analyzer.getPaths(v1, v3);
@@ -147,7 +140,7 @@ public class MarketAnalyzerTest extends Assert {
MarketAnalyzer analyzer = new MarketAnalyzer(market);
analyzer.setJumps(2);analyzer.setMaxDistance(10);analyzer.setTank(15);
Collection<Path<Vendor>> paths = analyzer.getPaths(v10, v6);
Collection<Path<Place>> paths = analyzer.getPaths(v10, v6);
TestUtil.assertCollectionContainAll(paths, Path.toPath(v10, v6), Path.toPath(v10, v11, v6),
Path.toPath(v10, v8, v6));
@@ -163,7 +156,7 @@ public class MarketAnalyzerTest extends Assert {
MarketAnalyzer analyzer = new MarketAnalyzer(market);
analyzer.setJumps(3);analyzer.setMaxDistance(10);analyzer.setTank(15);
Collection<Path<Vendor>> paths = analyzer.getPaths(v10, v6);
Collection<Path<Place>> paths = analyzer.getPaths(v10, v6);
TestUtil.assertCollectionContainAll(paths, Path.toPath(v10, v6), Path.toPath(v10, v11, v6), Path.toPath(v10, v11, v10, v6),
Path.toPath(v10, v8, v6), Path.toPath(v10, v8, v10, v6), Path.toPath(v10, v8, v11, v6));

8
core/src/test/java/ru/trader/core/MarketAnalyzerTest2.java
View File

@@ -26,10 +26,10 @@ public class MarketAnalyzerTest2 extends Assert {
// Balance: 6000000, cargo: 440, tank: 40, distance: 13.4, jumps: 6
// Ithaca (Palladium to LHS 3262) -> Morgor -> LHS 3006 -> LHS 3262 (Consumer Technology to Ithaca) -> LHS 3006 -> Morgor -> Ithaca
// Profit: 981200, avg: 490600, distance: 67.5, lands: 2
Vendor ithaca = market.get().stream().filter((v)->v.getName().equals("Ithaca")).findFirst().get();
Vendor morgor = market.get().stream().filter((v)->v.getName().equals("Morgor")).findFirst().get();
Vendor lhs3006 = market.get().stream().filter((v)->v.getName().equals("LHS 3006")).findFirst().get();
Vendor lhs3262 = market.get().stream().filter((v)->v.getName().equals("LHS 3262")).findFirst().get();
Place ithaca = market.get().stream().filter((v)->v.getName().equals("Ithaca")).findFirst().get();
Place morgor = market.get().stream().filter((v)->v.getName().equals("Morgor")).findFirst().get();
Place lhs3006 = market.get().stream().filter((v)->v.getName().equals("LHS 3006")).findFirst().get();
Place lhs3262 = market.get().stream().filter((v)->v.getName().equals("LHS 3262")).findFirst().get();
analyzer.setCargo(440);analyzer.setTank(40);analyzer.setMaxDistance(13.4);analyzer.setJumps(6);
Collection<PathRoute> paths = analyzer.getPaths(ithaca, ithaca, 6000000);
PathRoute expect = PathRoute.toPathRoute(ithaca, morgor, lhs3006, lhs3262, lhs3006, morgor, ithaca);

66
core/src/test/java/ru/trader/core/MarketTest1.java
View File

@@ -17,57 +17,57 @@ public class MarketTest1 extends Assert {
private final static Item ITEM2 = new SimpleItem("Item2");
private final static Item ITEM3 = new SimpleItem("Item3");
private final static Offer bestSellOffer1 = new SimpleOffer(OFFER_TYPE.SELL,ITEM1,10);
private final static Offer bestSellOffer2 = new SimpleOffer(OFFER_TYPE.SELL,ITEM2,15);
private final static Offer bestSellOffer3 = new SimpleOffer(OFFER_TYPE.SELL,ITEM3,20);
private final Offer bestSellOffer1 = new SimpleOffer(OFFER_TYPE.SELL,ITEM1,10,1);
private final Offer bestSellOffer2 = new SimpleOffer(OFFER_TYPE.SELL,ITEM2,15,1);
private final Offer bestSellOffer3 = new SimpleOffer(OFFER_TYPE.SELL,ITEM3,20,1);
private final static Offer bestBuyOffer1 = new SimpleOffer(OFFER_TYPE.BUY,ITEM1,100);
private final static Offer bestBuyOffer2 = new SimpleOffer(OFFER_TYPE.BUY,ITEM2,200);
private final static Offer bestBuyOffer3 = new SimpleOffer(OFFER_TYPE.BUY,ITEM3,100);
private final static Offer bestBuyOffer4 = new SimpleOffer(OFFER_TYPE.BUY,ITEM2,150);
private final Offer bestBuyOffer1 = new SimpleOffer(OFFER_TYPE.BUY,ITEM1,100,1);
private final Offer bestBuyOffer2 = new SimpleOffer(OFFER_TYPE.BUY,ITEM2,200,1);
private final Offer bestBuyOffer3 = new SimpleOffer(OFFER_TYPE.BUY,ITEM3,100,1);
private final Offer bestBuyOffer4 = new SimpleOffer(OFFER_TYPE.BUY,ITEM2,150,1);
private final static Vendor sellVendor1 = new SimpleVendor();
private final static Vendor sellVendor2 = new SimpleVendor();
private final static Vendor sellVendor3 = new SimpleVendor();
private final static Vendor sellVendor4 = new SimpleVendor();
private final static Vendor buyVendor1 = new SimpleVendor();
private final static Vendor buyVendor2 = new SimpleVendor();
private final static Vendor buyVendor3 = new SimpleVendor();
private final static Vendor buyVendor4 = new SimpleVendor();
private final Vendor sellVendor1 = new SimpleVendor("",0,0,0);
private final Vendor sellVendor2 = new SimpleVendor("",0,0,0);
private final Vendor sellVendor3 = new SimpleVendor("",0,0,0);
private final Vendor sellVendor4 = new SimpleVendor("",0,0,0);
private final Vendor buyVendor1 = new SimpleVendor("",0,0,0);
private final Vendor buyVendor2 = new SimpleVendor("",0,0,0);
private final Vendor buyVendor3 = new SimpleVendor("",0,0,0);
private final Vendor buyVendor4 = new SimpleVendor("",0,0,0);
private Market market;
@Before
public void fillMarket(){
sellVendor1.add(bestSellOffer1);
sellVendor1.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM2,100));
sellVendor2.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM3,200));
sellVendor1.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM2,100,1));
sellVendor2.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM3,200,1));
sellVendor2.add(bestSellOffer2);
sellVendor3.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM1,300));
sellVendor3.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM2,300));
sellVendor3.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM1,300,1));
sellVendor3.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM2,300,1));
sellVendor3.add(bestSellOffer3);
sellVendor4.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM2,150));
sellVendor4.add(new SimpleOffer(OFFER_TYPE.SELL,ITEM2,150,1));
buyVendor1.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM2,50));
buyVendor1.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM2,50,1));
buyVendor1.add(bestBuyOffer1);
buyVendor2.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM1,40));
buyVendor2.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM1,40,1));
buyVendor2.add(bestBuyOffer2);
buyVendor2.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM3,50));
buyVendor2.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM3,50,1));
buyVendor3.add(bestBuyOffer3);
buyVendor3.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM2,20));
buyVendor4.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM1,80));
buyVendor3.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM2,20,1));
buyVendor4.add(new SimpleOffer(OFFER_TYPE.BUY,ITEM1,80,1));
buyVendor4.add(bestBuyOffer4);
market = new SimpleMarket();
market.add(sellVendor1);
market.add(sellVendor2);
market.add(sellVendor3);
market.add(sellVendor4);
market.add(buyVendor1);
market.add(buyVendor2);
market.add(buyVendor3);
market.add(buyVendor4);
market.add(sellVendor1.getPlace());
market.add(sellVendor2.getPlace());
market.add(sellVendor3.getPlace());
market.add(sellVendor4.getPlace());
market.add(buyVendor1.getPlace());
market.add(buyVendor2.getPlace());
market.add(buyVendor3.getPlace());
market.add(buyVendor4.getPlace());
}
@Test

4
core/src/test/java/ru/trader/core/VendorTest.java
View File

@@ -15,8 +15,8 @@ public class VendorTest extends Assert {
private final static Item ITEM1 = new SimpleItem("Item1");
private final static Item ITEM2 = new SimpleItem("Item2");
private final static Offer SELL_OFFER = new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 10);
private final static Offer BUY_OFFER = new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 10);
private final Offer SELL_OFFER = new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 10, 1);
private final Offer BUY_OFFER = new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 10, 1);
private Vendor sellVendor;
private Vendor buyVendor;

16
core/src/test/java/ru/trader/core/VendorTest2.java
View File

@@ -18,15 +18,15 @@ public class VendorTest2 extends Assert {
private final static Item ITEM1 = new SimpleItem("Item1");
private final static Item ITEM2 = new SimpleItem("Item2");
private final static Item ITEM3 = new SimpleItem("Item3");
private final static Offer SELL_OFFER1 = new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 10);
private final static Offer SELL_OFFER2 = new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 10);
private final static Offer SELL_OFFER3 = new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 10);
private final static Offer DUBLE_SELL_OFFER1 = new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100);
private final Offer SELL_OFFER1 = new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 10, 1);
private final Offer SELL_OFFER2 = new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 10, 1);
private final Offer SELL_OFFER3 = new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 10, 1);
private final Offer DUBLE_SELL_OFFER1 = new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1);
private final static Offer BUY_OFFER1 = new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 100);
private final static Offer BUY_OFFER2 = new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 10);
private final static Offer BUY_OFFER3 = new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 10);
private final static Offer DUBLE_BUY_OFFER1 = new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 10);
private final Offer BUY_OFFER1 = new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 100, 1);
private final Offer BUY_OFFER2 = new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 10, 1);
private final Offer BUY_OFFER3 = new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 10, 1);
private final Offer DUBLE_BUY_OFFER1 = new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 10, 1);
private Vendor sellVendor;

186
core/src/test/java/ru/trader/graph/PathRouteTest.java
View File

@@ -26,18 +26,18 @@ public class PathRouteTest extends Assert {
private PathRoute initTest1(){
LOG.info("Init test 1");
v1 = new SimpleVendor("v1");
v2 = new SimpleVendor("v2");
v1 = new SimpleVendor("v1",0,0,0);
v2 = new SimpleVendor("v2",0,0,0);
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 300));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 350));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 400));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, 1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, 1));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 300, 1));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 350, 1));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 400, 1));
PathRoute res = new PathRoute(new Vertex<>(v1));
res = (PathRoute) res.connectTo(new Vertex<>(v2), false);
PathRoute res = new PathRoute(new Vertex<>(v1.getPlace()));
res = (PathRoute) res.connectTo(new Vertex<>(v2.getPlace()), false);
res.finish();
res.sort(10000, 5);
return res.getRoot();
@@ -66,20 +66,20 @@ public class PathRouteTest extends Assert {
private PathRoute initTest2(){
LOG.info("Init test 2");
v1 = new SimpleVendor("v1");
v2 = new SimpleVendor("v2");
v3 = new SimpleVendor("v3");
v1 = new SimpleVendor("v1",0,0,0);
v2 = new SimpleVendor("v2",0,0,0);
v3 = new SimpleVendor("v3",0,0,0);
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 300));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 350));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 400));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, 1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, 1));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 300, 1));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 350, 1));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 400, 1));
PathRoute res = new PathRoute(new Vertex<>(v1));
res = (PathRoute) res.connectTo(new Vertex<>(v2), false);
res = (PathRoute) res.connectTo(new Vertex<>(v3), false);
PathRoute res = new PathRoute(new Vertex<>(v1.getPlace()));
res = (PathRoute) res.connectTo(new Vertex<>(v2.getPlace()), false);
res = (PathRoute) res.connectTo(new Vertex<>(v3.getPlace()), false);
res.finish();
res.sort(10000, 5);
return res.getRoot();
@@ -113,26 +113,26 @@ public class PathRouteTest extends Assert {
private PathRoute initTest3(){
LOG.info("Init test 3");
v1 = new SimpleVendor("v1");
v2 = new SimpleVendor("v2");
v3 = new SimpleVendor("v3");
v4 = new SimpleVendor("v4");
v1 = new SimpleVendor("v1",0,0,0);
v2 = new SimpleVendor("v2",0,0,0);
v3 = new SimpleVendor("v3",0,0,0);
v4 = new SimpleVendor("v4",0,0,0);
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320));
v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, 1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, 1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150, 1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320, 1));
v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390, 1));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200));
v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225, 1));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200, 1));
v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450, 1));
PathRoute res = new PathRoute(new Vertex<>(v1));
res = (PathRoute) res.connectTo(new Vertex<>(v2), false);
res = (PathRoute) res.connectTo(new Vertex<>(v3), false);
res = (PathRoute) res.connectTo(new Vertex<>(v4), false);
PathRoute res = new PathRoute(new Vertex<>(v1.getPlace()));
res = (PathRoute) res.connectTo(new Vertex<>(v2.getPlace()), false);
res = (PathRoute) res.connectTo(new Vertex<>(v3.getPlace()), false);
res = (PathRoute) res.connectTo(new Vertex<>(v4.getPlace()), false);
res.finish();
res.sort(10000, 5);
return res.getRoot();
@@ -176,28 +176,28 @@ public class PathRouteTest extends Assert {
private PathRoute initTest4(){
LOG.info("Init test 4");
v1 = new SimpleVendor("v1");
v2 = new SimpleVendor("v2");
v3 = new SimpleVendor("v3");
v4 = new SimpleVendor("v4");
v5 = new SimpleVendor("v5");
v1 = new SimpleVendor("v1",0,0,0);
v2 = new SimpleVendor("v2",0,0,0);
v3 = new SimpleVendor("v3",0,0,0);
v4 = new SimpleVendor("v4",0,0,0);
v5 = new SimpleVendor("v5",0,0,0);
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 410));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 270));
v4.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 300));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 410, 1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, 1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, 1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 270, 1));
v4.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 300, 1));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 470));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 300));
v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 370));
v5.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 400));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 470, 1));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 300, 1));
v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 370, 1));
v5.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 400, 1));
PathRoute res = new PathRoute(new Vertex<>(v1));
res = (PathRoute) res.connectTo(new Vertex<>(v2), false);
res = (PathRoute) res.connectTo(new Vertex<>(v3), false);
res = (PathRoute) res.connectTo(new Vertex<>(v4), false);
res = (PathRoute) res.connectTo(new Vertex<>(v5), false);
PathRoute res = new PathRoute(new Vertex<>(v1.getPlace()));
res = (PathRoute) res.connectTo(new Vertex<>(v2.getPlace()), false);
res = (PathRoute) res.connectTo(new Vertex<>(v3.getPlace()), false);
res = (PathRoute) res.connectTo(new Vertex<>(v4.getPlace()), false);
res = (PathRoute) res.connectTo(new Vertex<>(v5.getPlace()), false);
res.finish();
res.sort(10000, 5);
return res.getRoot();
@@ -249,26 +249,26 @@ public class PathRouteTest extends Assert {
private PathRoute initTest5(){
LOG.info("Init test 5");
v1 = new SimpleVendor("v1");
v2 = new SimpleVendor("v2");
v3 = new SimpleVendor("v3");
v4 = new SimpleVendor("v4");
v1 = new SimpleVendor("v1",0,0,0);
v2 = new SimpleVendor("v2",0,0,0);
v3 = new SimpleVendor("v3",0,0,0);
v4 = new SimpleVendor("v4",0,0,0);
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320));
v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, 1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, 1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150, 1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320, 1));
v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390, 1));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200));
v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225, 1));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200, 1));
v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450, 1));
PathRoute res = new PathRoute(new Vertex<>(v1));
res = (PathRoute) res.connectTo(new Vertex<>(v2), false);
res = (PathRoute) res.connectTo(new Vertex<>(v3), false);
res = (PathRoute) res.connectTo(new Vertex<>(v4), false);
PathRoute res = new PathRoute(new Vertex<>(v1.getPlace()));
res = (PathRoute) res.connectTo(new Vertex<>(v2.getPlace()), false);
res = (PathRoute) res.connectTo(new Vertex<>(v3.getPlace()), false);
res = (PathRoute) res.connectTo(new Vertex<>(v4.getPlace()), false);
res.finish();
res.sort(500, 5);
return res.getRoot();
@@ -314,19 +314,19 @@ public class PathRouteTest extends Assert {
private PathRoute initTest6A(){
LOG.info("Init test 6A");
v1 = new SimpleVendor("v1");
v2 = new SimpleVendor("v2");
v1 = new SimpleVendor("v1",0,0,0);
v2 = new SimpleVendor("v2",0,0,0);
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, 1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, 1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150, 1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320, 1));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225, 1));
PathRoute res = new PathRoute(new Vertex<>(v1));
res = (PathRoute) res.connectTo(new Vertex<>(v2), false);
PathRoute res = new PathRoute(new Vertex<>(v1.getPlace()));
res = (PathRoute) res.connectTo(new Vertex<>(v2.getPlace()), false);
res.finish();
res.sort(500, 5);
return res.getRoot();
@@ -334,17 +334,17 @@ public class PathRouteTest extends Assert {
private PathRoute initTest6B(){
LOG.info("Init test 6B");
v3 = new SimpleVendor("v3");
v4 = new SimpleVendor("v4");
v3 = new SimpleVendor("v3",0,0,0);
v4 = new SimpleVendor("v4",0,0,0);
v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390));
v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390, 1));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200));
v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200, 1));
v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450, 1));
PathRoute res = new PathRoute(new Vertex<>(v2));
res = (PathRoute) res.connectTo(new Vertex<>(v3), false);
res = (PathRoute) res.connectTo(new Vertex<>(v4), false);
PathRoute res = new PathRoute(new Vertex<>(v2.getPlace()));
res = (PathRoute) res.connectTo(new Vertex<>(v3.getPlace()), false);
res = (PathRoute) res.connectTo(new Vertex<>(v4.getPlace()), false);
res.finish();
res.sort(500, 5);
return res.getRoot();

40
core/src/test/java/ru/trader/graph/RouteGraphTest.java
View File

@@ -5,10 +5,7 @@ import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.trader.core.*;
import ru.trader.store.simple.SimpleItem;
import ru.trader.store.simple.SimpleMarket;
import ru.trader.store.simple.SimpleOffer;
import ru.trader.store.simple.SimpleVendor;
import ru.trader.store.simple.*;
import java.util.ArrayList;
@@ -22,36 +19,47 @@ public class RouteGraphTest extends Assert {
private static Vendor v2;
private static Vendor v3;
private static Vendor v4;
private static Place p1;
private static Place p2;
private static Place p3;
private static Place p4;
static {
p1 = new SimplePlace("v1");
p2 = new SimplePlace("v2");
p3 = new SimplePlace("v3");
p4 = new SimplePlace("v4");
v1 = new SimpleVendor("v1");
v2 = new SimpleVendor("v2");
v3 = new SimpleVendor("v3");
v4 = new SimpleVendor("v4");
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320));
v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, 1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, 1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, 1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150, 1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320, 1));
v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390, 1));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200));
v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225, 1));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200, 1));
v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450, 1));
market.add(v1);market.add(v2);market.add(v3);market.add(v4);
p1.add(v1);p2.add(v2);p3.add(v3);p4.add(v4);
market.add(p1);market.add(p2);market.add(p3);market.add(p4);
}
@Test
public void testRoutes() throws Exception {
RouteGraph graph = new RouteGraph(v1, market.get(), 1, 1, true, 4);
RouteGraph graph = new RouteGraph(p1, market.get(), 1, 1, true, 4);
graph.setBalance(500);
graph.setCargo(5);
//Profit: 150 180 200 230 670 620 950 890 620 950 1015 1180 890 950 930
//Landings: 1 2 3 4 4 2 3 3 2 3 4 4 3 3 4
//Prof: 150 90 66.66 57.5 167.5 310 316.66 296.66 310 316.66 253.75 295 296.66 316.66 232.5
ArrayList<Path<Vendor>> routes = (ArrayList<Path<Vendor>>) graph.getPathsTo(v4, 5);
ArrayList<Path<Place>> routes = (ArrayList<Path<Place>>) graph.getPathsTo(p4, 5);
assertEquals(5, routes.size());
PathRoute path = (PathRoute) routes.get(0).getRoot();

11
core/src/test/java/ru/trader/graph/RouteSearcherTest.java
View File

@@ -4,6 +4,7 @@ import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import ru.trader.core.Market;
import ru.trader.core.Place;
import ru.trader.core.Vendor;
import ru.trader.store.simple.Store;
@@ -24,7 +25,7 @@ public class RouteSearcherTest extends Assert {
// Balance: 6000000, cargo: 440, tank: 40, distance: 13.4, jumps: 6
// Ithaca (Palladium to LHS 3262) -> Morgor -> LHS 3006 -> LHS 3262 (Consumer Technology to Ithaca) -> LHS 3006 -> Morgor -> Ithaca
// Profit: 981200, avg: 490600, distance: 67.5, lands: 2
Vendor ithaca = market.get().stream().filter((v)->v.getName().equals("Ithaca")).findFirst().get();
Place ithaca = market.get().stream().filter((v)->v.getName().equals("Ithaca")).findFirst().get();
RouteSearcher searcher = new RouteSearcher(13.4, 40);
RouteGraph graph = new RouteGraph(ithaca, market.get(), 40, 13.4, true, 6);
@@ -32,7 +33,7 @@ public class RouteSearcherTest extends Assert {
graph.setBalance(6000000);
List<Path<Vendor>> epaths = graph.getPathsTo(ithaca, 10);
List<Path<Place>> epaths = graph.getPathsTo(ithaca, 10);
PathRoute expect = epaths.stream().map(p -> (PathRoute) p).findFirst().get();
List<PathRoute> apaths = searcher.getPaths(ithaca, ithaca, market.get(), 6, 6000000, 440, 10);
@@ -46,15 +47,15 @@ public class RouteSearcherTest extends Assert {
// Balance: 6000000, cargo: 440, tank: 40, distance: 13.6, jumps: 6
// Ithaca (Palladium to LHS 3262) -> Morgor -> LHS 3006 -> LHS 3262 (Consumer Technology to Ithaca) -> LHS 3006 -> Morgor -> Ithaca
// Profit: 981200, avg: 490600, distance: 67.5, lands: 2
Vendor ithaca = market.get().stream().filter((v)->v.getName().equals("Ithaca")).findFirst().get();
Vendor lhs3262 = market.get().stream().filter((v)->v.getName().equals("LHS 3262")).findFirst().get();
Place ithaca = market.get().stream().filter((v)->v.getName().equals("Ithaca")).findFirst().get();
Place lhs3262 = market.get().stream().filter((v)->v.getName().equals("LHS 3262")).findFirst().get();
RouteSearcher searcher = new RouteSearcher(13.6, 40);
RouteGraph graph = new RouteGraph(ithaca, market.get(), 40, 13.6, true, 6);
graph.setCargo(440);
graph.setBalance(6000000);
List<Path<Vendor>> epaths = graph.getPathsTo(ithaca, 10);
List<Path<Place>> epaths = graph.getPathsTo(ithaca, 10);
PathRoute expect = epaths.stream().map(p -> (PathRoute) p).findFirst().get();
List<PathRoute> apaths = searcher.getPaths(ithaca, ithaca, market.get(), 6, 6000000, 440, 10);

16
core/src/test/java/ru/trader/store/simple/ItemStatTest.java
View File

@@ -20,15 +20,15 @@ public class ItemStatTest extends Assert {
@Before
public void fill(){
itemSellStat.put(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 10));
itemSellStat.put(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 20));
itemSellStat.put(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 30));
itemSellStat.put(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 40));
itemSellStat.put(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 10, 1));
itemSellStat.put(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 20, 1));
itemSellStat.put(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 30, 1));
itemSellStat.put(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 40, 1));
itemBuyStat.put(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 100));
itemBuyStat.put(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200));
itemBuyStat.put(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 300));
itemBuyStat.put(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 400));
itemBuyStat.put(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 100, 1));
itemBuyStat.put(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200, 1));
itemBuyStat.put(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 300, 1));
itemBuyStat.put(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 400, 1));
}

4
core/src/test/resources/test.xml
View File

@@ -8,12 +8,12 @@
<item name="Item 5" id="i5"/>
<item name="Item 6" id="i6"/>
</items>
<vendors>
<places>
<vendor name="Vendor 1">
<offer item="i1" type="SELL" price="140"/>
</vendor>
<vendor name="Empty system" x="1" y="2" z="3"/>
</vendors>
</places>
</market>

2
core/src/test/resources/world.xml
View File

File diff suppressed because one or more lines are too long

6
utils/src/main/java/ru/trader/store/XSSFImporter.java
View File

@@ -57,7 +57,9 @@ public class XSSFImporter {
XMLReader saxParser = XMLReaderFactory.createXMLReader();
saxParser.setContentHandler(getHandler());
saxParser.parse(getInputSource());
market.addVendors(vendors);
for (Vendor vendor : vendors) {
market.add(vendor.getPlace());
}
} finally {
if (pkg!=null) {
try { pkg.close();} catch (IOException e) {LOG.warn("Error on close pkg",e);}
@@ -113,7 +115,7 @@ public class XSSFImporter {
market.add(item);
} else {
LOG.trace("add offer");
Offer offer = new SimpleOffer(cell.column % 2 == 0? OFFER_TYPE.BUY : OFFER_TYPE.SELL, item, Double.valueOf(formattedValue));
Offer offer = new SimpleOffer(cell.column % 2 == 0? OFFER_TYPE.BUY : OFFER_TYPE.SELL, item, Double.valueOf(formattedValue), 1000);
vendors.get(cell.column/2 -1).add(offer);
}
}