Complete.Org: Mailing Lists: Archives: freeciv-dev: September 2004:
[Freeciv-Dev] (PR#7282) Patch: connect as orders
Home

[Freeciv-Dev] (PR#7282) Patch: connect as orders

[Top] [All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index] [Thread Index]
To: jdorje@xxxxxxxxxxxxxxxxxxxxx
Subject: [Freeciv-Dev] (PR#7282) Patch: connect as orders
From: "Gregory Berkolaiko" <Gregory.Berkolaiko@xxxxxxxxxxxxx>
Date: Thu, 23 Sep 2004 22:43:53 -0700
Reply-to: rt@xxxxxxxxxxx

<URL: http://rt.freeciv.org/Ticket/Display.html?id=7282 >

> [glip - Thu Sep 23 02:46:23 2004]:
> 
> 
> On Wed, 22 Sep 2004, Jason Short wrote:
> 
> > > > * there is a little bug when you just hit ctrl-shift-r, it shows
0 for
> > > > the tile you are on, even though it's not 0.  If you move pointer to
> > > > another tile and then come back, it shows the correct value
> > > 
> > > not fixed
> > 
> > I'm not sure why this is happening.  I don't think it's a critical bug.
> 
> I might have a look

Fixed this bug (by brutally setting "time" in add_part).

Also removed some old cruft.

Jason, please check that comments / docs are understandable and I think
we can commit the thing.

Gr
? depcomp
? undep.sh
Index: ai/aiunit.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/ai/aiunit.c,v
retrieving revision 1.335
diff -u -r1.335 aiunit.c
--- ai/aiunit.c 13 Sep 2004 15:54:49 -0000      1.335
+++ ai/aiunit.c 24 Sep 2004 05:42:27 -0000
@@ -196,7 +196,7 @@
 
   result =
       test_unit_move_to_tile(punit->type, unit_owner(punit),
-                             ACTIVITY_IDLE, FALSE, punit->x, punit->y, 
+                             ACTIVITY_IDLE, punit->x, punit->y, 
                              dest_x, dest_y, unit_flag(punit, F_IGZOC));
   if (result == MR_OK) {
     return 1;
Index: client/control.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/control.c,v
retrieving revision 1.140
diff -u -r1.140 control.c
--- client/control.c    16 Sep 2004 07:48:29 -0000      1.140
+++ client/control.c    24 Sep 2004 05:42:27 -0000
@@ -620,6 +620,41 @@
 }
 
 /**************************************************************************
+  Return whether the unit can connect with given activity (or with
+  any activity if activity arg is set to ACTIVITY_IDLE)
+
+  This function is client-specific.
+**************************************************************************/
+bool can_unit_do_connect (struct unit *punit, enum unit_activity activity) 
+{
+  struct player *pplayer = unit_owner(punit);
+  Terrain_type_id terrain = map_get_terrain(punit->x, punit->y);
+  struct tile_type *ttype = get_tile_type(terrain);
+
+  if (!can_unit_do_activity(punit, activity)) {
+    return FALSE;
+  }
+
+  switch (activity) {
+  case ACTIVITY_ROAD:
+    return TRUE;
+  case ACTIVITY_RAILROAD:
+    if (!player_knows_techs_with_flag(pplayer, TF_RAILROAD)) {
+      return FALSE;
+    }
+    return TRUE;
+  case ACTIVITY_IRRIGATE:
+    if (ttype->irrigation_result != terrain) {
+      return FALSE;
+    }
+    return TRUE;
+  default:
+    break;
+  }
+  return FALSE;
+}
+
+/**************************************************************************
 prompt player for entering destination point for unit connect
 (e.g. connecting with roads)
 **************************************************************************/
@@ -633,6 +668,12 @@
     /* Enter or change the hover connect state. */
     set_hover_state(punit_focus, HOVER_CONNECT, activity);
     update_unit_info_label(punit_focus);
+
+    enter_goto_state(punit_focus);
+    create_line_at_mouse_pos();
+  } else {
+    assert(goto_is_active());
+    goto_add_waypoint();
   }
 }
 
@@ -1640,13 +1681,23 @@
 void do_unit_connect(struct unit *punit, int x, int y,
                     enum unit_activity activity)
 {
-  struct packet_unit_connect req;
+  if (is_air_unit(punit)) {
+    append_output_window(_("Game: Sorry, airunit connect "
+                          "not yet implemented."));
+  } else {
+    int dest_x, dest_y;
+
+    draw_line(x, y);
+    get_line_dest(&dest_x, &dest_y);
+    if (same_pos(dest_x, dest_y, x, y)) {
+      send_connect_route(punit, activity);
+    } else {
+      append_output_window(_("Game: Didn't find a route to "
+                            "the destination!"));
+    }
+  }
 
-  req.activity_type = activity;
-  req.unit_id = punit->id;
-  req.dest_x = x;
-  req.dest_y = y;
-  send_packet_unit_connect(&aconnection, &req);
+  set_hover_state(NULL, HOVER_NONE, ACTIVITY_LAST);
 }
  
 /**************************************************************************
Index: client/control.h
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/control.h,v
retrieving revision 1.43
diff -u -r1.43 control.h
--- client/control.h    17 May 2004 01:29:46 -0000      1.43
+++ client/control.h    24 Sep 2004 05:42:27 -0000
@@ -35,6 +35,8 @@
 extern bool draw_goto_line;
 extern bool non_ai_unit_focus;
 
+bool can_unit_do_connect(struct unit *punit, enum unit_activity activity);
+
 void do_move_unit(struct unit *punit, struct unit *target_unit);
 void do_unit_goto(int x, int y);
 void do_unit_nuke(struct unit *punit);
Index: client/goto.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/goto.c,v
retrieving revision 1.72
diff -u -r1.72 goto.c
--- client/goto.c       16 Sep 2004 07:48:29 -0000      1.72
+++ client/goto.c       24 Sep 2004 05:42:28 -0000
@@ -75,11 +75,15 @@
 static void decrement_drawn(int src_x, int src_y, enum direction8 dir);
 static void reset_last_part(void);
 
+static int get_activity_time(int map_x, int map_y, struct player *pplayer);
+
+
 /**************************************************************************
   Various stuff for the goto routes
 **************************************************************************/
 static bool is_active = FALSE;
 static bool is_init = FALSE;
+static int connect_initial;
 
 /********************************************************************** 
   Called once per game.
@@ -196,7 +200,21 @@
   p->end_x = x;
   p->end_y = y;
   p->end_moves_left = pf_last_position(p->path)->moves_left;
-  p->time = pf_last_position(p->path)->turn;
+
+  if (hover_state == HOVER_CONNECT) {
+    int move_rate = goto_map.template.move_rate;
+    int moves = pf_last_position(p->path)->total_MC;
+
+    p->time = moves / move_rate;
+    if (connect_initial > 0) {
+      p->time += connect_initial;
+    }
+    freelog(PATH_LOG_LEVEL, "To (%d,%d) MC: %d, connect_initial: %d",
+            x, y, moves, connect_initial);
+
+  } else {
+    p->time = pf_last_position(p->path)->turn;
+  }
 
   /* Refresh tiles so turn information is shown. */
   refresh_tile_mapcanvas(old_x, old_y, FALSE);
@@ -233,6 +251,7 @@
                  goto_map.num_parts * sizeof(*goto_map.parts));
   p = &goto_map.parts[goto_map.num_parts - 1];
 
