widelands-dev team mailing list archive
-
widelands-dev team
-
Mailing list archive
-
Message #13742
[Merge] lp:~widelands-dev/widelands/congestion into lp:widelands
ypopezios has proposed merging lp:~widelands-dev/widelands/congestion into lp:widelands.
Commit message:
Repeat request for AppVeyor, after bot's failure.
Requested reviews:
ypopezios (ypopezios)
Related bugs:
Bug #1535115 in widelands: "ai roads getting jammed a lot"
https://bugs.launchpad.net/widelands/+bug/1535115
For more details, see:
https://code.launchpad.net/~widelands-dev/widelands/congestion/+merge/348422
--
Your team Widelands Developers is subscribed to branch lp:~widelands-dev/widelands/congestion.
=== modified file 'src/economy/flag.cc'
--- src/economy/flag.cc 2018-04-07 16:59:00 +0000
+++ src/economy/flag.cc 2018-06-22 18:00:26 +0000
@@ -312,6 +312,22 @@
}
/**
+ * Called by workers wanting to drop a ware to their building's flag.
+ * \return true/allow on low congestion-risk.
+*/
+bool Flag::has_capacity_for_ware(WareInstance& ware) const {
+ // avoid iteration for the easy cases
+ if (ware_filled_ < ware_capacity_ - 2) return true;
+ if (ware_filled_ >= ware_capacity_) return false;
+
+ DescriptionIndex const descr_index = ware.descr_index();
+ for (int i = 0; i < ware_filled_; ++i) {
+ if (wares_[i].ware->descr_index() == descr_index) return false;
+ }
+ return true;
+}
+
+/**
* Returns true if the flag can hold more wares.
*/
bool Flag::has_capacity() const {
@@ -339,10 +355,13 @@
}
void Flag::add_ware(EditorGameBase& egbase, WareInstance& ware) {
-
assert(ware_filled_ < ware_capacity_);
+ init_ware(egbase, ware, wares_[ware_filled_++]);
+ if (upcast(Game, game, &egbase))
+ ware.update(*game); // will call call_carrier() if necessary
+}
- PendingWare& pi = wares_[ware_filled_++];
+void Flag::init_ware(EditorGameBase& egbase, WareInstance& ware, PendingWare& pi) {
pi.ware = &ware;
pi.pending = false;
pi.nextstep = nullptr;
@@ -362,29 +381,22 @@
}
ware.set_location(egbase, this);
-
- if (upcast(Game, game, &egbase))
- ware.update(*game); // will call call_carrier() if necessary
}
/**
- * \return true if an ware is currently waiting for a carrier to the given Flag.
+ * \return a ware currently waiting for a carrier to the given destflag.
*
* \note Due to fetch_from_flag() semantics, this function makes no sense
* for a building destination.
*/
-bool Flag::has_pending_ware(Game&, Flag& dest) {
+Flag::PendingWare* Flag::has_pending_ware_for_flag(Flag& destflag) {
for (int32_t i = 0; i < ware_filled_; ++i) {
- if (!wares_[i].pending)
- continue;
-
- if (wares_[i].nextstep != &dest)
- continue;
-
- return true;
+ PendingWare* pw = &wares_[i];
+ if (pw->pending && pw->nextstep == &destflag &&
+ destflag.allow_ware_from_flag(*pw->ware, *this)) return pw;
}
- return false;
+ return nullptr;
}
/**
@@ -394,101 +406,112 @@
#define MAX_TRANSFER_PRIORITY 16
/**
- * Called by carrier code to indicate that the carrier is moving to pick up an
- * ware. Ware with highest transfer priority is chosen.
- * \return true if an ware is actually waiting for the carrier.
- */
-bool Flag::ack_pickup(Game&, Flag& destflag) {
- int32_t highest_pri = -1;
- int32_t i_pri = -1;
-
- for (int32_t i = 0; i < ware_filled_; ++i) {
- if (!wares_[i].pending)
- continue;
-
- if (wares_[i].nextstep != &destflag)
- continue;
-
- if (wares_[i].priority > highest_pri) {
- highest_pri = wares_[i].priority;
- i_pri = i;
-
- // Increase ware priority, it matters only if the ware has to wait.
- if (wares_[i].priority < MAX_TRANSFER_PRIORITY)
- wares_[i].priority++;
- }
- }
-
- if (i_pri >= 0) {
- wares_[i_pri].pending = false;
- return true;
- }
-
- return false;
-}
-/**
* Called by the carriercode when the carrier is called away from his job
* but has acknowledged a ware before. This ware is then freed again
* to be picked by another carrier. Returns true if an ware was indeed
* made pending again
*/
bool Flag::cancel_pickup(Game& game, Flag& destflag) {
- int32_t lowest_prio = MAX_TRANSFER_PRIORITY + 1;
- int32_t i_pri = -1;
-
for (int32_t i = 0; i < ware_filled_; ++i) {
- if (wares_[i].pending)
- continue;
-
- if (wares_[i].nextstep != &destflag)
- continue;
-
- if (wares_[i].priority < lowest_prio) {
- lowest_prio = wares_[i].priority;
- i_pri = i;
+ PendingWare& pw = wares_[i];
+ if (!pw.pending && pw.nextstep == &destflag) {
+ pw.pending = true;
+ pw.ware->update(game); // will call call_carrier() if necessary
+ return true;
}
}
- if (i_pri >= 0) {
- wares_[i_pri].pending = true;
- wares_[i_pri].ware->update(game); // will call call_carrier() if necessary
- return true;
- }
-
return false;
}
/**
- * Wake one sleeper from the capacity queue.
-*/
-void Flag::wake_up_capacity_queue(Game& game) {
- while (!capacity_wait_.empty()) {
- Worker* const w = capacity_wait_[0].get(game);
- capacity_wait_.erase(capacity_wait_.begin());
- if (w && w->wakeup_flag_capacity(game, *this))
- break;
- }
-}
-
-/**
- * Called by carrier code to retrieve one of the wares on the flag that is meant
- * for that carrier.
- *
- * This function may return 0 even if \ref ack_pickup() has already been
- * called successfully.
-*/
-WareInstance* Flag::fetch_pending_ware(Game& game, PlayerImmovable& dest) {
- int32_t best_index = -1;
-
- for (int32_t i = 0; i < ware_filled_; ++i) {
- if (wares_[i].nextstep != &dest)
- continue;
-
- // We prefer to retrieve wares that have already been acked
- if (best_index < 0 || !wares_[i].pending)
- best_index = i;
- }
-
+ * Called by carrier code to find the best among the wares on this flag
+ * that are meant for the provided dest.
+ * \return index of found ware or -1 if not found appropriate
+*/
+int32_t Flag::find_pending_ware(PlayerImmovable& dest) {
+ int32_t highest_pri = -1;
+ int32_t best_index = -1;
+ bool ware_pended = false;
+
+ for (int32_t i = 0; i < ware_filled_; ++i) {
+ PendingWare& pw = wares_[i];
+ if (pw.nextstep != &dest) continue;
+
+ if (pw.priority < MAX_TRANSFER_PRIORITY) pw.priority++;
+ // Release promised pickup, in case we find a preferable ware
+ if (!ware_pended && !pw.pending) {
+ ware_pended = pw.pending = true;
+ }
+
+ // If dest is flag, we exclude wares that can stress it
+ if (&dest != building_ &&
+ !dynamic_cast<Flag&>(dest).allow_ware_from_flag(*pw.ware, *this)) {
+ continue;
+ }
+
+ if (pw.priority > highest_pri) {
+ highest_pri = pw.priority;
+ best_index = i;
+ }
+ }
+
+ return best_index;
+}
+
+/**
+ * Like find_pending_ware above, but for carriers who are currently carrying a ware.
+ * \return -2 if denied drop
+*/
+int32_t Flag::find_swapable_ware(WareInstance& ware, Flag& destflag) {
+ DescriptionIndex const descr_index = ware.descr_index();
+ int32_t highest_pri = -1;
+ int32_t best_index = -1;
+ bool has_same_ware = false;
+ bool has_allowed = false;
+ bool ware_pended = false;
+
+ for (int32_t i = 0; i < ware_filled_; ++i) {
+ PendingWare& pw = wares_[i];
+ if (pw.nextstep != &destflag) {
+ if (pw.ware->descr_index() == descr_index) has_same_ware = true;
+ continue;
+ }
+
+ if (pw.priority < MAX_TRANSFER_PRIORITY) pw.priority++;
+ // Release promised pickup, in case we find a preferable ware
+ if (!ware_pended && !pw.pending) {
+ ware_pended = pw.pending = true;
+ }
+
+ // We prefer to retrieve wares that won't stress the destflag
+ if (destflag.allow_ware_from_flag(*pw.ware, *this)) {
+ if (!has_allowed) {
+ has_allowed = true;
+ highest_pri = -1;
+ }
+ } else {
+ if (has_allowed) continue;
+ }
+
+ if (pw.priority > highest_pri) {
+ highest_pri = pw.priority;
+ best_index = i;
+ }
+ }
+
+ if (best_index > -1) {
+ return (ware_filled_ > ware_capacity_ - 3 || has_allowed) ? best_index : -1;
+ } else {
+ return (ware_filled_ < ware_capacity_ - 2 ||
+ (ware_filled_ < ware_capacity_ && !has_same_ware)) ? -1 : -2;
+ }
+}
+
+/**
+ * Called by carrier code to retrieve a ware found by the previous methods.
+*/
+WareInstance* Flag::fetch_pending_ware(Game& game, int32_t best_index) {
if (best_index < 0)
return nullptr;
@@ -499,14 +522,39 @@
sizeof(wares_[0]) * (ware_filled_ - best_index));
ware->set_location(game, nullptr);
-
- // wake up capacity wait queue
- wake_up_capacity_queue(game);
-
return ware;
}
/**
+ * Called by carrier code to notify waiting carriers
+ * which may be interested in the new state of this flag.
+*/
+void Flag::ware_departing(Game& game) {
+ // Wake up one sleeper from the capacity queue.
+ while (!capacity_wait_.empty()) {
+ Worker* const w = capacity_wait_[0].get(game);
+ capacity_wait_.erase(capacity_wait_.begin());
+ if (w && w->wakeup_flag_capacity(game, *this)) return;
+ }
+
+ // Consider pending wares of neighboring flags.
+ for (int32_t dir = 1; dir <= 6; ++dir) {
+ Road* const road = get_road(dir);
+ if (!road) continue;
+
+ Flag* other = &road->get_flag(Road::FlagEnd);
+ if (other == this) {
+ other = &road->get_flag(Road::FlagStart);
+ }
+
+ PendingWare* pw = other->has_pending_ware_for_flag(*this);
+ if (pw && road->notify_ware(game, *other)) {
+ pw->pending = false;
+ }
+ }
+}
+
+/**
* Return a List of all the wares currently on this Flag. Do not rely
* the result value to stay valid and do not change them
*/
@@ -532,7 +580,7 @@
memmove(&wares_[i], &wares_[i + 1], sizeof(wares_[0]) * (ware_filled_ - i));
if (upcast(Game, game, &egbase))
- wake_up_capacity_queue(*game);
+ ware_departing(*game);
return;
}
@@ -600,27 +648,16 @@
for (int32_t dir = 1; dir <= 6; ++dir) {
Road* const road = get_road(dir);
- Flag* other;
- Road::FlagId flagid;
-
- if (!road) {
- continue;
- }
-
- if (&road->get_flag(Road::FlagStart) == this) {
- flagid = Road::FlagStart;
- other = &road->get_flag(Road::FlagEnd);
- } else {
- flagid = Road::FlagEnd;
+ if (!road) continue;
+
+ Flag* other = &road->get_flag(Road::FlagEnd);
+ if (other == this) {
other = &road->get_flag(Road::FlagStart);
}
-
- if (other != &nextflag) {
- continue;
- }
+ if (other != &nextflag) continue;
// Yes, this is the road we want; inform it
- if (road->notify_ware(game, flagid)) {
+ if (other->update_ware_from_flag(game, wares_[i], *road, *this)) {
return;
}
@@ -634,6 +671,70 @@
}
/**
+ * Called by neighboring flags, before agreeing for a carrier
+ * to take one of their wares heading to this flag.
+ * \return true/allow on low congestion-risk.
+*/
+bool Flag::allow_ware_from_flag(WareInstance& ware, Flag& flag) {
+ // avoid iteration for the easy cases
+ if (ware_filled_ < ware_capacity_ - 2) return true;
+
+ DescriptionIndex const descr_index = ware.descr_index();
+ bool has_swapable = false;
+ for (int i = 0; i < ware_filled_; ++i) {
+ PendingWare& pw = wares_[i];
+ if (pw.pending && pw.nextstep == &flag) {
+ has_swapable = true;
+ } else if (pw.ware->descr_index() == descr_index) {
+ return false;
+ }
+ }
+ return (ware_filled_ < ware_capacity_ || has_swapable) ? true : false;
+}
+
+/**
+ * Called when a ware is trying to reach this flag through the provided road,
+ * having just arrived to the provided flag.
+ * Swaps pending wares if possible. Otherwise,
+ * asks road for carrier on low congestion-risk.
+ * \return false if the ware is not immediately served.
+*/
+bool Flag::update_ware_from_flag(Game& game, PendingWare& pw1, Road& road, Flag& flag) {
+ WareInstance& w1 = *pw1.ware;
+ DescriptionIndex const w1_descr_index = w1.descr_index();
+ bool has_same_ware = false;
+ bool has_swapable = false;
+ for (int i = 0; i < ware_filled_; ++i) {
+ PendingWare& pw2 = wares_[i];
+ WareInstance& w2 = *pw2.ware;
+ if (w2.descr_index() == w1_descr_index) {
+ if (pw2.nextstep == &flag) {
+ // swap pending wares remotely
+ init_ware(game, w1, pw2);
+ flag.init_ware(game, w2, pw1);
+ w1.update(game);
+ w2.update(game);
+ return true;
+ }
+
+ has_same_ware = true;
+ } else if (pw2.pending && pw2.nextstep == &flag) {
+ has_swapable = true;
+ }
+ }
+
+ // ask road for carrier on low congestion-risk
+ if (ware_filled_ < ware_capacity_ - 2 ||
+ (!has_same_ware && (ware_filled_ < ware_capacity_ || has_swapable))) {
+ if (road.notify_ware(game, flag)) {
+ pw1.pending = false;
+ return true;
+ }
+ }
+ return false;
+}
+
+/**
* Called whenever a road gets broken or split.
* Make sure all wares on this flag are rerouted if necessary.
*
=== modified file 'src/economy/flag.h'
--- src/economy/flag.h 2018-04-07 16:59:00 +0000
+++ src/economy/flag.h 2018-06-22 18:00:26 +0000
@@ -116,7 +116,15 @@
bool is_dead_end() const;
+ struct PendingWare {
+ WareInstance* ware; ///< the ware itself
+ bool pending; ///< if the ware is pending
+ int32_t priority; ///< carrier prefers the ware with highest priority
+ OPtr<PlayerImmovable> nextstep; ///< next step that this ware is sent to
+ };
+
bool has_capacity() const;
+ bool has_capacity_for_ware(WareInstance&) const;
uint32_t total_capacity() {
return ware_capacity_;
}
@@ -126,10 +134,14 @@
void wait_for_capacity(Game&, Worker&);
void skip_wait_for_capacity(Game&, Worker&);
void add_ware(EditorGameBase&, WareInstance&);
- bool has_pending_ware(Game&, Flag& destflag);
- bool ack_pickup(Game&, Flag& destflag);
+ void init_ware(EditorGameBase&, WareInstance&, PendingWare&);
+ PendingWare* has_pending_ware_for_flag(Flag&);
bool cancel_pickup(Game&, Flag& destflag);
- WareInstance* fetch_pending_ware(Game&, PlayerImmovable& dest);
+ void ware_departing(Game&);
+ bool allow_ware_from_flag(WareInstance&, Flag&);
+ int32_t find_swapable_ware(WareInstance&, Flag&);
+ int32_t find_pending_ware(PlayerImmovable&);
+ WareInstance* fetch_pending_ware(Game&, int32_t);
Wares get_wares();
void call_carrier(Game&, WareInstance&, PlayerImmovable* nextstep);
@@ -151,20 +163,13 @@
float scale,
RenderTarget* dst) override;
- void wake_up_capacity_queue(Game&);
-
static void
flag_job_request_callback(Game&, Request&, DescriptionIndex, Worker*, PlayerImmovable&);
void set_flag_position(Coords coords);
private:
- struct PendingWare {
- WareInstance* ware; ///< the ware itself
- bool pending; ///< if the ware is pending
- int32_t priority; ///< carrier prefers the ware with highest priority
- OPtr<PlayerImmovable> nextstep; ///< next step that this ware is sent to
- };
+ bool update_ware_from_flag(Game&, PendingWare&, Road&, Flag&);
struct FlagJob {
Request* request;
=== modified file 'src/economy/road.cc'
--- src/economy/road.cc 2018-04-07 16:59:00 +0000
+++ src/economy/road.cc 2018-06-22 18:00:26 +0000
@@ -542,7 +542,8 @@
* Called by Flag code: an ware should be picked up from the given flag.
* \return true if a carrier has been sent on its way, false otherwise.
*/
-bool Road::notify_ware(Game& game, FlagId const flagid) {
+bool Road::notify_ware(Game& game, Flag& flag) {
+ FlagId flagid = &flag == flags_[Road::FlagEnd] ? Road::FlagEnd : Road::FlagStart;
uint32_t const gametime = game.get_gametime();
assert(busyness_last_update_ <= gametime);
uint32_t const tdelta = gametime - busyness_last_update_;
=== modified file 'src/economy/road.h'
--- src/economy/road.h 2018-04-07 16:59:00 +0000
+++ src/economy/road.h 2018-06-22 18:00:26 +0000
@@ -107,7 +107,7 @@
void presplit(Game&, Coords split);
void postsplit(Game&, Flag&);
- bool notify_ware(Game& game, FlagId flagid);
+ bool notify_ware(Game& game, Flag& flag);
void remove_worker(Worker&) override;
void assign_carrier(Carrier&, uint8_t);
=== modified file 'src/logic/map_objects/tribes/carrier.cc'
--- src/logic/map_objects/tribes/carrier.cc 2018-04-15 06:13:09 +0000
+++ src/logic/map_objects/tribes/carrier.cc 2018-06-22 18:00:26 +0000
@@ -43,6 +43,7 @@
static_cast<Bob::Ptr>(&Carrier::road_pop), true};
/**
+ * Called by road code when the carrier has arrived successfully.
* Work on the given road, assume the location is correct.
*/
void Carrier::start_task_road(Game& game) {
@@ -50,7 +51,7 @@
top_state().ivar1 = 0;
- promised_pickup_to_ = NOONE;
+ operation_ = INIT;
}
/**
@@ -77,14 +78,14 @@
return pop_task(game);
}
- // Check for pending wares
- if (promised_pickup_to_ == NOONE)
- find_pending_ware(game);
+ if (operation_ == INIT) {
+ operation_ = find_source_flag(game);
+ }
- if (promised_pickup_to_ != NOONE) {
+ if (operation_ > NOP) {
if (state.ivar1) {
state.ivar1 = 0;
- return start_task_transport(game, promised_pickup_to_);
+ return start_task_transport(game, operation_);
} else {
// Short delay before we move to pick up
state.ivar1 = 1;
@@ -114,10 +115,10 @@
* a ware there, we have to make sure that they do not count on us anymore.
*/
void Carrier::road_pop(Game& game, State& /* state */) {
- if (promised_pickup_to_ != NOONE && get_location(game)) {
+ if (operation_ > NOP && get_location(game)) {
Road& road = dynamic_cast<Road&>(*get_location(game));
- Flag& flag = road.get_flag(static_cast<Road::FlagId>(promised_pickup_to_));
- Flag& otherflag = road.get_flag(static_cast<Road::FlagId>(promised_pickup_to_ ^ 1));
+ Flag& flag = road.get_flag(static_cast<Road::FlagId>(operation_));
+ Flag& otherflag = road.get_flag(static_cast<Road::FlagId>(operation_ ^ 1));
flag.cancel_pickup(game, otherflag);
}
@@ -155,35 +156,85 @@
return pop_task(game);
}
- if (state.ivar1 == -1)
+ int32_t const ivar1 = state.ivar1;
+ if (ivar1 == -1)
// If we're "in" the target building, special code applies
- deliver_to_building(game, state);
-
- else if (!does_carry_ware())
- // If we don't carry something, walk to the flag
- pickup_from_flag(game, state);
-
- else {
- Road& road = dynamic_cast<Road&>(*get_location(game));
- // If the ware should go to the building attached to our flag, walk
- // directly into said building
- Flag& flag = road.get_flag(static_cast<Road::FlagId>(state.ivar1 ^ 1));
-
- WareInstance& ware = *get_carried_ware(game);
- assert(ware.get_location(game) == this);
-
+ return deliver_to_building(game, state);
+
+ WareInstance* ware = get_carried_ware(game);
+ if (ware) {
+ assert(ware->get_location(game) == this);
+ }
+
+ Road& road = dynamic_cast<Road&>(*get_location(game));
+ int32_t const dest = ware ? ivar1 ^ 1 : ivar1;
+ Flag& flag = road.get_flag(static_cast<Road::FlagId>(dest));
+
+ if (ware) {
+ // If the ware should go to the building attached to our flag,
+ // walk directly into said building
// A sanity check is necessary, in case the building has been destroyed
- PlayerImmovable* const next = ware.get_next_move_step(game);
-
- if (next && next != &flag && &next->base_flag() == &flag)
- enter_building(game, state);
-
- // If the flag is overloaded we are allowed to drop wares as
- // long as we can pick another up. Otherwise we have to wait.
- else if ((flag.has_capacity() || !swap_or_wait(game, state)) &&
- !start_task_walktoflag(game, state.ivar1 ^ 1))
- // Drop the ware, possible exchanging it with another one
- drop_ware(game, state);
+
+ PlayerImmovable* next = ware->get_next_move_step(game);
+ if (next && next != &flag && &next->base_flag() == &flag) {
+ if (!start_task_walktoflag(game, dest)) {
+ // Enter building
+ state.ivar1 = -1;
+ start_task_move(game, WALK_NW, descr().get_right_walk_anims(does_carry_ware()), true);
+ }
+ return;
+ }
+ }
+
+ if (!start_task_walktoflag(game, dest, operation_ == WAIT)) {
+ // If the flag is overloaded we are allowed to drop wares,
+ // as long as we can pick another up. Otherwise we have to wait.
+
+ Flag& otherflag = road.get_flag(static_cast<Road::FlagId>(dest ^ 1));
+ int32_t otherware_idx = ware ? flag.find_swapable_ware(*ware, otherflag) :
+ flag.find_pending_ware(otherflag);
+ if (operation_ == WAIT) {
+ if (otherware_idx < -1) {
+ return start_task_waitforcapacity(game, flag); // join flag's wait queue
+ } else {
+ operation_ = dest ^ 1; // resume transport without joining flag's wait queue
+ set_animation(game, descr().get_animation("idle"));
+ return schedule_act(game, 20);
+ }
+ } else if (otherware_idx < -1) {
+ operation_ = WAIT; // move one node away
+ set_animation(game, descr().get_animation("idle"));
+ return schedule_act(game, 20);
+ }
+
+ WareInstance* otherware = flag.fetch_pending_ware(game, otherware_idx);
+
+ if (ware) {
+ // Drop our ware
+ flag.add_ware(game, *fetch_carried_ware(game));
+ }
+
+ // Pick up new load, if any
+ if (otherware) {
+ set_carried_ware(game, otherware);
+ flag.ware_departing(game);
+
+ operation_ = state.ivar1 = dest;
+ set_animation(game, descr().get_animation("idle"));
+ schedule_act(game, 20);
+ } else {
+ Flag::PendingWare* pw = otherflag.has_pending_ware_for_flag(flag);
+ if (pw) {
+ pw->pending = false;
+
+ operation_ = state.ivar1 = dest ^ 1;
+ set_animation(game, descr().get_animation("idle"));
+ schedule_act(game, 20);
+ } else {
+ operation_ = NOP;
+ pop_task(game);
+ }
+ }
}
}
@@ -197,9 +248,10 @@
void Carrier::deliver_to_building(Game& game, State& state) {
BaseImmovable* const pos = game.map()[get_position()].get_immovable();
- if (dynamic_cast<Flag const*>(pos))
+ if (dynamic_cast<Flag const*>(pos)) {
+ operation_ = INIT;
return pop_task(game); // we are done
- else if (upcast(Building, building, pos)) {
+ } else if (upcast(Building, building, pos)) {
// Drop all wares addressed to this building
while (WareInstance* const ware = get_carried_ware(game)) {
// If the building has disappeared and immediately been replaced
@@ -230,201 +282,51 @@
}
/**
- * Walks to the queued flag and picks up one acked ware
- *
- * \param g Game the carrier lives on
- * \param s Flags sent to the task
- */
-void Carrier::pickup_from_flag(Game& game, State& state) {
- int32_t const ivar1 = state.ivar1;
- if (!start_task_walktoflag(game, ivar1)) {
-
- promised_pickup_to_ = NOONE;
-
- Road& road = dynamic_cast<Road&>(*get_location(game));
- Flag& flag = road.get_flag(static_cast<Road::FlagId>(ivar1));
- Flag& otherflag = road.get_flag(static_cast<Road::FlagId>(ivar1 ^ 1));
-
- // Are there wares to move between our flags?
- if (WareInstance* const ware = flag.fetch_pending_ware(game, otherflag)) {
- set_carried_ware(game, ware);
-
- set_animation(game, descr().get_animation("idle"));
- return schedule_act(game, 20);
- } else {
- molog("[Carrier]: Nothing suitable on flag.\n");
- return pop_task(game);
- }
- }
-}
-
-/**
- * Drop one ware in a flag, and pick up a new one if we acked it
- *
- * \param g Game the carrier lives on.
- * \param s Flags sent to the task
- */
-void Carrier::drop_ware(Game& game, State& state) {
- WareInstance* other = nullptr;
- Road& road = dynamic_cast<Road&>(*get_location(game));
- Flag& flag = road.get_flag(static_cast<Road::FlagId>(state.ivar1 ^ 1));
-
- if (promised_pickup_to_ == (state.ivar1 ^ 1)) {
- // If there's an ware we acked, we can drop ours even if the flag is
- // flooded
- other = flag.fetch_pending_ware(game, road.get_flag(static_cast<Road::FlagId>(state.ivar1)));
-
- if (!other && !flag.has_capacity()) {
- molog("[Carrier]: strange: acked ware from busy flag no longer "
- "present.\n");
-
- promised_pickup_to_ = NOONE;
- set_animation(game, descr().get_animation("idle"));
- return schedule_act(game, 20);
- }
-
- state.ivar1 = promised_pickup_to_;
- promised_pickup_to_ = NOONE;
- }
-
- // Drop our ware
- flag.add_ware(game, *fetch_carried_ware(game));
-
- // Pick up new load, if any
- if (other) {
- set_carried_ware(game, other);
-
- set_animation(game, descr().get_animation("idle"));
- return schedule_act(game, 20);
- } else
- return pop_task(game);
-}
-
-/**
- * When picking up wares, if some of them is targeted to the building attached
- * to target flag walk straight into it and deliver.
- *
- * \param g Game the carrier lives on.
- * \param s Flags sent to the task.
- */
-void Carrier::enter_building(Game& game, State& state) {
- if (!start_task_walktoflag(game, state.ivar1 ^ 1)) {
- state.ivar1 = -1;
- return start_task_move(game, WALK_NW, descr().get_right_walk_anims(does_carry_ware()), true);
- }
-}
-
-/**
- * Swaps wares from an overloaded flag for as long as the carrier can pick
- * up new wares from it. Otherwise, changes the carrier state to wait.
- *
- * \param g Game the carrier lives on.
- * \param s Flags sent to the task.
- *
- * \return true if the carrier must wait before delivering his wares.
- */
-bool Carrier::swap_or_wait(Game& game, State& state) {
- // Road that employs us
- Road& road = dynamic_cast<Road&>(*get_location(game));
- // Flag we are delivering to
- Flag& flag = road.get_flag(static_cast<Road::FlagId>(state.ivar1 ^ 1));
- // The other flag of our road
- Flag& otherflag = road.get_flag(static_cast<Road::FlagId>(state.ivar1));
-
- if (promised_pickup_to_ == (state.ivar1 ^ 1)) {
- // All is well, we already acked an ware that we can pick up
- // from this flag
- return false;
- } else if (flag.has_pending_ware(game, otherflag)) {
- if (!flag.ack_pickup(game, otherflag))
- throw wexception(
- "MO(%u): transport: overload exchange: flag %u is fucked up", serial(), flag.serial());
-
- promised_pickup_to_ = state.ivar1 ^ 1;
- return false;
- } else if (!start_task_walktoflag(game, state.ivar1 ^ 1, true))
- start_task_waitforcapacity(game, flag); // wait one node away
-
- return true;
-}
-
-/**
- * Called by Road code to indicate that a new ware has arrived on a flag
- * (0 = start, 1 = end).
+ * Called by road code to indicate that the given flag
+ * (0 = start, 1 = end) has a ware ready for transfer.
* \return true if the carrier is going to fetch it.
*/
bool Carrier::notify_ware(Game& game, int32_t const flag) {
State& state = top_state();
- // Check if we've already acked something
- if (promised_pickup_to_ != NOONE)
- return false;
-
- // If we are currently in a transport.
- // Explanation:
- // a) a different carrier / road may be better suited for this ware
- // (the transport code does not have priorities for the actual
- // carrier that is notified)
- // b) the transport task has logic that allows it to
- // drop an ware on an overloaded flag iff it can pick up an ware
- // at the same time.
- // We should ack said ware to avoid more confusion before we move
- // onto the flag, but we can't do that if we have already acked
- // something.
- // c) we might ack for a flag that we are actually moving away from;
- // this will get us into trouble if wares have arrived on the other
- // flag while we couldn't ack them.
- //
- // (Maybe the need for this lengthy explanation is proof that the
- // ack system needs to be reworked.)
- if (State const* const transport = get_state(taskTransport))
- if ((transport->ivar1 == -1 && find_closest_flag(game) != flag) || flag == transport->ivar1)
- return false;
-
- // Ack it if we haven't
- promised_pickup_to_ = flag;
-
- if (state.task == &taskRoad)
+ if (operation_ == WAIT) {
+ if (state.objvar1.get(game) ==
+ &dynamic_cast<Road&>(*get_location(game)).get_flag(static_cast<Road::FlagId>(flag))) {
+ operation_ = flag;
+ send_signal(game, "wakeup");
+ return true;
+ }
+ } else if (operation_ == NOP) {
+ operation_ = flag;
send_signal(game, "ware");
- else if (state.task == &taskWaitforcapacity)
- send_signal(game, "wakeup");
+ return true;
+ }
- return true;
+ return false;
}
/**
- * Find a pending ware on one of the road's flags, ack it and set promised_pickup_to_
- * accordingly.
+ * Find a pending ware meant for our road,
+ * remove its pending status, and
+ * \return the flag it is on.
*/
-void Carrier::find_pending_ware(Game& game) {
+int32_t Carrier::find_source_flag(Game& game) {
+ assert(operation_ == INIT);
+
Road& road = dynamic_cast<Road&>(*get_location(game));
- uint32_t havewarebits = 0;
-
- assert(promised_pickup_to_ == NOONE);
-
- if (road.get_flag(Road::FlagStart).has_pending_ware(game, road.get_flag(Road::FlagEnd))) {
- havewarebits |= 1;
- }
-
- if (road.get_flag(Road::FlagEnd).has_pending_ware(game, road.get_flag(Road::FlagStart))) {
- havewarebits |= 2;
- }
-
- // If both flags have an ware, we pick the one closer to us.
- if (havewarebits == 3) {
- havewarebits = 1 << find_closest_flag(game);
- }
-
- // Ack our decision
- if (havewarebits == 1) {
- promised_pickup_to_ = START_FLAG;
- if (!road.get_flag(Road::FlagStart).ack_pickup(game, road.get_flag(Road::FlagEnd)))
- throw wexception("Carrier::find_pending_ware: start flag is messed up");
-
- } else if (havewarebits == 2) {
- promised_pickup_to_ = END_FLAG;
- if (!road.get_flag(Road::FlagEnd).ack_pickup(game, road.get_flag(Road::FlagStart)))
- throw wexception("Carrier::find_pending_ware: end flag is messed up");
+ int32_t near = find_closest_flag(game);
+ Flag& nearflag = road.get_flag(static_cast<Road::FlagId>(near));
+ Flag& farflag = road.get_flag(static_cast<Road::FlagId>(near ^ 1));
+
+ Flag::PendingWare* pw;
+ if (pw = nearflag.has_pending_ware_for_flag(farflag)) {
+ pw->pending = false;
+ return near;
+ } else if (pw = farflag.has_pending_ware_for_flag(nearflag)) {
+ pw->pending = false;
+ return near ^ 1;
+ } else {
+ return NOP;
}
}
@@ -497,7 +399,7 @@
Worker::log_general_info(egbase);
- molog("promised_pickup_to = %i\n", promised_pickup_to_);
+ molog("operation_ = %i\n", operation_);
}
/*
@@ -521,7 +423,7 @@
uint8_t packet_version = fr.unsigned_8();
if (packet_version == kCurrentPacketVersion) {
Carrier& carrier = get<Carrier>();
- carrier.promised_pickup_to_ = fr.signed_32();
+ carrier.operation_ = fr.signed_32();
} else {
throw UnhandledVersionError("Carrier", packet_version, kCurrentPacketVersion);
}
@@ -546,7 +448,7 @@
Worker::do_save(egbase, mos, fw);
fw.unsigned_8(kCurrentPacketVersion);
- fw.signed_32(promised_pickup_to_);
+ fw.signed_32(operation_);
}
CarrierDescr::CarrierDescr(const std::string& init_descname,
=== modified file 'src/logic/map_objects/tribes/carrier.h'
--- src/logic/map_objects/tribes/carrier.h 2018-04-15 06:13:09 +0000
+++ src/logic/map_objects/tribes/carrier.h 2018-06-22 18:00:26 +0000
@@ -24,6 +24,7 @@
#include "logic/map_objects/tribes/worker.h"
namespace Widelands {
+class PendingWare;
class CarrierDescr : public WorkerDescr {
public:
@@ -49,7 +50,7 @@
MO_DESCR(CarrierDescr)
explicit Carrier(const CarrierDescr& carrier_descr)
- : Worker(carrier_descr), promised_pickup_to_(NOONE) {
+ : Worker(carrier_descr), operation_(NOP) {
}
~Carrier() override {
}
@@ -66,7 +67,7 @@
static Task const taskRoad;
private:
- void find_pending_ware(Game&);
+ int32_t find_source_flag(Game&);
int32_t find_closest_flag(Game&);
// internal task stuff
@@ -77,17 +78,14 @@
static Task const taskTransport;
void deliver_to_building(Game&, State&);
- void pickup_from_flag(Game&, State&);
- void drop_ware(Game&, State&);
- void enter_building(Game&, State&);
- bool swap_or_wait(Game&, State&);
- /// -1: no ware acked; 0/1: acked ware for start/end flag of road
// This should be an enum, but this clutters the code with too many casts
- static const int32_t NOONE = -1;
- static const int32_t START_FLAG = 0;
- static const int32_t END_FLAG = 1;
- int32_t promised_pickup_to_;
+ static const int32_t INIT = -3; // ready to undertake or resume operations
+ static const int32_t WAIT = -2; // waiting for flag capacity
+ static const int32_t NOP = -1; // idling
+ static const int32_t START_FLAG = 0; // serving start flag of road
+ static const int32_t END_FLAG = 1; // serving end flag of road
+ int32_t operation_;
// saving and loading
protected:
=== modified file 'src/logic/map_objects/tribes/worker.cc'
--- src/logic/map_objects/tribes/worker.cc 2018-05-05 17:10:37 +0000
+++ src/logic/map_objects/tribes/worker.cc 2018-06-22 18:00:26 +0000
@@ -1840,12 +1840,11 @@
if (upcast(Flag, flag, pos)) {
// Is this "our" flag?
if (flag->get_building() == location) {
- if (state.ivar1 && flag->has_capacity()) {
- if (WareInstance* const ware = fetch_carried_ware(game)) {
- flag->add_ware(game, *ware);
- set_animation(game, descr().get_animation("idle"));
- return schedule_act(game, 20); // rest a while
- }
+ WareInstance* const ware = get_carried_ware(game);
+ if (state.ivar1 && ware && flag->has_capacity_for_ware(*ware)) {
+ flag->add_ware(game, *fetch_carried_ware(game));
+ set_animation(game, descr().get_animation("idle"));
+ return schedule_act(game, 20); // rest a while
}
// Don't try to enter building if it is a dismantle site
@@ -2078,15 +2077,18 @@
if (ware) {
// We're in the building, walk onto the flag
if (upcast(Building, building, location)) {
- if (start_task_waitforcapacity(game, building->base_flag()))
- return;
-
- return start_task_leavebuilding(game, false); // exit throttle
+ Flag& baseflag = building->base_flag();
+ if (baseflag.has_capacity_for_ware(*ware)) {
+ start_task_leavebuilding(game, false); // exit throttle
+ } else {
+ start_task_waitforcapacity(game, baseflag);
+ }
+ return;
}
// We're on the flag, drop the ware and pause a little
if (upcast(Flag, flag, location)) {
- if (flag->has_capacity()) {
+ if (flag->has_capacity_for_ware(*ware)) {
flag->add_ware(game, *fetch_carried_ware(game));
set_animation(game, descr().get_animation("idle"));
@@ -2166,9 +2168,10 @@
// The ware has decided that it doesn't want to go to us after all
// In order to return to the warehouse, we're switching to State_DropOff
- if (WareInstance* const ware =
- dynamic_cast<Flag&>(*location).fetch_pending_ware(game, employer)) {
+ Flag& flag = dynamic_cast<Flag&>(*location);
+ if (WareInstance* const ware = flag.fetch_pending_ware(game, flag.find_pending_ware(employer))) {
set_carried_ware(game, ware);
+ flag.ware_departing(game);
}
set_animation(game, descr().get_animation("idle"));
@@ -2231,24 +2234,15 @@
static_cast<Bob::Ptr>(&Worker::waitforcapacity_pop), true};
/**
- * Checks the capacity of the flag.
- *
- * If there is none, a wait task is pushed, and the worker is added to the
- * flag's wait queue. The function returns true in this case.
- * If the flag still has capacity, the function returns false and doesn't
- * act at all.
+ * Pushes a wait task and
+ * adds the worker to the flag's wait queue.
*/
-bool Worker::start_task_waitforcapacity(Game& game, Flag& flag) {
- if (flag.has_capacity())
- return false;
-
+void Worker::start_task_waitforcapacity(Game& game, Flag& flag) {
push_task(game, taskWaitforcapacity);
top_state().objvar1 = &flag;
flag.wait_for_capacity(game, *this);
-
- return true;
}
void Worker::waitforcapacity_update(Game& game, State&) {
=== modified file 'src/logic/map_objects/tribes/worker.h'
--- src/logic/map_objects/tribes/worker.h 2018-04-07 16:59:00 +0000
+++ src/logic/map_objects/tribes/worker.h 2018-06-22 18:00:26 +0000
@@ -163,7 +163,7 @@
void start_task_releaserecruit(Game&, Worker&);
void start_task_fetchfromflag(Game&);
- bool start_task_waitforcapacity(Game&, Flag&);
+ void start_task_waitforcapacity(Game&, Flag&);
void start_task_leavebuilding(Game&, bool changelocation);
void start_task_fugitive(Game&);
