From bcd7ebbd0493740afbd7d0f34a69cd7d6ca3a25c Mon Sep 17 00:00:00 2001 From: Mo Date: Sat, 26 Sep 2015 16:51:45 +0300 Subject: [PATCH] improve reserving for missions --- .../main/java/ru/trader/model/RouteModel.java | 45 +++-- .../main/java/ru/trader/analysis/Route.java | 101 ++++++++-- .../java/ru/trader/analysis/RouteEntry.java | 53 ++--- .../java/ru/trader/analysis/RouteFiller.java | 186 ++++++++++-------- .../java/ru/trader/analysis/RouteReserve.java | 52 +++++ .../ru/trader/analysis/RouteSearcher.java | 6 +- .../ru/trader/analysis/RouteFillerTest.java | 49 ++--- 7 files changed, 333 insertions(+), 159 deletions(-) create mode 100644 core/src/main/java/ru/trader/analysis/RouteReserve.java diff --git a/client/src/main/java/ru/trader/model/RouteModel.java b/client/src/main/java/ru/trader/model/RouteModel.java index 5e81b7b..8c80e3c 100644 --- a/client/src/main/java/ru/trader/model/RouteModel.java +++ b/client/src/main/java/ru/trader/model/RouteModel.java @@ -6,7 +6,7 @@ import javafx.beans.property.SimpleDoubleProperty; import ru.trader.analysis.Route; import ru.trader.analysis.RouteEntry; import ru.trader.analysis.RouteFiller; -import ru.trader.controllers.MainController; +import ru.trader.analysis.RouteReserve; import ru.trader.core.Offer; import ru.trader.core.Order; import ru.trader.model.support.BindingsHelper; @@ -123,24 +123,31 @@ public class RouteModel { public void add(int offset, MissionModel mission){ int completeIndex = -1; - long cargo = MainController.getProfile().getShipCargo(); Offer offer = mission.getOffer(); if (offer != null){ - completeIndex = RouteFiller.addOrders(_route, offset, offer, cargo); - for (RouteEntryModel entry : entries) { - entry.sellOrders().clear(); - entry.refresh(market); + Collection reserves = RouteFiller.getReserves(_route, offset, offer); + if (!reserves.isEmpty()) { + _route.reserve(reserves); + completeIndex = RouteReserve.getCompleteIndex(reserves, offset); + for (RouteEntryModel entry : entries) { + entry.sellOrders().clear(); + entry.refresh(market); + } + fillSellOrders(); } - fillSellOrders(); } else if (mission.isDelivery()){ - completeIndex = RouteFiller.reservedCargo(_route, offset, mission.getTarget().getStation(), mission.getCount(), cargo); - for (RouteEntryModel entry : entries) { - entry.refresh(market); + RouteReserve reserve = RouteFiller.getReserves(_route, offset, mission.getTarget().getStation(), mission.getCount()); + if (reserve != null) { + _route.reserve(reserve); + completeIndex = reserve.getToIndex(); + for (RouteEntryModel entry : entries) { + entry.refresh(market); + } } } else if (mission.isCourier()){ - completeIndex = _route.find(mission.getTarget().getStation(), offset); + completeIndex = _route.find(mission.getTarget().getStation(), offset+1); } if (completeIndex != -1){ entries.get(completeIndex).add(mission); @@ -148,20 +155,28 @@ public class RouteModel { } public void addAll(int offset, Collection missions){ - long cargo = MainController.getProfile().getShipCargo(); for (MissionModel mission : missions) { Offer offer = mission.getOffer(); int completeIndex = -1; if (offer != null){ - completeIndex = RouteFiller.addOrders(_route, offset, offer, cargo); + Collection reserves = RouteFiller.getReserves(_route, offset, offer); + if (!reserves.isEmpty()) { + _route.reserve(reserves); + completeIndex = RouteReserve.getCompleteIndex(reserves, offset); + } } else if (mission.isDelivery()){ - completeIndex = RouteFiller.reservedCargo(_route, offset, mission.getTarget().getStation(), mission.getCount(), cargo); + RouteReserve reserve = RouteFiller.getReserves(_route, offset, mission.getTarget().getStation(), mission.getCount()); + if (reserve != null) { + _route.reserve(reserve); + completeIndex = reserve.getToIndex(); + } } else if (mission.isCourier()){ - completeIndex = _route.find(mission.getTarget().getStation(), offset); + completeIndex = _route.find(mission.getTarget().getStation(), offset+1); } if (completeIndex != -1){ + if (completeIndex == 0 && _route.isLoop()) completeIndex = _route.getJumps()-1; entries.get(completeIndex).add(mission); } } diff --git a/core/src/main/java/ru/trader/analysis/Route.java b/core/src/main/java/ru/trader/analysis/Route.java index 67c1a67..65b7fa6 100644 --- a/core/src/main/java/ru/trader/analysis/Route.java +++ b/core/src/main/java/ru/trader/analysis/Route.java @@ -1,5 +1,6 @@ package ru.trader.analysis; +import org.jetbrains.annotations.NotNull; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import ru.trader.core.Vendor; @@ -17,6 +18,7 @@ public class Route implements Comparable { private long time = 0; private int lands = 0; private int refills = 0; + private long cargo=0; public Route(RouteEntry root) { entries = new ArrayList<>(); @@ -48,6 +50,14 @@ public class Route implements Comparable { return balance; } + public long getCargo() { + return cargo; + } + + void setCargo(long cargo) { + this.cargo = cargo; + } + public double getProfit() { return profit; } @@ -92,7 +102,7 @@ public class Route implements Comparable { public void addAll(Collection entries){ LOG.trace("Add {} entries {} to route {}", entries, this); - entries.addAll(entries); + this.entries.addAll(entries); updateStats(); } @@ -110,22 +120,52 @@ public class Route implements Comparable { return vendors; } - public int find(Vendor vendor, int offset){ - int size = entries.size(); - for (int i = 0; i < size; i++) { - int index = i + offset; - if (index >= size){ - if (isLoop()) index -= size; - else break; - } - RouteEntry entry = entries.get(index); - if (entry.is(vendor)){ - return i; + public int find(Vendor vendor, int fromIndex){ + for (Route.LoopIterator iterator = loopIterator(fromIndex); iterator.hasNext(); ) { + RouteEntry entry = iterator.next(); + if (entry.is(vendor)) { + return iterator.getRealIndex(); } } return -1; } + public void reserve(final RouteReserve reserve){ + for (Route.LoopIterator iterator = loopIterator(reserve.getFromIndex()); iterator.hasNext(); ) { + RouteEntry entry = iterator.next(); + if (entry.isTransit()) continue; + if (iterator.getRealIndex() == reserve.getToIndex() && (reserve.getFromIndex() != reserve.getToIndex() || iterator.getIndex() > 0)) { + break; + } + entry.reserve(reserve.getCount(), cargo); + } + if (reserve.getOrder() != null) { + entries.get(reserve.getFromIndex()).addOrder(reserve.getOrder()); + } + } + + public void reserve(Collection reserves){ + reserves.forEach(this::reserve); + } + + public void unreserve(final RouteReserve reserve){ + for (Route.LoopIterator iterator = loopIterator(reserve.getFromIndex()); iterator.hasNext(); ) { + RouteEntry entry = iterator.next(); + if (entry.isTransit()) continue; + if (iterator.getRealIndex() == reserve.getToIndex() && (reserve.getFromIndex() != reserve.getToIndex() || iterator.getIndex() > 0)) { + break; + } + entry.fill(reserve.getCount()); + } + if (reserve.getOrder() != null) { + entries.get(reserve.getFromIndex()).removeOrder(reserve.getOrder()); + } + } + + public void unreserve(Collection reserves){ + reserves.forEach(this::unreserve); + } + public boolean contains(Collection vendors){ return vendors.isEmpty() || vendors.size() <= entries.size() @@ -178,7 +218,7 @@ public class Route implements Comparable { } @Override - public int compareTo(Route o) { + public int compareTo(@NotNull Route o) { return Double.compare(getScore(), o.getScore()); } @@ -208,4 +248,39 @@ public class Route implements Comparable { ", lands=" + lands + '}'; } + + public interface LoopIterator extends Iterator{ + int getIndex(); + int getRealIndex(); + } + + public LoopIterator loopIterator(int from){ + return new LoopIterator() { + private final int size = entries.size() - (isLoop() ? 1 : from); + private int i = -1; + + @Override + public int getIndex(){ + return i; + } + + @Override + public int getRealIndex(){ + int index = i + from; + if (index >= size) index -= size; + return index; + } + + @Override + public boolean hasNext() { + return i < size-1; + } + + @Override + public RouteEntry next() { + i++; + return entries.get(getRealIndex()); + } + }; + } } diff --git a/core/src/main/java/ru/trader/analysis/RouteEntry.java b/core/src/main/java/ru/trader/analysis/RouteEntry.java index d4b6039..58d6b6f 100644 --- a/core/src/main/java/ru/trader/analysis/RouteEntry.java +++ b/core/src/main/java/ru/trader/analysis/RouteEntry.java @@ -3,7 +3,10 @@ package ru.trader.analysis; import ru.trader.core.Order; import ru.trader.core.Vendor; -import java.util.*; +import java.util.AbstractList; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; import java.util.stream.Collectors; public class RouteEntry { @@ -15,6 +18,7 @@ public class RouteEntry { private double profit; private long time; private long fulltime; + private long reserved; public RouteEntry(Vendor vendor, double refill, double fuel, double profit) { orders = new ArrayList<>(); @@ -22,6 +26,7 @@ public class RouteEntry { this.refill = refill; this.fuel = fuel; this.profit = profit; + reserved = 0; } public Vendor getVendor() { @@ -85,18 +90,11 @@ public class RouteEntry { } void removeOrder(Order order){ - assert order instanceof OrderWrapper; - orders.remove(order); - } - - void clearTemporal(){ - for (Iterator iterator = orders.iterator(); iterator.hasNext(); ) { - OrderWrapper order = iterator.next(); - if (!order.fixed){ - iterator.remove(); - } + if (order instanceof OrderWrapper) { + orders.remove(order); + } else { + orders.removeIf(order::equals); } - orders.forEach(OrderWrapper::reset); } public List getOrders() { @@ -117,18 +115,23 @@ public class RouteEntry { return orders.stream().filter(o -> o.fixed).collect(Collectors.toList()); } - void reserve(long count){ - List fixedOrders = getFixedOrders(); - fixedOrders.sort((o1, o2) -> Double.compare(o1.getProfitByTonne(), o2.getProfitByTonne())); - for (Order order : fixedOrders) { - long newCount = order.getCount() - count; - if (newCount < 0){ - newCount = 0; + void reserve(final long count, final long cargo){ + long empty = cargo - getCargo(); + long need = count - empty; + if (need > 0){ + List fixedOrders = getFixedOrders(); + fixedOrders.sort((o1, o2) -> Double.compare(o1.getProfitByTonne(), o2.getProfitByTonne())); + for (Order order : fixedOrders) { + long newCount = order.getCount() - need; + if (newCount < 0){ + newCount = 0; + } + need -= order.getCount() - newCount; + order.setCount(newCount); + if (need <= 0) break; } - count -= order.getCount() - newCount; - order.setCount(newCount); - if (count <= 0) break; } + reserved += count; } void fill(long count){ @@ -140,10 +143,14 @@ public class RouteEntry { order.setCount(newCount); if (count <= 0) break; } + reserved -= count; + if (reserved < 0){ + reserved = 0; + } } public long getCargo(){ - return orders.stream().mapToLong(Order::getCount).sum(); + return orders.stream().filter(o -> o.fixed).mapToLong(Order::getCount).sum() + reserved; } void clearOrders(){ diff --git a/core/src/main/java/ru/trader/analysis/RouteFiller.java b/core/src/main/java/ru/trader/analysis/RouteFiller.java index 3f9b9dc..0b795bf 100644 --- a/core/src/main/java/ru/trader/analysis/RouteFiller.java +++ b/core/src/main/java/ru/trader/analysis/RouteFiller.java @@ -27,6 +27,7 @@ public class RouteFiller { public void fill(Route route){ this.route = route; route.setBalance(balance); + route.setCargo(cargo); fillOrders(); updateEntries(); route.updateStats(); @@ -358,34 +359,19 @@ public class RouteFiller { } } - public static double[] getLostProfits(Route route, int offset, Vendor target, long count, long cargo){ - List entries = route.getEntries(); - int size = entries.size() - (route.isLoop() ? 1 : 0); + public static double[] getLostProfits(Route route, int fromIndex, Vendor target, long count) { + final double[] profits = getLostProfits(route, count); + int size = route.isLoop() ? route.getJumps()-1: route.getJumps(); double[] res = new double[size]; for (int i = 0; i < size; i++) { - int index = i + offset; + int index = i + fromIndex; if (index >= size) index -= size; - RouteEntry entry = entries.get(index); - if (entry.isTransit()) continue; - List orders = new ArrayList<>(entry.getFixedOrders()); - orders.sort((o1, o2) -> Double.compare(o1.getProfitByTonne(), o2.getProfitByTonne())); - long empty = cargo - orders.stream().mapToLong(Order::getCount).sum(); - long need = count - empty; - double profit = 0; - for (Order order : orders) { - if (need > 0){ - long reserved = Math.min(order.getCount(), need); - profit += reserved * order.getProfitByTonne(); - need -= reserved; - } else { - break; - } - } + double profit = profits[index]; for (int j = 0; j < size; j++) { - index = i - j + offset; + index = i - j + fromIndex; if (index >= size) index -= size; if (index < 0) index += size; - entry = entries.get(index); + RouteEntry entry = route.get(index); if (!entry.isTransit() && entry.is(target)) { break; } @@ -395,83 +381,114 @@ public class RouteFiller { return res; } - public static int reservedCargo(final Route route, final int offset, Vendor target, long count, long cargo){ - //TODO: compute current cargo if already reserved - int lastIndex = -1; - List entries = route.getEntries(); - int size = entries.size() - (route.isLoop() ? 1 : 0); - for (int i = 0; i < size; i++) { - int index = i + offset; - if (index >= size) index -= size; - RouteEntry entry = entries.get(index); - if (entry.isTransit()) continue; - if (i > 0 && entry.is(target)) { - lastIndex = index; - if (index == 0 && route.isLoop()) lastIndex = size; - break; - } - long empty = cargo - entry.getCargo(); - long need = count - empty; - if (need > 0){ - entry.reserve(need); - } - } - return lastIndex; - } - public static void fillCargo(final Route route, final int offset, Vendor target, long count){ + public static double[] getLostProfits(Route route, long count){ List entries = route.getEntries(); - int size = entries.size() - (route.isLoop() ? 1 : 0); - for (int i = 0; i < size; i++) { - int index = i + offset; - if (index >= size) index -= size; - RouteEntry entry = entries.get(index); - if (entry.isTransit()) continue; - if (entry.is(target)) { - break; - } - entry.fill(count); - } - } - - public static void removeOrders(final Route route, final Offer buyOffer){ - List entries = route.getEntries(); - int size = entries.size() - (route.isLoop() ? 1 : 0); + int size = entries.size(); + double[] res = new double[size]; for (int i = 0; i < size; i++) { RouteEntry entry = entries.get(i); if (entry.isTransit()) continue; - Optional order = entry.getOrders().stream().filter(o -> o.getBuy().equals(buyOffer)).findAny(); - if (order.isPresent()){ - fillCargo(route, i, buyOffer.getVendor(), order.get().getCount()); - entry.removeOrder(order.get()); + List orders = new ArrayList<>(entry.getFixedOrders()); + orders.sort((o1, o2) -> Double.compare(o1.getProfitByTonne(), o2.getProfitByTonne())); + long empty = route.getCargo() - entry.getCargo(); + long need = count - empty; + double profit = 0; + for (Order order : orders) { + if (need > 0) { + long reserved = Math.min(order.getCount(), need); + profit += reserved * order.getProfitByTonne(); + need -= reserved; + } else { + break; + } } + res[i] += profit; } + return res; } - public static int addOrders(final Route route, final int startEntry, final Offer buyOffer, final long cargo){ - final double[] profits = getLostProfits(route, startEntry, buyOffer.getVendor(), buyOffer.getCount(), cargo); + private static double getLostProfit(int fromIndex, int toIndex, double[] lostProfits) { + double res = 0; + for (int i = 0; i < lostProfits.length; i++) { + int index = i + fromIndex; + if (index >= lostProfits.length) index -= lostProfits.length; + if (index == toIndex && (i > 0 || fromIndex != toIndex)) { + break; + } + res += lostProfits[index]; + } + return res; + } + + private static int getLastIndex(final int fromIndex, final Offer buyOffer, final Order[] sells){ + long need = buyOffer.getCount(); + for (int i = 0; i < sells.length; i++) { + int index = i + fromIndex; + if (index >= sells.length) index -= sells.length; + Order sell = sells[index]; + if (sell == null) continue; + if (sell.getCount() >= need) { + return index; + } + need -= sell.getCount(); + } + return -1; + } + + public static RouteReserve getReserves(final Route route, final int fromIndex, final Vendor target, long count){ + int toIndex = route.find(target, fromIndex+1); + return toIndex != -1 ? new RouteReserve(fromIndex, toIndex, count) : null; + } + + public static Collection getReserves(final Route route, final int fromIndex, final Offer buyOffer){ + List entries = route.getEntries(); + int size = entries.size()-1; + final double[] profits = getLostProfits(route, buyOffer.getCount()); + final Order[] orders = new Order[size]; + for (int i = 0; i < size; i++) { + RouteEntry entry = entries.get(i); + Offer sell = entry.getVendor().getSell(buyOffer.getItem()); + if (sell != null) { + orders[i] = new Order(sell, buyOffer, route.getBalance(), buyOffer.getCount()); + } + } class SortHelper { - RouteEntry entry; - int index; - Order sell; + final RouteEntry entry; + final int index; + final int endIndex; + final Order sell; + final double profit; SortHelper(RouteEntry entry, int index) { this.entry = entry; this.index = index; - Offer sell = entry.getVendor().getSell(buyOffer.getItem()); - if (sell != null){ - this.sell = new Order(sell, buyOffer, route.getBalance(), buyOffer.getCount()); + this.sell = orders[index]; + int lastIndex = getLastIndex(index, buyOffer, orders); + if (lastIndex != -1) { + endIndex = route.find(buyOffer.getVendor(), lastIndex+1); + if (endIndex != -1) { + double lost = getLostProfit(index, endIndex, profits); + profit = sell != null ? lost - sell.getProfit() : lost; + } else { + profit = 0; + } + } else { + endIndex = -1; + profit = 0; } } + private boolean isSeller(){ + return sell != null && endIndex != -1; + } + private double getProfit(){ - return sell != null ? profits[index] - sell.getProfit() : profits[index]; + return profit; } } - List entries = route.getEntries(); - int size = entries.size()-1; List sortedEntries = new ArrayList<>(size); for (int i = 0; i < size; i++) { RouteEntry entry = entries.get(i); @@ -479,23 +496,22 @@ public class RouteFiller { } sortedEntries.sort((e1, e2) -> Double.compare(e1.getProfit(), e2.getProfit())); - int completeIndex = -1; long need = buyOffer.getCount(); double balance = route.getBalance(); + boolean checkIndex = !route.isLoop(); + Collection reserves = new ArrayList<>(); for (SortHelper helper : sortedEntries) { + if (checkIndex && fromIndex > helper.index) continue; RouteEntry entry = helper.entry; - if (helper.sell != null){ + if (helper.isSeller()){ Order order = new Order(helper.sell.getSell(), buyOffer, balance, need); - int lastIndex = reservedCargo(route, helper.index, buyOffer.getVendor(), order.getCount(), cargo); - if (completeIndex == -1 || completeIndex+startEntry < completeIndex + startEntry){ - completeIndex = lastIndex; - } - entry.addOrder(order); + RouteReserve reserve = new RouteReserve(order, helper.index, helper.endIndex); + reserves.add(reserve); need -= order.getCount(); if (need <= 0) break; } balance += entry.getProfit(); } - return completeIndex; + return reserves; } } diff --git a/core/src/main/java/ru/trader/analysis/RouteReserve.java b/core/src/main/java/ru/trader/analysis/RouteReserve.java new file mode 100644 index 0000000..d8faeb5 --- /dev/null +++ b/core/src/main/java/ru/trader/analysis/RouteReserve.java @@ -0,0 +1,52 @@ +package ru.trader.analysis; + +import ru.trader.core.Order; + +import java.util.Collection; + +public class RouteReserve { + private final Order order; + private final int fromIndex; + private final int toIndex; + private final long count; + + public RouteReserve(int fromIndex, int toIndex, long count) { + order = null; + this.fromIndex = fromIndex; + this.toIndex = toIndex; + this.count = count; + } + + public RouteReserve(Order order, int fromIndex, int toIndex) { + this.order = order; + this.fromIndex = fromIndex; + this.toIndex = toIndex; + count = order.getCount(); + } + + public Order getOrder() { + return order; + } + + public int getFromIndex() { + return fromIndex; + } + + public int getToIndex() { + return toIndex; + } + + public long getCount() { + return count; + } + + public static int getCompleteIndex(Collection reserves, int fromIndex){ + int completeIndex = -1; + for (RouteReserve reserve : reserves) { + if (completeIndex == -1 || completeIndex + fromIndex < reserve.getToIndex() + fromIndex){ + completeIndex = reserve.getToIndex(); + } + } + return completeIndex; + } +} diff --git a/core/src/main/java/ru/trader/analysis/RouteSearcher.java b/core/src/main/java/ru/trader/analysis/RouteSearcher.java index 441b13c..a18fe27 100644 --- a/core/src/main/java/ru/trader/analysis/RouteSearcher.java +++ b/core/src/main/java/ru/trader/analysis/RouteSearcher.java @@ -8,7 +8,9 @@ import ru.trader.core.Place; import ru.trader.core.Profile; import ru.trader.core.Vendor; -import java.util.*; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; public class RouteSearcher { private final static Logger LOG = LoggerFactory.getLogger(RouteSearcher.class); @@ -152,6 +154,7 @@ public class RouteSearcher { } Route route = new Route(entries); route.setBalance(scorer.getProfile().getBalance()); + route.setCargo(scorer.getProfile().getShip().getCargo()); return route; } @@ -188,6 +191,7 @@ public class RouteSearcher { } Route route = new Route(entries); route.setBalance(scorer.getProfile().getBalance()); + route.setCargo(scorer.getProfile().getShip().getCargo()); return route; } } diff --git a/core/src/test/java/ru/trader/analysis/RouteFillerTest.java b/core/src/test/java/ru/trader/analysis/RouteFillerTest.java index d6818d1..a99b733 100644 --- a/core/src/test/java/ru/trader/analysis/RouteFillerTest.java +++ b/core/src/test/java/ru/trader/analysis/RouteFillerTest.java @@ -9,6 +9,7 @@ import ru.trader.core.*; import ru.trader.store.simple.SimpleMarket; import ru.trader.store.simple.SimpleOffer; +import java.util.Collection; import java.util.List; public class RouteFillerTest extends Assert { @@ -484,30 +485,30 @@ public class RouteFillerTest extends Assert { assertEquals(3, route.getLands()); /* v1 3x100 + 2x20 -> v2 5x50 -> v3 3x60 -> v4 */ - double[] profits = RouteFiller.getLostProfits(route, 0, v4, cargo, cargo); + double[] profits = RouteFiller.getLostProfits(route, 0, v4, cargo); assertArrayEquals(new double[]{750, 430, 180, 0}, profits, 0.001); - profits = RouteFiller.getLostProfits(route, 0, v1, cargo, cargo); + profits = RouteFiller.getLostProfits(route, 0, v1, cargo); assertArrayEquals(new double[]{0, 430, 180, 0}, profits, 0.001); - profits = RouteFiller.getLostProfits(route, 1, v2, cargo, cargo); + profits = RouteFiller.getLostProfits(route, 1, v2, cargo); assertArrayEquals(new double[]{320, 0, 500, 320}, profits, 0.001); - profits = RouteFiller.getLostProfits(route, 2, v3, cargo, cargo); + profits = RouteFiller.getLostProfits(route, 2, v3, cargo); assertArrayEquals(new double[]{570, 250, 0, 570}, profits, 0.001); - profits = RouteFiller.getLostProfits(route, 0, v3, cargo, cargo); + profits = RouteFiller.getLostProfits(route, 0, v3, cargo); assertArrayEquals(new double[]{570, 250, 0, 570}, profits, 0.001); - profits = RouteFiller.getLostProfits(route, 0, v1, 2, cargo); + profits = RouteFiller.getLostProfits(route, 0, v1, 2); assertArrayEquals(new double[]{0, 0, 0, 0}, profits, 0.001); /* v1 -2x20 -> v2 -2x50 -> v3 -> v4 */ - profits = RouteFiller.getLostProfits(route, 0, v4, 4, cargo); + profits = RouteFiller.getLostProfits(route, 0, v4, 4); assertArrayEquals(new double[]{120, 100, 0, 0}, profits, 0.001); /* v1 -1x100 - 2x20 -> v2 -3x50 -> v3 -1x60 -> v4 */ - profits = RouteFiller.getLostProfits(route, 0, v4, 5, cargo); + profits = RouteFiller.getLostProfits(route, 0, v4, 5); assertArrayEquals(new double[]{330, 210, 60, 0}, profits, 0.001); } @@ -559,22 +560,22 @@ public class RouteFillerTest extends Assert { assertEquals(4, route.getLands()); /* v1 3x100 + 2x20 -> v2 5x50 -> v3 3x60 -> v4 5x50 -> v3 transit -> v1 */ - double[] profits = RouteFiller.getLostProfits(route, 0, v4, cargo, cargo); + double[] profits = RouteFiller.getLostProfits(route, 0, v4, cargo); assertArrayEquals(new double[]{750, 430, 180, 0, 750}, profits, 0.001); - profits = RouteFiller.getLostProfits(route, 0, v1, cargo, cargo); + profits = RouteFiller.getLostProfits(route, 0, v1, cargo); assertArrayEquals(new double[]{0, 680, 430, 250, 0}, profits, 0.001); - profits = RouteFiller.getLostProfits(route, 1, v2, cargo, cargo); + profits = RouteFiller.getLostProfits(route, 1, v2, cargo); assertArrayEquals(new double[]{320, 0, 750, 570, 320}, profits, 0.001); - profits = RouteFiller.getLostProfits(route, 2, v3, cargo, cargo); + profits = RouteFiller.getLostProfits(route, 2, v3, cargo); assertArrayEquals(new double[]{570, 250, 0, 820, 570}, profits, 0.001); - profits = RouteFiller.getLostProfits(route, 0, v3, cargo, cargo); + profits = RouteFiller.getLostProfits(route, 0, v3, cargo); assertArrayEquals(new double[]{570, 250, 0, 820, 570}, profits, 0.001); - profits = RouteFiller.getLostProfits(route, 0, v1, 2, cargo); + profits = RouteFiller.getLostProfits(route, 0, v1, 2); assertArrayEquals(new double[]{0, 0, 0, 0, 0}, profits, 0.001); } @@ -627,22 +628,22 @@ public class RouteFillerTest extends Assert { assertEquals(5, route.getLands()); /* v1 3x100 + 2x20 -> v2 5x50 -> v3 3x60 -> v4 5x20 -> v3 3x10 -> v1 */ - double[] profits = RouteFiller.getLostProfits(route, 0, v4, cargo, cargo); + double[] profits = RouteFiller.getLostProfits(route, 0, v4, cargo); assertArrayEquals(new double[]{750, 430, 180, 0, 780}, profits, 0.001); - profits = RouteFiller.getLostProfits(route, 0, v1, cargo, cargo); + profits = RouteFiller.getLostProfits(route, 0, v1, cargo); assertArrayEquals(new double[]{0, 560, 310, 130, 30}, profits, 0.001); - profits = RouteFiller.getLostProfits(route, 1, v2, cargo, cargo); + profits = RouteFiller.getLostProfits(route, 1, v2, cargo); assertArrayEquals(new double[]{320, 0, 630, 450, 350}, profits, 0.001); - profits = RouteFiller.getLostProfits(route, 2, v3, cargo, cargo); + profits = RouteFiller.getLostProfits(route, 2, v3, cargo); assertArrayEquals(new double[]{570, 250, 0, 100, 0}, profits, 0.001); - profits = RouteFiller.getLostProfits(route, 0, v3, cargo, cargo); + profits = RouteFiller.getLostProfits(route, 0, v3, cargo); assertArrayEquals(new double[]{570, 250, 0, 100, 0}, profits, 0.001); - profits = RouteFiller.getLostProfits(route, 0, v1, 2, cargo); + profits = RouteFiller.getLostProfits(route, 0, v1, 2); assertArrayEquals(new double[]{0, 0, 0, 0, 0}, profits, 0.001); } @@ -660,9 +661,13 @@ public class RouteFillerTest extends Assert { /* v1 3x100 + 2x20 -> v2 5x50 -> v3 3x60 -> v4 5x20 -> v3 3x10 -> v1 */ Offer offer = SimpleOffer.fakeBuy(v2, ITEM3, 210, 3); - int completeIndex = RouteFiller.addOrders(route, 1, offer, cargo); + Collection reserves = RouteFiller.getReserves(route, 1, offer); + assertEquals(2, reserves.size()); + int completeIndex = RouteReserve.getCompleteIndex(reserves, 1); assertEquals(1, completeIndex); + route.reserve(reserves); + Order order1 = new Order(v1.getSell(ITEM2), v2.getBuy(ITEM2), 3); Order order2 = new Order(v1.getSell(ITEM4), v2.getBuy(ITEM4), 1); Order order3 = new Order(v2.getSell(ITEM1), v3.getBuy(ITEM1), 5); @@ -680,7 +685,7 @@ public class RouteFillerTest extends Assert { order2 = new Order(v1.getSell(ITEM4), v2.getBuy(ITEM4), 2); - RouteFiller.removeOrders(route, offer); + route.unreserve(reserves); TestUtil.assertCollectionEquals(route.get(0).getOrders(), order1, order2); TestUtil.assertCollectionEquals(route.get(1).getOrders(), order3); TestUtil.assertCollectionEquals(route.get(2).getOrders(), order4);