+  p->time = 0;
   if (goto_map.num_parts == 1) {
     /* first part */
     struct unit *punit = find_unit_by_id(goto_map.unit_id);
@@ -240,20 +259,22 @@
     p->start_x = punit->x;
     p->start_y = punit->y;
     p->start_moves_left = punit->moves_left;
+    if (hover_state == HOVER_CONNECT) {    
+      p->time = connect_initial;
+    }
   } else {
     struct part *prev = &goto_map.parts[goto_map.num_parts - 2];
 
     p->start_x = prev->end_x;
     p->start_y = prev->end_y;
     p->start_moves_left = prev->end_moves_left;
+    parameter.moves_left_initially = p->start_moves_left;
   }
   p->path = NULL;
   p->end_x = p->start_x;
   p->end_y = p->start_y;
-  p->time = 0;
   parameter.start_x = p->start_x;
   parameter.start_y = p->start_y;
-  parameter.moves_left_initially = p->start_moves_left;
   p->map = pf_create_map(&parameter);
 }
 
@@ -375,16 +396,287 @@
   return TB_NORMAL;
 }
 
+/****************************************************************************
+  Return the number of MP needed to do the connect activity at this
+  position.  A negative number means it's impossible.
+****************************************************************************/
+static int get_activity_time(int map_x, int map_y, struct player *pplayer)
+{
+  struct tile *ptile = map_get_tile(map_x, map_y);
+  struct tile_type *ttype = get_tile_type(ptile->terrain);
+  int activity_mc = 0;
+
+  assert(hover_state == HOVER_CONNECT);
+  assert(terrain_control.may_road);
+ 
+  switch (connect_activity) {
+  case ACTIVITY_IRRIGATE:
+    if (ttype->irrigation_time == 0) {
+      return -1;
+    }
+    if (map_has_special(map_x, map_y, S_MINE)) {
+      /* Don't overwrite mines. */
+      return -1;
+    }
+
+    if (tile_has_special(ptile, S_IRRIGATION)) {
+      break;
+    }
+
+    activity_mc = ttype->irrigation_time;
+    break;
+  case ACTIVITY_RAILROAD:
+  case ACTIVITY_ROAD:
+    if (ttype->road_time == 0
+        || (tile_has_special(ptile, S_RIVER)
+            && !player_knows_techs_with_flag(pplayer, TF_BRIDGE))) {
+      /* 0 means road is impossible here (??) */
+      return -1;
+    }
+    if (!tile_has_special(ptile, S_ROAD)) {
+      activity_mc += ttype->road_time;
+    }
+    if (connect_activity == ACTIVITY_ROAD 
+        || tile_has_special(ptile, S_RAILROAD)) {
+      break;
+    }
+    activity_mc += ttype->rail_time;
+    /* No break */
+    break;
+  default:
+    die("Invalid connect activity.");
+  }
+
+  return activity_mc;
+}
+
+/****************************************************************************
+  When building a road or a railroad, we don't want to go next to 
+  nonallied cities
+****************************************************************************/
+static bool is_non_allied_city_adjacent(struct player *pplayer, int x, int y)
+{
+  adjc_iterate(x, y, x1, y1) {
+    if (is_non_allied_city_tile(map_get_tile(x1, y1), pplayer)) {
+      return TRUE;
+    }
+  } adjc_iterate_end;
+  
+  return FALSE;
+}
+
+/****************************************************************************
+  PF jumbo callback for the cost of a connect by road. 
+  In road-connect mode we are concerned with 
+  (1) the number of steps of the resulting path
+  (2) (the tie-breaker) time to build the path (travel plus activity time).
+  In rail-connect the priorities are reversed.
+
+  param->data should contain the result of get_settler_speed(punit) / 10.
+****************************************************************************/
+static int get_connect_road(int src_x, int src_y, enum direction8 dir,
+                           int dest_x, int dest_y, 
+                           int src_cost, int src_extra,
+                           int *dest_cost, int *dest_extra,
+                           struct pf_parameter *param)
+{
+  int activity_time, move_cost, moves_left;
+  int total_cost, total_extra;
+
+  if (map_get_known(dest_x, dest_y, param->owner) == TILE_UNKNOWN) {
+    return -1;
+  }
+
+  activity_time = get_activity_time(dest_x, dest_y, param->owner);  
+  if (activity_time < 0) {
+    return -1;
+  }
+
+  move_cost = param->get_MC(src_x, src_y, dir, dest_x, dest_y, param);
+  if (move_cost == PF_IMPOSSIBLE_MC) {
+    return -1;
+  }
+
+  if (is_non_allied_city_adjacent(param->owner, dest_x, dest_y)) {
+    /* We don't want to build roads to enemies plus get ZoC problems */
+    return -1;
+  }
+
+  /* Ok, the move is possible.  What are the costs? */
+
+  /* Extra cost here is the final length of the road */
+  total_extra = src_extra + 1;
+
+  /* Special cases: get_MC function doesn't know that we would have built
+   * a road (railroad) on src tile by that time */
+  if (map_has_special(dest_x, dest_y, S_ROAD)) {
+    move_cost = MOVE_COST_ROAD;
+  }
+  if (connect_activity == ACTIVITY_RAILROAD
+      && map_has_special(dest_x, dest_y, S_RAILROAD)) {
+    move_cost = MOVE_COST_RAIL;
+  }
+
+  move_cost = MIN(move_cost, param->move_rate);
+  total_cost = src_cost;
+  moves_left = param->move_rate - (src_cost % param->move_rate);
+  if (moves_left < move_cost) {
+    /* Emulating TM_WORST_TIME */
+    total_cost += moves_left;
+  }
+  total_cost += move_cost;
+
+  /* Now need to include the activity cost.  If we have moves left, they
+   * will count as a full turn towards the activity time */
+  moves_left = param->move_rate - (total_cost % param->move_rate);
+  if (activity_time > 0) {
+    int speed = *(int *)param->data;
+    
+    activity_time /= speed;
+    activity_time--;
+    total_cost += moves_left;
+  }
+  total_cost += activity_time * param->move_rate;
+
+  /* Now we determine if we have found a better path.  When building a road,
+   * we care most about the length of the result.  When building a rail, we 
+   * care most about the constructions time (assuming MOVE_COST_RAIL == 0) */
+
+  /* *dest_cost==-1 means we haven't reached dest until now */
+  if (*dest_cost != -1) {
+    if (connect_activity == ACTIVITY_ROAD) {
+      if (total_extra > *dest_extra 
+         || (total_extra == *dest_extra && total_cost >= *dest_cost)) {
+       /* No, this path is worse than what we already have */
+       return -1;
+      }
+    } else {
+      /* assert(connect_activity == ACTIVITY_RAILROAD) */
+      if (total_cost > *dest_cost 
+         || (total_cost == *dest_cost && total_cost >= *dest_cost)) {
+       return -1;
+      }
+    }
+  }
+
+  /* Ok, we found a better path! */  
+  *dest_cost = total_cost;
+  *dest_extra = total_extra;
+  
+  return (connect_activity == ACTIVITY_ROAD ? 
+         total_extra * PF_TURN_FACTOR + total_cost : 
+         total_cost * PF_TURN_FACTOR + total_extra);
+}
+
+/****************************************************************************
+  PF jumbo callback for the cost of a connect by irrigation. 
+  Here we are only interested in how long it will take to irrigate the path.
+
+  param->data should contain the result of get_settler_speed(punit) / 10.
+****************************************************************************/
+static int get_connect_irrig(int src_x, int src_y, enum direction8 dir,
+                             int dest_x, int dest_y, 
+                             int src_cost, int src_extra,
+                             int *dest_cost, int *dest_extra,
+                             struct pf_parameter *param)
+{
+  int activity_time, move_cost, moves_left, total_cost;
+
+  if (map_get_known(dest_x, dest_y, param->owner) == TILE_UNKNOWN) {
+    return -1;
+  }
+
+  activity_time = get_activity_time(dest_x, dest_y, param->owner);  
+  if (activity_time < 0) {
+    return -1;
+  }
+
+  if (!is_cardinal_dir(dir)) {
+    return -1;
+  }
+
+  move_cost = param->get_MC(src_x, src_y, dir, dest_x, dest_y, param);
+  if (move_cost == PF_IMPOSSIBLE_MC) {
+    return -1;
+  }
+
+  if (is_non_allied_city_adjacent(param->owner, dest_x, dest_y)) {
+    /* We don't want to build irrigation for enemies plus get ZoC problems */
+    return -1;
+  }
+
+  /* Ok, the move is possible.  What are the costs? */
+
+  move_cost = MIN(move_cost, param->move_rate);
+  total_cost = src_cost;
+  moves_left = param->move_rate - (src_cost % param->move_rate);
+  if (moves_left < move_cost) {
+    /* Emulating TM_WORST_TIME */
+    total_cost += moves_left;
+  }
+  total_cost += move_cost;
+
+  /* Now need to include the activity cost.  If we have moves left, they
+   * will count as a full turn towards the activity time */
+  moves_left = param->move_rate - (total_cost % param->move_rate);
+  if (activity_time > 0) {
+    int speed = *(int *)param->data;
+    
+    activity_time /= speed;
+    activity_time--;
+    total_cost += moves_left;
+  }
+  total_cost += activity_time * param->move_rate;
+
+  /* *dest_cost==-1 means we haven't reached dest until now */
+  if (*dest_cost != -1 && total_cost > *dest_cost) {
+      return -1;
+  }
+
+  /* Ok, we found a better path! */  
+  *dest_cost = total_cost;
+  *dest_extra = 0;
+  
+  return total_cost;
+}
+
 /********************************************************************** 
   Fill the PF parameter with the correct client-goto values.
 ***********************************************************************/
 static void fill_client_goto_parameter(struct unit *punit,
                                       struct pf_parameter *parameter)
 {
+  static int speed;
+
   pft_fill_unit_parameter(parameter, punit);
   assert(parameter->get_EC == NULL);
   parameter->get_EC = get_EC;
   assert(parameter->get_TB == NULL);
+  assert(parameter->get_MC != NULL);
+  if (hover_state == HOVER_CONNECT) {
+    if (connect_activity == ACTIVITY_IRRIGATE) {
+      parameter->get_costs = get_connect_irrig;
+    } else {
+      parameter->get_costs = get_connect_road;
+    }
+    parameter->is_pos_dangerous = NULL;
+
+    /* 10 is a factor used in activity times for some reason */
+    speed = get_settler_speed(punit) / 10;
+    parameter->data = &speed;
+
+    /* Take into account the activity time at the origin */
+    connect_initial = get_activity_time(punit->x, punit->y, 
+                                        unit_owner(punit)) / speed;
+    assert(connect_initial >= 0);
+    if (connect_initial > 0) {
+      parameter->moves_left_initially = 0;
+      if (punit->moves_left == 0) {
+       connect_initial++;
+      }
+    } /* otherwise moves_left_initially = punit->moves_left (default) */
+  }
+
   if (is_attack_unit(punit) || is_diplomat_unit(punit)) {
     parameter->get_TB = get_TB_aggr;
   } else if (unit_flag(punit, F_TRADE_ROUTE)
@@ -393,15 +685,16 @@
   } else {
     parameter->get_TB = no_fights_or_unknown;
   }
+
+  /* Note that in connect mode the "time" does not correspond to any actual
+   * move rate. */
   parameter->turn_mode = TM_WORST_TIME;
+
   parameter->start_x = punit->x;
   parameter->start_y = punit->y;
 
   /* Omniscience is always FALSE in the client */
   parameter->omniscience = FALSE;
-
-  /* May be overwritten by the caller. */
-  parameter->moves_left_initially = punit->moves_left;
 }
 
 /********************************************************************** 
@@ -552,6 +845,7 @@
       p.activity[i] = ACTIVITY_LAST;
       freelog(PACKET_LOG_LEVEL, "  packet[%d] = move %s: %d,%d => %d,%d",
              i, dir_get_name(p.dir[i]), old_x, old_y, new_x, new_y);
+      p.activity[i] = ACTIVITY_LAST;
     }
     old_x = new_x;
     old_y = new_y;
@@ -618,6 +912,87 @@
 }
 
 /**************************************************************************
+  Send the current connect route (i.e., the one generated via HOVER_STATE)
+  to the server.
+**************************************************************************/
+void send_connect_route(struct unit *punit, enum unit_activity activity)
+{
+  struct pf_path *path = NULL;
+  int i;
+  struct packet_unit_orders p;
+  int old_x, old_y;
+
+  assert(is_active);
+  assert(punit->id == goto_map.unit_id);
+
+  memset(&p, 0, sizeof(p));
+
+  for (i = 0; i < goto_map.num_parts; i++) {
+    path = pft_concat(path, goto_map.parts[i].path);
+  }
+
+  p.unit_id = punit->id;
+  p.repeat = FALSE;
+  p.vigilant = FALSE; /* Should be TRUE? */
+
+  p.length = 0;
+  old_x = path->positions[0].x;
+  old_y = path->positions[0].y;
+
+  for (i = 0; i < path->length; i++) {
+    switch (activity) {
+    case ACTIVITY_IRRIGATE:
+      if (!map_has_special(old_x, old_y, S_IRRIGATION)) {
+       /* Assume the unit can irrigate or we wouldn't be here. */
+       p.orders[p.length] = ORDER_ACTIVITY;
+       p.activity[p.length] = ACTIVITY_IRRIGATE;
+       p.length++;
+      }
+      break;
+    case ACTIVITY_ROAD:
+    case ACTIVITY_RAILROAD:
+      if (!map_has_special(old_x, old_y, S_ROAD)) {
+       /* Assume the unit can build the road or we wouldn't be here. */
+       p.orders[p.length] = ORDER_ACTIVITY;
+       p.activity[p.length] = ACTIVITY_ROAD;
+       p.length++;
+      }
+      if (activity == ACTIVITY_RAILROAD) {
+       if (!map_has_special(old_x, old_y, S_RAILROAD)) {
+         /* Assume the unit can build the rail or we wouldn't be here. */
+         p.orders[p.length] = ORDER_ACTIVITY;
+         p.activity[p.length] = ACTIVITY_RAILROAD;
+         p.length++;
+       }
+      }
+      break;
+    default:
+      die("Invalid connect activity.");
+      break;
+    }
+
+    if (i != path->length - 1) {
+      int new_x = path->positions[i + 1].x;
+      int new_y = path->positions[i + 1].y;
+
+      assert(!same_pos(new_x, new_y, old_x, old_y));
+
+      p.orders[p.length] = ORDER_MOVE;
+      p.dir[p.length] = get_direction_for_step(old_x, old_y, new_x, new_y);
+      p.length++;
+
+      old_x = new_x;
+      old_y = new_y;
+    }
+  }
+
+  p.dest_x = old_x;
+  p.dest_y = old_y;
+
+  send_packet_unit_orders(&aconnection, &p);
+}
+
+/**************************************************************************
   Send the current goto route (i.e., the one generated via
   HOVER_STATE) to the server.  The route might involve more than one
   part if waypoints were used.  FIXME: danger paths are not supported.
Index: client/goto.h
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/goto.h,v
retrieving revision 1.14
diff -u -r1.14 goto.h
--- client/goto.h       16 Sep 2004 07:48:29 -0000      1.14
+++ client/goto.h       24 Sep 2004 05:42:28 -0000
@@ -37,6 +37,7 @@
                    enum unit_activity final_activity);
 void send_patrol_route(struct unit *punit);
 void send_goto_route(struct unit *punit);
+void send_connect_route(struct unit *punit, enum unit_activity activity);
 
 struct pf_path *path_to_nearest_allied_city(struct unit *punit);
 
Index: client/mapctrl_common.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/mapctrl_common.c,v
retrieving revision 1.39
diff -u -r1.39 mapctrl_common.c
--- client/mapctrl_common.c     2 Aug 2004 16:59:14 -0000       1.39
+++ client/mapctrl_common.c     24 Sep 2004 05:42:28 -0000
@@ -625,7 +625,9 @@
 **************************************************************************/
 void update_line(int canvas_x, int canvas_y)
 {
-  if ((hover_state == HOVER_GOTO || hover_state == HOVER_PATROL)
+  if ((hover_state == HOVER_GOTO
+       || hover_state == HOVER_PATROL
+       || hover_state == HOVER_CONNECT)
       && draw_goto_line) {
     int x, y, old_x, old_y;
 
@@ -645,7 +647,9 @@
 ****************************************************************************/
 void overview_update_line(int overview_x, int overview_y)
 {
-  if ((hover_state == HOVER_GOTO || hover_state == HOVER_PATROL)
+  if ((hover_state == HOVER_GOTO
+       || hover_state == HOVER_PATROL
+       || hover_state == HOVER_CONNECT)
       && draw_goto_line) {
     int x, y, old_x, old_y;
 
Index: client/packhand.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/packhand.c,v
retrieving revision 1.403
diff -u -r1.403 packhand.c
--- client/packhand.c   21 Sep 2004 05:00:50 -0000      1.403
+++ client/packhand.c   24 Sep 2004 05:42:28 -0000
@@ -105,7 +105,6 @@
   }
   punit->activity_target = packet->activity_target;
   punit->paradropped = packet->paradropped;
-  punit->connecting = packet->connecting;
   punit->done_moving = packet->done_moving;
   punit->occupy = packet->occupy;
   if (packet->transported) {
@@ -1184,7 +1183,6 @@
       clear_goto_dest(punit);
     }
     punit->paradropped = packet_unit->paradropped;
-    punit->connecting = packet_unit->connecting;
     if (punit->done_moving != packet_unit->done_moving) {
       punit->done_moving = packet_unit->done_moving;
       check_focus = TRUE;
Index: client/tilespec.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/client/tilespec.c,v
retrieving revision 1.200
diff -u -r1.200 tilespec.c
--- client/tilespec.c   17 Sep 2004 22:18:11 -0000      1.200
+++ client/tilespec.c   24 Sep 2004 05:42:29 -0000
@@ -2030,13 +2030,11 @@
     }
   }
 
-  if (punit->connecting) {
-    ADD_SPRITE_FULL(sprites.unit.connect);
-  }
-
   if (unit_has_orders(punit)) {
     if (punit->orders.repeat) {
       ADD_SPRITE_FULL(sprites.unit.patrol);
+    } else if (punit->activity != ACTIVITY_IDLE) {
+      ADD_SPRITE_SIMPLE(sprites.unit.connect);
     } else {
       ADD_SPRITE_FULL(sprites.unit.go_to);
     }
Index: common/packets.def
===================================================================
RCS file: /home/freeciv/CVS/freeciv/common/packets.def,v
retrieving revision 1.52
diff -u -r1.52 packets.def
--- common/packets.def  21 Sep 2004 05:00:51 -0000      1.52
+++ common/packets.def  24 Sep 2004 05:42:29 -0000
@@ -729,13 +729,6 @@
   CITY city_id;
 end
 
-PACKET_UNIT_CONNECT=66;cs
-  UNIT unit_id;
-  ACTIVITY activity_type;
-  COORD dest_x;
-  COORD dest_y;
-end
-
 PACKET_UNIT_BRIBE_INQ=67;cs,handle-per-conn,dsend
   UNIT unit_id;
 end
Index: common/unit.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/common/unit.c,v
retrieving revision 1.217
diff -u -r1.217 unit.c
--- common/unit.c       13 Sep 2004 15:54:53 -0000      1.217
+++ common/unit.c       24 Sep 2004 05:42:29 -0000
@@ -559,31 +559,6 @@
 }
 
 /**************************************************************************
-Return whether the unit can connect with given activity (or with
-any activity if activity arg is set to ACTIVITY_IDLE)
-**************************************************************************/
-bool can_unit_do_connect (struct unit *punit, enum unit_activity activity) 
-{
-  struct player *pplayer = unit_owner(punit);
-
-  if (!unit_flag(punit, F_SETTLERS))
-    return FALSE;
-
-  if (activity == ACTIVITY_IDLE)   /* IDLE here means "any activity" */
-    return TRUE;
-
-  if (activity == ACTIVITY_ROAD 
-      || activity == ACTIVITY_IRRIGATE 
-      || (activity == ACTIVITY_RAILROAD
-         && player_knows_techs_with_flag(pplayer, TF_RAILROAD))
-      || (activity == ACTIVITY_FORTRESS 
-         && player_knows_techs_with_flag(pplayer, TF_FORTRESS)))
-  return TRUE;
-
-  return FALSE;
-}
-
-/**************************************************************************
   Return the name of the activity in a static buffer.
 **************************************************************************/
 const char *get_activity_text(enum unit_activity activity)
@@ -774,9 +749,6 @@
               (current == ACTIVITY_FORTIFIED) ? ACTIVITY_FORTIFYING : current;
   bool result;
 
-  if (punit->connecting)
-    return can_unit_do_connect(punit, current);
-
   punit->activity = ACTIVITY_IDLE;
   punit->activity_target = S_NO_SPECIAL;
 
@@ -1001,7 +973,6 @@
   punit->activity=new_activity;
   punit->activity_count=0;
   punit->activity_target = S_NO_SPECIAL;
-  punit->connecting = FALSE;
   if (new_activity == ACTIVITY_IDLE && punit->moves_left > 0) {
     /* No longer done. */
     punit->done_moving = FALSE;
@@ -1491,14 +1462,14 @@
                           bool igzoc)
 {
   return MR_OK == test_unit_move_to_tile(punit->type, unit_owner(punit),
-                                        punit->activity, punit->connecting,
+                                        punit->activity,
                                         punit->x, punit->y, dest_x, dest_y,
                                         igzoc);
 }
 
 /**************************************************************************
   unit can be moved if:
-  1) the unit is idle or on goto or connecting.
+  1) the unit is idle or on server goto.
   2) the target location is on the map
   3) the target location is next to the unit
   4) there are no non-allied units on the target tile
@@ -1513,9 +1484,9 @@
 enum unit_move_result test_unit_move_to_tile(Unit_Type_id type,
                                             struct player *unit_owner,
                                             enum unit_activity activity,
-                                            bool connecting, int src_x,
-                                            int src_y, int dest_x,
-                                            int dest_y, bool igzoc)
+                                            int src_x, int src_y,
+                                            int dest_x, int dest_y,
+                                            bool igzoc)
 {
   struct tile *pfromtile, *ptotile;
   bool zoc;
@@ -1523,8 +1494,7 @@
 
   /* 1) */
   if (activity != ACTIVITY_IDLE
-      && activity != ACTIVITY_GOTO
-      && !connecting) {
+      && activity != ACTIVITY_GOTO) {
     return MR_BAD_ACTIVITY;
   }
 
@@ -1733,7 +1703,6 @@
   punit->moves_left = unit_move_rate(punit);
   punit->moved = FALSE;
   punit->paradropped = FALSE;
-  punit->connecting = FALSE;
   punit->done_moving = FALSE;
   if (is_barbarian(pplayer)) {
     punit->fuel = BARBARIAN_LIFE;
Index: common/unit.h
===================================================================
RCS file: /home/freeciv/CVS/freeciv/common/unit.h,v
retrieving revision 1.124
diff -u -r1.124 unit.h
--- common/unit.h       13 Sep 2004 15:54:53 -0000      1.124
+++ common/unit.h       24 Sep 2004 05:42:30 -0000
@@ -156,7 +156,6 @@
   bool debug;
   bool moved;
   bool paradropped;
-  bool connecting;
 
   /* This value is set if the unit is done moving for this turn. This
    * information is used by the client.  The invariant is:
@@ -253,7 +252,6 @@
 bool can_unit_paradrop(struct unit *punit);
 bool can_unit_bombard(struct unit *punit);
 bool can_unit_change_homecity(struct unit *punit);
-bool can_unit_do_connect(struct unit *punit, enum unit_activity activity);
 const char *get_activity_text(enum unit_activity activity);
 bool can_unit_continue_current_activity(struct unit *punit);
 bool can_unit_do_activity(struct unit *punit, enum unit_activity activity);
@@ -331,9 +329,9 @@
 enum unit_move_result test_unit_move_to_tile(Unit_Type_id type,
                                             struct player *unit_owner,
                                             enum unit_activity activity,
-                                            bool connecting, int src_x,
-                                            int src_y, int dest_x,
-                                            int dest_y, bool igzoc);
+                                            int src_x, int src_y,
+                                            int dest_x, int dest_y,
+                                            bool igzoc);
 bool unit_type_really_ignores_zoc(Unit_Type_id type);
 bool zoc_ok_move(struct unit *punit, int x, int y);
 
Index: common/aicore/path_finding.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/common/aicore/path_finding.c,v
retrieving revision 1.21
diff -u -r1.21 path_finding.c
--- common/aicore/path_finding.c        6 Aug 2004 13:43:12 -0000       1.21
+++ common/aicore/path_finding.c        24 Sep 2004 05:42:30 -0000
@@ -106,7 +106,6 @@
   struct pf_node *lattice;      /* Lattice of nodes */
   utiny_t *status;             /* Array of node statuses 
                                 * (enum pf_node_status really) */
-  bool extras;                  /* Are any extra-cost callbacks supplied? */
   struct pqueue *danger_queue; /* Dangerous positions go there */
   struct danger_node *d_lattice;       /* Lattice with danger stuff */
 };
@@ -189,7 +188,7 @@
   Calculates cached values of the target node: 
   node_known_type and zoc
 ******************************************************************/
-static void init_node(struct pf_map *pf_map, struct pf_node * node, 
+static void init_node(struct pf_map *pf_map, struct pf_node *node, 
                          int x, int y)
 {
   struct pf_parameter *params = pf_map->params;
@@ -232,7 +231,6 @@
   }
 }
 
-
 /*****************************************************************
   Obtain cost-of-path from pure cost and extra cost
 *****************************************************************/
@@ -241,6 +239,72 @@
   return PF_TURN_FACTOR * cost + extra * pf_map->params->move_rate;
 }
 
+/**************************************************************************
+  Bare-bones PF iterator.  All Freeciv rules logic is hidden in get_costs
+  callback (compare to pf_next function).
+  Plan: 1. Process previous position
+        2. Get new nearest position and return it
+**************************************************************************/
+static bool jumbo_iterate_map(struct pf_map *pf_map)
+{
+  mapindex_t index;
+  struct pf_node *node = &pf_map->lattice[pf_map->index];
+
+  pf_map->status[pf_map->index] = NS_PROCESSED;
+
+  /* Processing Stage */
+  /* The previous position is contained in {x,y} fields of map */
+
+  adjc_dir_iterate(pf_map->x, pf_map->y, x1, y1, dir) {
+    mapindex_t index1 = map_pos_to_index(x1, y1);
+    struct pf_node *node1 = &pf_map->lattice[index1];
+    utiny_t *status = &pf_map->status[index1];
+    int priority;    
+
+
+    if (*status == NS_PROCESSED) {
+      /* This gives 15% speedup */
+      continue;
+    }
+
+    if (*status == NS_UNINIT) {
+      node1->cost = -1;
+    }
+
+    /* User-supplied callback get_costs takes care of everything (ZOC, 
+     * known, costs etc).  See explanations in path_finding.h */
+    priority = pf_map->params->get_costs(pf_map->x, pf_map->y, dir, x1, y1, 
+                                        node->cost, node->extra_cost,
+                                        &node1->cost, &node1->extra_cost, 
+                                        pf_map->params);
+    if (priority >= 0) {
+      /* We found a better route to xy1, record it 
+       * (the costs are recorded already) */
+      *status = NS_NEW;
+      node1->dir_to_here = dir;
+      pq_insert(pf_map->queue, index1, -priority);
+    }
+
+  } adjc_dir_iterate_end;
+
+  /* Get the next nearest node */
+  for (;;) {
+    bool removed = pq_remove(pf_map->queue, &index);
+
+    if (!removed) {
+      return FALSE;
+    }
+    if (pf_map->status[index] == NS_NEW) {
+      break;
+    }
+    /* If the node has already been processed, get the next one. */
+  }
+
+  pf_map->index = index;
+  index_to_map_pos(&(pf_map->x), &(pf_map->y), index);
+
+  return TRUE;
+}
 
 /*****************************************************************
   Primary method for iterative path-finding.
@@ -257,6 +321,11 @@
     return danger_iterate_map(pf_map);
   }
 
+  if (pf_map->params->get_costs) {
+    /* It is somewhat different when we have the jumbo callback */
+    return jumbo_iterate_map(pf_map);
+  }
+
   pf_map->status[pf_map->index] = NS_PROCESSED;
 
   /* There is no exit from DONT_LEAVE tiles! */
@@ -308,17 +377,10 @@
       cost += node->cost;
 
       /* Evaluate the extra cost if it's relevant */
-      if (pf_map->extras) {
+      if (pf_map->params->get_EC) {
         extra = node->extra_cost;
-        if (pf_map->params->get_EC) {
-          /* Add the cached value */
-          extra += node1->extra_tile;
-        }
-        if (pf_map->params->get_moveEC) {
-          /* This one cannot be cached */
-          extra += pf_map->params->get_moveEC(pf_map->x, pf_map->y, dir, 
-                                              x1, y1, pf_map->params);
-        }
+       /* Add the cached value */
+       extra += node1->extra_tile;
       }
 
       /* Update costs and add to queue, if we found a better route to xy1. */
@@ -336,8 +398,7 @@
        }
       }
 
-    }
-    adjc_dir_iterate_end;
+    } adjc_dir_iterate_end;
   }
 
   /* Get the next nearest node */
@@ -417,13 +478,9 @@
     pf_map->d_lattice[pf_map->index].step = 0;
   }
 
-  pf_map->extras = (parameter->get_EC != NULL 
-                    || parameter->get_moveEC != NULL);
-
   return pf_map;
 }
 
-
 /*********************************************************************
   After usage the map must be destroyed.
 *********************************************************************/
Index: common/aicore/path_finding.h
===================================================================
RCS file: /home/freeciv/CVS/freeciv/common/aicore/path_finding.h,v
retrieving revision 1.8
diff -u -r1.8 path_finding.h
--- common/aicore/path_finding.h        6 Aug 2004 13:43:12 -0000       1.8
+++ common/aicore/path_finding.h        24 Sep 2004 05:42:30 -0000
@@ -324,11 +324,6 @@
   int (*get_EC) (int x, int y, enum known_type known,
                 struct pf_parameter * param);
 
-  /* Same as above but this extra cost may depend on both origin and target
-   * tiles. Can be NULL. */
-  int (*get_moveEC) (int from_x, int from_y, enum direction8 dir,
-                     int to_x, int to_y, struct pf_parameter * param);
-
   /* Although the rules governing ZoC are universal, the amount of
    * information available at server and client is different. To 
    * compensate for it, we might need to supply our own version 
@@ -344,6 +339,32 @@
   bool (*is_pos_dangerous) (int x, int y, enum known_type,
                             struct pf_parameter * param);
 
+  /* This is a jumbo callback which overrides all previous ones.  It takes 
+   * care of everything (ZOC, known, costs etc).  
+   * Variables:
+   *   from_x, from_y        -- position of the source tile
+   *   from_cost, from_extra -- costs of the source tile
+   *   to_x, to_y            -- position of the dest tile
+   *   to_cost, to_extra     -- costs of the dest tile
+   *   dir                   -- direction from source to dest
+   *   param                 -- a pointer to this struct
+   * If the dest tile hasn't been reached before, to_cost is -1.
+   *
+   * The callback should:
+   * - evaluate the costs of the move
+   * - calculate the cost of the whole path
+   * - compare it to the ones recorded at dest tile
+   * - if new cost are not better, return -1
+   * - if new costs are better, record them in to_cost/to_extra and return
+   *   the cost-of-the-path which is the overall measure of goodness of the 
+   *   path (less is better) and used to order newly discovered locations. */
+  int (*get_costs) (int from_x, int from_y, 
+                   enum direction8 dir,
+                   int to_x, int to_y, 
+                   int from_cost, int from_extra,
+                   int *to_cost, int *to_extra,
+                   struct pf_parameter *param);
+
   /* User provided data. Can be used to attach arbitrary information
    * to the map. */
   void *data;
Index: common/aicore/pf_tools.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/common/aicore/pf_tools.c,v
retrieving revision 1.20
diff -u -r1.20 pf_tools.c
--- common/aicore/pf_tools.c    25 Aug 2004 18:24:20 -0000      1.20
+++ common/aicore/pf_tools.c    24 Sep 2004 05:42:30 -0000
@@ -544,7 +544,6 @@
   parameter->turn_mode = TM_CAPPED;
   parameter->get_TB = NULL;
   parameter->get_EC = NULL;
-  parameter->get_moveEC = NULL;
   parameter->is_pos_dangerous = NULL;
   parameter->get_zoc = NULL;
   BV_CLR_ALL(parameter->unit_flags);
Index: server/gotohand.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/server/gotohand.c,v
retrieving revision 1.184
diff -u -r1.184 gotohand.c
--- server/gotohand.c   13 Sep 2004 15:54:54 -0000      1.184
+++ server/gotohand.c   24 Sep 2004 05:42:31 -0000
@@ -1309,7 +1309,6 @@
   if (same_pos(punit->x, punit->y, dest_x, dest_y) ||
       !goto_is_sane(punit, dest_x, dest_y, FALSE)) {
     punit->activity = ACTIVITY_IDLE;
-    punit->connecting = FALSE;
     send_unit_info(NULL, punit);
     if (same_pos(punit->x, punit->y, dest_x, dest_y)) {
       return GR_ARRIVED;
@@ -1337,7 +1336,6 @@
              pplayer->name, unit_type(punit)->name,
              punit->x, punit->y, dest_x, dest_y);
       punit->activity = ACTIVITY_IDLE;
-      punit->connecting = FALSE;
       send_unit_info(NULL, punit);
       return GR_FAILED;
     }
@@ -1401,13 +1399,6 @@
        return GR_OUT_OF_MOVEPOINTS;
       }
 
-      /* single step connecting unit when it can do it's activity */
-      if (punit->connecting
-         && can_unit_do_activity(punit, punit->activity)) {
-       /* for connecting unit every step is a destination */
-       return GR_ARRIVED;
-      }
-
       freelog(LOG_DEBUG, "Moving on.");
     } while(!same_pos(x, y, waypoint_x, waypoint_y));
   } else {
@@ -1416,17 +1407,11 @@
            pplayer->name, unit_type(punit)->name,
            punit->x, punit->y, dest_x, dest_y);
     handle_unit_activity_request(punit, ACTIVITY_IDLE);
-    punit->connecting = FALSE;
     send_unit_info(NULL, punit);
     return GR_FAILED;
   }
   /** Finished moving the unit for this turn **/
 
-  /* ensure that the connecting unit will perform it's activity
-     on the destination file too. */
-  if (punit->connecting && can_unit_do_activity(punit, punit->activity))
-    return GR_ARRIVED;
-
   /* normally we would just do this unconditionally, but if we had an
      airplane goto we might not be finished even if the loop exited */
   if (same_pos(punit->x, punit->y, dest_x, dest_y)) {
@@ -1437,7 +1422,6 @@
     status = GR_OUT_OF_MOVEPOINTS;
   }
 
-  punit->connecting = FALSE;
   send_unit_info(NULL, punit);
   return status;
 }
Index: server/savegame.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/server/savegame.c,v
retrieving revision 1.194
diff -u -r1.194 savegame.c
--- server/savegame.c   23 Sep 2004 16:14:48 -0000      1.194
+++ server/savegame.c   24 Sep 2004 05:42:31 -0000
@@ -1289,9 +1289,6 @@
       = secfile_lookup_int_default(file, (int) S_NO_SPECIAL,
                                   "player%d.u%d.activity_target", plrno, i);
 
-    punit->connecting
-      = secfile_lookup_bool_default(file, FALSE,
-                                   "player%d.u%d.connecting", plrno, i);
     punit->done_moving = secfile_lookup_bool_default(file,
        (punit->moves_left == 0), "player%d.u%d.done_moving", plrno, i);
 
@@ -1360,7 +1357,7 @@
                        "player%d.u%d.activity_list", plrno, i);
        punit->has_orders = TRUE;
        for (j = 0; j < len; j++) {
-         if (orders_buf[j] == '\0' || dir_buf == '\0'
+         if (orders_buf[j] == '\0' || dir_buf[j] == '\0'
              || act_buf[j] == '\0') {
            freelog(LOG_ERROR, _("Savegame error: invalid unit orders."));
            free_unit_orders(punit);
@@ -2441,9 +2438,6 @@
     secfile_insert_int(file, punit->activity_target, 
                                "player%d.u%d.activity_target",
                                plrno, i);
-    secfile_insert_bool(file, punit->connecting, 
-                               "player%d.u%d.connecting",
-                               plrno, i);
     secfile_insert_bool(file, punit->done_moving,
                        "player%d.u%d.done_moving", plrno, i);
     secfile_insert_int(file, punit->moves_left, "player%d.u%d.moves",
Index: server/unithand.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/server/unithand.c,v
retrieving revision 1.305
diff -u -r1.305 unithand.c
--- server/unithand.c   13 Sep 2004 15:54:54 -0000      1.305
+++ server/unithand.c   24 Sep 2004 05:42:32 -0000
@@ -101,44 +101,6 @@
 }
 
 /**************************************************************************
-Handler for PACKET_UNIT_CONNECT request. The unit is send on way and will 
-build something (roads only for now) along the way, using server-side
-path-finding. 
-
-FIXME: This should be rewritten to use client-side path finding along so 
-that we can show in the client where the road-to-be-built will be and 
-enable the use of waypoints to alter this route. - Per
-**************************************************************************/
-void handle_unit_connect(struct player *pplayer, int unit_id,
-                        enum unit_activity activity_type, int dest_x,
-                        int dest_y)
-{
-  struct unit *punit = player_find_unit_by_id(pplayer, unit_id);
-
-  if (!is_normal_map_pos(dest_x, dest_y) || !punit
-      || !can_unit_do_connect(punit, activity_type)) {
-    return;
-  }
-
-  set_goto_dest(punit, dest_x, dest_y);
-
-  set_unit_activity(punit, activity_type);
-  punit->connecting = TRUE;
-
-  send_unit_info(NULL, punit);
-
-  /* 
-   * Avoid wasting first turn if unit cannot do the activity on the
-   * starting tile.
-   */
-  if (!can_unit_do_activity(punit, activity_type)) {
-    (void) do_unit_goto(punit,
-                       get_activity_move_restriction(activity_type),
-                       FALSE);
-  }
-}
-
-/**************************************************************************
  Upgrade all units of a given type.
 **************************************************************************/
 void handle_unit_type_upgrade(struct player *pplayer, Unit_Type_id type)
@@ -938,7 +900,7 @@
 
   reason =
       test_unit_move_to_tile(punit->type, unit_owner(punit),
-                            punit->activity, punit->connecting,
+                            punit->activity,
                             punit->x, punit->y, dest_x, dest_y, igzoc);
   if (reason == MR_OK)
     return TRUE;
@@ -1616,6 +1578,7 @@
     return;
   }
 
+
   for (i = 0; i < packet->length; i++) {
     switch (packet->orders[i]) {
     case ORDER_MOVE:
Index: server/unittools.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/server/unittools.c,v
retrieving revision 1.304
diff -u -r1.304 unittools.c
--- server/unittools.c  22 Sep 2004 07:17:57 -0000      1.304
+++ server/unittools.c  24 Sep 2004 05:42:32 -0000
@@ -595,20 +595,6 @@
 
   unit_restore_movepoints(pplayer, punit);
 
-  if (punit->connecting && !can_unit_do_activity(punit, activity)) {
-    punit->activity_count = 0;
-    if (do_unit_goto(punit, get_activity_move_restriction(activity), FALSE)
-       == GR_DIED) {
-      return;
-    }
-  }
-
-  /* if connecting, automagically build prerequisities first */
-  if (punit->connecting && activity == ACTIVITY_RAILROAD &&
-      !map_has_special(punit->x, punit->y, S_ROAD)) {
-    activity = ACTIVITY_ROAD;
-  }
-
   if (activity == ACTIVITY_EXPLORE) {
     bool more_to_explore = ai_manage_explorer(punit);
 
@@ -781,18 +767,8 @@
     update_tile_knowledge(punit->x, punit->y);
     unit_list_iterate (map_get_tile(punit->x, punit->y)->units, punit2) {
       if (punit2->activity == activity) {
-       bool alive = TRUE;
-       if (punit2->connecting) {
-         punit2->activity_count = 0;
-         alive = (do_unit_goto(punit2,
-                               get_activity_move_restriction(activity),
-                               FALSE) != GR_DIED);
-       } else {
-         set_unit_activity(punit2, ACTIVITY_IDLE);
-       }
-       if (alive) {
-         send_unit_info(NULL, punit2);
-       }
+       set_unit_activity(punit2, ACTIVITY_IDLE);
+       send_unit_info(NULL, punit2);
       }
     } unit_list_iterate_end;
   }
@@ -1835,7 +1811,6 @@
   }
   packet->activity_target = punit->activity_target;
   packet->paradropped = punit->paradropped;
-  packet->connecting = punit->connecting;
   packet->done_moving = punit->done_moving;
   if (punit->transported_by == -1) {
     packet->transported = FALSE;
@@ -2629,8 +2604,7 @@
   if (punit->activity != ACTIVITY_IDLE
       && punit->activity != ACTIVITY_SENTRY
       && punit->activity != ACTIVITY_EXPLORE
-      && punit->activity != ACTIVITY_GOTO
-      && !punit->connecting) {
+      && punit->activity != ACTIVITY_GOTO) {
     set_unit_activity(punit, ACTIVITY_IDLE);
   }
 }

[Prev in Thread] Current Thread [Next in Thread]