JP6392187B2 - Behavior control system, method and program thereof - Google Patents

Description

  The present invention relates to a technique for controlling actions of a plurality of control objects. For example, the present invention relates to a robot cooperative control technique for obtaining a behavior plan of each robot for moving a plurality of robots cooperatively from a formation formation state at a start position and forming formations at a target position.

  In recent years, research has been actively conducted to efficiently control a large number of autonomous mobile robots. Their missions vary, such as monitoring places where people can't enter, transporting goods, etc., but technology is being sought for efficient formation of platoons through the coordinated operation of many robots. (For example, refer nonpatent literature 1). In order to realize efficient formation of a formation by a large number of robots, it is important to plan the arrangement and operation order of each robot in advance. Various solutions have been proposed depending on differences in the shape of the robot assumed when solving such a problem and the condition of the connection state to be maintained (for example, Non-Patent Documents 2 and 3).

  For example, in the one shown in Non-Patent Document 1, an operation plan for platoon deformation is performed for a cube-shaped robot. Non-Patent Document 2 reports research on formation formation control for a hexagonal robot. In Non-Patent Document 3, research on formation control of a circular robot is reported.

Robert Fitch, Zack Butler, Daniel Rus, “Reconfiguration Planning for Heterogeneous Self-Reconfiguring Robots”, Proceedings of the 2003 IEEE Internatinoal Conference on Intelligent Robts and Systems, Las Vegas Nevada, 2003, pp. 2460-2467. Stanton Wong1 and Jennifer Walter, “Deterministic Distributed Algorithm for Self-Reconfiguration of Modular Robots from Arbitrary to Straight Chain Configurations”, Proceedings of the 2013 IEEE International Conference on Robotics and Automation, Karlsruhe, Germany, May 6-10, 2013, pp. 537-543. Michael Rubenstein, Alejandro Cornejo, Radhika Nagpal, “Programmable self-assembly in a thousand-robot swarm”, SCIENCE, August, 2014, Vol. 345, Issue 6198, pp.795-799.

  In conventional research, it is assumed that when a robot moves, it moves (wraps around) along the walls formed by other robots. For example, in order to realize an operation of moving around a cube-shaped robot, there is a problem that a mechanism that the robot should have becomes complicated.

  In view of such a current situation, in the present invention, when the control object moves, the control objects do not wrap around other control objects and move while maintaining the connected state. The formation control at any desired target position from the formation formation state at any starting position while maintaining the state where the controlled objects remain in contact without realizing a complex mechanism and realizing the formation control on the premise It is an object of the present invention to provide a controlled object cooperative formation technology that enables a deformation operation to be performed.

  In order to solve the above-described problem, according to one aspect of the present invention, the behavior control system sets p> q and sets p control objects arranged in a set of p start positions to q target objects. Action control for moving to a set of positions is performed. The action control system has a direction that is not parallel to the first direction as a second direction, a direction opposite to the first direction as a third direction, a direction opposite to the second direction as a fourth direction, Each start position and each target position are adjacent to other start positions and target positions in at least one of the first to fourth directions, and the set of target positions and the set of start positions are each a set of arbitrary Forming a shape, the control object is a first position adjacent in the first direction on the two-dimensional plane of the control object, a second position adjacent in the second direction, a third position adjacent in the third direction, And a fourth position that is adjacent in the fourth direction, and is controlled to move to any one of the first to fourth positions on the two-dimensional plane, and is in a certain position in the first direction. Through, parallel to the second direction In the case where the distance to the parallel axis is adjacent to the position included in the target position set, the distance from the parallel axis is increased in order from the position included in the target position set in order of the distance to the parallel axis. The intermediate transition process processing unit that obtains the position of the control object that forms the intermediate formation row by translating together, and the control object that forms the intermediate formation row from the position included in the set of target positions The order in which the position of the control object that forms the formation formation is reversed is opposite to the order in which the position of the control object that forms the intermediate formation formation is determined from the position included in the set of target positions in the reverse order. And a final development process processing unit that moves the control object in the direction of.

  In order to solve the above-described problem, according to another aspect of the present invention, the behavior control method sets p> q, and sets p control objects arranged in a set of p start positions to q control objects. Action control for moving to a set of target positions is performed. In the behavior control method, the direction that is not parallel to the first direction is the second direction, the direction opposite to the first direction is the third direction, the direction opposite to the second direction is the fourth direction, Each start position and each target position are adjacent to other start positions and target positions in at least one of the first to fourth directions, and the set of target positions and the set of start positions are each a set of arbitrary Forming a shape, the control object is a first position adjacent in the first direction on the two-dimensional plane of the control object, a second position adjacent in the second direction, a third position adjacent in the third direction, And it is assumed that the fourth position is adjacent in the fourth direction and is controlled to move to any one of the first to fourth positions on the two-dimensional plane, and the intermediate transition process processing unit is Pass through a position in the first direction When adjacent to a position included in the set of target positions, the distance from the parallel axis is small in order from the position included in the set of target positions toward the axis parallel to the second direction. The intermediate transition process processing step for obtaining the position of the control object forming the intermediate form train by translating together with the adjacent position, and the final development process processing unit for the control object forming the intermediate form formation In contrast, the control that forms the intermediate formations from the positions included in the set of target positions in the opposite order to the order in which the position of the control object forming the intermediate formations from the positions included in the set of target positions is obtained. And a final development process step of moving the control object in a direction opposite to the parallel movement direction when obtaining the position of the object.

In order to solve the above-described problem, according to another aspect of the present invention, the behavior control system sets p> q, and sets p control objects from a set of q start positions to q target positions. Perform action control to move to a set. The action control system has a direction that is not parallel to the first direction as a second direction, a direction opposite to the first direction as a third direction, a direction opposite to the second direction as a fourth direction, The direction that is not parallel to the plane formed by the first direction and the second direction is the fifth direction, the opposite direction to the fifth direction is the sixth direction, and each start position and each target position is the first direction, respectively. Direction to the sixth direction are adjacent to other start positions and target positions, the set of target positions and the set of start positions each form an arbitrary shape, and the control object is the control The first position adjacent in the first direction on the three-dimensional space of the object, the second position adjacent in the second direction, the third position adjacent in the third direction, the fourth position adjacent in the fourth direction, As the fifth position adjacent in the five directions It is assumed that the sixth position is adjacent in the sixth direction and is controlled to move to any one of the first to sixth positions on the three-dimensional space, and (1) in the first direction In order from the position included in the set of target positions, the coordinate value in the first direction is adjacent to the position included in the set of target positions that is small in order from the position included in the set of target positions so that the coordinate value is O ₁ or less. In this case, it is translated in the third direction together with the adjacent position, and (2) a position included in the set of target positions whose coordinate value in the first direction is not the coordinate value O ₁ is adjacent in the first direction. The coordinate value in the second direction is large so that there is a position included in the set of target positions to be translated in the first direction, and (3) the coordinate value in the second direction is less than or equal to O ₂ . In order from the position included in the set of target positions, Coordinate value in the direction is small, together with its adjacent position when adjacent to the position in the set of the target position is moved in parallel to the fourth direction, (4) coordinates the coordinate values in the second direction O the position in the set of non target position _2, so that the position in the set of target position adjacent in the second direction exists, by moving parallel to the second direction, control forming the extrusion end shape When determining the position of the control object that forms the end-of-extrusion shape from the position included in the set of target positions for the intermediate transition process processing unit that calculates the position of the object and the control object that forms the end-of-extrusion shape Final deployment process to move the control object in the opposite direction to the parallel movement direction when finding the position of the control object that forms the shape at the end of extrusion from the position included in the set of target positions in the reverse order place Including a science department.

In order to solve the above-mentioned problem, according to another aspect of the present invention, the behavior control method is configured such that p> q, and p control objects are set to q target positions from a set of q start positions. Perform action control to move to a set. In the behavior control method, the direction that is not parallel to the first direction is the second direction, the direction opposite to the first direction is the third direction, the direction opposite to the second direction is the fourth direction, The direction that is not parallel to the plane formed by the first direction and the second direction is the fifth direction, the opposite direction to the fifth direction is the sixth direction, and each start position and each target position is the first direction, respectively. Direction to the sixth direction are adjacent to other start positions and target positions, the set of target positions and the set of start positions each form an arbitrary shape, and the control object is the control The first position adjacent in the first direction on the three-dimensional space of the object, the second position adjacent in the second direction, the third position adjacent in the third direction, the fourth position adjacent in the fourth direction, 5th position adjacent in 5 directions, It is assumed that the sixth position is adjacent in the direction and is controlled to move to any one of the first to sixth positions on the three-dimensional space, and (1) a certain coordinate value in the first direction In the case where the coordinate value in the first direction is large and the position included in the set of target positions is adjacent to the position included in the set of target positions, the coordinate value in the first direction is small in order from the position included in the set of target positions so that O ₁ or less. Is translated in the third direction together with its adjacent positions, and (2) a position included in the set of target positions whose coordinate values in the first direction are not the coordinate value O ₁ is The target position has a large coordinate value in the second direction so that the position included in the set of positions exists, and (3) the coordinate value in the second direction is large so that it is less than or equal to a certain coordinate value O ₂ in the second direction. In order from the position included in the set Coordinate values in a small, together with its adjacent position when adjacent to the position in the set of the target position is moved in parallel to the fourth direction, (4) coordinates in the second direction coordinate value O ₂ Control target that forms a shape at the end of extrusion by translating a position included in a set of non-target positions in the second direction so that a position included in a set of adjacent target positions exists in the second direction The intermediate transition process processing step for determining the position of the object, and the order for determining the position of the control object that forms the end-of-extrusion shape from the position included in the set of target positions for the control object that forms the end-of-extrusion shape The final deployment process of moving the control object in the opposite direction to the parallel movement direction when determining the position of the control object that forms the shape at the end of extrusion from the position included in the set of target positions in the reverse order Processing steps.

  According to the present invention, even if the control object is not provided with a complicated mechanism, the formation at the arbitrary start position from the formation formation state at the arbitrary start position while maintaining the state where the control objects remain in contact with each other. There is an effect that the deformation operation can be performed to the formation state.

The figure for demonstrating the example of the movement of a robot. The figure for demonstrating the example of a start formation. The figure for demonstrating the movement of a robot. The figure for demonstrating the collection of start positions. FIG. 5A is a diagram for explaining the difference in the value of a according to which direction the mass unit filled with four robots is in contact with the mass unit to which the position Ps belongs in the set S of start positions. FIG. 5B is a diagram for explaining the difference in the value of a according to which direction the mass unit filled with four robots is in contact with the mass unit to which the position Ps belongs in the set S of start positions. FIG. 5C is a diagram for explaining the difference in the value of a according to which direction the mass unit filled with four robots is in contact with the mass unit to which the position Ps belongs in the set S of start positions. FIG. 5D is a diagram for explaining a difference in value of a according to which direction the mass unit filled with four robots is in contact with the mass unit to which the position Ps belongs in the set S of start positions. The figure for demonstrating the example transformed into a pushing formation from a starting formation. The figure for demonstrating the example of an extrusion formation. The figure for demonstrating the example of an intermediate form formation row. The figure for demonstrating the example transformed into a target formation from an intermediate form formation. The figure for demonstrating the example of a target formation. The figure for demonstrating the example of a horizontal extrusion position matching process. The figure for demonstrating the example which shows the position in the extrusion platoon row | line | column matched with a target position. The figure for demonstrating the example of void control. The figure for demonstrating the example of void control. The figure for demonstrating the example of void control. The figure for demonstrating the example transformed into a pushing formation from a starting formation. The figure for demonstrating the example of an extrusion formation. The figure for demonstrating the example of a vertical extrusion position matching process. The figure for demonstrating the example of intermediate form formation formation processing. The figure for demonstrating the example of intermediate form formation formation processing. The figure for demonstrating the example of intermediate form formation formation processing. The functional block diagram of the action control system which concerns on 1st embodiment. The figure which shows the example of the processing flow of the action control system which concerns on 1st embodiment. The figure which shows the example in case each lattice is a rhombus. The figure for demonstrating the example of the movement of a robot. The figure for demonstrating the movement of a robot. The figure for demonstrating the set of intermediate positions. The figure for demonstrating an upward direction extrusion process. The figure for demonstrating a flag extrusion process. The figure for demonstrating the last extrusion process. The figure for demonstrating Manhattan distance (delta). The figure for demonstrating the generation | occurrence | production position of a void. The figure for demonstrating the example of void control. The figure for demonstrating a final expansion | deployment process. The figure for demonstrating the movement of a robot. The figure for demonstrating Extend_Process_S. The figure for demonstrating the set of intermediate positions. The figure for demonstrating the deformation | transformation process from the shape 1 at the time of extrusion completion to the set M2 of an intermediate position. The figure for demonstrating the deformation | transformation process from the shape 1 at the time of extrusion completion to the set M2 of an intermediate position. The figure for demonstrating the deformation | transformation process from the shape 1 at the time of extrusion completion to the set M2 of an intermediate position. The figure for demonstrating Extend_Process_G. The figure for demonstrating Translate_from_M2_to_Mobile_G. The figure for demonstrating Make_Seed_M2. The figure for demonstrating the robot replacement | exchange process in the set M2 of an intermediate position.

  Hereinafter, embodiments of the present invention will be described. In the drawings used for the following description, constituent parts having the same function and steps for performing the same process are denoted by the same reference numerals, and redundant description is omitted.

<First embodiment>
First, the theoretical background of the behavior control system and method will be described. Hereinafter, a case where the control target that is the target of behavior control is a robot will be described as an example, but the control target may be other than the robot as long as it can be a target of control.

[Problem settings]
A number of robots cooperate to move from the formation state at the start position while maintaining the state in which each robot is in contact, and the task of forming the formation at the target position is as shown in FIG. Assuming the use of a square-shaped robot that can move by sliding the adjacent sides, as shown in FIG. 2, by moving a plurality of robots from a set S of start positions to a set G of target positions It is realized.

  For example, as shown in FIG. 1, the robot moves while maintaining the state in which another robot exists in one of the four squares around the robot. This method has an advantage that one robot itself can accurately measure the movement amount of one operation by moving the distance corresponding to the size of one robot. Also, by measuring the relative positions of adjacent robots that share one side, the position of each robot in the entire group of robots can be easily known. For this reason, it is difficult to cause a problem that the formation is collapsed due to an error in the movement amount of the robot. Further, as shown in FIG. 3, it is possible to move a plurality of robots at the same time as if a plurality of robots are connected. In FIG. 3, when transforming from platoon A to platoon B and when transforming from platoon D to platoon E, the two robots move simultaneously as if they were connected. It is assumed that the robot can know whether there is another robot at the next position and whether it is on the target position. For example, it is assumed that any robot can communicate with other robots existing in the mass around the robot, and at least one robot is equipped with GPS, or at least one robot does not move in one action control. In this case, each robot can easily know its absolute position by communicating with an adjacent robot with reference to a robot with GPS or a robot that has not moved. Alternatively, if the absolute position of at least one robot is known at the start position, it can be used to know the absolute position of each robot at each time without GPS.

  In this method, it is assumed that the order of movement of each robot is calculated in advance in the behavior control system before the movement of the robot starts, and each robot operates according to it.

  There are p robots (p is an integer of 2 or more, for example, p ≧ 50), and each robot shares one side or more with an adjacent robot (in other words, one side or more). It is possible to move in the XY-axis direction on the two-dimensional plane (in this example, the four directions up, down, left and right in the drawing). However, p robots form one group. There can be only one robot in each grid. Each robot is assumed to be stationary if there is another robot in the direction of movement. In FIG. 2, a grid in which R is written indicates a position where the robot exists. The area surrounded by the thick broken line indicates the start position set S, and the area surrounded by the bold solid line indicates the target position set G (hereinafter, this area is also referred to as “target platoon area G”). Indicates.

  Four robots adjacent to each other in the shape of a rice field are defined as one unit (hereinafter also referred to as “robot unit”). In other words, one robot unit is configured for every four robots, and the four robots that configure one robot robot are adjacent to other robots that configure one robot robot in two directions. This group of robot units shares one side for each robot unit in the set of start positions. Note that four squares corresponding to a robot unit formed by four robots are defined as one square unit (hereinafter also referred to as “mass unit”).

  Assume that the total number of target positions included in the set G of target positions is q, and the number p of robots is a more than the total number q of target positions. p = q + a. Note that p can also be said to be the total number of start positions included in the set S of start positions. The value of a varies depending on the shape of the set S of start positions. The shape of the set S of start positions consists of a core part formed by a series of robot units formed by four robots adjacent to each other in a square shape, and a fraction (1 to 3) that does not form a robot unit that touches the core part. ) Robots. The shape formed by the set G of target positions is not particularly limited as long as adjacent target positions are continuous in the vertical and horizontal directions. In other words, each target position is adjacent to another target position in at least one of the vertical and horizontal directions, and the formation at the target position of the robot is an arbitrary shape.

  It is assumed that the start position set S satisfies the following three conditions. (1) It is assumed that the part where the set S of start positions protrudes from the core part is included in the unit of mass adjacent to the core part (see FIG. 4). (2) It is assumed that the portion where the set S of start positions protrudes from the core portion does not become an L-shape that protrudes like a hook shape. (3) For each robot unit that becomes the core, the side of the robot unit that touches the protruding part shall be within one. (See FIG. 4).

[Robot coordinate settings]
The initial position (start position) of each robot i (i represents the robot number, i = 0,1,2,3, ..., p-1) is (Xr0 [i], Yr0 [i]) When the position is (Xre [j], Yre [j]) (j is the target position number, j = 0,1,2,3, ..., q-1, p = q + a) The problem can be defined as finding a behavior plan for the robot placed at the start position to move to the target position.

  The set S of the start positions (Xr0 [i], Yr0 [i]) and the set G of the target positions (Xre [j], Yre [j]) have one or more positions that are in contact, and the set S of the start positions The position having the smallest X coordinate among the positions on the side is defined as Ps (Xs, Ys) and the origin (0, 0) (see FIG. 2). All positions belonging to the set G of target positions have y-coordinate values larger than the position Ps, and the y-coordinate values of all robots belonging to the start position set S are values less than or equal to the y-coordinate value of the position Ps. Suppose that In addition, it is assumed that four robots are filled in the square unit to which the position Ps belongs.

  When the difference between the number p of robots belonging to the start position set S and the number q of robots belonging to the target position set G is a, the value of a is adjacent to the square unit to which the position Ps belongs in the start position set S. Depending on the number of mass units filled with four robots and their relative positional relationship. FIG. 5 illustrates the difference in the value of a according to which direction the mass unit filled with four robots is in contact with the mass unit to which the position Ps belongs in the set S of start positions. In FIG. 5, a broken line indicates the state of the remaining a robots after the movement of the target positions of q robots into the set G is completed. For example, in the case of FIG. 5A, four robots are filled in a square unit that only touches the square unit to which the position Ps belongs, and a = 8. After the movement of the target positions of the q robots into the set G, this occurs in the start position set S. Similarly, in the square unit to which the position Ps belongs, This is a case where there is a mass unit filled with the robot and the robot is not in contact with the other direction. In the case of FIG. 5B, in the set S of the start positions, a set G of target positions G of q robots when four robots are filled in a square unit that touches the square unit to which the position Ps belongs in the upward and left directions. It shows the state of the remaining a robots after moving inward, where a = 16. In the case of FIG. 5C, in the set S of start positions, a set G of target positions G of q robots when four robots are filled in a square unit that touches the square unit to which the position Ps belongs in the upward and rightward directions. It shows the state of the remaining a robots after moving inward, where a = 12. In the case of FIG. 5D, in the set S of start positions, a set G of target positions G of q robots in a case where four robots are filled in a square unit that touches the square unit to which the position Ps belongs in the upward and horizontal directions. It shows the state of the remaining a robots after moving inward, where a = 20. Here, the position of Ps is assumed to be at the lower left position in the square unit to which the position Ps belongs. When a robot exists in a square unit adjacent to the square unit to which the position Ps belongs, the set S of start positions is set so that four robots are always filled in the neighboring square unit. Further, among the square units adjacent to the square unit to which the position Ps belongs, at least one square unit includes a part of the set G of target positions, so that four robots are not filled.

[Definition of robot motion]
The action subject is each robot arranged in the room. The action “a” of the robot i takes any one of a total of five types, that is, stationary and movement of one lattice in the vertical and horizontal directions. For example, a [i] ∈ {0,1,2,3,4}
0: Still
1: Moves by one grid in the direction in which the X coordinate value increases on the two-dimensional plane (to the right in Fig. 2)
2: Move by one grid in the direction in which the Y coordinate value increases on the two-dimensional plane (downward in Fig. 2)
3: Move by one grid in the direction in which the X coordinate value decreases on the two-dimensional plane (leftward in Fig. 2)
4: Suppose that one grid moves in the direction in which the Y coordinate value decreases on the two-dimensional plane (upward in Fig. 2).

[Problems in search calculation]
The state space in such a mission environment has a state of the number of dimensions of the number of robots × 2, and the number of actions that can be selected exists by the number of robots that is the number of robot actions (= 5). For example, if the number of robots is 50 and the number of grids in the vertical and horizontal directions of the room is 20, the number of states becomes 20 to the 100th power, and the amount of resources required for the search calculation becomes enormous. Each time the number of robots increases by one, the number of states will increase 400 times.

  As explained in [Problem Setting], even if the constraint condition that robots are in contact with each other is incorporated, it is difficult to reduce the fundamental amount of calculation, which is a big problem when using multiple robots. .

  Specifically, for example, in the problem of guiding a large number of robots to a plurality of target positions, even though a route for reaching one position can be obtained by search calculation, it is possible to determine which target for each robot. The problem is whether to allocate the position. If this target position allocation is not successful, a robot that has reached the target position early will stay in a position that hinders the movement of the robot that comes later, making it difficult to form a robot platoon as a whole. End up. In order to avoid such a situation, considering how to allocate the target position to each robot by searching, there is a way to allocate to the target position by the factorial of the number of robots. The load on the robot increases dramatically with the number of robots.

  In addition, the search calculation when considering the search calculation for the robots to move while sharing one side with each other also takes into account the mutual movement of each robot. On the other hand, it increases exponentially.

[Introduction of three movement processes]
In the present embodiment, as one of the measures for solving these computational load problems, the process of robot operation is considered in three stages. The first is a robot extrusion process that pushes out the robots that form the group of target position sets G from the start position set S through position Ps and out of the start position set S, and the second is pushed out This is an intermediate transition process in which the robot group is transformed into an intermediate form for transitioning to the formation form of the set G of target positions. The third is a deployment operation from the intermediate form to the formation form of the set G of target positions. This is the final development process. Of these, search calculation by dynamic programming is performed only in the first step.

[Void control]
In this first robot extrusion process, the concept of void control is introduced in this embodiment. First, the term “void” as used herein refers to a gap that can be restored to the original position after a robot has moved to another position. In other words, a void is a virtual entity that moves in a direction opposite to the direction in which the robot moves. In such a group robot formation problem, the amount of search calculation explodes because it focuses on the movement of multiple robots, but if you change the viewpoint and focus on the movement of voids, the movement of many robots The planning problem can be considered as a single void motion plan, which is suitable for reducing the search calculation load.

  Here, let us consider the operation of a robot group at the position Ps among the robot group belonging to the set S of start positions, as a head robot. In the present embodiment, it is assumed that each robot goes out of the start position set S from the start position set S via the square unit to which the position Ps belongs. First, if the head robot comes out of the start position set S from the position Ps, one void is generated at the position Ps. Subsequently, the voids are sequentially buried in robots adjacent to the void position other than the head robot. By doing so, the void moves in the robot group. When the void reaches the position where the robot is located farthest from the position Ps (hereinafter also referred to as “tail robot position”), the robot at the position Ps is moved to the next new head robot. Should be set.

  Such a motion of the void can be calculated by a motion plan of one void with the position Ps of the head robot as the start position and the position of the tail robot as the goal position, and the calculation load is small. For example, a position where the robot is present (tail robot position) having the longest Manhattan distance from the position Ps may be calculated, and the void may be moved from the position Ps to the tail robot position along any path. As a constraint condition for the movement of the void to be considered in this calculation, it is only necessary to provide a restriction that the robot follows the position where the robot exists when the void moves.

[Robot extrusion process]
In this embodiment, two processes are prepared as the robot pushing process, and one of them is used. The first is a horizontal extrusion process, and the second is a vertical extrusion process.

[Horizontal extrusion process]
FIG. 2 and FIGS. 6 to 10 show the behavior of the robot when the lateral extrusion process is used as the robot extrusion process. The lateral extrusion process is shown in FIGS. In the lateral direction extrusion process, the robot is pushed out of the set S of starting positions by repeating the action of pushing a certain number of robots from the position Ps and the action of shifting the pushed robot by one square in the right direction (the positive direction of X). . The robot formation pushed out in this manner (hereinafter also referred to as “push formation”) can be easily transformed into a robot formation (hereinafter also referred to as “target formation”) located in the set G of target positions.

  First, each target position (Xre [j], Yre [j]) belonging to the set G of target positions is a platoon (extrusion platoon) taken by each robot at the time when extrusion from the set S of all robot start positions is completed. ) (Push-out position association processing) is performed for associating with a position in (). j is an index of the target position, and j = 0, 1, 2,..., q−1. The calculation process of the extrusion position association process is as follows. Here, a set of target positions that belong to the set G of target positions and whose y coordinate value is i_y is G_line (i_y). Also, the number in the extrusion column of the target position j is defined as jp [j]. Let the position in the extrusion row be (Xp [jp], Yp [jp]). jp = 0,1,2, ..., q-1.

<Horizontal extrusion position association processing>
(1) Assign each target position (Xre [j], Yre [j]) to G_line (i_y). For example, in the case of FIG. 2, G_line (1) = {(0,1)}, G_line (2) = {(0,2)}, G_line (3) = {(0,3)}, G_line (4) = {(-1,4), (0,4), (1,4), (8,4), (9,4), (10,4), (11,4)}, G_line ( 13) = {(-4,13), (-3,13), (3,13), (4,13),}.
(2) Set i_y ← 1. Counter variable cnt ← 0.
(3) If there is an element belonging to G_line (i_y), the value of jp [j] at the target position j with the smallest X coordinate is set to cnt (jp [j] ← cnt), and cnt is incremented (cnt ← cnt +1). Further, the value of the variable x_min [i_y] is set as the x coordinate value of the target position j (x_min [i_y] ← Xre [j]), and the process proceeds to (4). If there are no elements, go to (5). For example, in the case of FIG. 2, x_min [1] ← 0, x_min [2] ← 0, x_min [3] ← 0, x_min [4] ← -1,..., X_min [13] ← −4.

(4) If there is a position with the smallest X coordinate next to the target position j in G_line (i_y), it is set as the target position j. The value of jp [j] at the target position j is set to cnt, cnt is incremented, and (4) is repeated. If not, the value of the variable x_max [i_y] is set to the x coordinate value of the target position j (x_max [i_y] ← Xre [j]), i_y is incremented (i_y ← i_y + 1), and the process returns to (3). For example, in the case of FIG. 2, x_max [1] ← 0, x_max [2] ← 0, x_max [3] ← 0, x_max [4] ← 11,..., X_max [13] ← 4. By repeating (3) and (4), the value of jp [j] in the target position set G is as shown in FIG.
(5) Currently, record the i_y value in the variable y_max, and proceed to (6). For example, in the case of FIG. 2, y_max ← 14.
(6) Yp [jp [j]] ← Yre [j] for all values of j = 0 to q-1. By this processing, the y coordinate value Yp [jp [j]] of the position in the extrusion row is set as the y coordinate value Yre [j] of the target position j.

(7) Set the counter variable cnt ← 1.
(8) Set Xp [0] ← 0. If there is only one element in G_line (1), go to (10). If not, go to (9). Xp [0] is a square on the set G side of the target position adjacent to the position Ps (0,0) in the y direction, and Xp [0] ← 0 is defined by the definition of the position Ps. Note that the position Ps is a position where the set of start positions and the set of target positions are in contact with each other, the position on the set side of the start positions, and the position where the X coordinate is the smallest, and the origin (0, 0 ).
(9) Among the elements of G_line (1), when there is a target position with the X coordinate that is the cnt + 1st smallest X coordinate, this is set as the target position j, and Xp [jp [j]] ← cnt. Increment cnt and repeat (9). If not, go to (10).

(10) Set i_y ← 2. If i_y = y_max, the process ends. Otherwise, the process proceeds to (11).
(11) When the number of elements n [i_y] of G_line (i_y) is larger than the number of elements n [i_y-1] of G_line (i_y-1), the X coordinate is the first among the elements of G_line (i_y) Let Xp [jp [j]] ← Xp [jp [j] -n [i_y-1]], where the small target position is the target position j. This corresponds to the process of aligning the left edges. When the number of elements n [i_y] of G_line (i_y) is less than or equal to the number of elements n [i_y-1] of G_line (i_y-1), the target position with the smallest X coordinate among the elements of G_line (i_y) As a target position j, Xp [jp [j]] ← Xp [jp [j] -1]-(n [i_y] -1). This corresponds to the process of aligning the right edges.
(12) Among the elements of G_line (i_y), if there is a target position with the X coordinate next to the target position j, then Xp [jp [j]] ← Xp [jp [j ] -1] +1 and repeat (12). If not, proceed to (13).
(13) Increment i_y, and end if i_y = y_max. Otherwise, go to (11). By performing the processes (6) to (13), the value of jp [j] in the extrusion platoon of FIG. 7 becomes as shown in FIG.

  Through the value of jp [j], the position in the target row in FIG. 2 and the position in the push row in FIG. 7 are associated (see FIGS. 2 and 11). In other words, the target position (Xre [j], Yre [X] [Xp [jp], Yp [jp]) and the target position j's internal number jp [j] calculated as a result of this processing are used. j]) and the position in the extrusion row (Xp [jp [j]], Yp [jp [j]]) can be calculated (see FIGS. 2 and 11). The extrude formation first compresses the target formation positions with the same y coordinate so that there is no gap in the X direction, and then the target position number n [ If i_y is less than the number of target positions in the line made at the target position with y-coordinate value i_y-1, align its right edge position with the right edge of the line made at the target position with y-coordinate i_y-1, so Otherwise, the left end position is matched (corresponding to the above procedure (11)) to form the shape as shown in FIG. The extrusion row shown in FIG. 7 has a convenient shape for pushing out the robots one by one in the positive direction of Y from the position Ps.

Subsequently, the robot extrusion order is calculated. (Extrusion order calculation process). The kth target position number in the extrusion order is jk [k].
<Extruding order calculation process>
(1) Let Xp_max ← Xp [q-1] and Yp_max ← Yp [q-1] (see FIG. 11). Set cnt ← 1 and store j as jp [j] = q-1 in the value of jk [0] (see FIG. 12).
(2) Look for a jp_next value that satisfies Xp_max = Xp [jp_next] and Yp_max-1 = Yp [jp_next]. That is, it is determined whether or not the robot jp_next exists in the negative direction of Y of the robot located at the position (Xp_max, Yp_max) in the extrusion row.
If found, j in which jp [j] = jp_next is stored in jk [cnt] (jk [cnt] ← j). Xp_max ← Xp [jp_next] and Yp_max ← Yp [jp_next] are set, and cnt is incremented.
If not, the jp_next satisfying Xp_max-1 = Xp [jp_next] is selected with the largest Yp [jp_next] value, and j jp [j] = jp_next is stored in jk [cnt] (jk [cnt] cnt] ← j). Xp_max ← Xp [jp_next] and Yp_max ← Yp [jp_next] are set, and cnt is incremented.
(3) If cnt = q, repeat (2). If so, finish.

  The above processing means that the robots are sequentially pushed out from the robot heading to the target position corresponding to the position at the lower right in the push-out formation. That is, the robot that is first pushed out of the set S of start positions from the position Ps is the robot that goes to the target position jk [0], and the robot that is pushed out to the kth is the robot that goes to the target position jk [k]. It turns out that. FIG. 12 shows the positions in the extrusion row that are associated with the target positions indicated by the values of jk [k].

Hereinafter, a process of actually pushing out the robot from the position Ps will be described (push-out control process). A variable robot_target_index [i] is defined, and a target position number to which the robot i should go is stored.
<Extrusion control processing>
(1) Set k ← 0.
(2) The robot at position Ps is robot i, and robot_target_index [i] ← jk [k].
(3) If k = 0, do nothing and go to (4).
When k ≠ 0, it is determined whether Xp [jp [jk [k]]] = Xp [jp [jk [k-1]]].
When Xp [jp [jk [k]]] = Xp [jp [jk [k-1]]], the process proceeds to (4).
When Xp [jp [jk [k]]] ≠ Xp [jp [jk [k-1]]], move all robots that are not in the start position set S by one cell in the a = 1 direction, Move to 4).

(4) Let robot i be robot i_pushed_1 (i_pushed_1 ← i), and let robot i_pushed_2 be the robot with the same X coordinate as robot i and one smaller Y coordinate. Robot i_pushed_1 and robot i_pushed_2, and robot i_pushed_1 and X coordinate are the same, and all robots whose Y coordinate is larger than robot i_pushed1 (all robots that have the same X coordinate as robot i_pushed_1 and are not in S) are simultaneously a = Move one square in the direction of 2. Increment k. Note that, by moving the robot i_pushed_1 and the robot i_pushed_2 together in the same direction, it is possible to maintain the connection state between the group inside the set of start positions and the group outside the set of start positions.
(5) The position of the void generated in (4) (the position where robot i_pushed_2 was originally) is defined as position void_end.
(6) By filling the position void_end with a robot in S other than robot i_pushed_1 and robot i_pushed_2, the robot farthest from the position void_end is closer to the position void_end by one square than the current position.

(7) If k = q, go to (8). If k ≠ q, go to (2). Through the processes (1) to (7), the platoon located in the set of start positions in FIG. 2 (hereinafter also referred to as “start platoon”) is transformed into the platoon in FIG.
(8) Set xk ← 0. Let Xp_max ← Xp [q-1] and Yp_max ← Yp [q-1].
(9) Select one robot i not in S with xk = Xr [i].
(10) The y coordinate Yr [i] and Yp [jp [robot_target_index [i]]] of the robot i selected in (9) are compared. Move the outside robot by 1 square in the direction of a = 2 and move to (9). If equal, xk is incremented and the process proceeds to (11).
(11) If xk> Xp_max is not satisfied, the process proceeds to (9). If so, the process is terminated. By the processes (8) to (11), the formation in FIG. 6 is transformed into the extrusion formation in FIG.

Among the above processes, the procedure (6) (void control process Robot_Void_Control) will be described as follows.
<Void control processing Robot_Void_Control>
(1) The i_tail value when this processing Robot_Void_Control was executed last time is stored in the variable pre_i_tail (pre_i_tail ← i_tail). If this is the first time that this process is executed, pre_i_tail ← −1.
(2) Calculate how far each robot is from the position void_end. Hereinafter, this processing is also referred to as robot order calculation processing Robot_Joretu_Decision. In the robot order calculation process Robot_Joretu_Decision, an order variable value Joretu [Xr] [Yr] at each position is calculated. The robot order calculation process Robot_Joretu_Decision will be described later.

(3) (a) When pre_i_tail is a value other than -1 (when this processing is performed for the second time or later), the robot pre_i_tail is located in the mass unit to which it belonged one time step before If there is, the robot that is farthest from void_end (the robot at the position with the largest joretu value) is selected as robot i_tail (the number of the selected robot is assigned to i_tail). (b) When pre_i_tail is a value other than −1, there is no robot that is located in the square unit to which robot pre_i_tail belonged one step ago, and no other four robots are filled. When there is a unit, a robot that is in such a mass unit and is farthest from the void_end among them (the robot at the position with the largest joretu value) is selected as a robot i_tail. By performing the selection as shown in (b), a robot unit filled with four robots is configured, and the number of robots that are not included in the robot unit is less than four. (c) When pre_i_tail is a value other than -1, there is no robot located in the mass unit to which robot pre_i_tail belonged one time step ago, and no other four robots are filled When there is no position unit, the robot farthest from void_end (the robot having the largest joretu value) among the robots belonging to the tail robot group S_tail is selected and set as the robot i_tail. Note that a robot unit including the position Ps is j_head, and a group of robots located in the start position set S and not included in the robot unit j_head is referred to as a tail robot group S_tail. (d) When pre_i_tail is -1 (when this processing is performed for the first time), among the robots belonging to the tail robot group S_tail, the robot that is farthest from void_end (the robot with the largest joretu value) ) Is selected as the robot i_tail. For example, when the robots i_pushed_1 and i_pushed_2 move downward in the state of FIG. 13, a void is generated at the position void_end as shown in FIG. 14, and the robot i_tail is set. Note that the action of i_pushed_1 and i_pushed_2 from the start position set S is also referred to as a_head (= 2).

(4) The following position void_start is obtained using the robot i_tail. Assuming that there is a void at the position of the robot i_tail, the void can move from the position of the robot i_tail by two or more squares in the same direction following the adjacent robot. A direction in which the robot unit is not the robot unit j_head and satisfies the condition that four robots belong is searched. An action moving in the same direction as that direction is defined as a_tail (see FIG. 14). Subsequently, the robot unit number j_start to which the robot that has moved two squares or more in the direction of the action a_tail belongs is specified. In other words, two or more robots are adjacent to each other in the same direction d from the position of the robot i_tail, and in that direction d, the robot i_tail is at a square (two or more positions away). When the robot unit to which any one of the adjacent robots belongs is not the robot unit j_head and the condition that four robots belong to the condition, the action to move in the direction d is a_tail To do. The above-mentioned condition (a condition that two or more robots that are located at two or more positions away from the robot i_tail belong continuously, are not robot units j_head, and four robots belong to them) The robot unit number j_start that satisfies the condition is specified. Since there can be a plurality of robot units that satisfy the above conditions, an arbitrary robot unit can be specified as the robot unit j_start.

From the action a_tail and the position of the robot unit j_start (Xr_unit [j_start], Yr_unit [j_start]), the position void_start is set as follows (see FIG. 14).
When a_tail = 1: The X coordinate of void_start is 2 × Xr_unit [j_start] +1, and the Y coordinate is Yr [i_tail].
When a_tail = 2: The X coordinate of void_start is Xr [i_tail], and the Y coordinate is 2 × Yr_unit [j_start] +1.
When a_tail = 3: The X coordinate of void_start is 2 × Xr_unit [j_start], and the Y coordinate is Yr [i_tail].
When a_tail = 4: The X coordinate of void_start is Xr [i_tail], and the Y coordinate is 2 × Yr_unit [j_start].

However, (Xr_unit [j], Yr_unit [j]) (j = 0,1, ..., j_max-1) represents the position of the robot unit, and the robots belonging to the robot unit are i1, i2, i3, i4. Then, the position is
Xr [i1] = 2 × Xr_unit [j]
Yr [i1] = 2 × Yr_unit [j]
Xr [i2] = 2 × Xr_unit [j] +1
Yr [i2] = 2 × Yr_unit [j]
Xr [i3] = 2 × Xr_unit [j]
Yr [i3] = 2 × Yr_unit [j] +1
Xr [i4] = 2 × Xr_unit [j] +1
Yr [i4] = 2 × Yr_unit [j] +1
It is.
(5) The movement path of the void from the position void_start to the position void_end is calculated. Hereinafter, this processing is also referred to as void path calculation processing Void_Trajectory_Decision.
(6) Follow the void movement path calculated in (5) from void_end to _void_start and fill the void. Hereinafter, this processing is also referred to as void movement processing Void_Motion.

  In order to maintain the connection state of the robot when the last robot is moved, the process (4) indicates that “the position of the void is the robot included in the robot unit adjacent to the mass unit to which the last robot belongs. Of these, the position of the robot in contact with the mass unit to which the last robot belongs must not be considered. Therefore, the control system sets the p robots so that there is no void at the position of the robot in contact with the mass unit to which the last robot belongs among the robots included in the robot unit adjacent to the mass unit to which the last robot belongs. Control behavior. In FIG. 14, when the void uses the movement path NG, the robot i_tail is no longer adjacent to the robot in the vertical and horizontal directions, and all of the p robots cannot form a group, and the robots are connected to each other. It cannot be maintained. Therefore, control is performed so that the void at the position void_end is once moved to the position void_start and then moved to the position of the robot i_tail at a stroke. By performing such behavior control, all the p robots form one group, and the connection between the robots can be maintained.

  In order to appropriately perform the above-described void control, when there are robots in the mass unit adjacent to the mass unit to which the position Ps belongs, the robot starts to be filled with 4 robots in the adjacent mass unit. A set S of positions must be set, and the number p of start position sets must be set a more than the number q of set target positions.

Hereinafter, robot order calculation processing Robot_Joretu_Decision, void path calculation processing Void_Trajectory_Decision, and void movement processing Void_Motion for realizing such control will be described.
(Robot order calculation processing Robot_Joretu_Decision)
The robot order calculation processing Robot_Joretu_Decision can use the Dijkstra method or the like. For example:
(1) For each robot, check the number of the robot that is adjacent in the four directions. When the robot i_next exists adjacent to the movement direction of the action a of the robot i, the value of the next [a] [i] variable is set to i_next. When there is no robot, the value of the next [a] [i] variable is set to p (representing the number of robots).
(2) The value of the ordinal variable value Joretu [Xr] [Yr] at each position in the state space (Xr, Yr) is initialized to p (Joretu [Xr] [Yr] ← p).

(3) The value of the ordinal variable value Joretu at the position of void_end is set to 0 (Joretu [Xr] [Yr] ← 0). Furthermore, the value of the ordering variable value Joretu of the positions of all the robots moved by the action a_head immediately before executing this process is initialized to -1. In addition, the robot unit to which it belongs is initialized to -1 for the ordering variable value Joretu of the position of the robot that is not filled with four robots. Further, the Joretu value of the robot position adjacent in the opposite direction of the action a_tail from the position of void_start is set to -1. In addition, set the Joretu value of the position of the robot outside S to -1.
(4) The value of next [a] [j] is not p for all actions a of each robot i, except for the position of void_end and the position of the robot that is adjacent to the movement direction of action a_head from void_end Joretu [Xr [next [a] [i]]] [Yr [next [a] [i]]] and Joretu [Xr [next [a] [i]]] [Yr [next If the value of [a] [i]]] is not -1 and the minimum value plus 1 is less than the current Joretu [Xr [i]] [Yr [i]] , Assign the value to Joretu [Xr [i]] [Yr [i]] (Joretu [Xr [i]] [Yr [i]] ← Joretu [Xr [next [a] [i]]] [Yr [next [a] [i]]] + 1).
(5) Repeat (4) until Joretu value is no longer updated in the process of (4).

  By this process, (a) the position of all robots moved by action a_head, (b) if the robot unit to which the robot belongs is not filled with 4 robots, other robots belonging to that robot unit The position of the robot, (c) excluding the position of the robot that is adjacent to the position of void_start in the opposite direction of action a_tail, and the order variable value Joretu [Xr [i]] [Yr [i]] that is away from the position void_end Updated to be a value. The numerical values in square brackets in FIG. 15 show examples of values of the ordering variable value Joretu when there is no update in FIG.

(Void path calculation processing Void_Trajectory_Decision)
The void path calculation process Void_Trajectory_Decision is as follows.
(1) Position void_start is the first position of void trajectory (X, Y) = (void_trj_x [h], void_trj_y [h]) (h = 0,1,2,3 ...).
(2) Set orbital number h_trj ← 0.
(3) From the current void trajectory position (void_trj_x [h_trj], void_trj_y [h_trj]), among the robots i that are adjacent in all directions, the order value Joretu [Xr [i]] [ Yr [i]] is other than -1 and the position of robot i smaller than Joretu [void_trj_x [h_trj]] [void_trj_y [h_trj]] is the next void trajectory position (void_trj_x [h_trj + 1], void_trj_y [h_trj + 1]). At this time, the same action number as the movement direction of the void is stored in the void action history a_void [h_trj]. Increment h_trj.
(4) Repeat (3) until the current void trajectory position is equal to the position void_end.

By this processing, a void path from the position void_end to the position void_start is calculated.
(Void_Motion)
The void movement process Void_Motion is, for example, as follows. A robot moving in the same direction is moved at once along the calculated void trajectory. Of course, you may move one unit at a time without moving it at once.
(1) Set h_trj_buffer ← h_trj-1.
(2) Decrement h_trj and store the value of a_void [h_trj] in a_void_buffer.
(3) If h_trj = 0 is not satisfied, h_trj is decremented to determine whether or not a_void [h_trj] = a_void_buffer. When a_void [h_trj] = a_void_buffer, (3) is repeated. Otherwise (when a_void [h_trj] ≠ a_void_buffer), the void trajectory (void_trj_x [h_trj_buffer], void_trj_y [h_trj_buffer]) to (void_trj_x [h_trj + 1], void_trj_y [h_trj + 1]) Move all robots with action values stored in a_void_buffer and go to (4). By this process, the robot moving in the same direction is moved at a time. When h_trj = 0, the robot in the position from void trajectory (void_trj_x [h_trj_buffer], void_trj_y [h_trj_buffer]) to (void_trj_x [0], void_trj_y [0]) is the action value stored in a_void [0] Move to go to (5).
(4) Increment h_trj and return to (1).
(5) All robots that are adjacent to the robot i_tail in the direction of the action a_tail and reach the position void_start are moved by the action a_tail. In addition, this movement needs to move all together, not one by one. By this process, the void at the position void_start is moved to the position of the robot i_tail at once, and the robot adjacent to the robot i_tail is prevented from being lost.

With the above processing, it is possible to realize a lateral extrusion process which is one of robot extrusion processes. Next, the vertical direction extrusion process will be described.
[Vertical extrusion process]
FIG. 2, FIG. 16, FIG. 17, and FIG. 8 to FIG. 10 show how the robot operates when the vertical direction extrusion process is used as the robot extrusion process. The vertical extrusion process is shown in FIGS. In this process, first, the robots are pushed out in a row parallel to the Y axis, and then the robots pushed out are guided by the robots in the row parallel to the Y axis. Move to the height of the coordinates, and then form an extrusion row to extend the branch in the positive direction of the X axis. Details of the processing will be described below.

(1) A position where the X coordinate is one greater than the position Ps inside S where the set S of start positions and the set G of target positions are in contact is defined as Paxis (see FIG. 16). The position Ps and the position Paxis are positions within the same robot unit. Let y_max be the maximum value of the y coordinate of the set G of target positions. In the example of FIG. 2, y_max ← 13.
(2) Set yk ← 1.
(3) Select the robot at the position Ps and set it as the robot i_pushed_1.
(4) Let robot i_pushed_2 be the robot whose i coordinate is the same as robot i_pushed_1 and whose Y coordinate is one smaller value. Move robot i_pushed_1 and robot i_pushed_2 by one square in the direction of action a = 2. At the same time, all the robots outside the set S of the start positions are moved by one square in the direction of action a = 2. Increment yk.
(5) The void generated in (4) (the position where the robot i_pushed_2 was originally) is defined as a position void_end.

(6) By filling the position void_end with a robot other than the robots i_pushed_1 and i_pushed_2, the robot farther away from the position void_end is closer to the position void_end by one square from the current position. For example, the above-described void control process Robot_Void_Control is performed.
(7) When yk> y_max, move all robots outside S by one X coordinate in the direction of a = 1, and proceed to (8). If not, go to (3). When yk> y_max, a column in contact with Paxis and parallel to the Y axis is completed (see FIG. 16).
(8) Set yk ← 1.
(9) Count the number of target positions j whose Y coordinate value is yk, and let cnt_yk [yk]. For example, in the case of FIG. 16, cnt_yk [1] = 1 when yk = 1, cnt_yk [2] = 1 when yk = 2, cnt_yk [3] = 1 when yk = 3, and cnt_yk [ When 4] = 7,..., Yk = 13, cnt_yk [13] = 4.

(10) Count the number of robots cnt_end whose Y coordinate is equal to yk and whose X coordinate is 1 or more. If cnt_yk [yk] = cnt_end, yk is incremented and the process proceeds to (17). If cnt_yk ≠ cnt_end, the process proceeds to (11).
(11) Determine whether there is a robot whose X coordinate is 0 and whose Y coordinate is equal to yk. If there is, move all robots whose Y coordinate is equal to yk by 1 square in the direction of a = 1.
(12) Outside the set S of start positions, move the robot whose X coordinate is 0 and whose Y coordinate is smaller than yk by 1 square in the a = 2 direction.
(13) If the number of robots pushed out of the set S of start positions from the position Ps at the current yk value is smaller than cnt_yk [yk], the process proceeds to (14). If not, go to (10).

(14) The robot at the position Ps is i_pushed_1, and the robot i_pushed_1 has the same X coordinate as the robot i_pushed_1 and the Y coordinate is one smaller value as the robot i_pushed_2. Move robot i_pushed_1 and robot i_pushed_2 by one square in the direction of action a = 2.
(15) The void generated in (14) (the position where the robot i_pushed_2 was originally) is defined as a position void_end.
(16) By filling the position void_end with a robot in S other than robot i_pushed_1 and robot i_pushed_2, the robot farthest from the position void_end is moved closer to the position void_end by one square from the current position. For example, the above-described void control process Robot_Void_Control is performed. Move to (10).
(17) End when yk> y_max. If not, move to (9) Of the above processing, (1) to (7) are for transforming the starting row in Fig. 2 into the row in Fig. 16, and after (8) 16 is for transforming the formation of FIG. 16 into the extrusion formation of FIG. Next, an extrusion position association process in the case of the vertical direction extrusion process will be described.

<Vertical extrusion position association processing>
Among the following procedures, (1) to (6) are the same as the extrusion position association processing in the lateral extrusion process.
(1) Assign each target position (Xre [j], Yre [j]) to G_line (i_y).
(2) Set i_y ← 1. Counter variable cnt ← 0.
(3) If there is an element belonging to G_line (i_y), the value of jp [j] at the target position j with the smallest X coordinate is set to cnt (jp [j] ← cnt), and cnt is incremented (cnt ← cnt +1). Further, the value of the variable x_min [i_y] is set as the x coordinate value of the target position j (x_min [i_y] ← Xre [j]), and the process proceeds to (4). If there are no elements, go to (5).
(4) If there is a position with the smallest X coordinate next to the target position j in G_line (i_y), it is set as the target position j. The value of jp [j] at the target position j is set to cnt (jp [j] ← cnt), cnt is incremented (cnt ← cnt + 1), and (4) is repeated. If not, the value of the variable x_max [i_y] is set to the x coordinate value of the target position j (x_max [i_y] ← Xre [j]), i_y is incremented (i_y ← i_y + 1), and the process returns to (3).

(5) Currently, record the i_y value in the variable y_max, and proceed to (6).
(6) Yp [jp [j]] ← Yre [j] for all values of j = 0 to q-1.
(7) Set the counter variable cnt ← 1.
(8) Set Xp [0] ← 1. If there is only one element in G_line (1), go to (10). If not, go to (9).
(9) Among the elements of G_line (1), when there is a cnt + 1th target position with the X coordinate that is the smallest, this is set as the target position j, and Xp [jp [j]] ← cnt + 1. Increment cnt and repeat (9). If not, go to (10).

(10) Set i_y ← 2. If i_y = y_max, the process ends. Otherwise, the process proceeds to (11).
(11) Among the elements of G_line (i_y), the element with the smallest X coordinate of the target position is set as j, and Xp [jp [j]] ← 1. Align the left edge of each row i_y to x = 1.
(12) Among the elements of G_line (i_y), if there is a target position with the X coordinate next to the target position j, then Xp [jp [j]] ← Xp [jp [j ] -1] +1 and repeat (12). If not, proceed to (13).
(13) Increment i_y. If i_y = y_max, proceed to (14). Otherwise, go to (11).
(14) For each robot i that has been pushed out, search for j where (Xr [i], Yr [i]) = (Xp [jp [j]], Yp [jp [j]]) and robot_target_index [i] ← j.

  Through the value of jp [j], the position in the target row in FIG. 2 is associated with the position in the push row in FIG. 17 (see FIGS. 2 and 18). In other words, the target position (Xre [j], Yre [X] [Xp [jp], Yp [jp]) and the target position j's internal number jp [j] calculated as a result of this processing are used. j]) and the position in the extrusion row (Xp [jp [j]], Yp [jp [j]]) can be calculated (see FIGS. 2 and 18). Note that the extrusion row shown in FIG. 17 has a convenient shape for extruding the robot one by one in the positive direction of Y from the position Ps.

[Intermediate transition process]
In this process, first, a process for transforming the set G of target positions (see FIG. 19) into the intermediate formation row position (see FIG. 21) is calculated. In this case, the intermediate formation row just presses the wall that cannot be seen from the left and right sides of the target row (see Fig. 10) to compress the target row, etc. It is a convoy that gathered toward an axis parallel to the direction y (see FIG. 8), and the intermediate form convoy position is the position of the robot that forms the intermediate form convoy (see FIGS. 19 to 21). Such an intermediate formation row can be easily deformed from the extrusion formation row (see FIGS. 7 and 17), and the deformation from the intermediate formation row to the target formation is a reverse reproduction of this compression process. The connection between each other has the advantage that no violation occurs during the transformation process.

Hereinafter, the intermediate formation formation process will be described. The variables that record the history of the target position of the deformation process are (Xr_hist [j] [t], Yr_hist [j] [t]).
<Intermediate formation formation process>
(1) The X coordinate value of the target position j having the largest X coordinate is stored in the X coordinate value X_wall of the wall. For example, in the case of FIG. 19, X_wall ← 11.
(2) All behavior a values and target position j values are initialized to dest_next [a] [j] ← −1. (Xr_hist [j] [0], Yr_hist [j] [0]) ← (Xre [j], Yre [j]) and t ← 1.
(3) The number of the target position adjacent to the action a = 3 direction (left direction) of each target position j is stored in the variable dest_next [3] [j]. For a certain target position j, if the position on the left is the target position, the target position number is stored in dest_next [3] [j].
(4) Do the following for all robots j where Xre [j] = X_wall.
a. First, j_0 ← j.
b. The process of replacing the value of j_0 with the value of dest_next [3] [j_0] (j_0 ← dest_next [3] [j_0]) is repeated until dest_next [3] [j_0] =-1. In short, the target position existing at the left end is found, and the number of the target position is stored in j_0.
For j_0 obtained as a result of cb, if Xre [j_0]> 0, the target positions j and j_0 and all the target positions sandwiched between the two target positions are moved by one square in the left direction.

(5) Let (Xr_hist [j] [t], Yr_hist [j] [t]) ← (Xre [j], Yre [j]). Increment t. Decrement X_wall. If X_wall = 0, go to (6), otherwise go to (3). By the processes (1) to (5), the target positions existing on the right side of the X coordinate x = 0 are collected on an axis parallel to the y direction passing through the X coordinate x = 0. The target position in FIG. 19 is transformed to a state in the middle of generation of the intermediate form row position in FIG.
(6) The X coordinate value of the target position j having the smallest X coordinate is stored in the X coordinate value X_wall of the wall. For example, in the case of FIG. 19, X_wall ← −5.
(7) Initialize to dest_next [a] [j] ← −1 with all action a values and target position j values.
(8) The number of the target position adjacent to the action a = 1 direction (right direction) of each target position j is stored in the dest_next [1] [j] variable. For a certain target position j, if the position on the right is the target position, the target position number is stored in dest_next [1] [j].

(9) Do the following for all robots j where Xre [j] = X_wall.
a. First, j_0 ← j.
b. The process of replacing the value of j_0 with the value of dest_next [1] [j_0] (j_0 ← dest_next [1] [j_0]) is repeated until dest_next [1] [j_0] =-1. In short, the target position existing at the right end is found, and the number of the target position is stored in j_0.
For j_0 obtained as a result of cb, if Xre [j_0] <0, the target positions j and j_0 and all the target positions sandwiched between the two target positions j are moved by one square in the right direction.
(10) Let (Xr_hist [j] [t], Yr_hist [j] [t]) ← (Xre [j], Yre [j]). Increment t. Decrement X_wall. If X_wall = 0, end with t_all = t-1; otherwise, go to (8). Through the processes (6) to (10) and above, the target positions present on the left side of the X coordinate x = 0 are collected on an axis parallel to the y direction passing through the X coordinate 0. The state in the middle of the generation of the intermediate form formation in FIG. 20 is transformed into the intermediate form formation in FIG.

  Through the above processing, the deformation history from the set of target positions to the intermediate formation row position is recorded in the variable (Xr_hist [j] [t], Yr_hist [j] [t]) (t = 0, ..., t_all). .

The movement process of the robot from the extrusion formation row to the intermediate formation row is as follows. Simply move in each y-value robot row until the X coordinate of each robot matches that in the intermediate formations.
<Intermediate transition processing>
(1) Set yk ← 1.
(2) Select one robot i whose Y coordinate is equal to yk.
(3) If Xr [i]> Xr_hist [robot_target_index [i]] [t_all], move all robots whose Y coordinates are greater than or equal to yk by one square in the action a = 3 direction (left direction). If Xr [i] <Xr_hist [robot_target_index [i]] [t_all], move all robots whose Y coordinate is yk or more by one square in the action a = 1 direction (right direction). If Xr [i] = Xr_hist [robot_target_index [i]] [t_all], yk is incremented and the process proceeds to (4). If not, return to (2).
(4) If there is a robot whose Y coordinate value is equal to yk, go to (2), otherwise end.
By the above processing, the extruded formation row in FIG. 7 or 17 is transformed into the intermediate formation row in FIG.

[Final development process]
In the final expansion process, the movement history of the target position j stored in the variables (Xr_hist [j] [t], Yr_hist [j] [t]) may be traced backward from t = t_all to t = 0.
<Final development process>
(1) t ← t_all-1.
(2) For each robot i, compare (Xr_hist [robot_target_index [i]] [t], Yr_hist [robot_target_index [i]] [t]) and (Xr [i], Yr [i]) values and move Move one square with the action that becomes (Xr_hist [robot_target_index [i]] [t], Yr_hist [robot_target_index [i]] [t]). Decrement t.
(3) If t <0, end, otherwise go to (2).
Through the above processing, the intermediate form train in FIG. 8 is transformed into the set of target positions in FIG. 10 through FIG.

Hereinafter, a configuration for executing these processes will be described.
<Action control system 100 according to the first embodiment>
FIG. 22 is a functional block diagram of the behavior control system 100 according to the first embodiment, and FIG. 23 shows an example of the processing flow. As shown in FIG. 22, the behavior control system 100 includes a behavior selection unit 120, an adjacent state determination unit 124, a position update unit 123, a position determination unit 126, a storage unit 140, a communication unit 150, and an input unit. 160. The action selection unit 120 includes an extrusion process processing unit 120A, an intermediate transition process processing unit 120B, and a final development process processing unit 120C.

  Hereinafter, a case where the control target to be controlled is a robot will be described as an example. Of course, the control object may be other than the robot as long as it can be a control target.

  In the present embodiment, the behavior control system 100 controls the behavior of p robots and is mounted on one of the p robots. Note that the p-1 robot on which the behavior control system 100 is not mounted also includes the communication unit 150 and the adjacent state determination unit 124.

<Input unit 160>
The input unit 160 includes initial positions (Xr0 [i], Yr0 [i]) of the p robots i (in other words, a set of p start positions S = {(Xr0 [0], Yr0 [0] ]), (Xr0 [1], Yr0 [1]),…, (Xr0 [p-1], Yr0 [p-1])}) and a set of q target positions G = {(Xre [0] , Yre [0]), (Xre [1], Yre [1]),..., (Xre [q-1], Yre [q-1])} are input and stored in the storage unit 140.

<Communication unit 150>
All robots including the robot on which the behavior control system 100 is mounted communicate with other robots that are adjacent in the vertical and horizontal directions on the two-dimensional plane (hereinafter also referred to as “four directions”) via the communication unit 150. can do.

<Action selection unit 120>
The action selection unit 120 controls the p robots by the method described above (s120). The extrusion process processing unit 120A, the intermediate transition process processing unit 120B, and the final unfolding process processing unit 120C calculate the order and direction of the robot operations in advance and store them in the storage unit 140 before starting the robot operations. deep. The action selection unit 120 extracts the operation of each robot at each time from the storage unit 140, transmits a control signal indicating the moving direction to the robot to be moved at each time, and each robot operates according to the control signal.

(Extrusion process processor 120A)
The push-out process processing unit 120A of the action selection unit 120 takes out a set S of p start positions and a set of q target positions from the storage unit 140, and includes at least q sets of p start position sets S. The robot is moved and controlled to form an extrusion row, and the position of each robot in the extrusion row is output to the intermediate transition process processor 120B.

  In addition, the extrusion platoon is the platoon where the number of robots located at the same y coordinate value is the same as the intermediate form platoon and all the robots located at the same y coordinate value are continuously adjacent in the x-axis direction. A formation generated by a lateral extrusion process or a vertical extrusion process.

[Horizontal extrusion process]
In the case of the lateral extrusion process, the extrusion row has a magnitude relationship between the number n [i_y] of robots located at the y coordinate value i_y and the number n [i_y-1] of robots located at the y coordinate value i_y-1. Accordingly, one end of the robot continuously adjacent in the x-axis direction at the y-coordinate value i_y or one end of the robot continuously adjacent in the x-axis direction at the y-coordinate value i_y-1 Alternatively, it is a formation in which the robot at the other end is combined in the second direction. In the present embodiment, when the number n [i_y] is larger than the number n [i_y-1], the y coordinate value i_y and the left end of the robot continuously adjacent in the x-axis direction and the y coordinate value i_y-1 When the number n [i_y] is equal to or less than the number n [i_y-1] with the left end of the robot continuously adjacent in the x-axis direction, the y-coordinate value i_y is continuously adjacent in the x-axis direction. A column that is a combination of the right end of a robot and the right end of a robot that is adjacent in the x-axis direction in the y-coordinate value i_y-1 is defined as an extruded column.

  The extrusion process processing unit 120A takes out a set S of p start positions and a set of q target positions from the storage unit 140, performs a <lateral extrusion position association process>, and determines the position of the robot in the extrusion column and the target Correlate the position of the robot in the position. Next, the extrusion process processing unit 120A determines to which position in the extrusion row the robot pushed out from the set of start positions moves by the <pushing order calculation process>. The extrusion process processor 120A moves the robot in the positive direction of the y-axis from the set of start positions by the number of robots located at the same x-coordinate value of the extrusion platoon by <extrusion control processing>, and then starts The process of moving all the robots outside the set of positions in the positive direction of the x-axis is repeated, and the starting formation in FIG. 2 is transformed into the formation in FIG. Then, by <extrusion control processing>, robots are selected in ascending order of x-coordinate values, and it is determined whether or not they match the positions of the robots in the extrude line. By moving all robots having values in the positive direction of the y-axis, the formation in FIG. 6 is transformed into the extrusion formation in FIG.

[Vertical extrusion process]
The extrusion process processing unit 120A takes out a set S of p start positions and a set of q target positions from the storage unit 140, and makes the robot form a line parallel to the y-axis through the <vertical direction extrusion process>. Move the robot from the set of starting positions, then move the other robot along the row parallel to the y-axis to the y-coordinate value position in the intermediate formation row in the positive direction of the y-axis, and then , By moving in the positive direction of the x-axis, form an extruded row. Thereafter, the position of the robot in the extrusion row is associated with the position of the robot in the target position by <longitudinal extrusion position association processing>.

(Intermediate transition process processor 120B)
The intermediate transition process processing unit 120B of the action selection unit 120 takes out a set of q target positions, and passes an x-coordinate value parallel to the y-axis (in this embodiment, through the intermediate form formation generation process). By moving (compressing) the positions included in the set of target positions toward (x = 0), the positions of the robots forming the intermediate formation are obtained. At this time, the translation is performed in order from positions included in the set of target positions having a large distance to the parallel axis. When the translation is performed, if it is adjacent to another position included in the set of target positions, the translation is performed together with the adjacent position. The order and direction of movement of each robot when obtaining the position of the robot forming the intermediate form train from the positions included in the set of target positions is output to the final development process processing unit 120C.

  The intermediate transition process processing unit 120B receives the position of the robot in the extrusion process line from the extrusion process process part 120A, and compares the position of the robot in the intermediate form process line with the position of the robot in the extrusion process line by <intermediate transition process>. By transforming the formation in the x direction for each same y coordinate value, the formation is transformed into an intermediate formation formation.

(Final development process processor 120C)
The final development process processing unit 120C of the action selection unit 120 receives the order from the intermediate transition process processing unit 120B in the order of movement of each robot when obtaining the position of the robot that forms the intermediate form train from the position included in the set of target positions. The direction in which the position of the robot that forms the intermediate formation is determined from the positions included in the set of target positions for the robot that forms the intermediate formation by using [Final Deployment Process] using In this order, by moving the robot in a direction opposite to the parallel movement direction when obtaining the position of the robot forming the intermediate formation from the position included in the set of target positions, the robot forming the intermediate formation is set to the target position. Move to the set.

<Location update unit 123>
For each i = 0, 1,..., P−1, the position update unit 123 performs the action determined by the action selection unit 120 at the current position (Xr [i], Yr [i]) of the i-th robot. Calculates the position (Xr '[i], Yr' [i]) after movement (after action) of the robot when executed, and stores the calculated (Xr '[i], Yr' [i]) The position of the i-th robot stored in 140 is updated (S123). In other words, the position update unit 123 calculates a position assumed when the robot behaves (hereinafter also referred to as “assumed position”) based on the action determined by the action selection unit 120 and updates the position of the robot. Stored in the storage unit 140.

<Adjacent state determination unit 124>
The adjacent state determination unit 124 determines whether or not another robot is present in the upper, lower, left, and right adjacent positions on the two-dimensional plane of the robot (S124), and stores the determination result in the storage unit 140.

  Note that, as described above, the p-1 robot on which the behavior control system 100 is not mounted also includes the communication unit 150 and the adjacent state determination unit 124. Therefore, each robot i can determine in the adjacent state determination unit 124 whether there are other robots in its vertical and horizontal directions, and can output the determination result to the behavior control system 100 via the communication unit 150. The behavior control system 100 receives the determination result from each robot i via the communication unit 150 and stores it in the storage unit 140 together with the determination result of the adjacent state determination unit 124 included in the behavior control system 100. In addition, the p robots always have other robots in adjacent positions (4 directions) of each robot, and the group formed by the adjacent robots is a lump, so each robot i is connected via the communication unit 150. The p-1 determination results can be transmitted to the behavior control system 100 directly or via another robot. In addition, the behavior control system 100 can transmit a control signal so as to execute the selected behavior to each robot i directly or via another robot via the communication unit 150. In addition, other information can be transmitted and received between the p robots.

  Note that even if the robot is controlled to move, it cannot always be moved as controlled by the action selection unit 120 due to some trouble (such as equipment failure). On the other hand, the position of the robot that did not move is the same as before the control. Therefore, by controlling so that at least one robot does not move, the actual state of the robot controlled to move using the determination result by the adjacent state determination unit 124 based on the position of the robot that did not move is used as a reference. The position after acting (hereinafter also referred to as “post-behavior position”) (Xr "[i], Yr" [i]) can be obtained. If at least one robot such as GPS is equipped with GPS, the post-movement position can be obtained in the same manner with reference to the robot.

<Position determination unit 126>
The position determination unit 126 obtains a post-behavior position using the determination result of the adjacent state determination unit 124, and determines a post-behavior position (Xr "[i], Yr" [i]) and an assumed position (Xr '[i], It is determined whether or not Yr ′ [i]) matches (S126). If they do not match, it is considered that the robot controlled to move could not move as controlled due to some trouble. In this case, at least one of the post-behavior position (Xr "[i], Yr" [i]) and the assumed position (Xr '[i], Yr' [i]) may be corrected. Various methods can be considered as the correction method. For example, all the robots that have moved may be instructed to return to the pre-control position, and the post-behavior position (Xr "[i], Yr" [i]) may be corrected, or the assumed position (Xr '[i], Yr' [i]) may be corrected according to the post-action position (Xr "[i], Yr" [i]).

  At each time step, it is determined whether or not the set G of all target positions is filled by the robot (S127), and if it is filled, the mission is terminated. If not, continue the mission.

  For example, in a target position arrival determination unit (not shown), for each i = 0, 1,..., P−1, the post-action position (Xr ″ [i], Yr ″ [i]) output from the position determination unit 126 is used. Then, it is determined whether or not the set G of all target positions is filled by the robot, and if it is filled, the mission is terminated. When at least one or more target positions are not filled with the robot, the action selection unit 120 is controlled to be executed again.

The processes s120 to s127 described above are performed for each time step.
<Effect>
With such a configuration, even if the robot is not equipped with a complicated mechanism, the formation from the formation at any starting position is changed to the formation at any other target position while maintaining the state where the robots are in contact with each other. It may be possible to perform an action. In addition, the calculation load is not proportional to the factorial of the number of robots, and a self-position coordinate definition type formation formation algorithm can be obtained with a low plan calculation load that can be executed in real time. Moreover, since an absolute position can be acquired by determining a relative position with respect to a stationary robot, no additional position measurement equipment is required. Or, since the absolute position can be obtained by determining the relative position of the robot with at least one GPS or the robot whose position is defined in the start state, all robots have GPS etc. It is not necessary to have.

<Modification>
The start position set S is the condition shown in FIG. 4 ((1) The portion where the start position set S protrudes from the core portion is included in the square unit adjacent to the core portion. (2) Start position The part where the set S protrudes from the core part shall not be an L-shaped part that protrudes like a hook. (3) The robot where the protruding part touches one core robot unit (The side of the unit shall be contained within one). As described above, since the set G of target positions may be an arbitrary shape of a lump, behavior control when transforming an arbitrary shape of a lump satisfying the conditions of FIG. Thus, by moving in the opposite direction, the set G of target positions can be changed to an arbitrary shape satisfying the conditions of FIG. 4 while maintaining the connected state. Therefore, the set S ′ of start positions that does not satisfy the condition of FIG. 4 and forms an arbitrary shape of the lump is once transformed into an arbitrary shape of the lump that satisfies the condition of FIG. Consider a procedure for transforming from an arbitrary shape to a set S ′ of starting positions forming an arbitrary shape of a lump, and deforming by moving in the reverse direction in the reverse procedure), the shape after deformation (conditions in FIG. 4) (Any one shape of a lump satisfying the above) may be transformed into a set G of target positions forming any lump shape (a set of start positions in this embodiment may be calculated as corresponding to the shape after deformation) ). However, the set S of the start positions needs to include at least the formation of FIG. 5A or a part of the formation that can be transformed into the formation of FIG. 5A.

  The start position set S ′ and the target position set G may not be in contact with each other. The start position set S ′ may be transformed into a single arbitrary shape satisfying the conditions of FIG. 4 and moved so that the deformed shape S satisfies the conditions described in [Robot Coordinate Settings]. . In other words, the shape S after deformation and the set G of target positions are moved while maintaining the shape S so that there is at least one position in contact with the set G of target positions. The position with the smallest coordinate is Ps (Xs, Ys), and the origin (0, 0). At this time, all the positions belonging to the set G of target positions have y coordinate values larger than the position Ps, and the y coordinate values of all robots belonging to the shape S are values equal to or smaller than the y coordinate value of the position Ps. It may be moved while maintaining the shape S so that Further, the mass unit to which the position Ps belongs may be moved so that four robots are filled. Any existing technique may be used as a method of moving the shape S while maintaining the connected state.

  In the present embodiment, each lattice (mass) is a square, but may have other shapes. The lattice is continuously arranged in the left-right direction and the up-down direction. Each lattice is adjacent to the other two lattices in the left-right direction and adjacent to the other two lattices in the vertical direction. In other words, each grid is adjacent to other grids only in the same direction that the robot can move. Each lattice may have any shape as long as this condition is satisfied. Further, the term “orthogonal” does not necessarily mean strictly “vertically intersecting”. For example, as shown in FIG. 24, each lattice may be a rhombus, and each lattice is the other two lattices. One of the adjacent directions may be the vertical direction and the other is the horizontal direction. In this case, the vertical direction and the horizontal direction are orthogonal to each other.

  In other words, the control object is in the first direction (for example, the right direction), the second direction (for example, the downward direction) that is not parallel to the first direction, and the first direction on the two-dimensional plane. On the other hand, it is possible to move in the third direction (for example, the left direction) opposite to the second direction, and in the fourth direction (for example, upward direction) that is the opposite direction to the second direction. Control is performed so that the current area is moved to one of the adjacent areas in the first direction, the second direction, the third direction, and the fourth direction from the grid. In this case, on the two-dimensional plane of the robot, the position adjacent in the first direction is the first position, the position adjacent in the second direction is the second position, the position adjacent in the third direction is the third position, Positions adjacent in the four directions may be referred to as fourth positions.

  In the present embodiment, the example in which the behavior control system 100 is mounted on one of the p robots has been shown, but behavior control may be performed on a control target on a computer. In that case, unless a trouble occurs intentionally, the controlled object moves as controlled, so the assumed position (Xr '[i], Yr' [i]) and the post-movement position (Xr "[i], Yr "[i]) matches. In such a state, an ideal action plan for each control object i may be performed. The actual robot is made to execute the action plan until the mission obtained as a result is completed. The behavior control system 100 may include at least the behavior selection unit 120 and perform at least a behavior plan. The real robot includes a communication unit 150 and an adjacent state determination unit 124. After each action is completed, the adjacent state is determined, the post-action position is obtained using the determination result, and the post-action position (Xr "[i] , Yr "[i]) and the assumed position (Xr '[i], Yr' [i]) are determined to match. If they do not match, it is considered that the robot controlled to move could not move as controlled due to some trouble. Subsequent processing may be the same as in the first embodiment, or other processing may be performed. With such a configuration, it is possible to detect at least that movement was not possible as controlled.

<Second embodiment>
A description will be given centering on differences from the first embodiment.
First, the theoretical background of the behavior control system and method in this embodiment will be described.
[Problem settings]
A number of robots cooperate to move from a formation formation state at the start position while maintaining the state in which each robot is in contact, and perform a formation at the target position, for example, as illustrated in FIG. Assuming the use of a cube-type robot that can move by sliding the surfaces that touch each other, as shown in FIG. 26, by moving a plurality of robots from a set S of start positions to a set G of target positions. It is realized.

  In the present embodiment, formation of the formation from the set S of the start positions to the set G of the target positions is performed through the intermediate position set M. Hereinafter, the transformation from the set M of intermediate positions to the set G of target positions will be described. For deformation from the start position set S to the intermediate position set M, the deformation operation is calculated in the same manner as the deformation from the intermediate position set M to the target position set G. This is achieved by controlling the robot operation so that the history is played back in reverse.

  Further, in the present embodiment, it is assumed that the position to be taken by each robot in the set S of start positions and the set G of target positions is determined for each robot. Therefore, the robot group that is deformed from the set S of start positions and is in the set M of intermediate positions is that each robot appropriately converts each target position in the set G of target positions in the transformation from the form to the set G of target positions. While maintaining the form of the set M of intermediate positions, the operation of exchanging the positions of the robots is also performed.

  For example, as shown in FIG. 25, the robot moves while maintaining the state in which another robot is present in one of the six squares around the robot in the vertical and horizontal directions. This method has an advantage that one robot itself can accurately measure the movement amount of one operation by moving the distance corresponding to the size of one robot. In addition, by measuring the relative positions of adjacent robots that share one surface, the position of each robot in the entire group of robots can be easily known. For this reason, it is difficult to cause a problem that the formation is collapsed due to an error in the movement amount of the robot. Further, as shown in FIG. 3, it is possible to move a plurality of robots at the same time as if a plurality of robots are connected. In FIG. 3, when transforming from platoon A to platoon B and when transforming from platoon D to platoon E, the two robots move simultaneously as if they were connected. In the example of FIG. 3, in the moving direction, the two robots move at the same time as if they were connected, but in the direction orthogonal to the moving direction, the two robots move at the same time as if they were connected. Also good. For example, when moving in the positive direction of the X axis, the two robots may move simultaneously in the Y axis direction or the Z axis direction as if they were connected. Here, it is assumed that the robot can know whether or not another robot exists in the adjacent position and whether or not the robot is on the target position. For example, it is assumed that any robot can communicate with other robots existing in the mass around the robot, and at least one robot is equipped with GPS, or at least one robot does not move in one action control. In this case, each robot can easily know its absolute position by communicating with an adjacent robot with reference to a robot with GPS or a robot that has not moved. Alternatively, if the absolute position of at least one robot is known at the start position, it can be used to know the absolute position of each robot at each time without GPS.

  In this method, it is assumed that the order of movement of each robot is calculated in advance in the behavior control system before the movement of the robot starts, and each robot operates according to it.

  There are p robots (p is an integer greater than or equal to 9), and each robot shares one or more surfaces with an adjacent robot (in other words, with one or more surfaces in contact with each other). It is possible to move in the XYZ axis directions in the original space (in this example, six directions, up, down, left, and right, front and back in the drawing). However, p robots form one group. There can be only one robot in each grid. Each robot is assumed to be stationary if there is another robot in the direction of movement. Note that a cubic space where the robot can exist is also referred to as a mass or a lattice. In FIG. 26, each lattice (cube) indicates a position where the robot exists. In addition, the figure with the pyramid upside down (substantially a quadrangular pyramid shape with no bottom and head apex located below) indicates the set S of the starting positions, and the flag stands on the pyramid. A figure (a figure with a substantially quadrangular pyramid shape with no bottom, top vertex located above, and a flag standing on top of the head vertex) is a set G of target positions (hereinafter this area is referred to as “ Also referred to as “target row area G”).

  A robot in the set M at the intermediate position has eight robots adjacent to each other in a square shape as one unit (hereinafter also referred to as a “robot unit”), and a row on a rectangular plate composed of robot units. Form. In other words, every eight robots constitute one robot unit, and each of the eight robots constituting one robot unit is adjacent to another robot constituting one robot unit in three directions. This group of robot units shares one surface for each robot unit in the set M of intermediate positions. Note that eight squares corresponding to a robot unit formed by eight robots are defined as one square unit (hereinafter also referred to as “mass unit”).

  Assume that the total number of target positions included in the set G of target positions is q, and the number p of robots included in the set M of intermediate positions is a more than the total number q of target positions. p = q + a. a is an integer of 8 to 15, and is selected so that the value of p is a multiple of 8. This is a condition because the set M of intermediate positions is composed of mass units. It can be said that p is the total number of positions included in the set M of intermediate positions. The shape of the set M at the intermediate position is the shape of a rectangular flat plate, a straight line, or an L-shaped flat plate formed by a series of robot units formed by eight robots adjacent to each other in a square shape. In other words, the robot unit is arranged to form an L-shaped or rectangular flat plate. The Z coordinate of the position included in the set M of intermediate positions is assumed to take only a value of 0 or 1. The shape formed by the set G of target positions is not particularly limited as long as adjacent target positions are continuous in the vertical and horizontal directions. In other words, each target position is adjacent to another target position in at least any one of the up, down, left, and right directions, and the formation at the target position of the robot is an arbitrary shape.

[Robot coordinate settings]
Each robot i (i represents the robot number, i = 0,1,2,3, ..., p-1) is transformed from the initial position set M to the target position set G here. Therefore, the intermediate position is also called the initial position) is (Xr0 [i], Yr0 [i], Zr0 [i]) and the target position is (Xre [j], Yre [j], Zre [j]) (j Represents the target position number, j = 0,1,2,3, ..., q-1, p = q + a), and the start position is (Xrs [j], Yrs [j], Zrs [j]) (j is the number of the starting position, j = 0,1,2,3, ..., q-1, p = q + a), this problem is that the robot placed at the intermediate position It can be defined as seeking an action plan to move to a position.

  Among the positions included in the set M of intermediate positions (Xr0 [i], Yr0 [i], Zr0 [i]), the position where the X, Y, and Z coordinates are the smallest is the origin (0,0,0), Ps = (0,0,1) where the origin and the X, Y coordinates are the same, and the Z coordinate is 1, and the position where Ps is in contact with the positive direction of the Y axis is Pr = (0,1,1) (See FIG. 26, but the position of the origin cannot be seen by other robots). It is assumed that all the positions belonging to the target position set G have a Z coordinate value larger than the position Ps.

  Among the positions of the mass units forming the set M of intermediate positions, the mass unit including the position Ps is referred to as a seed position unit Used. For the seed position unit Used, two or more mass units must be in contact with each other in the positive direction along the X axis. That is, as shown in FIG. 27, it is assumed that three or more square units including the seed position unit Used are present in a form forming a straight line in the X-axis direction. Therefore, p is any multiple of 8 greater than 24. As described above, all the positions belonging to the target position set G have a Z coordinate value larger than the position Ps included in the seed position unit Used, and the seed position unit Used does not belong to the target position set G. p = q + a, and the seed position unit Used is included in a.

When the position of the robot unit is (Xr_unit [j], Yr_unit [j], Zr_unit [j]) (j = 0,1,2, ... j_max-1), the robot belonging to the robot unit j is i1, i2, i3, i4, i5, i6, i7, i8
Xr [i1] = 2xXr_unit [j]
Yr [i1] = 2xYr_unit [j]
Zr [i1] = 2xZr_unit [j]
Xr [i2] = 2xXr_unit [j] +1
Yr [i2] = 2xYr_unit [j]
Zr [i2] = 2xZr_unit [j]
Xr [i3] = 2xXr_unit [j]
Yr [i3] = 2xYr_unit [j] +1
Zr [i3] = 2xZr_unit [j]
Xr [i4] = 2xXr_unit [j] +1
Yr [i4] = 2xYr_unit [j] +1
Zr [i4] = 2xZr_unit [j]
Xr [i5] = 2xXr_unit [j]
Yr [i5] = 2xYr_unit [j]
Zr [i5] = 2xZr_unit [j] +1
Xr [i6] = 2xXr_unit [j] +1
Yr [i6] = 2xYr_unit [j]
Zr [i6] = 2xZr_unit [j] +1
Xr [i7] = 2xXr_unit [j]
Yr [i7] = 2xYr_unit [j] +1
Zr [i7] = 2xZr_unit [j] +1
Xr [i8] = 2xXr_unit [j] +1
Yr [i8] = 2xYr_unit [j] +1
Zr [i8] = 2xZr_unit [j] +1
It is.

[Definition of robot motion]
The action subject is each robot arranged in the room. The action “a” of the robot i takes one of seven types in total, that is, stationary, movement of one lattice in the up / down / left / right / front / rear direction. For example, a [i] ∈ {0,1,2,3,4,5,6}
0: Still
1: Move one grid in the direction of increasing X coordinate value (right direction) in 3D space
2: Move one grid in the direction of increasing Y coordinate value (downward) in 3D space
3: Move one grid in the direction of decreasing X coordinate value (left direction) in 3D space
4: Moves by one grid in the direction of decreasing Y coordinate value (upward) in 3D space
5: Moves by one grid in the direction in which the Z coordinate value increases (forward) in the three-dimensional space
6: Suppose that one grid moves in the direction (backward direction) in which the Z coordinate value decreases in the three-dimensional space.

[Problems in search calculation]
The state space in such a mission environment has a state of the number of dimensions of the number of robots × 3, and the number of actions that can be selected is the number of robot actions (= 7 ways). For example, if the number of robots is 50 and the number of grids in the vertical and horizontal height directions of the room is 20, the number of states will be 20 to the 150th power, and the amount of resources required for search calculation will be enormous . As the number of robots increases by one, the number of states will increase by 8000 times.

  As explained in [Problem Setting], even if the constraint condition that robots are in contact with each other is incorporated, it is difficult to reduce the fundamental amount of calculation, which is a big problem when using multiple robots. .

  Specifically, for example, in the problem of guiding a large number of robots to a plurality of target positions, even though a route for reaching one position can be obtained by search calculation, it is possible to determine which target for each robot. The problem is whether to allocate the position. If this target position allocation is not successful, a robot that has reached the target position early will stay in a position that hinders the movement of the robot that comes later, making it difficult to form a robot platoon as a whole. End up. In order to avoid such a situation, considering how to allocate the target position to each robot by searching, there is a way to allocate to the target position by the factorial of the number of robots. The load on the robot increases dramatically with the number of robots.

  In addition, the search calculation when considering the search calculation for the robots to move while sharing one surface with each other also takes into account the mutual movement of each robot. On the other hand, it increases exponentially.

[Introduction of two motion processes]
In the present embodiment, as one of the measures for solving these computational load problems, the robot operation process is considered in two stages. The first is a robot push-out process that pushes out the robot forming the formation of the set G of target positions from the set M at the intermediate position to the position Ps or out of the set M at the intermediate position via the position Pr. This is a final deployment process in which a deployment operation is performed from the pushed form to a formation form of a set G of target positions. In the first process, the following void control is performed.

[Void control]
In this first robot extrusion process, the concept of void control is introduced in this embodiment. First, the term “void” as used herein refers to a gap that can be restored to the original position after a robot has moved to another position. In other words, a void is a virtual entity that moves in a direction opposite to the direction in which the robot moves. In such a group robot formation problem, the amount of search calculation explodes because it focuses on the movement of multiple robots, but if you change the viewpoint and focus on the movement of voids, the movement of many robots The planning problem can be considered as a single void motion plan, which is suitable for reducing the search calculation load.

  Here, of the robot group belonging to the set M of intermediate positions, for example, the robot at the position Ps is assumed to be a head robot, and the operation will be considered. In the present embodiment, it is assumed that each robot exits from the set S of intermediate positions via the mass unit to which the position Ps belongs from the set M of intermediate positions. First, if the head robot comes out of the intermediate position set M from the position Ps, one void is generated at the position Ps. Subsequently, the voids are sequentially buried in robots adjacent to the void position other than the head robot. By doing so, the void moves in the robot group. When the void reaches the position where the robot is located farthest from the position Ps (hereinafter also referred to as “tail robot position”), the robot at the position Ps is moved to the next new head robot. Should be set.

  Such a motion of the void can be calculated by a motion plan of one void with the position Ps of the head robot as the start position and the position of the tail robot as the goal position, and the calculation load is small. For example, a position where the robot is present (tail robot position) having the longest Manhattan distance from the position Ps may be calculated, and the void may be moved from the position Ps to the tail robot position along any path. As a constraint condition for the movement of the void to be considered in this calculation, it is only necessary to provide a restriction that the robot follows the position where the robot exists when the void moves.

[Robot extrusion process]
Assume that the robot extrusion process consists of three stages. The first is an upward extrusion process in which the robot is pushed out from the position Ps in the positive direction of the Z-axis, and the pushed-out robot forms a pillar shape standing from the position Ps (see FIG. 28). Second, after the robot pushed in the positive direction of the Z-axis from the position Pr rises along the shape of the column, at the appropriate Z-coordinate value, the robot in the column uses the Y-axis. This is a flag pushing process that forms a pattern on the flag by moving one step in the negative direction (see FIG. 29). Third, the robot pushed in the positive direction of the Z-axis from the position Pr moves on the seed position unit Used, and the flag surface formed during the flag-extrusion process (the positive X-axis direction of the robot that has been pushed out ( Move to the position that touches the plane (position (1,0,2) in this embodiment) to the appropriate Z coordinate value and Y coordinate value on the flag surface. After that, the final extrusion process to form the compressed form (the shape at the end of extrusion), which is the starting state of the final deployment process, by moving one step in the negative direction of the X axis using the robot on the flag surface (See FIG. 30).

[Extrude void control common to each extrusion process]
The robot extrusion control from the common intermediate position set M in each extrusion process is performed by the tail mass unit determination operation plan executed in advance before the robot formation control starts, and each robot extrusion executed during the formation operation. It consists of an action plan for action determination. This control is called extrusion void control. A set of mass units (also referred to as a set of intermediate position units) included in the set M of robot intermediate positions in this control is defined as MU.

[Operation plan for determining tail mass unit]
Before the robot starts moving, the Manhattan distance from the seed position unit Used of each position unit in the mission space used for the two movement plans (e.g., eight squares instead of the Manhattan distance in one "mass") Manhattan distance in “mass units” consisting of However, the Manhattan distance from the seed position unit Used of two mass units Unext1 = (1,0,0) and Unext2 = (2,0,0) that are adjacent to the used in the X direction is 1, 2 respectively. Fixed, and mass units other than Used, Unext1, and Unext2 are treated as not touching other than Unext2 due to the format. In other words, the mass units other than Used, Unext1, and Unext2 are in direct contact with Used and Unext1 via Unext2. To do this, first, for each position unit (X, Y, Z) in the mission space, the Manhattan distance δ [X] [Y] [Z] from the seed position unit Used to each position unit is calculated as follows: Ask for. In the following, for simplicity of explanation, “position unit” is also simply referred to as “position”, and “seed position unit Used” is also simply referred to as “seed position Used”.

[Calculation of Manhattan distance δ]
(1) At each position (X, Y, Z) in the set MU of intermediate position units, prepare next [a] [X] [Y] [Z] and set the intermediate position unit in the direction of the adjacent action a. If there is no position (X, Y, Z) that is included in the set MU and is not Unext1, Used, set next [a] [X] [Y] [Z] ← 0, otherwise, next [a] [X] [Y] [Z] ← 1. In addition, since the set MU of intermediate position units forms a formation on a rectangular plate composed of robot units, it is clear that there are no adjacent robot units in the Z-axis direction. Therefore, the action a only needs to be calculated for 1 to 4.
(2) The Manhattan distance δ [X] [Y] [Z] at each position (X, Y, Z) in the set MU of intermediate position units is set to a value s_max larger than the number of position units in the set MU of intermediate position units. initialize.
(3) The Manhattan distance δ at the seed position Useed is initialized to 0, the Manhattan distance δ of Unext1 is initialized to 1, and the Manhattan distance δ of Unext2 is initialized to 2.
(4) Next [a] [X] [Y] [Z] values for all actions a at each position (X, Y, Z) in the set MU of intermediate position units other than positions Unext2, Unext1, Used If the position is not 0, the Manhattan distance δ [X 'among the positions (X', Y ', Z') that have been moved from the position (X, Y, Z ') by the action a other than the position Unext1, Used ] [Y '] [Z'] is examined, and if the value obtained by adding 1 to the minimum value is smaller than the current δ [X] [Y] [Z], the value is changed to δ [X] [Y ] Assign to [Z].
(5) Repeat (4) until there is no more update of the δ [X] [Y] [Z] value in the processing of (4) above.

  The Manhattan distance δ calculated by the above processing is a value of the Manhattan distance considering the movement of the robot only in the set MU of intermediate position units. FIG. 31 shows the Manhattan distance δ of each position unit in FIG. The Manhattan distance δ at positions other than the positions Unext2, Unext1, and Used is 3 or more. In this embodiment, the extrusion position is the position Ps or the position Pr, and the extrusion position is P. All positions that are P are included in the seed position unit Used. In this example, the extrusion direction a_head is the direction of a = 5 (movement in the positive direction of the Z axis). A method Tail_Robot_Decision for determining the tail robot unit using the Manhattan distance δ is described.

[Tail_Robot_Decision]
For each robot position unit (Xr_unit [j], Yr_unit [j], Zr_unit [j]) included in the set MU of intermediate position units, the one with the largest Manhattan distance δ value is selected as the tail robot unit T . Also, the seed position Useed is always set to the robot unit H in the following processing.

  In this embodiment, the robot group moves while maintaining a robot unit of eight robots. Therefore, when considering the connection maintenance of each robot when performing void control, the tail robot As long as attention is paid to the movement of voids in the vicinity of the unit T and the robot unit H, the number of voids may be within one in each robot unit.

[Operation plan for determining each robot operation]
The operation of each robot motion determination motion plan will be described below. In this operation plan, an operation plan for one “robot” is performed instead of “robot unit” composed of eight robots. In each robot motion determination motion plan, every time a robot of one mass unit is pushed out from the robot unit H, a total of eight voids are generated. First, for each of the generated voids, the void is the robot unit H. To calculate the path to follow from T to the tail robot unit T.

  Here, assuming that the maximum value of the Z coordinate values of the positions in the set G of target positions is Zmax, the total number of robots pushed out in the upward pushing process is Zmax-1. If the number of robots pushed out by a certain time is i_pole, when 0 <Zmax-1-i_pole ≦ 8, among the 8 robots pushed out from robot unit H next, in the upward pushing process The number of robots pushed out from Ps as the push-out position is np ← Zmax-1-i_pole, and the number of robots pushed out from Pr as the push-out position in the push-out process after the flag push-out process is 8-np. When Zmax-1-i_pole> 8, all eight robots pushed out from the robot unit H next are pushed out from the position Ps, and when Zmax-1-i_pole ≦ 0, they are pushed out from the robot unit H next. All eight robots are pushed out of position Pr.

  First, among the robots belonging to robot unit H, the robot that touches the position Ps in the direction opposite to the movement direction of the action a_head is the robot i_move_ps, and the robot that touches the position Pr in the direction opposite to the movement direction of the action a_head is the robot i_move_pr.

  In the robot extrusion from the robot unit H, the robot located at the position Ps in the robot unit H and the robot i_move_ps and the robot located at the position Pr and the robot i_move_pr make a pair and slide in the a_head direction. Moving. Therefore, the position of the void generated in the robot unit H is always one of the positions before the movement of the robots i_move_ps and i_move_pr. FIG. 32 shows an example of slide movement and the position of a generated void when the a_head direction is the positive Z-axis direction. The serial number of the generated voids is managed by iv (= 0,1,2,3 ... q-1) after the robot starts the extrusion process from the set MU of intermediate position units. When extrusion starts from the state where there are 8 robots in unit H), if the number of voids generated so far is iv_prev + 1, robot unit H is a set of intermediate position units MU Iv_prev + 1 is a multiple of 8, and iv_prev is (a multiple of 8-1). Let void [iv_prev + k] (k = 1,2,3,4,5,6,7,8) be a void generated by extrusion from robot unit H. Express the void trajectory as (void_trj_x [iv_prev + k] [t], void_trj_y [iv_prev + k] [t], void_trj_z [iv_prev + k] [t]) (t = 0,1,2,3…) To do. (Void_trj_x [iv_prev + k] [t], void_trj_y [iv_prev + k] [t], void_trj_z [iv_prev + k] [t]) represents the position of void void [iv_prev + k] at time t, The void trajectory is expressed by changing.

  When transforming p control objects from the set M of p intermediate positions into the shape at the end of extrusion, when moving the control object out of the intermediate position set, The void generated in the above is controlled so as to move from the position unit where the void is generated (that is, the robot unit H) to the robot located at the farthest position in the set of intermediate positions.

The trajectory calculation process (Void_Trajectory_Decision) of each void is performed in the following procedure when the δ value of the robot unit T is 3 or more. When the δ value of the robot unit T is 2 or less, Void_Trajectory_Decision_Seed described later is performed.
[Void_Trajectory_Decision]
(1) The occurrence position of each void void [iv_prev + k] is as follows.
When k ≦ np, since the upward pushing process (see FIG. 28) has not ended, the robot i is pushed out from the position Ps. At this time, the occurrence position of void [iv_prev + k] is the position before the movement of the robot i_move_ps.
When k> np, since the upward pushing process (see FIG. 28) is finished, the robot i is pushed out from the position Pr (FIGS. 29 and 30). At this time, the occurrence position of void [iv_prev + k] is the position before the movement of the robot i_move_pr.
(2) The occurrence position of each void (position before movement of the robot i_move_ps or robot i_move_pr) is set as the end point void_end [iv_prev + k] of the trajectory of each void.

(3) The eight voids whose generation positions are set in the above (1) should be traced from the position of the robot unit H to the position of the tail robot unit T (8 squares instead of one "mass") The path in “mass unit” is (void_unit_trj_x [tu], void_unit_trj_y [tu], void_unit_trj_z [tu]) (tu = 0,1,2,3…), and Void_Unit_Trajectory_Decision (void_unit_trj_x [tu], void_unit_trj_y [tu], void_unit_trj_z [tu]) is determined. The value of tu represents a point on the path from the tail robot unit T to the robot unit H. The position of the tail robot unit T is tu = 0, and the movement of the eight voids is reversed so as to increase as the robot unit H is approached. Set the orientation.
(4) (void_unit_trj_x [1], void_unit_trj_y [1], void_unit_trj_z [1]) is T ', and (void_unit_trj_x [2], void_unit_trj_y [2], void_unit_trj_z [2]) is T ". T' is a tail robot. A robot unit adjacent to the unit T, and T ″ is a robot unit adjacent to the robot unit T ′.

(5) The robots i_tail_0, i_tail_1, i_tail_2, and i_tail_3 are the four robots that are in the robot unit T ′ and not in contact with the position in the tail robot unit T, and set the target position of each void as follows: .
Target position of void [iv_prev + 1], void [iv_prev + 2] → position of robot i_tail_0
Target position of void [iv_prev + 3], void [iv_prev + 4] → position of robot i_tail_1
Target position of void [iv_prev + 5], void [iv_prev + 6] → position of robot i_tail_2
Target position of void [iv_prev + 7], void [iv_prev + 8] → position of robot i_tail_3
(6) From the same position as the occurrence position of each void in T "(occurrence position of each void in robot unit H when the robot unit H is translated to the position of T"), each void in T ' The trajectory to the target position (void_trj_x [iv_prev + k] [t], void_trj_y [iv_prev + k] [t], void_trj_z [iv_prev + k] [t]) is determined by Void_Local_Trajectory_Decision described later. The value of t is set to 0 at the target position in T ′ and is set in the opposite direction to the movement of the void so as to increase as it approaches each void generation position in T ″.

(7) End point (t = ts) of the trajectory (void_trj_x [iv_prev + k] [t], void_trj_y [iv_prev + k] [t], void_trj_z [iv_prev + k] [t]) determined in (6) above And the trajectory from the robot unit H to the void generation position is set by the following process (8).
(8) It ← 2.
(9) If (void_unit_trj_x [2 + it / 2-1], void_unit_trj_y [2 + it / 2-1], void_unit_trj_z [2 + it / 2-1]) does not match the position of robot unit H , (Void_unit_trj_x [2+ (it) / 2-1], void_unit_trj_y [2+ (it) / 2-1], void_unit_trj_z [2+ (it) / 2-1]) to (void_unit_trj_x [2 + it / 2 ], void_unit_trj_y [2 + it / 2], void_unit_trj_z [2 + it / 2]), (void_trj_x [iv_prev + k] [ts + it-2], void_trj_y [iv_prev + k] [ts + (void_trj_x [iv_prev + k] [ts + it-1], void_trj_y [iv_prev + k] [t +] from the position moved one step from it-2], void_trj_z [iv_prev + k] [ts + it-2]) it-1], void_trj_z [iv_prev + k] [t + it-1]), and the position moved two steps is (void_trj_x [iv_prev + k] [ts + it], void_trj_y [iv_prev + k] [ts + it ], void_trj_z [iv_prev + k] [ts + it]) and increment it twice. Repeat (9) until (void_unit_trj_x [2 + it / 2-1], void_unit_trj_y [2 + it / 2-1], void_unit_trj_z [2 + it / 2-1]) matches the position of robot unit H. If (void_unit_trj_x [2 + it / 2-1], void_unit_trj_y [2 + it / 2-1], void_unit_trj_z [2 + it / 2-1]) matches the robot unit H position, Finish as score trj_num [iv_prev + k] ← ts + it-2.

[Void_Local_Trajectory_Decision]
Processing of Void_Local_Trajectory_Decision is as follows. First, before the robot starts operation, five robot units T "[kt] (kt = 1, 2, 3, 4 and 5) are in contact with each other. Manhattan distance δlocal [vs] [al] (X, Y, Z) (vs = 0,1,2,3; al = 1,2,3,4,5,6) from four positions not touching T Are all calculated. Here, the Manhattan distance of one robot is obtained instead of the robot unit consisting of eight robots. Here, al is an action in six directions from the position of the robot unit T to the position of the robot unit T ′, and vs is an index of four robots (that position) that do not touch the tail robot unit T in the robot unit T ′. It is.

(1) al = 1, T = (0,0,0), T '= (1,0,0), T "[1] = (1,1,0), T" [2] = (1 , -1,0), T "[3] = (2,0,0), T" [4] = (1,0,1), T "[5] = (1,0, -1)
(2) al = 2, T = (0,0,0), T '= (0,1,0), T "[1] = (1,1,0), T" [2] = (- 1,1,0), T "[3] = (0,2,0), T" [4] = (0,1,1), T "[5] = (0,1, -1)
(3) al = 3, T = (0,0,0), T '= (-1,0,0), T "[1] = (-1,1,0), T" [2] = (-1, -1,0), T "[3] = (-2,0,0), T" [4] = (-1,0,1), T "[5] = (-1, (0, -1)
(4) al = 4, T = (0,0,0), T '= (0, -1,0), T "[1] = (1, -1,0), T" [2] = (-1, -1,0), T "[3] = (0, -2,0), T" [4] = (0, -1,1), T "[5] = (0,- 1, -1)
(5) al = 5, T = (0,0,0), T '= (0,0,1), T "[1] = (0,1,1), T" [2] = (0 , -1,1), T "[3] = (0,0,2), T" [4] = (1,0,1), T "[5] = (-1,0,1)
(6) al = 6, T = (0,0,0), T '= (0,0, -1), T "[1] = (0,1, -1), T" [2] = (0, -1, -1), T "[3] = (0,0, -2), T" [4] = (1,0, -1), T "[5] = (-1, (0, -1)

  Since the shape of the set M at the intermediate position is a rectangular flat plate, a straight line, or an L-shaped flat plate, the tail robot unit T and the robot units T ′ and T ″ do not touch in the Z-axis direction. The positional relationship between the tail robot unit T and the robot unit T ′ may be limited to 4. Further, three robot units T ”[kt] (kt = 1, 2, 3) are in contact with the robot unit T ′. You may limit that. For the Manhattan distance δlocal [vs] [al] (X, Y, Z) from four positions not in contact with the tail robot unit T in the robot unit T ′, (vs = 0, 1, 2, 3). Only 16 patterns of = 1, 2, 3, 4) may be calculated.

Hereinafter, a calculation method (Calculate_delta_local) of δlocal [vs] [al] (X, Y, Z) is shown.
[Calculate_delta_local]
(1) next_local [al] [a] [X] [Y] [Z at the position (X, Y, Z) of the robot unit T 'that does not touch the tail robot unit T and all the positions (X, Y, Z) of the robot unit T " ], And if there is a position not in contact with the tail robot unit T in the robot unit T ′ adjacent to the position (X, Y, Z) or a position in the robot unit T ″, next_local [al] [a ] [X] [Y] [Z] ← 1, otherwise, next_local [al] [a] [X] [Y] [Z] ← 0.
(2) δlocal [vs] [of each position (X, Y, Z) for all positions (X, Y, Z) of robot unit T 'and all positions (X, Y, Z) of robot unit T "within robot unit T' al] (X, Y, Z) values are initialized to a value s_max greater than 44 (number of 4 positions in T ′, 8 × 5 positions in T ″).

(3) For each vs and al, the following positions are set as target positions target_local [vs] [al], and the Manhattan distance δlocal [vs] [al] (24 ways) at the target positions is initialized to 0.
target_local [0] [1] = (3,0,0)
target_local [1] [1] = (3,0,1)
target_local [2] [1] = (3,1,0)
target_local [3] [1] = (3,1,1)
target_local [0] [2] = (0,3,0)
target_local [1] [2] = (0,3,1)
target_local [2] [2] = (1,3,0)
target_local [3] [2] = (1,3,1)
target_local [0] [3] = (-2,0,0)
target_local [1] [3] = (-2,0,1)
target_local [2] [3] = (-2,1,0)
target_local [3] [3] = (-2,1,1)
target_local [0] [4] = (0, -2,0)
target_local [1] [4] = (0, -2,1)
target_local [2] [4] = (1, -2,0)
target_local [3] [4] = (1, -2,1)
target_local [0] [5] = (0,0,3)
target_local [1] [5] = (0,1,3)
target_local [2] [5] = (1,0,3)
target_local [3] [5] = (1,1,3)
target_local [0] [6] = (0,0, -2)
target_local [1] [6] = (0,1, -2)
target_local [2] [6] = (1,0, -2)
target_local [3] [6] = (1,1, -2)
(4) The value of next_local [al] [a] [X] [Y] [Z] is 0 for all actions a at each position (X, Y, Z) except for the target position target_local [vs] [al] If not, the value of δlocal [vs] [al] (X, Y, Z) is examined, and the value obtained by adding 1 to the minimum value is the current δlocal [vs] [al] (X, Y, Z) If it is smaller than), the value is assigned to δlocal [vs] [al] (X, Y, Z). Repeat (4) until the δlocal [vs] [al] (X, Y, Z) value is no longer updated.

Return to Void_Local_Trajectory_Decision processing.
[Void_Local_Trajectory_Decision]
(1) The position of the robot unit T 'is (XT', YT ', ZT') and the position of the robot unit T "is (XT", YT ", ZT"). From the position of the robot unit T, the robot unit T ' The action in the direction toward the position is defined as the al value. The location of i_tail_0 is target_local [0] [al] (vs ← 0), the location of i_tail_1 is target_local [1] [al] (vs ← 1), and the location of i_tail_2 is target_local [2] [al] ( vs ← 2), and the position of i_tail_3 is assumed to be target_local [3] [al] (vs ← 3).

(2) The occurrence position of each void void [iv_prev + k] is (xv [iv_prev + k], yv [iv_prev + k], zv [iv_prev + k]), and the position vt "in the robot unit T" is Calculate as follows. The position of the mass unit of H is (xrh, yrh, zrh), and the value of the movement vector from T 'to T "is (Xdt, Ydt, Zdt) ← (XT", YT ", ZT")-(XT' , YT ', ZT')
If al = 1
vt "← (xv [iv_prev + k] -xrh * 2 + 2 + Xdt * 2, yv [iv_prev + k] -yrh * 2 + Ydt * 2, zv [iv_prev + k] -zrh * 2 + Zdt * 2 )
And if al = 2
vt "← (xv [iv_prev + k] -xrh * 2 + Xdt * 2, yv [iv_prev + k] -yrh * 2 + 2 + Ydt * 2, zv [iv_prev + k] -zrh * 2 + Zdt * 2 )
And if al = 3
vt "← (xv [iv_prev + k] -xrh * 2-2 + Xdt * 2, yv [iv_prev + k] -yrh * 2 + Ydt * 2, zv [iv_prev + k] -zrh * 2 + Zdt * 2 )
And if al = 4
vt "← (xv [iv_prev + k] -xrh * 2 + Xdt * 2, yv [iv_prev + k] -yrh * 2-2 + Ydt * 2, zv [iv_prev + k] -zrh * 2 + Zdt * 2 )
And if al = 5
vt "← (xv [iv_prev + k] -xrh * 2 + Xdt * 2, yv [iv_prev + k] -yrh * 2 + Ydt * 2, zv [iv_prev + k] -zrh * 2 + 2 + Zdt * 2 )
And if al = 6
vt "← (xv [iv_prev + k] -xrh * 2 + Xdt * 2, yv [iv_prev + k] -yrh * 2 + Ydt * 2, zv [iv_prev + k] -zrh * 2-2 + Zdt * 2 )
And

(3) tl ← 0, and the position of vt "is (void_local_x [iv_prev + k] [tl], void_local_y [iv_prev + k] [tl], void_local_z [iv_prev + k] [tl]).
(4) When the position (void_local_x [iv_prev + k] [tl], void_local_y [iv_prev + k] [tl], void_local_z [iv_prev + k] [tl]) does not match target_local [vs] [al]
Adjacent to the location (void_local_x [iv_prev + k] [tl], void_local_y [iv_prev + k] [tl], void_local_z [iv_prev + k] [tl]) and the value of δlocal [vs] [al] is (void_local_x [iv_prev + k] [tl], void_local_y [iv_prev + k] [tl], void_local_z [iv_prev + k] [tl]) position less than δlocal [vs] [al] value (void_local_x [iv_prev + k] [tl + 1], void_local_y [iv_prev + k] [tl + 1], void_local_z [iv_prev + k] [tl + 1]) and increment tl. Repeat (4) until (void_local_x [iv_prev + k] [tl], void_local_y [iv_prev + k] [tl], void_local_z [iv_prev + k] [tl]) matches target_local [vs] [al]. If the position (void_local_x [iv_prev + k] [tl], void_local_y [iv_prev + k] [tl], void_local_z [iv_prev + k] [tl]) matches target_local [vs] [al], go to (5) Transition.
(5) (void_trj_x [iv_prev + k] [t], void_trj_y [iv_prev + k] [t], void_trj_z [iv_prev + k] [t]) ← (void_local_x [iv_prev + k] [tl-t], void_local_y [ iv_prev + k] [tl-t], void_local_z [iv_prev + k] [tl-t]), and ts ← tl.

(6) If al = 1
(void_trj_x [iv_prev + k] [t], void_trj_y [iv_prev + k] [t], void_trj_z [iv_prev + k] [t]) ← (void_trj_x [iv_prev + k] [t] -2 + XT ', void_trj_y [ iv_prev + k] [t] + YT ', void_trj_z [iv_prev + k] [t] + ZT')
And
If al = 2
(void_trj_x [iv_prev + k] [t], void_trj_y [iv_prev + k] [t], void_trj_z [iv_prev + k] [t]) ← (void_trj_x [iv_prev + k] [t] XT ', void_trj_y [iv_prev + k ] [t] -2 + YT ', void_trj_z [iv_prev + k] [t] + ZT')
And
If al = 3
(void_trj_x [iv_prev + k] [t], void_trj_y [iv_prev + k] [t], void_trj_z [iv_prev + k] [t]) ← (void_trj_x [iv_prev + k] [t] + 2 + XT ', void_trj_y [ iv_prev + k] [t] + YT ', void_trj_z [iv_prev + k] [t] + ZT')
And
If al = 4
(void_trj_x [iv_prev + k] [t], void_trj_y [iv_prev + k] [t], void_trj_z [iv_prev + k] [t]) ← (void_trj_x [iv_prev + k] [t] XT ', void_trj_y [iv_prev + k ] [t] +2 + YT ', void_trj_z [iv_prev + k] [t] + ZT')
And
If al = 5
(void_trj_x [iv_prev + k] [t], void_trj_y [iv_prev + k] [t], void_trj_z [iv_prev + k] [t]) ← (void_trj_x [iv_prev + k] [t] + XT ', void_trj_y [iv_prev + k] [t] + YT ', void_trj_z [iv_prev + k] [t] -2 + ZT')
And
If al = 6
(void_trj_x [iv_prev + k] [t], void_trj_y [iv_prev + k] [t], void_trj_z [iv_prev + k] [t]) ← (void_trj_x [iv_prev + k] [t] XT ', void_trj_y [iv_prev + k ] [t] + YT ', void_trj_z [iv_prev + k] [t] + 2 + ZT')
And

The processing of Void_Unit_Trajectory_Decision is as follows.
[Void_Unit_Trajectory_Decision]
(1) The position of the tail robot unit T is (void_unit_trj_x [0], void_unit_trj_y [0], void_unit_trj_z [0]). It is assumed that tu ← 1 and the position of an adjacent robot unit having a Manhattan distance δ smaller than the tail robot unit T is (void_unit_trj_x [tu], void_unit_trj_y [tu], void_unit_trj_z [tu]).
(2) If (void_unit_trj_x [tu], void_unit_trj_y [tu], void_unit_trj_z [tu]) is not robot unit H, increment tu and position (void_unit_trj_x [tu-1], void_unit_trj_y [tu-1], Let (void_unit_trj_x [tu], void_unit_trj_y [tu], void_unit_trj_z [tu]) be the position of an adjacent robot unit having a Manhattan distance δ smaller than the robot unit in void_unit_trj_z [tu-1]). Repeat (2) until (void_unit_trj_x [tu], void_unit_trj_y [tu], void_unit_trj_z [tu]) reaches the robot unit H position.

When the δ value of the robot unit T is 2 or less, the trajectory calculation process (Void_Trajectory_Decision_Seed) for each void is performed according to the following procedure.
[Void_Trajectory_Decision_Seed]
(1) The occurrence position of each void void [iv_prev + k] is as follows.
When k ≦ np, the occurrence position of void [iv_prev + k] is the position before the movement of the robot i_move_ps.
When k> np, the occurrence position of void [iv_prev + k] is the position before the movement of the robot i_move_pr.
(2) The occurrence position of each void is the end point void_end [iv_prev + k] of the trajectory of each void.

(3) The eight voids whose occurrence positions are set in the above (1) should follow the path of the position unit to be followed from the position of robot unit H to the position of tail robot unit T (void_unit_trj_x [tu], void_unit_trj_y [tu], void_unit_trj_z [tu]) (tu = 0,1,2,3 ...) and set as follows.
When T = Unext2
(void_unit_trj_x [0], void_unit_trj_y [0], void_unit_trj_z [0]) ← (2,0,0)
(void_unit_trj_x [1], void_unit_trj_y [1], void_unit_trj_z [1]) ← (1,0,0)
(void_unit_trj_x [2], void_unit_trj_y [2], void_unit_trj_z [2]) ← (0,0,0)
And when T = Unext1
(void_unit_trj_x [0], void_unit_trj_y [0], void_unit_trj_z [0]) ← (1,0,0)
(void_unit_trj_x [1], void_unit_trj_y [1], void_unit_trj_z [1]) ← (0,0,0)
And The value of tu represents a point on the path from the tail robot unit T to the robot unit H. The position of the tail robot unit T is tu = 0, and the value increases in the opposite direction to the movement of the void so as to approach H. Set.

(4) Let T 'be (void_unit_trj_x [1], void_unit_trj_y [1], void_unit_trj_z [1]).
(5) A point that is in T ′, is not in contact with the position in the tail robot unit T, has a Y coordinate of 1 and a Z coordinate of 0 is set as a target position of each void. For example,
When T = Unext2 → (2,1,0)
When T = Unext1 → (1,1,0)
And
(6) The target position of each void is (void_trj_x [0], void_trj_y [0], void_trj_z [0]). t ← 0.
(7) If the value of incrementing t and decrementing void_trj_x [t-1] is 0 or more, (void_trj_x [t], void_trj_y [t], void_trj_z [t]) ← (void_trj_x [t-1]- 1, void_trj_y [t-1], void_trj_z [t-1]). If the value obtained by decrementing void_trj_x [t-1] is less than 0, proceed to (8).
(8) When k ≦ np, t is incremented to (void_trj_x [t], void_trj_y [t], void_trj_z [t]) = (0,0,0).
(9) Increment t and set trj_num [iv_prev + k] ← t. al ← 3.

[Void movement control]
Hereinafter, a control method for moving the void from the position of the robot unit H to the position of the tail robot unit T using each of the above-described robot operation determination operation plans will be described. As shown in FIG. 33, void generation in the robot unit H and void expulsion in the tail robot unit T are performed so that there is no blank at the position of the robot that is in contact with the tail robot unit T in the robot unit T ′. As a result, the connection of the entire robot group is maintained. In the selection algorithm of the tail robot unit T, the δ of the position of the tail robot unit T (Manhattan distance between the robot unit H and the tail robot unit T) is 3 or more so that the robot unit H and the robot unit T ′ do not directly touch each other. This condition is set. With this control method, control is performed so that the number of voids is within one in each robot unit.

The following is repeatedly called and executed in the push-out control until the extruding process ends when all but voids generated during the tail robot unit T are other than Unext1, Unext2, and Used. The calling algorithm will be described later.
[Void_Control]
(1) When this process is executed for the first time or when the internal variable i_motion_flg = 0, i_motion_flg ← 1, and when iv_prev <(p-24) -1, Void_Trajectory_Decision is set to q-1> iv_prev ≧ (p -24) When Void_Trajectory_Decision_Seed is executed, trj_cnt [iv_prev + 1], ..., trj_cnt [iv_prev + 8], is set to -1. When q-1-iv_prev is 8 or more, the value of iv_prev is incremented 8 times. Otherwise, the value of iv_prev is incremented q-1-iv_prev times.

(2) When i_motion_flg = 1, execute the following until void [iv_prev] goes out of robot unit H. If void [iv_prev] is evicted, i_motion_flg ← 0.
The following processing is performed from the one with the largest occurrence number (iv = iv_prev).
(2-i) When trj_cnt [iv] =-10 → Do nothing for void [iv].
(2-ii) When trj_cnt [iv] <trj_num [iv] and trj_cnt [iv] ≧ 0 →
Set i = trj_cnt [iv] and do the following:
There is another void in the robot unit Nv that contains the position nv (void_trj_x [trj_num [iv] -i-1], void_trj_y [trj_num [iv] -i-1], void_trj_z [trj_num [iv] -i-1]) Confirm that all voids with numbers smaller than themselves belong to the robot unit whose Manhattan distance δ is larger than the robot unit Nv. If confirmed, the robot at the position of nv is moved to the position (void_trj_x [trj_num [iv] -i], void_trj_y [trj_num [iv] -i], void_trj_z [trj_num [iv] -i]). Increment trj_cnt [iv]. If you cannot confirm, do nothing.
(2-iii) When trj_cnt [iv] = trj_num [iv] →
All robots that are adjacent in the direction opposite to the direction of al from the current position of void [iv] and that are traced are moved one step in the direction of al, and trj_cnt [iv] ← −10. When iv ≧ p−24 and iv is an odd number, i_motion_flg is set to 3.
(2-iv) When trj_cnt [iv] =-1 →
If the robot unit H is filled with 8 robots, all robots with Z coordinates of 2 or more where the position of void [iv] and the X and Y coordinates are the same are moved one step in the direction of a_head. Also, the robot at the position where void [iv] occurs and the robot (position Ps or Pr) adjacent to the robot in the direction of action a_head are moved one step in the direction of a_head. Set trj_cnt [iv] ← 0. If you are not satisfied, do nothing.

(3) When i_motion_flg = 5, the following operations are performed for the robots in the tail robot unit T.
Increment the Z coordinate of all robots whose Y coordinate is 0 and Z coordinate is 0. If iv <q-1, set i_motion_flg to 1 and finish.
(4) When i_motion_flg = 4, the following operations are performed for the robots in the tail robot unit T.
Increment Y coordinate of all robots with Y coordinate 0 and Z coordinate 1, set i_motion_flg to 5 and finish.
(5) When i_motion_flg = 3, the following operations are performed for the robots in the tail robot unit T.
Decrement the Z coordinate of all robots whose Y coordinate is 1 and Z coordinate is 1, set i_motion_flg to 4 and finish.

[Upward extrusion process]
The variables for storing the position of each robot i at each time step tm in the following extrusion process are (motion_x [tm] [i], motion_y [tm] [i], motion_z [tm] [i]).

Hereafter, in each push-out process described below, each robot's motion plan is made and the result is stored in (motion_x [tm] [i], motion_y [tm] [i], motion_z [tm] [i]) Go.
[Motion_Data_Update]
Store the current position of each robot i in (motion_x [tm] [i], motion_y [tm] [i], motion_z [tm] [i]), and increment tm.

  A maximum value of the Z coordinate values of the positions in the set G of target positions is set as Zmax, and a column parallel to the Z axis composed of Zmax-1 robots is formed. Starting from the robot at the position Ps, the robot is pushed in the positive direction (upward) of the Z axis (see FIG. 28). Processing of this process (Upward_Pushing) is as follows.

[Upward_Pushing]
(1) Set i_pole ← 0 as a variable representing the height of the extruded column. tm ← 0. Execute [Motion_Data_Update].
(2) When Zmax-1-i_pole> 8, the above-described Void_Control is executed as np ← 8. When Zmax-1-i_pole ≦ 8, Void_Control is executed as np ← Zmax-1-i_pole. Substitute the total number of robots whose Z coordinate is 2 or more for i_pole. Run Motion_Data_Update.
(3) Repeat (2) until Zmax-1 = i_pole.

[Flag extruding process]
In the flag push-out process (see FIG. 29), the flag shape formed continuously from the position of the height of each Z coordinate value (from 2 to Zmax) in the pillar generated in the previous process in the negative Y-axis direction. Expressed as the number of robots in contact _y_num [Z]. The total number of _y_num [Z] from Z = 2 to Zmax is _y_all. _y_num [Z] is calculated in the final expansion process described later. Note that the values of Zmax and _y_num [Z] can be obtained from a set of target positions given in advance. The process of pushing out the flag is the same when the robot pushed out from the position Pr reaches the Z coordinate value to reach to the Z coordinate value to be reached while reaching the Z coordinate value to reach the Z coordinate value to be reached by following the extruded column surface. At the same time as all the robots with the Z coordinate value, the process of moving the position one step in the negative Y-axis direction is repeated until the flag shape is completed. It is executed in the following process.

[Flag_Pushing]
(1) Set variable _z ← 0. The number of extruded robots_i_pushed ← 0.
(2) Repeat steps (3) to (7) below while _z <Zmax-1.
(3) Set _y ← 0, and repeat (4) to (6) for _y <_y_num [_z + 2].
(4) Execute Update_Y_Branch described later. The total number of robots with the Z coordinate at _z + 2 is counted, and the number −1 is stored in the variable _y.
(5) When _i_pushed <_y_all, execute Void_Control with np ← 0 (push from position Pr). If VoidControl pushes out a new robot, increment i_pushed. When _i_pushed = _y_all, the robot whose X coordinate is 0, Y coordinate is 1, and Z coordinate is 2 or more is moved one step in the positive direction of the Z axis.
(6) Execute [Motion_Data_Update].
(7) Increment _z.

[Update_Y_Branch]
In Update_Y_Branch, the robot that has reached the Z coordinate value that should be reached is moved one step in the Y-axis negative direction simultaneously with all the robots with the same Z coordinate value.
(1) When there is a robot at the position (0,1, _z + 2), all the robots whose Z coordinate value is _z + 2 are moved one step in the negative Y direction.
(2) Execute [Motion_Data_Update].

[Final extrusion process]
The shape formed in the final extrusion process is represented by variables _x_num [Y] [Z] (Y = 0 to _y_num [Z], Z = 2 to Zmax) representing the floor shape in the XY plane at each Z value. The The value of _x_num is calculated in the final expansion process described later. The value of _x_num can be obtained from a set of target positions given in advance. The value of _x_num stores the number of robots having respective Y and Z values that are continuously in contact with the flag shape formed in the previous process in a direction parallel to the X axis. The shape after the final extrusion process is finished is referred to as a shape at the end of extrusion. In the final push-out process, the robot pushed out from the position Pr moves along the flag shape to the Y coordinate value and Z coordinate value to be reached while following the flag shape formed in the previous process (this embodiment First, after arriving at the Z coordinate value that should be reached, move to the Y coordinate value that should be reached), and when reaching the Y coordinate value and the Z coordinate value to be reached, the same Y coordinate value and Z coordinate value are reached. At the same time as all of the robots, the process of moving the position one step in the negative direction of the X axis is a process that is repeated until the shape is completed at the end of extrusion. It is executed in the following process.

[Last_Pushing]
(1) Set i_pushed ← 0. Set _z ← 0.
(2) While _z <Zmax-1, repeat steps (3) to (9).
(3) Set _y ← 0, and repeat (4) to (8) while _y ≦ _y_num [_z + 2].
(4) Set _x ← 0, the variable _x_all ← 0 to store the number of extruded robots, and repeat (5) to (7) during _x <_x_num [_y] [_ z + 2].
(5) Execute Update_X_Floor described later. After execution, the number of robots −1 at positions Y = _y and Z = _z + 2 is stored in _x.
(6) When _x_all <_x_num [_y] [_ z + 2], execute Void_Control as np ← 0. After the execution, when the robot is pushed out from the position Pr, _x_all is incremented, the number i of the pushed robot is stored in the variable pushed_floor [i_pushed], Set_Pushed_Cube_Trajectory described later is executed, and i_pushed is incremented.
(7) Execute [Motion_Data_Update].
(8) Increment _y.
(9) Increment _z.
(10) Repeat Void_Control until all generated voids are expelled.

[Set_Pushed_Cube_Trajectory]
(1) In the process Set_Pushed_Cube_Trajectory, the target action action_floor [i_pushed] [tp] at the time tp of the robot pushed_floor [i_pushed] is set. For example, the setting is as follows.
action_floor [i_pushed] [0] ← 1,
action_floor [i_pushed] [1] ← 4,
(1-1) 2 ≦ tp <_z + 2
action_floor [i_pushed] [tp] ← 5,
(1-2) _z + 2 ≦ tp <_z + 2 + _y,
action_floor [i_pushed] [tp] ← 4,
(1-3) tp = _z + 2 + _y,
action_floor [i_pushed] [tp] ← 3,
(1-4) tp> _z + 2 + _y,
action_floor [i_pushed] [tp] ← 0,
And
(2) time_pushed_robot [i_pushed] ← 0.

[Update_X_Floor]
In the process Update_X_Floor, the target action action_floor [i_pushed] [tp] set in the process Set_Pushed_Cube_Trajectory is executed. For example, it executes as follows.
(1) Execute (2) for all _p from _p = 0 to i_pushed-1.
(2) The value of action_floor [_p] [time_pushed_robot [_p]] is
When 0: Do nothing
When 1: Increment X coordinate of robot pushed_floor [_p]. Increment time_pushed_robot [_p].

  When 3: Moves all robots whose Y coordinate is _y and Z coordinate is _z + 2 one step in the negative X-axis direction. Increment time_pushed_robot [_p].

  When 4: The Y coordinate of the robot pushed_floor [_p] is decremented. Increment time_pushed_robot [_p].

5: Increment the Z coordinate of the robot pushed_floor [_p]. Increment time_pushed_robot [_p].
(3) Execute [Motion_Data_Update].

[Final development process]
The final development process will be described with reference to FIG. FIG. 34E shows an example of a shape at the end of extrusion, and FIG. 34A shows an example of a virtual robot (hereinafter also referred to as a virtual robot) located in a set of target positions. In the final deployment process, first, a virtual robot whose virtual plane perpendicular to the X axis is at the target position (Xre [j], Yre [j], Zre [j]) is moved from the X axis positive infinity to the X axis. Move in the negative direction and press the virtual robot that hits the virtual plane to compress all robots so that the X coordinate value is 0 or less (corresponding to process Extend_Process_X_Minus in Fig. 34B), and then perpendicular to the X axis Move the virtual robot at the target position from the X axis negative direction infinity to the X axis positive direction, press the virtual robot that hits the virtual plane, and for all robots whose X coordinate is not 0, The robot is compressed so that there is a robot in the positive direction of the X-axis (corresponding to FIG. 34C, process Extend_Process_X_Plus), and then the virtual plane perpendicular to the Y-axis is the virtual position at the target position. Moved the robot from Y-axis positive infinity to Y-axis negative direction and hit the virtual plane Press the virtual robot to compress all robots so that the Y coordinate value is 0 or less (corresponding to FIG. 34D, process Extend_Process_Y_Minus), and then the virtual plane perpendicular to the Y axis is the virtual position at the target position. Move the robot from Y-axis negative direction infinity to Y-axis positive direction, and press the virtual robot that hits the virtual plane, and there is a robot that touches the robot's Y-axis positive direction for all robots whose Y coordinate is not 0 This is a process of calculating the operation of each robot when it is compressed so as to be in a state of being in FIG. 34E (corresponding to the process Extend_Process_Y_Plus). Through this process, the shape of the set G of target positions is deformed so as to be the same as the shape of the robot after the final extrusion process (the shape at the end of extrusion). The processing for that is as follows.

[Extend_Process]
(1) Set tm ← 0. The position of the virtual robot i is set to the target position (Xre [i], Yre [i], Zre [i]). Execute [Motion_Data_Update]. Execute [Extend_Process_X_Minus] described later.
(2) Execute [Extend_Process_X_Plus] described later.
(3) Execute [Extend_Process_Y_Minus] described later.
(4) Execute [Extend_Process_Y_Plus] described later.
(5) At the position of the virtual robot i at the current time tm, the maximum value of the Z coordinate is Zmax, and the number of virtual robots whose X coordinate is 0 at each Z coordinate value_z-1 is _y_num [_z] In addition, the number of virtual robots −1 whose Y coordinate value is _y at each Z coordinate value_z is stored in _x_num [_y] [_ z].

[Extend_Process_X_Minus]
(1) Let Xmax be the maximum value of the X coordinate for all virtual robots.
(2) Set _xw = Xmax and repeat (3) to (5) while _xw> 0.
(3) The variable destination_to_be_compressed [i] ← 0 is set for all virtual robots i. Set _flg_c ← 0.
(4) For the virtual robot i whose X coordinate value is _xw, execute the following.
(4-1) For all virtual robots i whose X coordinate value is _xw, destination_to_be_compressed [i] ← 1.
(4-2) Destination_to_be_compressed [in] ← 1 for all virtual robots in adjacent to the virtual robot i in the negative direction of the X-axis.
(4-3) _flg_c ← 1.
(5) When _flg_c = 1, the X coordinate values of all virtual robots with destination_to_be_compressed [i] = 1 are decremented and [Motion_Data_Update] is executed. Decrement _xw.

[Extend_Process_X_Plus]
(1) The minimum value of the X coordinate of the virtual robot position at the current time tm is Xmin, _xw = Xmin, and (2) to (4) are repeated while _xw <0.
(2) The variable destination_to_be_compressed [i] ← 0 is set for all virtual robots i. Set _flg_c ← 0.
(3) For the virtual robot i whose X coordinate value is _xw, execute the following.
(3-1) Destination_to_be_compressed value of virtual robots i to in adjacent virtual robots i if there is no X coordinate among all virtual robots in the X axis that are adjacent to each other without interruption Is 1, and _flg_c ← 1.
(4) When _flg_c = 1, the X coordinate values of all virtual robots with destination_to_be_compressed [i] = 1 are incremented and [Motion_Data_Update] is executed. Increment _xw.

[Extend_Process_Y_Minus]
(1) The maximum value of the Y coordinate of the virtual robot position at the current time tm is set to Ymax, _yw = Ymax, and (2) to (4) are repeated while _yw> 0.
(2) The variable destination_to_be_compressed [i] ← 0 is set for all virtual robots i. Set _flg_c ← 0.
(3) For the virtual robot i whose Y coordinate value is _yw, execute the following.
(3-1) Destination_to_be_compressed [i] ← 1 is set for all virtual robots i whose Y coordinate value is _yw.
(3-2) Destination_to_be_compressed [in] ← 1 is set for all virtual robots in adjacent to the virtual robot i without interruption in the negative Y-axis direction.
(3-3) Set _flg_c ← 1.
(4) When _flg_c = 1, the Y coordinate values of all virtual robots with destination_to_be_compressed [i] = 1 are decremented and [Motion_Data_Update] is executed. Decrement _yw.

[Extend_Process_Y_Plus]
(1) The minimum value of the Y coordinate of the virtual robot position at the current time tm is set to Ymin, _yw = Ymin, and (2) to (4) are repeated while _yw <0.
(2) The variable destination_to_be_compressed [i] ← 0 is set for all virtual robots i. Set _flg_c ← 0.
(3) For the virtual robot i whose Y coordinate value is _yw, execute the following.
(3-1) Destination_to_be_compressed value of virtual robots i to in the adjacent virtual robots i to in if none of the virtual robots in the Y-axis positive direction is adjacent to the virtual robot i and the Y coordinate is 0 Is 1, and _flg_c ← 1.
(4) When _flg_c = 1, the Y coordinate values of all virtual robots with destination_to_be_compressed [i] = 1 are incremented, and [Motion_Data_Update] is executed. Increment _yw.

[Transformation transformation from set M at intermediate position to set G at target position]
As described above, the process Transform_from_M_to_G for calculating the movement until the robot in the set M at the intermediate position moves to the set G at the target position by the formation control is as follows.
[Transform_from_M_to_G]
(1) Execute Extend_Process. From t = 0 to tm-1, the value of (motion_x [t] [i], motion_y [t] [i], motion_z [t] [i]) is changed to the variable (compressed_x [t] [i], compressed_y [t ] [i], compressed_z [t] [i]). Store the value of tm in variable tc.
(2) Execute Upward_Pushing.
(3) Execute Flag_Pushing.
(4) Execute Last_Pushing.

(5) For all virtual robots j, (motion_x [tm-1] [i], motion_y [tm-1] [i], motion_z [tm-1] [i]) = (compress_x [j] [tc -1], compress_y [j] [tc-1], compress_z [j] [tc-1]) are identified and stored in the value of destination_robot_index [j].
(6) The following processing is performed for times t = tm to tm + tc-1.
(6-1) For all robots i (motion_x [t] [i], motion_y [t] [i], motion_z [t] [i]) ← (motion_x [tm-1] [i], motion_y [tm -1] [i], motion_z [tm-1] [i]).
(6-2) For all virtual robots j (motion_x [t] [destination_robot_index [j]], motion_y [t] [destination_robot_index [j]], motion_z [t] [destination_robot_index [j]]) ← (compress_x [j ] [tc-1- (t-tm)], compress_y [j] [tc-1- (t-tm)], compress_z [j] [tc-1- (t-tm)]).
(7) From t = 0 to tm + tc-1, the variable (transform_M_to_G_x [t] [i], transform_M_to_G_y [t] [i], transform_M_to_G_z [t] [i]) is changed to (motion_x [t] [i] , motion_y [t] [i], motion_z [t] [i]) are stored. t_m_to_g ← tm + tc-1.

  With the above processing, the process until the robot in the intermediate position set M moves to the target position set G is (transform_M_to_G_x [t] [i], transform_M_to_G_y [t] [i], transform_M_to_G_z [t] [i ]).

[Transformation from set S of starting positions to set M of intermediate positions]
The formation transformation from the start position set S to the intermediate position set M is performed by changing (1) to (4) in the formation transformation process [Transform_from_M_to_G] from the intermediate position set M to the target position set G described above. All the points corresponding to the set G are replaced with the set S at the start position, and the process is executed. What is necessary is just to reversely reproduce the time series result of the deformation calculated in the processing.

As described above, the process of calculating the movement until the robot in the set S of start positions moves to the set M of intermediate positions by the formation control is as follows.
[Transformation_from_S_to_M]
(1) Execute Extend_Process by replacing all locations corresponding to the target position set G with the start position set S. From t = 0 to tm-1, the value of (motion_x [t] [i], motion_y [t] [i], motion_z [t] [i]) is changed to the variable (compressed_x [t] [i], compressed_y [t ] [i], compressed_z [t] [i]). Store the value of tm in variable tc.
(2) The Upward_Pushing is executed by replacing all points corresponding to the target position set G with the start position set S.
(3) Flag_Pushing is executed by replacing all locations corresponding to the target position set G with the start position set S.
(4) Last_Pushing is executed by replacing all locations corresponding to the target position set G with the start position set S.
(5) For all virtual robots j, (motion_x [tm-1] [i], motion_y [tm-1] [i], motion_z [tm-1] [i]) = (compress_x [j] [tc -1], compress_y [j] [tc-1], compress_z [j] [tc-1]) are identified and stored in the value of destination_robot_index_2 [j].

(6) The following processing is performed for time t = tm to tc-1.
(6-1) For all robots i (motion_x [t] [i], motion_y [t] [i], motion_z [t] [i]) ← (motion_x [tm-1] [i], motion_y [tm -1] [i], motion_z [tm-1] [i]).
(6-2) For all virtual robots j (motion_x [t] [destination_robot_index_2 [j]], motion_y [t] [destination_robot_index_2 [j]], motion_z [t] [destination_robot_index_2 [j]]) ← (compress_x [j ] [tc-1- (t-tm)], compress_y [j] [tc-1- (t-tm)], compress_z [j] [tc-1- (t-tm)]).
(7) From t = 0 to tm + tc-1, the variable (transform_S_to_M_x [t] [i], transform_S_to_M_y [t] [i], transform_S_to_M_z [t] [i]) is changed to (motion_x [tm + tc-1 -t] [i], motion_y [tm + tc-1-t] [i], motion_z [tm + tc-1-t] [i]) are stored. t_s_to_m ← tm + tc-1.

  By the above processing, the process until the robot in the start position set S moves to the intermediate position set M is (transform_S_to_M_x [t] [i], transform_S_to_M_y [t] [i], transform_S_to_M_z [t] [i ]).

[Homo formation deformation from start position set S to target position set G]
By combining the above processing, a deformation process from the set S of start positions to the set G of target positions is obtained.
[Transformation_from_S_to_G_Homo]
(1) Execute [Transformation_from_M_to_G].
(2) Execute [Transformation_from_S_to_M].
(3) From t = 0 to t_s_to_m, the variable (transform_S_to_G_x [t] [i], transform_S_to_G_y [t] [i], transform_S_to_G_z [t] [i]) ] [i], transform_S_to_M_z [t] [i]) are stored.
(4) From t = t_s_to_m + 1 to t_s_to_m + 1 + t_m_to_g, the variable (transform_S_to_G_x [t] [i], transform_S_to_G_y [t] [i], transform_S_to_G_z [t] [i]) t_s_to_m + 1)] [i], transform_M_to_G_y [t- (t_s_to_m + 1)] [i], transform_M_to_G_z [t- (t_s_to_m + 1)] [i]) are stored.

  With the above processing, the process until the robot in the start position set S moves to the target position set G is (transform_S_to_G_x [t] [i], transform_S_to_G_y [t] [i], transform_S_to_G_z [t] [i ]).

[Hetero formation deformation from start position set S to target position set G]
It is assumed that the position j in the start position set S and the position j in the target position set G are occupied by the same robot. In such a case, in order for the robot i that was in the specific position j in the set S of start positions to move to the specific position j in the set G of target positions, in addition to the processing of Trandformation_from_S_to_G_Homo described above It is necessary to exchange the positions of the robots in the set M of intermediate positions. The replacement process for this purpose is [Transformation_M_to_M], and the hetero-tandem deformation process from the start position set S to the target position set G is as follows.

[Transformation_from_S_to_G_Hetero]
(1) Execute [Transformation_from_M_to_G].
(2) Execute [Transformation_from_S_to_M].
(3) Execute [Transformation_from_M_to_M].
(4) From t = 0 to t_s_to_m, the variable (transform_S_to_G_x [t] [i], transform_S_to_G_y [t] [i], transform_S_to_G_z [t] [i]) is transformed into (transform_S_to_M_x [t] [i], transform_S_to_M_y [t ] [i], transform_S_to_M_z [t] [i]) are stored.
(5) From t = t_s_to_m + 1 to t_s_to_m + 1 + t_m_to_m, the variable (transform_S_to_G_x [t] [i], transform_S_to_G_y [t] [i], transform_S_to_G_z [t] [i]) is changed to (transform_M_to_M_x t_s_to_m + 1)] [i], transform_M_to_M_y [t- (t_s_to_m + 1)] [i], transform_M_to_M_z [t- (t_s_to_m + 1)] [i]) are stored.
(6) In t = t_s_to_m + 1 + t_m_to_m + 1 to t_s_to_m + 1 + t_m_to_m + 1 + t_m_to_g, variables (transform_S_to_G_x [t] [i], transform_S_to_G_y [t] [i] t, ransform_S_to_G_t [ ) To (transform_M_to_G_x [t- (t_s_to_m + 1 + t_m_to_m + 1)] [cube_after [i]], transform_M_to_G_y [t- (t_s_to_m + 1 + t_m_to_m + 1)] [cube_after [i]], transform_M_to-G_ The value of (t_s_to_m + 1 + t_m_to_m + 1)] [cube_after [i]]) is stored.

  With the above processing, the robot i in the specific position j in the start position set S moves to the specific position j in the target position set G, while the robot in the start position set S The process until moving to the set G of target positions is stored in (transform_S_to_G_x [t] [i], transform_S_to_G_y [t] [i], transform_S_to_G_z [t] [i]). Hereinafter, the processing content of Transformation_M_to_M will be described.

[Transformation_M_to_M]
In the process Transformation_M_to_M, the robot i at the specific position j in the start position set S moves to the specific position j in the target position set G. Replace.
(1) The values of cube_id [i] and cube_id_inv [i] are set to values larger than q for all robots i in the set M of intermediate positions. The position of the robot i in the set M of intermediate positions before execution of this processing is stored in a buffer (cube_buffer_x [i], cube_buffer_y [i], cube_buffer_z [i]). tm ← 0. Run Motion_Data_Update.
(2) Set the value of cube_id [destination_robot_index_2 [j]] to destination_robot_index [j] for position j in set S of all start positions and position j in set G of target positions (cube_id [destination_robot_index_2 [ j]] ← destination_robot_index [j]). Furthermore, the value of cube_id_inv [destination_robot_index [j]] is set to destination_robot_index_2 [j] for the position j in the set S of all start positions and the position j in the set G of target positions (cube_id_inv [destination_robot_index [j ]] ← destination_robot_index_2 [j]). As a result, the robot that has moved from the position j in the set S of start positions and moved to the position destination_robot_index_2 [j] in the set M of intermediate positions is moved to the position j in the set G of target positions. That is, the association that the user must move to destination_robot_index [j] at the position in the set M of intermediate positions is performed.

(3) For all robot numbers i, in order of increasing i, if cube_id [i]> q, the value of cube_id [i] satisfies cube_id_inv [iv]> q and the smallest iv Set the value. By this processing, a robot that is not in any position in the start position set S in the intermediate position set M and a robot that is not in any position in the target position set G in the intermediate position set M Are related.
(4) Set variable already [i] to 0 for all robot numbers i.
(5) Steps (6) to (11) are executed in ascending order of i for all robot numbers i.
(6) As _i ← cube_id [i] and _flg_id ← 0, (7) to (10) are repeated unless i = _i.
(7) When _flg_id = 0, _flg_id ← 1 and substitute the value of i for _i.
(8) Set the variable cube_after [_i] ← cube_id [_i].
(9) Execute Change_Hetero described later.
(10) _already [_i] ← 1. _i ← cube_id [_i].
(11) _already [i] ← 1.

  In the processing after the above (3), the robot at the position i = 0 in the intermediate position set M moves from the robot at the intermediate position indicated by cube_id [i] to the position in the set M, and the cube_id [i] The robot was moved in a relay form to move to the position in the set M of the intermediate position indicated by cube_id [cube_id [i]], and finally cube_id […… cube_id [cube_id [cube_id [cube_id [cube_id [i]]]]]] is a batch movement process until the destination indicated by i returns to i.

[Change_Hetero]
In the process Change_Hetero, control is performed so that the robot at the position destination_robot_index_2 [j] in the set M of intermediate positions moves to the position destination_robot_index [j] in the set M of intermediate positions. For example, the control is performed as follows.
(1) When i = _i, execute (2) to (12). Otherwise, execute (13) to (23).
(2) When Z coordinate value of robot_i> 0, execute (3) to (7). If not, execute (8) to (12).
(3) When either Xr [_i] = cube_buffer_x [cube_id [_i]] or Yr [_i] = cube_buffer_y [cube_id [_i]] is not satisfied, execute (4) to (5). If not (when both are satisfied), (6) to (7) are executed.

(4) Both robot_i and the robot that touches robot_i in the negative Z-axis direction are moved one step in the positive Z-axis direction.
(5) When the Z coordinate of the robot cube_id [_i] is 1, the robot cube_id [_i] is moved one step in the Z axis positive direction together with the robot that is in contact with the robot cube_id [_i] in the negative Z axis direction. If not, move the robot cube_id [_i] in the positive direction of the Z axis together with the robot in contact with the positive direction of the Z axis. Run Motion_Data_Update. Execute Horizontal_Change and Vertical_Change described later.
(6) Move both robot_i and robot cube_id [_i] by one in the positive direction of the Z-axis. Run Motion_Data_Update.
(7) If the X coordinate of the robot_i is an even number, the robot_i is moved one step in the positive direction of the X axis. Otherwise, the robot_i is moved one step in the negative direction of the X axis. Run Motion_Data_Update. Execute Vertical_Change.
(8) When either Xr [_i] = cube_buffer_x [cube_id [_i]] or Yr [_i] = cube_buffer_y [cube_id [_i]] is not satisfied, (9) to (10) are executed. If not (when both are satisfied), (11) to (12) are executed.

(9) Move both robot_i and the robot that touches robot_i in the positive Z-axis direction by one step in the negative Z-axis direction.
(10) When the Z coordinate of the robot cube_id [_i] is 1, the robot cube_id [_i] is moved one step in the Z axis negative direction together with the robot that is in contact with the robot cube_id [_i] in the negative Z axis direction. If not, move the robot cube_id [_i] in the negative Z-axis direction by one step with the robot in contact with the Z-axis positive direction. Run Motion_Data_Update. Execute Horizontal_Change and Vertical_Change described later.
(11) Move both robot_i and robot cube_id [_i] by one in the negative Z-axis direction. Run Motion_Data_Update.
(12) If the X coordinate of the robot_i is an even number, the robot_i is moved one step in the positive direction of the X axis. Otherwise, the robot_i is moved one step in the negative direction of the X axis. Run Motion_Data_Update. Execute Vertical_Change.
(13) When Z coordinate value of robot_i> 0, (14) to (18) are executed. If not, execute (19) to (23).

(14) If a robot whose X coordinate is equal to cube_buffer_x [i] and whose Y coordinate is equal to cube_buffer_y [i] is robot init_cube and its Z coordinate is 0, the robot init_cube is moved one step in the direction of the Z axis. . Run Motion_Data_Update. Execute Horizontal_Change.
(15) When the value of cube_id [_i] is neither i nor init_cube, execute (16) to (17). If not, execute (18).
(16) When cube_buffer_z [cube_id [_i]]> 0, the robot cude_id [_i] and the robot that is in contact with the robot cude_id [_i] in the Z-axis negative direction are both moved one step in the Z-axis positive direction. Otherwise, the robot cude_id [_i] and the robot that is in contact with the robot cude_id [_i] in the Z-axis positive direction are both moved one step in the Z-axis positive direction.
(17) Execute Motion_Data_Update. Execute Vertical_Change.
(18) When cube_id [_i] = i, execute Vertical_Single_Change; otherwise (cube_id [_i] = init_cube), execute Vertical_Single_Change_Inv.

(19) When a robot init_cube whose X coordinate is equal to cube_buffer_x [i] and whose Y coordinate is equal to cube_buffer_y [i] is the robot init_cube and the Z coordinate is 1, the robot init_cube is moved one step in the negative Z-axis direction. . Run Motion_Data_Update. Execute Horizontal_Change.
(20) When the value of cube_id [_i] is neither i nor init_cube, execute (21) to (22). If not, execute (23).
(21) When cube_buffer_z [cube_id [_i]]> 0, the robot cude_id [_i] and the robot in contact with the robot cude_id [_i] in the negative Z-axis direction are both moved one step in the negative Z-axis direction. Otherwise, the robot cude_id [_i] and the robot that is in contact with the robot cude_id [_i] in the positive Z-axis direction are both moved one step in the negative Z-axis direction.
(22) Execute Motion_Data_Update. Execute Vertical_Change.
(23) When cube_id [_i] = i, execute Vertical_Single_Change, otherwise execute Vertical_Single_Change_Inv.

[Horizontal_Change]
In the process Horizontal_Change, the robot_i is moved to a position adjacent to either the X coordinate or the Y coordinate of the position of the destination robot cube_id [_i]. Here, the X coordinate value of the destination position is cube_buffer_x [cube_id [_i]], the Y coordinate value is cube_buffer_y [cube_id [_i]], and it depends on the positional relationship between the robot_i and the destination position. Move robot_i so that the X coordinate value of robot_i is cube_buffer_x [cube_id [_i]] ± 1 or the Y coordinate value is cube_buffer_y [cube_id [_i]] ± 1 . For example, the control is performed as follows.
(1) When the X coordinate value of the robot_i is equal to cube_buffer_x [cube_id [_i]] and the Y coordinate value of the robot_i is equal to cube_buffer_y [cube_id [_i]], the following is executed and the process ends. If not, go to (2).
If the X coordinate value of the robot_i is an even number, the robot_i is moved one step in the positive direction of the X axis, and if it is an odd number, it is moved one step in the negative direction of the X axis. Run Motion_Data_Update.

(2) When the X coordinate value of robot_i is smaller than cube_buffer_x [cube_id [_i]] and the Y coordinate value of robot_i is not equal to cube_buffer_y [cube_id [_i]], the following is executed. If not, go to (3).
Until the X coordinate value of the robot_i becomes equal to cube_buffer_x [cube_id [_i]], the robot_i is moved one step in the positive direction of the X axis and the Motion_Data_Update is executed repeatedly. Subsequently, until the absolute value of the difference between the Y coordinate value of robot_i and cube_buffer_y [cube_id [_i]] is equal to 1, the Y coordinate value of robot_i is cube_buffer_y [cube_id [_i]] Repeatedly execute Motion_Data_Update by moving one step in the Y-axis direction in the direction approaching.

(3) When the X coordinate value of robot_i is smaller than cube_buffer_x [cube_id [_i]] and the Y coordinate value of robot_i is equal to cube_buffer_y [cube_id [_i]], the following is executed. If not, go to (4).
Until the absolute value of the difference between the X coordinate value of robot_i and cube_buffer_x [cube_id [_i]] becomes equal to 1, the robot_i is moved one step in the positive direction of the X axis and Motion_Data_Update is executed repeatedly.

(4) When the X coordinate value of robot_i is larger than cube_buffer_x [cube_id [_i]] and the Y coordinate value of robot_i is not equal to cube_buffer_y [cube_id [_i]], the following is executed and the process is terminated. If not, go to (5).
Until robot_i's Y coordinate value and cube_buffer_y [cube_id [_i]] are equal, move robot_i one step in the Y-axis direction so that robot_i's Y coordinate value approaches cube_buffer_y [cube_id [_i]] Repeat moving and executing Motion_Data_Update. Subsequently, the robot_i is moved one step in the negative direction of the X axis until the absolute value of the difference between the X coordinate value of the robot_i and cube_buffer_x [cube_id [_i]] is equal to 1, and Motion_Data_Update is executed. repeat.

(5) When the X coordinate value of the robot_i is larger than cube_buffer_x [cube_id [_i]] and the Y coordinate value of the robot_i is equal to cube_buffer_y [cube_id [_i]], the following is executed and the process ends. If not, go to (6).
Until the absolute value of the difference between the X coordinate value of the robot_i and cube_buffer_x [cube_id [_i]] becomes equal to 1, the robot_i is moved one step in the negative direction of the X axis and Motion_Data_Update is executed repeatedly.

(6) When the X coordinate value of the robot_i is equal to cube_buffer_x [cube_id [_i]] and the Y coordinate value of the robot_i is larger than cube_buffer_y [cube_id [_i]], the following is executed and the process ends. If not, go to (7).
Until the absolute value of the difference between the Y coordinate value of robot_i and cube_buffer_y [cube_id [_i]] is equal to 1, the robot_i is moved one step in the negative Y-axis direction and Motion_Data_Update is executed repeatedly.

(7) When the X coordinate value of the robot_i is equal to cube_buffer_x [cube_id [_i]] and the Y coordinate value of the robot_i is smaller than cube_buffer_y [cube_id [_i]], the following is executed.
Until the absolute value of the difference between the Y coordinate value of robot_i and cube_buffer_y [cube_id [_i]] is equal to 1, the robot_i is moved one step in the positive direction of the Y axis and the Motion_Data_Update is executed repeatedly.

[Vertical_Change]
In the process Vertical_Change, the robot_i is moved from the position adjacent to either the X coordinate or the Y coordinate of the movement destination position to the movement destination position.
(1) When Zr [_i] = 2 and Zr [cube_id [_i]] = 2, execute the following and finish. If not, go to (2).
(1-1) If Xr [_i] = Xr [cube_id [_i]], go to (1-1-1), otherwise go to (1-1-2).
(1-1-1) If Xr [_i] is an even number, go to (1-1-1-1), otherwise go to (1-1-1-2).
(1-1-1-1) Move robot_i and robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update.
If Yr [_i]> Yr [cube_id [_i]], go to (1-1-1-1-1), otherwise go to (1-1-1-1-2) .
(1-1-1-1-1) Move robot_i one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative Y-axis direction. Run Motion_Data_Update. Move the robot that touches robot_i and robot_i in the negative Z-axis direction by one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update.
(1-1-1-1-2) Move robot_i one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move the robot that touches robot_i and robot_i in the negative Z-axis direction by one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update.
(1-1-1-2) Move robot_i and robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update. If Yr [_i]> Yr [cube_id [_i]], go to (1-1-1-2-1), otherwise go to (1-1-1-2-2).
(1-1-1-2-1) Move robot_i one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the negative Y-axis direction. Run Motion_Data_Update. Move the robot that touches robot_i and robot_i in the negative Z-axis direction by one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update.
(1-1-1-2-2) Move robot_i one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move the robot that touches robot_i and robot_i in the negative Z-axis direction by one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update.
(1-1-2) (When Xr [_i] = Xr [cube_id [_i]]) If Yr [_i] is an even number, move to (1-1-2-1), otherwise In case of (1-1-2-2).
(1-1-2-1) Move robot_i and robot cube_id [_i] one step in the Y-axis positive direction. Run Motion_Data_Update.
If Xr [_i]> Xr [cube_id [_i]], go to (1-1-2-1-1), otherwise go to (1-1-2-1-2).
(1-1-2-1-1) Move robot_i one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative X-axis direction. Run Motion_Data_Update. Move the robot that touches robot_i and robot_i in the negative Z-axis direction by one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update.
(1-1-2-1-2) Move robot_i one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the X axis. Run Motion_Data_Update. Move the robot that touches robot_i and robot_i in the negative Z-axis direction by one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update.
(1-1-2-2) Move robot_i and robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update.
If Xr [_i]> Xr [cube_id [_i]], go to (1-1-2-2-1), otherwise go to (1-1-2-2-2).
(1-1-2-2-1) Move robot_i one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot_i one step in the negative X-axis direction. Run Motion_Data_Update. Move the robot that touches robot_i and robot_i in the negative Z-axis direction by one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update.
(1-1-2-2-2) Move robot_i one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot_i one step in the positive direction of the X axis. Run Motion_Data_Update. Move the robot that touches robot_i and robot_i in the negative Z-axis direction by one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update.

(2) When Zr [_i] = 2 and Zr [cube_id [_i]] = 1, go to (2-1), otherwise go to (3).
(2-1) A robot that makes contact with the robot cube_id [_i] in the positive direction of the Z-axis is defined as a robot_pair.
If Xr [_i] = Xr [_pair], go to (2-1-1), otherwise go to (2-1-2).
(2-1-1) If Xr [_i] is an even number, shift to (2-1-1-1), otherwise shift to (2-1-1-2).
(2-1-1-1) Move robot_pair one step in the positive direction of the X axis. Run Motion_Data_Update.
If Yr [_i]> Yr [_pair], go to (2-1-1-1-1), otherwise go to (2-1-1-1-2).
(2-1-1-1-1) Move robot_pair one step in the positive direction of the Y axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot_pair one step in the negative direction of the X axis. Run Motion_Data_Update. Move robot_pair one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i and robot_pair one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update.
(2-1-1-1-2) Move robot_pair one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot_i one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot_pair one step in the negative direction of the X axis. Run Motion_Data_Update. Move robot_pair one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot_i and robot_pair one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update.
(2-1-1-2) (When Xr [_i] is not an even number) Move robot_pair one step in the negative X-axis direction. Run Motion_Data_Update.
If Yr [_i]> Yr [_pair], go to (2-1-1-2-1), otherwise go to (2-1-1-2-2).
(2-1-1-2-1) Move robot_pair one step in the positive Y-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot_pair one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_pair one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i and robot_pair one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update.
(2-1-1-2-2) Move robot_pair one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot_i one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot_pair one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_pair one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot_i and robot_pair one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update.
(2-1-2) (If Xr [_i] = Xr [_pair] is not true) If Yr [_i] is an even number, go to (2-1-2-1), otherwise (2- Move to 1-2-2).
(2-1-2-1) Move robot_pair one step in the positive Y-axis direction. Run Motion_Data_Update.
If Xr [_i]> Xr [_pair], go to (2-1-2-1-1), otherwise go to (2-1-2-1-2).
(2-1-2-1-1) Move robot_pair one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot_pair one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_pair one step in the negative direction of the X axis. Run Motion_Data_Update. Move robot_i and robot_pair one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update.
(2-1-2-1-2) Move robot_pair one step in the negative X-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot_pair one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_pair one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i and robot_pair one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update.
(2-1-2-2) (When Yr [_i] is not an even number) Move robot_pair one step in the negative Y-axis direction. Run Motion_Data_Update.
If Xr [_i]> Xr [_pair], go to (2-1-2-2-1), otherwise go to (2-1-2-2-2).
(2-1-2-2-1) Move robot_pair one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot_pair one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot_pair one step in the negative direction of the X axis. Run Motion_Data_Update. Move robot_i and robot_pair one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update.
(2-1-2-2-2) Move robot_pair one step in the negative X-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot_pair one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot_pair one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i and robot_pair one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update.

(3) If Zr [_i] <0 and Zr [cube_id [_i]] <0, go to (3-1), otherwise go to (4).
(3-1) If Xr [_i] = Xr [cube_id [_i]], go to (3-1-1), otherwise go to (3-1-2).
(3-1-1) If Xr [_i] is an even number, shift to (3-1-1-1), otherwise shift to (3-1-1-2).
(3-1-1-1) Move robot_i and robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update.
If Yr [_i]> Yr [cube_id [_i]], go to (3-1-1-1-1), otherwise go to (3-1-1-1-2).
(3-1-1-1-1) Move robot_i one step in the negative direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i and robot_i in the Z-axis positive direction by one step in the Z-axis positive direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update.
(3-1-1-1-2) Move robot_i one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot_i and robot_i in the Z-axis positive direction by one step in the Z-axis positive direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update.
(3-1-1-2) (When Xr [_i] is not an even number) Move robot_i and robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update.
If Yr [_i]> Yr [cube_id [_i]], go to (3-1-1-2-1), otherwise go to (3-1-1-2-2).
(3-1-1-2-1) Move robot_i one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i and robot_i in the Z-axis positive direction by one step in the Z-axis positive direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update.
(3-1-1-2-2) Move robot_i one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot_i and robot_i in the Z-axis positive direction by one step in the Z-axis positive direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update.
(3-1-2) (If Xr [_i] = Xr [cube_id [_i]] is not true) If Yr [_i] is an even number, go to (3-1-2-1), otherwise Move to (3-1-2-2).
(3-1-2-1) Move robot_i and robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update.
If Xr [_i]> Xr [cube_id [_i]], go to (3-1-2-1-1), otherwise go to (3-1-2-1-2).
(3-1-2-1-1) Move robot_i one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i and robot_i in the Z-axis positive direction by one step in the Z-axis positive direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update.
(3-1-2-1-2) Move robot_i one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i and robot_i in the Z-axis positive direction by one step in the Z-axis positive direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update.
(3-1-2-2) Move robot_i and robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update.
If Xr [_i]> Xr [cube_id [_i]], go to (3-1-2-2-1), otherwise go to (3-1-2-2-2).
(3-1-2-2-1) Move robot_i one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot_i one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i and robot_i in the Z-axis positive direction by one step in the Z-axis positive direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update.
(3-1-2-2-2) Move robot_i one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot_i one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i and robot_i in the Z-axis positive direction by one step in the Z-axis positive direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update.

(4) When Zr [_i] <0 and Zr [cube_id [_i]] = 0, the process proceeds to (4-1). Otherwise, the process ends.
(4-1) A robot that makes contact with the robot cube_id [_i] in the negative Z-axis direction is defined as a robot_pair. If Xr [_i] = Xr [_pair], go to (4-1-1), otherwise go to (4-1-2).
(4-1-1) If Xr [_i] is an even number, shift to (4-1-1-1), otherwise shift to (4-1-1-2).
(4-1-1-1) Move robot_pair one step in the positive direction of the X axis. Run Motion_Data_Update. If Yr [_i]> Yr [_pair], go to (4-1-1-1-1), otherwise go to (4-1-1-1-2).

        (4-1-1-1-1) Move robot_pair one step in the positive direction of the Y axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot_pair one step in the negative direction of the X axis. Run Motion_Data_Update. Move robot_pair one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i and robot_pair one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update.

        (4-1-1-1-2) Otherwise, move robot_pair one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot_pair one step in the negative direction of the X axis. Run Motion_Data_Update. Move robot_pair one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot_i and robot_pair one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update.

      (4-1-1-2) (When Xr [_i] is not an even number) Move robot_pair one step in the negative X-axis direction. Run Motion_Data_Update. If Yr [_i]> Yr [_pair], go to (4-1-1-2-1), otherwise go to (4-1-1-2-2).

        (4-1-1-2-1) Move robot_pair one step in the positive direction of the Y axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot_pair one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_pair one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i and robot_pair one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update.

        (4-1-1-2-2) Move robot_pair one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot_pair one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_pair one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot_i and robot_pair one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update.

    (4-1-2) (If Xr [_i] = Xr [_pair] is not true) If Yr [_i] is an even number, go to (4-1-2-1), otherwise (4- Move to 1-2-2).

      (4-1-2-1) Move robot_pair one step in the positive direction of the Y-axis. Run Motion_Data_Update. If Xr [_i]> Xr [_pair], go to (4-1-2-1-1), otherwise go to (4-1-2-1-2).

        (4-1-2-1-1) Move robot_pair one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot_pair one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_pair one step in the negative direction of the X axis. Run Motion_Data_Update. Move robot_i and robot_pair one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update.

        (4-1-2-1-2) Move robot_pair one step in the negative X-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot_pair one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_pair one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i and robot_pair one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update.

      (4-1-2-2) Move robot_pair one step in the negative Y-axis direction. Run Motion_Data_Update. If Xr [_i]> Xr [_pair], go to (4-1-2-2-1), otherwise go to (4-1-2-2-2).

        (4-1-2-2-1) Move robot_pair one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot_pair one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot_pair one step in the negative direction of the X axis. Run Motion_Data_Update. Move robot_i and robot_pair one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update.

        (4-1-2-2-2) Move robot_pair one step in the negative X-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot_pair one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot_pair one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i and robot_pair one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update.

[Vertical_Single_Change]
(1) When the value of Xr [_i] -cube_buffer_x [cube_id [_i]] is 0, it shifts to (1-1), when it is 1, it shifts to (1-2), and when it is -1 (1- Move to 3).
(1-1) When Yr [_i] -cube_buffer_y [cube_id [_i]] is 1, move robot_i one step in the Y axis negative direction, and -1 to 1 in the Y axis positive direction. Move step.
(1-2) Move robot_i one step in the negative X-axis direction.
(1-3) Move robot_i one step in the positive direction of the X axis.
(2) Execute Motion_Data_Update.
(3) When Zr [_i]> 0, both robot_i and the robot that touches robot_i in the negative Z-axis direction are moved one step in the negative Z-axis direction. If not, both robot_i and robot_i that are in contact with the robot in the positive Z-axis direction are moved one step in the positive Z-axis direction.
(4) Execute Motion_Data_Update.

[Vertical_Single_Change_Inv]
(1) If Zr [_i] = 2 and Zr [cube_id [_i]] = 1, go to (1-1), otherwise go to (2).
(1-1) If Xr [_i] = Xr [cube_id [id]], go to (1-1-1), otherwise go to (1-1-2).
(1-1-1) If Xr [_i] is an even number, shift to (1-1-1-1), otherwise shift to (1-1-1-2).

      (1-1-1-1) Move robot cube_id [_i] one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot_i one step in the positive direction of the X axis. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update. If Yr [_i]> Yr [cube_id [_i]], go to (1-1-1-1-1), otherwise go to (1-1-1-1-2).

        (1-1-1-1-1) Move robot_i one step in the negative X-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative Y-axis direction. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update.

        (1-1-1-1-2) Move robot_i one step in the negative X-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Y-axis. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update.

      (1-1-1-2) (When Xr [_i] is not an even number) Move robot cube_id [_i] one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot_i one step in the negative X-axis direction. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update. If Yr [_i]> Yr [cube_id [_i]], go to (1-1-1-2-1), otherwise go to (1-1-1-2-2).

        (1-1-1-2-1) Move robot_i one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative Y-axis direction. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update.

        (1-1-1-2-2) Move robot_i one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Y-axis. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update.

    (1-1-2) (If Xr [_i] = Xr [cube_id [id]] is not true) If Yr [_i] is an even number, go to (1-1-2-1), otherwise Move to (1-1-2-2).

      (1-1-2-1) Move robot cube_id [_i] one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Y-axis. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update. If Xr [_i]> Xr [cube_id [_i]], go to (1-1-2-1-1), otherwise go to (1-1-2-1-2).

        (1-1-2-1-1) Move robot_i one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the negative X-axis direction. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update.

(1-1-2-1-2) Move robot_i one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the X axis. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update. }}
(1-1-2-2) (When Yr [_i] is not an even number) Move the robot cube_id [_i] one step in the positive direction of the Z axis. Run Motion_Data_Update. Move robot_i one step in the negative Y-axis direction. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update. If Xr [_i]> Xr [cube_id [_i]], go to (1-1-2-2-1), otherwise go to (1-1-2-2-2).

        (1-1-2-2-1) Move robot_i one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the negative X-axis direction. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update.

(1-1-2-2-2) Move robot_i one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the X axis. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update.
(2) When Zr [_i] =-1 and Zr [cube_id [_i]] = 0, the process proceeds to (2-1), and the process is terminated.

  (2-1) If Xr [_i] = Xr [cube_id [id]], go to (2-1-1), otherwise go to (2-1-2).

    (2-1-1) If Xr [_i] is an even number, shift to (2-1-1-1), otherwise shift to (2-1-1-2).

      (2-1-1-1) Move robot cube_id [_i] one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the X axis. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update. If Yr [_i]> Yr [cube_id [_i]], go to (2-1-1-1-1), otherwise go to (2-1-1-1-2).

        (2-1-1-1-1) Move robot_i one step in the negative X-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative Y-axis direction. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update.

        (2-1-1-1-2) Move robot_i one step in the negative X-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Y-axis. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update.

      (2-1-1-2) (When Xr [_i] is not an even number) Move robot cube_id [_i] one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative X-axis direction. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update. If Yr [_i]> Yr [cube_id [_i]], go to (2-1-1-2-1), otherwise go to (2-1-1-2-2).

        (2-1-1-2-1) Move robot_i one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative Y-axis direction. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update.

        (2-1-1-2-2) Move robot_i one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Y-axis. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update.

    (2-1-2) (If Xr [_i] = Xr [cube_id [id]] is not true) If Yr [_i] is an even number, go to (2-1-2-1), otherwise Move to (2-1-2-2).

      (2-1-2-1) Move robot cube_id [_i] one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Y-axis. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update. If Xr [_i]> Xr [cube_id [_i]], go to (2-1-2-1-1), otherwise go to (2-1-2-1-2).

        (2-1-2-1-1) Move robot_i one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the negative X-axis direction. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update.

        (2-1-2-1-2) Move robot_i one step in the negative Y-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the X axis. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update.

      (2-1-2-2) (When Yr [_i] is not an even number) Move the robot cube_id [_i] one step in the negative Z-axis direction. Run Motion_Data_Update. Move robot_i one step in the negative Y-axis direction. Move robot cube_id [_i] one step in the negative Y-axis direction. Run Motion_Data_Update. If Xr [_i]> Xr [cube_id [_i]], go to (2-1-2-2-1), otherwise go to (2-1-2-2-2).

        (2-1-2-2-1) Move robot_i one step in the positive Y-axis direction. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the negative X-axis direction. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update.

        (2-1-2-2-2) Move robot_i one step in the positive direction of the Y-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the negative X-axis direction. Run Motion_Data_Update. Move robot_i one step in the positive direction of the X axis. Move robot cube_id [_i] one step in the positive direction of the X axis. Run Motion_Data_Update. Move robot_i one step in the positive direction of the Z-axis. Run Motion_Data_Update. Move robot cube_id [_i] one step in the positive Y-axis direction. Run Motion_Data_Update.

<Action control system 100 according to the second embodiment>
FIG. 22 is a functional block diagram of the behavior control system 100 according to the second embodiment, and FIG. 23 shows an example of the processing flow. As shown in FIG. 22, the behavior control system 100 includes a behavior selection unit 120, an adjacent state determination unit 124, a position update unit 123, a position determination unit 126, a storage unit 140, a communication unit 150, and an input unit. 160. The action selection unit 120 includes an extrusion process processing unit 120A, an intermediate transition process processing unit 120B, a final development process processing unit 120C, and a position replacement unit 120D.

  Hereinafter, a case where the control target to be controlled is a robot will be described as an example. Of course, the control object may be other than the robot as long as it can be a control target.

  In the present embodiment, the behavior control system 100 controls the behavior of p robots and is mounted on one of the p robots. Note that the p-1 robot on which the behavior control system 100 is not mounted also includes the communication unit 150 and the adjacent state determination unit 124.

<Input unit 160>
In the input unit 160, the intermediate positions (Xr0 [i], Yr0 [i], Zr0 [i]) of the p robots i (in other words, a set of p intermediate positions M = {(Xr0 [0 ], Yr0 [0], Zr0 [0]), (Xr0 [1], Yr0 [1], Zr0 [1]), ..., (Xr0 [p-1], Yr0 [p-1], Zr0 [p -1])}) and a set of q starting positions S = {(Xrs [0], Yrs [0]), (Xrs [1], Yrs [1]), ..., (Xrs [q-1 ], Yrs [q-1])}, a set of q target positions G = {(Xre [0], Yre [0]), (Xre [1], Yre [1]), ..., (Xre [ q-1], Yre [q-1])} are input and stored in the storage unit 140.

<Communication unit 150>
All robots including the robot on which the behavior control system 100 is mounted communicate with other robots adjacent in the up / down / left / right front / rear direction (hereinafter also referred to as “six directions”) via the communication unit 150. Can communicate.

<Action selection unit 120>
The action selection unit 120 controls the p robots by the method described above (s120). Note that the extrusion process processing unit 120A, the intermediate transition process processing unit 120B, the final development process processing unit 120C, and the position switching unit 120D calculate the order and direction of each robot operation in advance before starting the robot operation, 140 is stored. The action selection unit 120 extracts the operation of each robot at each time from the storage unit 140, transmits a control signal indicating the moving direction to the robot to be moved at each time, and each robot operates according to the control signal.

(Extrusion process processor 120A)
The push-out process processing unit 120A of the action selection unit 120 takes out a set M of p intermediate positions, a set G of q target positions, and a set S of q start positions from the storage unit 140, and p intermediate positions At least q robots located in the set M are moved and controlled to form a shape at the end of extrusion, and the position of each robot in the shape at the end of extrusion is output to the final development process processing unit 120C.

The shape at the end of extrusion is a shape in which the robot forms a plane at the coordinate value O ₁ and the coordinate value O ₂ . The shape at the end of extrusion corresponds to a formation formed by the virtual robot obtained by the above-mentioned [final deployment process] when the coordinate value O ₁ is x = 0 and the coordinate value O ₂ is y = 0. By setting the shape at the end of extrusion to such a shape, the movement path of the robot can be secured when the shape is changed from the set M at the intermediate position to the shape at the end of extrusion.

  The extrusion process processing unit 120A executes the above-described [upward push process], [flag push process], and [final push process] using the set M of p intermediate positions and the set G of q target positions. Then, the sequence and direction of the operation of each robot for deforming from the set M of p intermediate positions to the shape at the end of extrusion is acquired.

(Intermediate transition process processor 120B)
The intermediate transition process processing unit 120B of the action selection unit 120 takes out a set G of q target positions, and (1) the coordinate value in the first direction is large so as to be equal to or less than a certain coordinate value O ₁ in the first direction. In the order from the position included in the set of target positions, if the coordinate value in the first direction is small, and if it is adjacent to the position included in the set of target positions, it is translated in the third direction together with the adjacent position. (Compress), (2) a position included in a set of target positions whose coordinate values in the first direction are not coordinate value O ₁ so that a position included in a set of target positions adjacent in the first direction exists. , is translated in a first direction (compressing), (3) such that one coordinate value O ₂ or less in the second direction, it is greater coordinate values in the second direction, in order from the position in the set target position , Small coordinate value in the second direction, target Together with its adjacent position when adjacent to the position in the set of location is moved parallel to the fourth direction (compression), (4) target coordinate value in the second direction is not the coordinate value O ₂ The position of the robot that forms the shape at the end of extrusion is obtained by translating the positions included in the position set in the second direction so that the positions included in the set of adjacent target positions in the second direction exist. . For example, the first direction, the second direction, the third direction, and the fourth direction are the x-axis positive direction, the y-axis positive direction, the x-axis negative direction, and the y-axis negative direction, respectively, and the coordinate value O ₁ is x = 0, the coordinates O ₂ is taken as y = 0, by executing the above-mentioned final deployment process, it is possible to determine the position of the robot which forms the extrusion end shape. The order and direction of movement of each robot when obtaining the position of the robot forming the end-of-extrusion shape from the positions included in the set G of target positions are output to the final development process processing unit 120C.

(Final development process processor 120C)
The final development process processing unit 120C of the action selection unit 120 acquires the position of each robot in the shape at the end of extrusion from the extrusion process processing unit 120A, and extrudes from the position included in the target position set G from the intermediate transition process processing unit 120B. The order and direction of movement of each robot when obtaining the position of the robot forming the end shape is acquired. Then, the final development process processing unit 120C performs the reverse order to the order of obtaining the position of the robot forming the end-of-extrusion shape from the position included in the target position set for the robot forming the end-of-extrusion shape. By moving the robot in the direction opposite to the parallel movement direction when determining the position of the robot that forms the end shape from the position included in the set of target positions, the robot that forms the shape at the end of extrusion is moved to the target position. Move to set.

  In the processing in the extrusion process processing unit 120A, the intermediate transition process processing unit 120B, and the final development process processing unit 120C, a set S of q start positions is used instead of the set G of q target positions. The order and direction of movement of each robot for transforming from the position set M to the start position set S can be acquired. Move the robot in the start position set S to the intermediate position set by moving the robot in the opposite direction to the robot in the start position set S in the reverse order to the acquired order and direction. Can be moved to.

(Position changing part 120D)
The position exchanging unit 120D obtains the position in the set of intermediate positions M of the robot i from the final development process processing unit 120C when the target position set G is transformed into the set of intermediate positions M.

  The position exchanging unit 120D acquires the position in the set of intermediate positions M of the robot i from the push-out process processing unit 120A when the start position set S is transformed into the set of intermediate positions M.

  The position exchanging unit 120D executes the process Transformation_M_to_M to change the robot i from the position in the intermediate position set M of the robot i from the start position set S to the intermediate position set M. The movement order and direction of each robot for moving the robot i to the position in the intermediate position set M when the robot i is transformed into the intermediate position set M is acquired.

<Location update unit 123>
For each i = 0, 1,..., P−1, the position update unit 123 performs the action selection unit 120 at the current position (Xr [i], Yr [i], Zr [i]) of the i-th robot. The position (Xr '[i], Yr' [i], Zr '[i]) after the robot's movement (after the action) when the action determined in step 1 is executed is calculated, and the calculated (Xr' [i ], Yr ′ [i], Zr ′ [i]), the position of the i-th robot stored in the storage unit 140 is updated (S123). In other words, the position update unit 123 calculates a position assumed when the robot behaves (hereinafter also referred to as “assumed position”) based on the action determined by the action selection unit 120 and updates the position of the robot. Stored in the storage unit 140.

<Adjacent state determination unit 124>
The adjacent state determination unit 124 determines whether or not another robot is present in the upper, lower, left, and right adjacent positions on the two-dimensional plane of the robot (S124), and stores the determination result in the storage unit 140.

  Note that, as described above, the p-1 robot on which the behavior control system 100 is not mounted also includes the communication unit 150 and the adjacent state determination unit 124. Therefore, each robot i can determine in the adjacent state determination unit 124 whether there is another robot in the up / down / left / right front / rear direction and output the determination result to the behavior control system 100 via the communication unit 150. The behavior control system 100 receives the determination result from each robot i via the communication unit 150 and stores it in the storage unit 140 together with the determination result of the adjacent state determination unit 124 included in the behavior control system 100. In addition, the p robots always have other robots in adjacent positions (6 directions) of each robot, and the group formed by the adjacent robots is a lump, so each robot i is connected via the communication unit 150. The p-1 determination results can be transmitted to the behavior control system 100 directly or via another robot. In addition, the behavior control system 100 can transmit a control signal so as to execute the selected behavior to each robot i directly or via another robot via the communication unit 150. In addition, other information can be transmitted and received between the p robots.

  Note that even if the robot is controlled to move, it cannot always be moved as controlled by the action selection unit 120 due to some trouble (such as equipment failure). On the other hand, the position of the robot that did not move is the same as before the control. Therefore, by controlling so that at least one robot does not move, the actual state of the robot controlled to move using the determination result by the adjacent state determination unit 124 based on the position of the robot that did not move is used as a reference. (Xr "[i], Yr" [i], Zr "[i]) can be obtained after the action is taken, and at least one such as GPS If the robot is equipped with GPS, the post-movement position can be obtained in the same manner with reference to the robot.

<Position determination unit 126>
The position determination unit 126 obtains the post-behavior position using the determination result of the adjacent state determination unit 124, and the post-behavior position (Xr "[i], Yr" [i], Zr "[i]) and the assumed position ( Xr ′ [i], Yr ′ [i], Zr ′ [i]) are matched (S126) If there is no match, the robot controlled to move is It is probable that the vehicle could not move as controlled due to a trouble, in this case the post-action position (Xr "[i], Yr" [i], Zr "[i]) and the assumed position (Xr '[i], Yr' [i] and / or Zr ′ [i]) may be corrected. Various methods can be considered as the correction method. For example, all the robots that have moved may be instructed to return to the pre-control position, and the post-behavior position (Xr "[i], Yr" [i], Zr "[i]) may be corrected. And correct the assumed position (Xr '[i], Yr' [i], Zr '[i]) according to the post-action position (Xr "[i], Yr" [i], Zr "[i]) May be.

  At each time step, it is determined whether or not the set G of all target positions is filled by the robot (S127), and if it is filled, the mission is terminated. If not, continue the mission.

  For example, in the target position arrival determination unit (not shown), the post-action positions (Xr "[i], Yr" [i], Zr) output from the position determination unit 126 for each i = 0, 1,. "[i]) determines whether or not the set G of all target positions is filled by the robot, and if it is filled, the mission is terminated. The robot moves to at least one target position. If it is not filled, the behavior selection unit 120 is controlled to be executed again.

  The processes s120 to s127 described above are performed for each time step.

<Effect>
With such a configuration, the same effect as that of the first embodiment can be obtained in the three-dimensional space. Further, the process Transformation_M_to_M is simplified by adopting an L-shaped or rectangular flat plate in which the shape of the set M at the intermediate position is an L-shaped block composed of eight robots.

<Modification>
In this embodiment, each lattice (mass) is a cube, but may have other shapes. The lattice is continuously arranged in the left-right direction, the up-down direction, and the front-rear direction. Each lattice is adjacent to the other two lattices in the left-right direction, is adjacent to the other two lattices in the vertical direction, and is adjacent to the other two lattices in the front-rear direction. In other words, each grid is adjacent to other grids only in the same direction that the robot can move. Each lattice may have any shape as long as this condition is satisfied. Further, the term “orthogonal” does not necessarily mean strictly “perpendicularly”. For example, each lattice may be a parallelepiped, and each lattice is adjacent to the other two lattices. One side may be the up-down direction and the other side may be the left-right direction.

  In other words, the control object is in the first direction (for example, the right direction), the second direction (for example, the upper direction) that is not parallel to the first direction, and the first direction in the three-dimensional space. A third direction (for example, the left direction) opposite to the second direction, a fourth direction (for example, the downward direction) opposite to the second direction, a direction not parallel to the plane formed by the first direction and the second direction. Can be moved in the fifth direction (for example, the forward direction) and the sixth direction, which is the opposite direction to the fifth direction, and from the current region (lattice, square) to the current region by one action control. On the other hand, it is controlled to move to any of the adjacent areas in the first direction, the second direction, the third direction, the fourth direction, the fifth direction, and the sixth direction. In this case, on the three-dimensional plane of the robot, the position adjacent in the first direction is the first position, the position adjacent in the second direction is the second position, the position adjacent in the third direction is the third position, A position adjacent in the four directions may be referred to as a fourth position, a position adjacent in the fifth direction as a fifth position, and a position adjacent in the sixth direction as a sixth position.

  In the present embodiment, the example in which the behavior control system 100 is mounted on one of the p robots has been shown, but behavior control may be performed on a control target on a computer. In that case, unless a trouble occurs intentionally, the controlled object moves as controlled, so the assumed position (Xr '[i], Yr' [i], Zr '[i]) and the post-movement position ( Xr "[i], Yr" [i], Zr "[i]) coincide with each other. In such a state, an ideal action plan for each control object i may be performed. The real robot is caused to execute an action plan until the given task is finished, and the real robot includes the communication unit 150 and the adjacent state determination unit 124, and determines the adjacent state after each action and uses the determination result. The post-behavior position is obtained, and the post-behavior position (Xr "[i], Yr" [i], Zr "[i]) and the assumed position (Xr '[i], Yr' [i], Zr '[i ]). If they do not match, it is considered that the robot controlled to move could not move as controlled due to some trouble. Subsequent processing may be the same as in the first embodiment, or other processing may be performed. With such a configuration, it is possible to detect at least that movement was not possible as controlled.

  In this embodiment, one position determination is performed for one action control. However, when a plurality of robots are moved in one action control, each robot is moved each time it is moved. It is good also as a structure which performs determination.

  In this embodiment, the robot unit is composed of 8 robots of 2 × 2 × 2, but may be composed of M × N × Q robots. However, M, N, and Q are each an integer of 2 or more. Even when moving in such a state, as in the case of a 2 × 2 × 2 robot unit, even if any robot in the group of robots is missing, each robot It is not necessary to destroy the positional relationship of contact with each other. When the number of M × N × Q is increased, the number of robot units decreases, and the number of patterns that can be acted on decreases, so the amount of calculation of the Manhattan distance δ decreases. However, if even one obstacle is included in a square unit with M x N x Q squares as one unit, it will be treated as being unable to move to that square unit, so M x N x Q Increasing the number of vehicles increases the range in which movement is not possible and the range in which action can be reduced. In the first place, it is only necessary to check the Manhattan distance from each position unit to the position unit of the robot unit H in the motion plan, so that the amount of calculation is sufficiently reduced as compared with the prior art. For this reason, in order to keep a large range in which the robot can act, it is desirable to use 2 × 2 × 2 robots as a robot unit.

  Further, in this embodiment, in the set S of start positions and the set G of target positions, the position that each robot should take is determined for each robot, but it is not necessary to decide the position that each robot should take. Good. In this case, the process Transformation_from_S_to_G_Homo is executed, and the robot may be controlled based on (transform_S_to_G_x [t] [i], transform_S_to_G_y [t] [i], transform_S_to_G_z [t] [i]) obtained as a result.

<Third embodiment>
A description will be given centering on differences from the second embodiment.
[A set of start, target and intermediate positions]
In the third embodiment, the shape of the set of intermediate positions is different from the second embodiment. A set of intermediate positions in the third embodiment is M2. The condition of the shape of the set M2 at the intermediate position is that the ceiling is composed of robot units with 2 x 2 4 squares, and the thickness of the ceiling can be as much as one robot, but the robot in contact with the ceiling is always One or more exist (see FIG. 37). If a robot with the same X and Y coordinate values as the robot exists under the robot i ([Xri], [Yri], [Zri]) on the ceiling, all of those robots It must be hanging from and touching the robot i on the ceiling. The set S of start positions and the set G of target positions in the third embodiment include a seed robot having a shape in which four robots are connected in a square shape. In the start position set S, the Z-axis coordinate value is at the minimum position, and in the target position set G, the Z-axis coordinate value is at the maximum position, and the X and Y coordinates are both 0. (See FIG. 35). The coordinate position of the seed robot at the start position S and the target position G is the same.

In the third embodiment, the formation movement from the start position set S to the target position set G is divided into the following processes.
(1) Compression process from start position set S to shape 1 at the end of extrusion: [Extend_Process_S]
(2) Deformation process from shape 1 at the end of extrusion to set M2 of intermediate positions: [Make_Ceiling]
(3) Expansion process from shape 2 at the end of extrusion to set G of target positions: [Extend_Process_G]
(4) Deformation process from set M2 of intermediate positions to shape 2 at the end of extrusion: [Translate_from_M2_to_Mobile_G]
(5) Robot replacement process in set M2 of intermediate positions: [Permutation_in_M2]

Hereinafter, each process will be described.
[Compression process from set S of start positions to shape 1 at the end of extrusion]
The compression process [Extend_Process_S] from the shape of the set S at the start position to the extrusion end shape 1 is obtained by adding the following compression process in the Z-axis upward direction to the final expansion process in the second embodiment.

[Extend_Process_Z_Plus]
(1) The minimum value of the Z coordinate of the virtual robot position at the current time tm is Zmin, the maximum value of the Z coordinate is Zmax, _zw ← Zmin, and (2) to (4) are repeated while _zw <Zmax.
(2) The variable destination_to_be_compressed [i] ← 0 is set for all virtual robots i. Set _flg_c ← 0.
(3) For the virtual robot i whose Z coordinate value is _zw, execute the following.
(3-1) If there is no Z-coordinate Zmax among all the virtual robots in the Z-axis positive direction without being interrupted in the positive direction of the Z-axis from the virtual robot i, all of the virtual robots in the range from the virtual robot i to the virtual robot in The destination_to_be_compressed value of the virtual robot is set to 1 and _flg_c ← 1.
(4) When _flg_c = 1, the Z coordinate values of all virtual robots with destination_to_be_compressed [i] = 1 are incremented, and [Motion_Data_Update] is executed. Increment _zw.

With the above processing, the virtual plane perpendicular to the Z axis moves from the Z axis negative direction infinity to the Z axis positive direction at the current time tm, and the robot that hits the virtual plane moves. Compress all robots whose Z coordinate is not Zmax so that there is a robot in contact with the robot in the positive Z-axis direction.
[Extend_Process_S]
(1) Set tm ← 0, set the position of each virtual robot i as a set S of start positions, and execute [Motion_Data_Update]. [Extend_Process_X_Minus] is executed (corresponding to the transformation from FIG. 36A to FIG. 36B).
(2) Execute [Extend_Process_X_Plus] (corresponding to the transformation from FIG. 36B to FIG. 36C).
(3) [Extend_Process_Y_Minus] is executed (corresponding to the transformation from FIG. 36C to FIG. 36D).
(4) Execute [Extend_Process_Y_Plus] (corresponding to the transformation from FIG. 36D to FIG. 36E).
(5) Execute [Extend_Process_Z_Plus] (corresponding to the transformation from FIG. 36E to FIG. 36F).
(6) At the position of the virtual robot i at the current time tm, the maximum value of the Z coordinate is Zmax, the minimum value is Zmin, and the number of robots whose X coordinate is 0 at each Z coordinate value_z minus 1 In y_num [_z-Zmin], the number of robots whose Y coordinate value is _y-1 at each Z coordinate value_z is stored in _x_num [-_ y] [_ z-Zmin]. The shape formed by the robot group after executing [Extend_Process_Z_Plus] is referred to as a shape 1 at the end of extrusion.

[Deformation process from shape 1 at the end of extrusion to set M2 at intermediate position]
The deformation process from the shape 1 at the end of extrusion to the set M2 at the intermediate position (corresponding to the deformation from FIG. 36F to FIG. 37) is the following process.
(1) At the end of extrusion, move some of the robots that are not on the ceiling to the ceiling so that the number of robots existing on the ceiling of shape 1 (the surface formed by the robot whose Z coordinate takes the maximum value (Zmax)) is a multiple of 4 (See FIG. 38).
(2) Compress in the positive direction of the X, Y, and Z axes.
(3) The ceiling shape is deformed so as to be a rectangle made up of square units composed of four robots (see FIGS. 39 and 40).
(4) Perform compression in the X axis, Y axis, and Z axis positive directions so that a plane with X = 0, Y = 0, Z = maximum value is constructed by the robot.

  The process (1) is executed by [Move_Odd_Robots] described later. In [Move_Odd_Robots], robots whose Z coordinate is Zmax-1 or less and whose X coordinate value is 0 have one or more robots in contact with those robots in the negative X-axis direction, Repeat the process of moving to the ceiling along the plane of = 0 until the number of robots contained in the ceiling is a multiple of four. If there are no more robots that can be moved on the plane with X = 0, out of the robots whose Z coordinate is Zmax-1 or less, Y coordinate is 0, and X coordinate value is 0, those robots have Y axis The number of robots included in the ceiling is a multiple of 4 by moving one that has one or more robots connected in the negative direction to the ceiling along the columns with X = 0 and Y = 0. Repeat until. That is, in this embodiment, the number of robots included under the ceiling is 4 (the maximum number of remainders obtained by dividing an integer by 4 + 1) or more.

The process (3) is executed by [Make_2x2_Rectangle_Ceiling] described later. As shown in FIGS. 39 and 40, the shape of the ceiling is adjusted to a rectangle by moving the position of the robot protruding from the target rectangle into the rectangle.
[Make_Ceiling]
(1) Execute [Move_Odd_Robots] described later.
(2) Execute [Extend_Process_X_Plus].
(3) Execute [Extend_Process_Y_Plus].
(4) Execute [Extend_Process_Z_Plus].
(5) At the position of the virtual robot i at the current time tm, the maximum value of the Z coordinate is Zmax, and the number of robots whose X coordinate is 0 at each Z coordinate value_z is _y_num [_z-Zmin ] Is stored in _x_num [-_ y] [_ z-Zmin], the number of robots whose Y coordinate value is _y at each Z coordinate value_z.
(6) Execute [Make_2x2_Rectangle_Ceiling] described later.
(7) Run [Extend_Process_X_Plus].
(8) Execute [Extend_Process_Y_Plus].
(9) Execute [Extend_Process_Z_Plus].
(10) At the position of the virtual robot i at the current time tm, the maximum value of the Z coordinate is Zmax, and the number of robots whose X coordinate is 0 at each Z coordinate value_z-1 is _y_num [_z-Zmin ] Is stored in _x_num [-_ y] [_ z-Zmin], the number of robots whose Y coordinate value is _y at each Z coordinate value_z. Store tm-1 in variable push_time_start.
(11) [Extend_Process_S] Each virtual robot i as a position in the shape 2 at the end of extrusion, to which the virtual robot i at each position in the set S of start positions moved by [Extend_Process_S] [Make_Ceiling] Is stored in variables (Xsp [i], Ysp [i], Zsp [i]).
(12) At each time of t = 0, push_time_start, the variable (transform_S_to_M2_x [t] [i], transform_S_to_M2_y [t] [i], transform_S_to_M2_z [t] [i]), (motion_x [t] [i], The value of motion_y [t] [i], motion_z [t] [i]) is stored.

[Move_Odd_Robots]
(1) Count the number of robots whose Z coordinate is Zmax and store in the variable ceiling_cnt. The remainder value obtained by dividing the ceiling_cnt value by 4 is stored in the variable add_num.
(2) Repeat (3) to (4) from _z = (Zmax-Zmin + 1) -1 to _z = 0.
(3) Repeat (4) from _y = _y_num [_z] to _y = 0.
(4) If _x_num [_z] [_ y] is 1 or more and add_num is not 0, execute the following. (An operation example is shown in FIG. 38.)
(4-1) Variable add_x ← 0. While add_x is smaller than _x_num [_z] [_ y] and add_num is not 0, (4-2) to (4-5) are repeated.
(4-2) All robots having Y coordinates of _y and Z coordinates of _z are moved one step in the positive direction of the X axis (corresponding to the transformation from FIG. 38A to FIG. 38B). Execute [Motion_Data_Update]. At this time, a robot whose X coordinate is 1, Y coordinate is _y, and Z coordinate is _z is designated as robot ip.
(4-3) Increment add_x and decrement add_num.
(4-4) Move the robot ip one step in the positive direction of the Z axis and execute [Motion_Data_Update] until the Z coordinate of the robot ip reaches Zmax (corresponding to the transformation from FIG. 38B to FIG. 38C). .
(4-5) All robots whose Y coordinate is the Y coordinate of the robot ip and whose Z coordinate is Z_max are moved one step in the negative direction of the X axis (corresponding to the deformation from FIG. 38C to FIG. 38D). Execute [Motion_Data_Update].
(5) Repeat (6) from _z = Zmax-1 to _z = 0.
(6) If _y_num [_z] is 1 or more and add_num is not 0, execute the following.
(6-1) Set variable add_x ← 0. While add_x is smaller than _y_num [_z] and add_num is not 0, (6-2) to (6-5) are repeated.
(6-2) Move all robots whose X coordinate is 0 and Z coordinate is _z by one step in the Y axis positive direction. Execute [Motion_Data_Update]. At this time, a robot whose X coordinate is 0, Y coordinate is 1, and Z coordinate is _z is designated as robot ip.
(6-3) Increment add_x and decrement add_num.
(6-4) Move the robot ip one step in the positive direction of the Z axis and execute [Motion_Data_Update] until the Z coordinate of the robot ip reaches Zmax.
(6-5) Move all robots whose X coordinate is the robot ip X coordinate and Z coordinate is Z_max by one step in the negative Y-axis direction. Execute [Motion_Data_Update].

[Make_2x2_Rectangle_Ceiling]
(1) Determine the length of the ceiling in the X and Y directions.
(1-1) Count the number of robots included in the ceiling (Z coordinate value is Zmax) and store it in ceiling_cnt. Replace ceiling_cnt with the value divided by 4 (ceiling_cnt ← ceiling_cnt / 4).
(1-2) From the variables ic = 1 to ic = ceiling_cnt-1, extract the ic whose remainder is 0 after dividing the ceiling_cnt and set the value obtained by dividing the ceiling_cnt by the extracted ic to jc (= ceiling_cnt / ic ), And in the combination of ic and jc (in other words, in the combination of divisor ic and quotient jc when ceiling_cnt is the dividend, ic is the divisor, and the remainder is 0), 2 × jc is y_num [ A combination that is smaller than Zmax-Zmin] and 2 × ic is smaller than x_num [Zmax-Zmin] [0] is extracted, and the absolute value of the difference between ic and jc is the smallest among the extracted combinations Is selected as the horizontal and vertical length of the rectangle. Store the selected ic in variable _lat and jc in variable _lon.
(2) Exchange in the Y-axis direction (see FIG. 39).
(2-1) Among the robots included in the ceiling, the number of robots whose X coordinate is -_x is counted and stored in the variable y_ceiling_num [_x].
(2-2) Repeat (2-3) to (2-8) from variable _x = 0 to _x = -x_num [Zmax-Zmin] [0].
(2-3) Repeat steps (2-4) to (2-8) while y_ceiling_num [_x] is larger than 2 × _lon.
(2-4) All robots whose X coordinate is -_x are moved one step in the positive direction of the Y-axis (corresponding to deformation from FIG. 39A to FIG. 39B). Execute [Motion_Data_Update].
(2-5) The number of robots whose X coordinate is -_x among the robots included in the ceiling is counted and stored in the variable y_ceiling_num [_x].
(2-6) For the smallest _xx from variable _xx = _x + 1 to _xx = -x_num [Zmax-Zmin] [0] and y_ceiling_num [_xx] smaller than 2 × _lon, (2-7) Execute (2-8).
(2-7) All robots with Y coordinate 1 are moved one step in the negative direction of the X axis and [Motion_Data_Update] is executed _xx-_x times (corresponding to transformation from FIG. 39B to FIG. 39C) .
(2-8) All robots whose X coordinates are -_xx are moved one step in the negative Y-axis direction (corresponding to transformation from FIG. 39C to FIG. 39D), and [Motion_Data_Update] is executed.
(3) Exchange in the X-axis direction (see FIG. 40).
(3-1) Among the robots included in the ceiling, the number of robots whose Y coordinate is -_y is counted and stored in the variable x_ceiling_num [_y].
(3-2) Repeat (3-3) to (3-8) from variable _y = 0 to _y = -y_num [Zmax-Zmin].
(3-3) Repeat (3-4) to (3-8) while x_ceiling_num [_y] is larger than 2 × _lat.
(3-4) All robots whose Y coordinate is -_y are moved one step in the positive direction of the X axis (corresponding to the transformation from FIG. 40A to FIG. 40B). Execute [Motion_Data_Update].
(3-5) The number of robots whose Y coordinate is -_y among the robots included in the ceiling is counted and stored in the variable x_ceiling_num [_y].
(3-6) For variables _yy = _y + 1 to _yy = -y_num [Zmax-Zmin] where x_ceiling_num [_yy] is smaller than 2 × _lat, (2-7) to (2 -8) is executed.
(3-7) All robots with X coordinates of 1 are moved one step in the negative Y-axis direction, and [Motion_Data_Update] is executed _yy-_y times (corresponding to the transformation from FIG. 40B to FIG. 40C) ).
(3-8) All robots whose Y coordinate is -_yy are moved one step in the negative direction of the X axis (corresponding to the transformation from FIG. 40C to FIG. 40D), and [Motion_Data_Update] is executed.

[Development process from shape 2 at the end of extrusion to set G of target positions]
The final expansion process [Extend_Process_G] that transforms from the shape 2 at the end of extrusion to the set G of target positions is a process in which a compression process is added downward in the Z-axis direction to the final expansion process in the second embodiment. Therefore, the shape 2 at the end of extrusion indicates that the virtual surface perpendicular to the Z axis moves the shape at the end of extrusion in the second embodiment from the Z axis positive direction infinity to the Z axis negative direction, and hits the virtual surface. The shape is compressed so that all robots whose Z coordinate is not Zmin are in a state where there is a robot in the negative Z-axis direction of the robot. However, since the compressed formation is pushed into a space where the X coordinate and the Y coordinate are positive, the compression direction in the X-axis and Y-axis directions is different from that in the second embodiment.

[Extend_Process_G]
(1) Set tm ← 0, set the position of each virtual robot i as a set G of target positions, and execute [Extend_Process_X_Minus_Inv] (corresponding to the transformation from FIG. 41A to FIG. 41B).
(2) [Extend_Process_X_Plus_Inv] described later is executed (corresponding to the transformation from FIG. 41B to FIG. 41C).
(3) [Extend_Process_Y_Minus_Inv] described later is executed (corresponding to the transformation from FIG. 41C to FIG. 41D).
(4) [Extend_Process_Y_Plus_Inv] described later is executed (corresponding to the transformation from FIG. 41D to FIG. 41E).
(5) [Extend_Process_Z_Minus] described later is executed (corresponding to the transformation from FIG. 41E to FIG. 41F).
(6) At the position of the virtual robot i at the current time tm, the maximum value of the Z coordinate is Zmax_g, the minimum value is Zmin_g, and the number of virtual robots whose X coordinate is 0 at each Z coordinate value_z minus 1 In _y_num_g [_z-_Zmin_g], the number -1 of virtual robots with Y coordinate value _y at each Z coordinate value _z is stored in _x_num_g [_y] [_ z-_Zmin_g]. Store the value of tm-1 in the variable push_time_goal.
(7) The position i in the shape 2 at the end of extrusion after each position i in the target position set G is moved by compression is stored in variables (Xgp [i], Ygp [i], Zgp [i]) To do.
(8) At each time from t = 0 to push_time_goal, the variable (transform_P2_to_G_x [t] [j], transform_P2_to_G_y [t] [j], transform_P2_to_G_z [t] [j]), (motion_x [push_time_goal-t] [j ], motion_y [push_time_goal-t] [j], motion_z [push_time_goal-t] [j]) are stored.

[Extend_Process_Z_Minus]
(1) The minimum Z coordinate of the virtual robot position at the current time tm is Zmin, the maximum Z coordinate is Zmax, _zw = Zmax-1 and _zw> Zmin, (2) to (4) repeat.
(2) The variable destination_to_be_compressed [i] ← 0 is set for all virtual robots i. Set _flg_c ← 0.
(3) For the virtual robot i whose Z coordinate value is _zw, execute the following.
(3-1) If there is no Z-coordinate Zmin among all the virtual robots in the Z axis that are adjacent to the virtual robot i without interruption in the negative direction of the Z axis, The destination_to_be_compressed value of the virtual robot is set to 1 and _flg_c ← 1.
(4) When _flg_c = 1, the Z coordinate values of all virtual robots with destination_to_be_compressed [i] = 1 are decremented and [Motion_Data_Update] is executed. Decrement _zw.

[Extend_Process_X_Minus_Inv]
(1) Let Xmin be the minimum value of the X coordinate for all virtual robots.
(2) Set _xw = Xmin and repeat (3) to (5) while _xw <0.
(3) The variable destination_to_be_compressed [i] ← 0 is set for all virtual robots i. Set _flg_c ← 0.
(4) For the virtual robot i whose X coordinate value is _xw, execute the following.
(4-1) Set destination_to_be_compressed [i] ← 1.
(4-2) Destination_to_be_compressed [in] ← 1 of all virtual robots in adjacent to the virtual robot i in the positive X-axis direction without interruption.
(4-3) _flg_c ← 1.
(5) When _flg_c = 1, X coordinate values of all virtual robots with destination_to_be_compressed [i] = 1 are incremented, and [Motion_Data_Update] is executed. Increment _xw.

[Extend_Process_X_Plus_Inv]
(1) The maximum value of the X coordinate of the virtual robot position at the current time tm is set to Xmax, _xw = Xmax, and (2) to (4) are repeated while _xw> 0.
(2) The variable destination_to_be_compressed [i] ← 0 is set for all virtual robots i. Set _flg_c ← 0.
(3) For the virtual robot i whose X coordinate value is _xw, execute the following.
(3-1) Destination_to_be_compressed [in] of the adjacent virtual robots i to in when there is no X-coordinate among all the adjacent virtual robots in the X-axis negative direction without interruption from the virtual robot j ← 1, _flg_c ← 1.
(4) When _flg_c = 1, the X coordinate values of all virtual robots with destination_to_be_compressed [i] = 1 are decremented and [Motion_Data_Update] is executed. Decrement _xw.

[Extend_Process_Y_Minus_Inv]
(1) The minimum value of the Y coordinate of the virtual robot position at the current time tm is set to Ymin, _yw = Ymin, and (2) to (4) are repeated while _yw <0.
(2) The variable destination_to_be_compressed [i] ← 0 is set for all virtual robots i. Set _flg_c ← 0.
(3) For the virtual robot i whose Y coordinate value is _yw, execute the following.
(3-1) Destination_to_be_compressed [i] ← 1.
(3-2) It is assumed that destination_to_be_compressed [in] ← 1 of all virtual robots in adjacent to the virtual robot j without interruption in the Y-axis positive direction.
(3-3) Set _flg_c ← 1.
(4) When _flg_c = 1, the Y coordinate values of all virtual robots with destination_to_be_compressed [i] = 1 are incremented, and [Motion_Data_Update] is executed. Increment _yw.

[Extend_Process_Y_Plus_Inv]
(1) The maximum value of the Y coordinate of the virtual robot position at the current time tm is set to Ymax, _yw = Ymax, and (2) to (4) are repeated while _yw> 0.
(2) The variable destination_to_be_compressed [i] ← 0 is set for all virtual robots i. Set _flg_c ← 0.
(3) For the virtual robot i whose Y coordinate value is _yw, execute the following.
(3-1) If there are no virtual robots in the Y-axis positive direction that are adjacent to the virtual robot i without a Y coordinate, the destination_to_be_compressed [in ] ← 1 and _flg_c ← 1.
(4) When _flg_c = 1, the Y coordinate values of all virtual robots with destination_to_be_compressed [i] = 1 are decremented and [Motion_Data_Update] is executed. Decrement _yw.

[Deformation process from set M2 at intermediate position to shape 2 at the end of extrusion]
In this process, first, the seed robot is moved from the intermediate position set M2 to a position where the Z coordinate is lowest (corresponding to Make_seed_M2 described later). Subsequently, the robot in the set M2 at the intermediate position is pushed out to the shape 2 at the end of extrusion in the form of reverse reproduction of the extrusion process in the second embodiment. That is, the robot in the set M2 at the intermediate position is first pushed out one by one from the robot that can be pushed in the positive direction of the X axis from the X = 0 plane, and contacts the seed robot along the X = 0 plane. Move to the position. When there are no robots that can be pushed in the X-axis positive direction from the X = 0 plane, the robots that can push out from the column with X = 0 and Y = 0 in the Y-axis positive direction are pushed out one by one. Move along the pillar to the position where it touches the seed robot. The robot that has reached the position in contact with the seed robot pushes the seed robot in contact with the Z-axis downward, and falls within the position of the seed robot. The robot that was the original seed that was pushed out moves to a position in the shape 2 at the end of extrusion. The movement is the same movement form as the extrusion process shown in the second embodiment (post formation → flag formation → final extrusion form formation).

Subsequently, when there are no more robots that can be pushed in the positive direction of the Y axis from the columns with X = 0 and Y = 0, no robots other than those with columns with X = 0 and Y = 0 are placed above the seed robot. Since it does not remain, the robot is pushed down the seed robot one by one by sliding the pillars downward one by one.
[Translate_from_M2_to_Mobile_G]
(1) Set tm ← 0, set the position of each robot i to (Xsp [i], Ysp [i], Zsp [i]), and execute Motion_Data_Update. [Make_Seed_M2] described later is executed (corresponding to the transformation from FIG. 42A to FIG. 42B).
(2) [Robot_Translation] described later is executed (corresponding to the transformation from FIG. 42B to FIG. 42E).
(3) Move all robots except the seed robot one step in the negative direction of the X axis. Run Motion_Data_Update.
(4) All robots other than the seed robot are moved one step in the negative Y-axis direction (corresponding to the transformation from FIG. 42E to FIG. 42F together with the processes (3) and (4)). Run Motion_Data_Update. Store tm-1 in translate_time.
(5) At each time from t = 0 to translate_time, the variable (transform_M2_to_P2_x [t] [i], transform_M2_to_P2_y [t] [i], transform_M2_to_P2_z [t] [i]), (motion_x [t] [i], The value of motion_y [t] [i], motion_z [t] [i]) is stored.
(6) Store the position of each robot i in (Xtr [i], Ytr [i], Ztr [i]).

[Make_Seed_M2]
(1) Move all robots whose Z coordinate value is Zmax one step in the positive direction of the X axis. Run Motion_Data_Update.
(2) Move all robots whose Z coordinate value is Zmax one step in the positive direction of the Y axis. Motion_Data_Update is executed (corresponding to the transformation from FIG. 43A to FIG. 43B together with the processes (1) and (2)).
(3) Move all robots whose Z coordinate value is Zmax and Y coordinate value is -1 or less by one step in the negative X-axis direction. Run Motion_Data_Update.
(4) Move all robots whose Z coordinate value is Zmax and X coordinate value is -1 or less by one step in the negative Y-axis direction. Motion_Data_Update is executed (corresponding to the transformation from FIG. 43B to FIG. 43C together with the processes (3) and (4)).
(5) Execute [Extend_Process_X_Plus].
(6) Move the robot at position (1,0, Zmax), (1,1, Zmax), (0,1, Zmax) one step until each Z coordinate value becomes equal to the minimum Z coordinate value Zmin. The movement in the Z-axis negative direction and the execution of Motion_Data_Update are repeated (corresponding to the transformation from FIG. 43C to FIG. 43D together with the processes (5) and (6)).
(7) Number of robots whose X coordinate is 0 at each Z coordinate value_z at the position of robot i at the current time tm, where the maximum value of Z coordinate is Zmax, the minimum value of Z coordinate is Zmin, and each Z coordinate value_z Is stored in _y_num [_z-Zmin], and the number of robots whose Y coordinate value is _y-1 at each Z coordinate value_z is stored in _x_num [-_ y] [_ z-Zmin].

[Robot_Translation]
(1) Repeat (2) to (8) with all values from _z = Zmax-Zmin to _z = 1.
(2) Repeat (3) to (8) for all values from _y = y_num [_z] to _y = 0.
(3) Repeat (4) to (8) with all values from _x = x_num [_z] [_ y] to _x = 0.
(4) Let ip be the robot at position (0, -_ y, _z + Zmin).
(5) Move all robots with the same Y and Z coordinates as robot ip by one step in the positive direction of the X axis. Run Motion_Data_Update.
(6) The robot ip is moved in the positive direction of the Y axis until the Y coordinate of the robot ip reaches 0, and the Motion_Data_Update is executed repeatedly.
(7) Until the robot ip contacts one of the seed robots, the robot ip is moved in the negative Z-axis direction, and the Motion_Data_Update is executed repeatedly.
(8) For the robot ip, Travel_Goal described later is executed.
(9) Repeat (10) to (14) for all values from _z = Zmax-Zmin to _z = 1.
(10) Repeat (11) to (14) with all values from _y = y_num [_z] to _y = 1.
(11) Let ip be the robot at position (0,0, _z + Zmin).
(12) Move all robots with the same Z coordinate as robot ip by one step in the Y axis positive direction. Run Motion_Data_Update.
(13) The robot ip is moved in the negative Z-axis direction until the robot ip contacts one of the seed robots, and the Motion_Data_Update is executed repeatedly.
(14) For the robot ip, Travel_Goal described later is executed.
(15) Repeat (16) to (17) with all values from _z = Zmax to _z = Zmin + 1.
(16) Let ip be the robot at position (0,0, Zmin + 1).
(17) For the robot ip, Travel_Goal described later is executed.

[Travel_Goal]
(1) When this processing is first executed, variables _pole_cnt, _flag_cnt, _flag_y, _flag_z, _flag_x, _flag_zz, _flag_yy, and _floor_cnt are initialized to 0. When this process is executed for the first time, the variable _flag_all is the sum of the robots with the X coordinate of 0 and the Y coordinate negative in the shape 2 at the end of extrusion, and the variable _floor_all is the robot with a negative X coordinate. Stores the sum of.

If (2) _pole_cnt <(Zmax_g−Zmin_g + 1), the following is executed to finish (corresponding to the transformation from FIG. 42B to FIG. 42C). If not, go to (3).
(2-1) If the X coordinate of the robot ip is 1 and the Y coordinate is 0, all the robots adjacent above the robot ip are moved in the positive direction of the Y axis. Run Motion_Data_Update.
(2-2) If the X coordinate of the robot ip is 0 and the Y coordinate is 1, all the robots adjacent above the robot ip are moved in the positive direction of the X axis. Run Motion_Data_Update.
(2-3) If the X coordinate of the robot ip is 0 and the Y coordinate is 0, all the robots adjacent above the robot ip are moved in the positive direction of the Y axis. Run Motion_Data_Update. Move all adjacent robots above robot ip in the positive direction of the X axis. Run Motion_Data_Update.
(2-4) Move all robots connected to robot ip that have the same X and Y coordinate values as robot ip in the negative direction of the Z axis. Run Motion_Data_Update. Increment _pole_cnt.

(3) If _flag_cnt <_flag_all, the following is executed to finish (corresponding to the transformation from FIG. 42C to FIG. 42D). If not, go to (4).
If (3-1) _flag_y <_y_num_g [_flag_z + Zmin_g], (3-2) to (3-8) are executed. If not, execute only (3-8).
(3-2) If the X coordinate of the robot ip is 0 and the Y coordinate is 1, all the robots adjacent above the robot ip are moved in the positive direction of the X axis. Run Motion_Data_Update. Move all the robots adjacent above robot ip in the negative Y-axis direction. Run Motion_Data_Update.
(3-3) If the X coordinate of the robot ip is 1 and the Y coordinate is 1, all the robots adjacent above the robot ip are moved in the negative direction of the Y axis. Run Motion_Data_Update.
(3-4) If the X coordinate of the robot ip is 0 and the Y coordinate is 0, all the robots adjacent above the robot ip are moved in the positive direction of the X axis. Run Motion_Data_Update.
(3-5) Move all robots that have the same X and Y coordinate values as robot ip and are connected to robot ip in the negative Z-axis direction. Run Motion_Data_Update.
(3-6) If the robot ip is in contact with the negative Z-axis direction as ig, move the robot ig in the negative Z-axis direction and execute Motion_Data_Update, and the Z coordinate of the robot ig will be _flag_z + Zmin_g Repeat until.
(3-7) Move all robots with the same Z coordinate as robot ig by one step in the positive Y-axis direction. Increment _flag_cnt.
(3-8) Increment _flag_y and if _flag_y> y_num_g [_flag_z + Z_min_g], increment _flag_z and set _flag_y to 0.

(4) If _flag_x <_x_num_g [_flag_zz + Zmin_g] [_ flag_yy], (4-1) to (4-8) are executed (corresponding to the transformation from FIG. 42D to FIG. 42E). If not, execute only (4-8) and exit.
(4-1) If the X coordinate of the robot ip is 1 and the Y coordinate is 0, all the robots adjacent above the robot ip are moved in the positive direction of the Y axis. Run Motion_Data_Update. Move all adjacent robots above robot ip in the negative X-axis direction. Run Motion_Data_Update.
(4-2) If the X coordinate of the robot ip is 1 and the Y coordinate is 1, all the robots adjacent above the robot ip are moved in the negative direction of the X axis. Run Motion_Data_Update.
(4-3) If the X coordinate of the robot ip is 0 and the Y coordinate is 0, all the robots adjacent above the robot ip are moved in the positive direction of the Y axis. Run Motion_Data_Update.
(4-4) Move all robots that have the same X and Y coordinate values as robot ip and that are connected to robot ip in the negative Z-axis direction. Run Motion_Data_Update.
(4-5) The robot ip is in contact with the Z axis in the negative direction, and ig is set.If the robot ig is moved in the Z axis negative direction and Motion_Data_Update is executed, the Z coordinate of the robot ig is set to _flag_zz + Zmin_g. Repeat until.
(4-6) The robot ig is moved in the positive direction of the Y axis and the Motion_Data_Update is executed until the Z coordinate of the robot ig becomes _flag_yy + 1.
(4-7) Move all robots with the same Y and Z coordinates as robot ig by one step in the X axis positive direction. Increment _flag_cnt.
(4-8) _flag_x is incremented, if _flag_x> x_num_g [_flag_zz + Z_min_g] [_ flag_yy], then _flag_yy is incremented. To do. Set _flag_x to 0.

[Robot replacement process in set M2 at intermediate position]
According to the conditions related to the shape of the set of intermediate positions M2, among the robots that make up the ceiling of the set of intermediate positions M2, whether to have a robot adjacent in the negative Z-axis direction, at least of the robots that make up the ceiling There is only a guarantee that one is true. As shown in FIG. 44, in the robot replacement operation in this process, after the replacement source robot i_origin is pushed out above the ceiling, the replacement source robot i_origin moves to the vicinity of the replacement destination robot i_target on the ceiling. Therefore, when selecting the replacement source robot i_origin, there is a limitation that a robot having a robot adjacent in the negative Z-axis direction must be selected as the replacement source robot i_origin. Therefore, in this process, first, a robot having a robot adjacent in the negative Z-axis direction is selected as the replacement source robot i_origin. After the replacement operation, the robot i_origin_2 whose replacement destination is the position (X_origin, Y_origin, Z_origin) where the replacement source robot i_origin was originally reached the position (X_origin, Y_origin, Z_origin). Let i_origin_2 behave as a virtual replacement robot in subsequent replacement operations. That is, the flow is as follows.

(1) The replacement source robot i_origin is selected from the robots in the ceiling having the robot adjacent in the negative Z-axis direction.
(2) The robot i_origin is moved to the position of the replacement destination robot i_target [0], and the robot i_target [0] is expelled from the place where the robot i_target [0] was originally located. i_perm ← 0.
(3) The following iterative process (4) is executed.
(4) The robot i_target [i_perm] is moved to the position of the replacement robot i_target [i_perm + 1] of the robot i_target [i_perm]. If i_target [i_perm + 1] = i_origin is not satisfied, the robot i_target [i_perm + 1] is expelled from the place where the robot i_target [i_perm + 1] was originally located. i_perm is incremented and (4) is repeated. If i_target [i_perm + 1] = i_origin, the process ends and proceeds to (5).
(5) Let i_origin_2 ← i_target [i_perm], and let i_target [i_perm] be any robot that has not been replaced. Repeat (7) to (10) until there are no robots that have not been replaced.
(7) Move the robot i_origin_2 to the position of the replacement destination robot i_target [i_perm], and expel the robot i_target [i_perm] from the place where the robot i_target [i_perm] was originally located.
(8) The following iterative process (9) is executed.
(9) Move the robot i_target [i_perm] to the position of the robot i_target [i_perm + 1] to which the robot i_target [i_perm] is replaced, and place the robot i_target [i_perm + 1] where the robot i_target [i_perm + 1] was originally Kick out from. If the evicted robot is a robot i_origin_2, the process is terminated, and if not, (9) is repeated.
(10) The robot i_origin_2 is returned to the position at the time when the process of (5) was performed.

The actual processing is shown below.
[Permutation_in_M2]
(1) Execute Permutation_Initialization described later.
(2) Execute Permutaiton_Origin described later.
(3) Execute Permutaiton_Others described later.
(4) The value of tm-1 is stored in permutation_time, and at each time from t = 0 to permutation_time, the variable (transform_M2_to_M2_x [t] [i], transform_M2_to_M2_y [t] [i], transform_M2_to_M2_z [t] [i] ) Stores the values of (motion_x [t] [i], motion_y [t] [i], motion_z [t] [i]).

[Permutation_Initialization]
(1) For all robots i (i = 0,..., P-1), initialize the variable already [i] to 0, cube_id [i] to p, and cube_after [i] to p.
(2) For all i (i = 0,..., P-1), the position (Xtr [j], Ytr [j]) equal to the position (Xgp [i], Ygp [i], Zgp [i]) , Ztr [j]), and the value of variable cube_id [i] indicating the replacement destination of robot i is j.
(3) Store the values of (Xsp [i], Ysp [i], Zsp [i]) in (cube_buffer_x [i], cube_buffer_y [i], cube_buffer_z [i]).
(4) Set tm ← 0, and set the position of each robot to (Xsp [i], Ysp [i], Zsp [i]). Run Motion_Data_Update.

[Permutation_Origin]
(1) Select one robot ci that exists on the ceiling and touches the negative Z-axis.
(2) Set flg_ci ← 0 and _i = cube_id [ci].
(3) Repeat (4) to (7) while _i is not equal to ci.
(4) When flg_ci = 0, _i ← ci and flg_ci ← 1.
(5) cube_after [_i] ← cube_id [_i].

(6) When ci is not equal to cube_id [_i], [Change_Hetero_Ceiling (ci, _i, cube_id [_i])] described later is executed as variable _dest ← cube_id [_i]. If equal, do the following:
(6-1) One robot ii whose X coordinate is equal to cube_buffer_x [ci] and whose Y coordinate is equal to cube_buffer_y [ci] is specified, and [Horizontal_Change_Odd] is executed as _dest ← ii.
(6-2) If the difference between the X coordinate of robot_i and cube_buffer_x [ci] is 1, move robot_i one step in the negative direction of the X axis. -In case of 1, move robot_i one step in the positive direction of the X axis. Run Motion_Data_Update.
(6-3) If the difference between the Y coordinate of robot_i and cube_buffer_y [ci] is 1, move robot_i one step in the negative Y-axis direction. -In case of 1, move robot_i one step in the positive direction of the Y-axis. Run Motion_Data_Update.
(6-4) Until the Z coordinate value of robot_i reaches Zmax, move all robots that have the same X and Y coordinates as robot_i by one step in the negative direction of the Z axis, and repeat Motion_Data_Update.
(6-5) Variable seed_perm ← _i, zero_perm = ci.

(7) Already [_i] ← 1 and _i = cube_id [_i].
(8) Already [ci] ← 1.

[Permutation_Others]
(1) When already [i] = 0 for all robots ci, (2) execute the following.
(2) flg_ci ← 0, flg_oo = 0, and _i = cube_id [ci].
(3) If ci = _i is not
Set flg_oo ← 1 and buffer the X coordinate of the robot seed_perm in the variable x0 and the Y coordinate of the robot seed_perm in the variable y0. Execute [Change_Hetero_Ceiling (seed_perm, seed_perm, ci)].
(4) Repeat (5) to (8) while _i is not equal to ci.
(5) If flg_ci = 0, _i ← ci and flg_ci ← 1.
(6) Set cube_after [_i] ← cube_id [_i].
(7) When ci is not equal to cube_id [_i], [Change_Hetero_Ceiling (seed_perm, _i, cube_id [_i])] described later is executed. If they are equal, [Change_Hetero_Ceiling (seed_perm, _i, seed_perm)] is executed.
(8) Already [_i] ← 1 and _i = cube_id [_i].
(9) Already [ci] ← 1.

(10) When flg_oo = 1, execute the following.
(10-1) One robot ii whose X coordinate is x0 and Y coordinate is y0 is selected, _dest ← ii is set, _i in [Horizontal_Change_Odd] is replaced with seed_perm, and [Horizontal_Change_Odd] is executed.
(10-2) If the difference between the X coordinate of the robot seed_perm and the X coordinate of the robot ii is 1, the robot seed_perm is moved one step in the negative direction of the X axis. -In the case of 1, the robot seed_perm is moved one step in the positive direction of the X axis. Run Motion_Data_Update.
(10-3) If the difference between the Y coordinate of the robot seed_perm and the Y coordinate of the robot ii is 1, the robot seed_perm is moved one step in the negative direction of the Y axis. In the case of “−1”, the robot seed_perm is moved one step in the positive direction of the Y axis. Run Motion_Data_Update.
(10-4) All robots with the same X and Y coordinate values as the robot seed_perm are moved one step in the negative direction of the Z axis and Motion_Data_Update is executed in the robots with the same X and Y coordinate values as the robot seed_perm. Repeat until the Z coordinate of the largest Z coordinate value reaches Zmax.

[Horizontal_Change_Odd]
[Horizontal_Change_Odd] is processing in which cube_id [_i] is replaced with _dest and step (1) is replaced with the following in [Horizontal_Change] of the second embodiment.
(1) When the X coordinate value of the robot_i is equal to cube_buffer_x [_dest] and the Y coordinate value of the robot_i is equal to cube_buffer_y [_dest], the following is executed and the process ends. If not, go to (2).
If the X coordinate value of the robot_i is an even number, the robot_i is moved one step in the negative direction of the X axis, and if it is an odd number, it is moved one step in the positive direction of the X axis. Run Motion_Data_Update.

[Change_Hetero_Ceiling (_io, _i, _id)]
(1) When _io = _i, all robots having the same X and Y coordinate values as _i are moved one step in the positive direction of the Z axis. Run Motion_Data_Update.
(2) Set [_dest ← _id] and execute [Horizontal_Change_Odd].
(3) All robots with the same X and Y coordinate values as _id are moved one step in the Z-axis positive direction until Motion_Data_Update is executed until the Z coordinate of Robot_i is equal to the Z coordinate of Robot_id. repeat.
(4) Execute [Vertical_Change_Ceiling] described later.
(5) If the Z coordinate of the largest Z coordinate value among the robots with the same X, Y coordinate value as robot_i is smaller than Zmax, all robots with the same X, Y coordinate value as robot_i The movement of one step in the positive axis direction and the execution of Motion_Data_Update are repeated until the Z coordinate of the largest Z coordinate value among the robots having the same X and Y coordinate values as robot_i becomes Zmax. If the Z coordinate of the largest Z coordinate value among the robots with the same X and Y coordinate values as Robot_i is greater than Zmax, all the robots with the same X and Y coordinate values as Robot_i are in the negative direction of the Z axis. The process of moving to 1 step and executing Motion_Data_Update is repeated until the Z coordinate of the robot having the maximum Z coordinate value among the robots having the same X and Y coordinate values as robot_i becomes Zmax.

[Vertical_Change_Ceiling]
(1) If robot_i and robot_id have the same X coordinate, go to (1-1); otherwise go to (2).

  (1-1) If the X coordinate of the robot_i is an odd number, shift to (1-1-1), otherwise shift to (1-1-2).

    (1-1-1) Robot_i and all robots whose X and Y coordinates are the same as robot_i and in the Z-axis positive direction are moved one step in the X-axis positive direction, and robot_id and robot_id Move all robots with the same X and Y coordinates in the positive Z-axis direction by one step in the positive X-axis direction. Run Motion_Data_Update. If the Y coordinate of the robot_i is larger than the Y coordinate of the robot_id, go to (1-1-1-1), otherwise go to (1-1-1-2).

      (1-1-1-1) Move all robots whose X and Y coordinates are equal to robot_id and whose Z coordinate is larger than robot_id by one step in the positive direction of the Y-axis. Run Motion_Data_Update.

      The robot_i and all robots having the same X and Y coordinates as the robot_i and in the positive Z-axis direction are moved one step in the negative X-axis direction. Run Motion_Data_Update.

      Robot_id and all robots whose X and Y coordinates are the same as the robot_id in the positive Z-axis direction are moved one step in the positive Y-axis direction. Run Motion_Data_Update.

      Move all robots whose X and Y coordinates are the same in the Z axis positive direction as the robot_i and robot_i, and move one step in the Y axis negative direction, and the robot _id and robot _id are equal in the X and Y coordinates Move all robots in the positive Z-axis direction by one step in the negative Y-axis direction. Run Motion_Data_Update.

      All robots with the same X and Y coordinate values as robot_i are moved one step in the negative Z-axis direction, and Motion_Data_Update is executed. Repeat until the Z coordinate of the coordinate value becomes Zmax.

(1-1-1-2)
All robots whose X and Y coordinates are equal to robot_id and whose Z coordinate is larger than robot_id are moved one step in the negative direction of the Y axis. Run Motion_Data_Update.

      The robot_i and all robots having the same X and Y coordinates as the robot_i and in the positive Z-axis direction are moved one step in the negative X-axis direction. Run Motion_Data_Update.

      Robot_id and all robots having the same X and Y coordinates as robot_id and in the positive Z-axis direction are moved one step in the negative Y-axis direction. Run Motion_Data_Update.

      Move all robots whose X and Y coordinates are the same in the Z-axis positive direction as robot_i and robot_i, and move one step in the Y-axis positive direction. Robot_id and robot_id and X and Y coordinates are equal Move all robots in the positive Z-axis direction by one step in the positive Y-axis direction. Run Motion_Data_Update.

      All robots with the same X and Y coordinate values as robot_i are moved one step in the negative Z-axis direction, and Motion_Data_Update is executed. Repeat until the Z coordinate of the coordinate value becomes Zmax.

    (1-1-2) (When the X coordinate of robot_i is not an odd number) Robot_i and all robots whose X and Y coordinates are the same as Z Move one step, and move robot_id and all robots whose X and Y coordinates are equal to the robot_id in the positive Z-axis direction by one step in the negative X-axis direction. Run Motion_Data_Update. If the Y coordinate of robot_i is larger than the Y coordinate of robot_id, the process proceeds to (1-1-2-1). Otherwise, the process proceeds to (1-1-2-2).

      (1-1-2-1) Move all robots whose X and Y coordinates are equal to robot_id and whose Z coordinate is larger than robot_id by one step in the positive direction of the Y axis. Run Motion_Data_Update.

      The robot_i and all robots whose X and Y coordinates are the same as the robot_i and in the positive Z-axis direction are moved one step in the positive X-axis direction. Run Motion_Data_Update.

      Robot_id and all robots whose X and Y coordinates are the same as the robot_id in the positive Z-axis direction are moved one step in the positive Y-axis direction. Run Motion_Data_Update.

      Move all robots whose X and Y coordinates are the same in the Z axis positive direction as the robot_i and robot_i, and move one step in the Y axis negative direction, and the robot _id and robot _id are equal in the X and Y coordinates Move all robots in the positive Z-axis direction by one step in the negative Y-axis direction. Run Motion_Data_Update.

      All robots with the same X and Y coordinate values as robot_i are moved one step in the negative Z-axis direction, and Motion_Data_Update is executed. Repeat until the Z coordinate of the coordinate value becomes Zmax.

      (1-1-2-2) All robots whose X and Y coordinates are the same as robot_id and whose Z coordinate is larger than robot_id are moved one step in the negative Y-axis direction. Run Motion_Data_Update.

      The robot_i and all robots whose X and Y coordinates are the same as the robot_i and in the positive Z-axis direction are moved one step in the positive X-axis direction. Run Motion_Data_Update.

      Robot_id and all robots having the same X and Y coordinates as robot_id and in the positive Z-axis direction are moved one step in the negative Y-axis direction. Run Motion_Data_Update.

      Move all robots whose X and Y coordinates are the same in the Z-axis positive direction as robot_i and robot_i, and move one step in the Y-axis positive direction. Robot_id and robot_id and X and Y coordinates are equal Move all robots in the positive Z-axis direction by one step in the positive Y-axis direction. Run Motion_Data_Update.

All robots with the same X and Y coordinate values as robot_i are moved one step in the negative Z-axis direction, and Motion_Data_Update is executed. Repeat until the Z coordinate of the coordinate value becomes Zmax.
(2) If the Y coordinate of robot_i is an odd number, go to (2-1), otherwise go to (2-2).

  (2-1) Move all robots whose X and Y coordinates are the same in the Z-axis positive direction as robot_i and robot_i by one step in the Y-axis positive direction, and robot_id and robot_id and X , Move all robots with the same Y coordinate in the positive Z-axis direction by one step in the positive Y-axis direction. Run Motion_Data_Update. If the X coordinate of the robot_i is larger than the X coordinate of the robot_id, go to (2-1-1), otherwise go to (2-1-2).

    (2-1-1) Move all robots whose X and Y coordinates are equal to robot_id and whose Z coordinate is larger than robot_id by one step in the positive direction of the X axis. Run Motion_Data_Update.

    Robot_i and all robots having the same X and Y coordinates as robot_i and in the positive Z-axis direction are moved one step in the negative Y-axis direction. Run Motion_Data_Update.

    Robot_id and all robots whose X and Y coordinates are the same as the robot_id in the positive direction of the Z axis are moved one step in the positive direction of the X axis. Run Motion_Data_Update.

    Move all robots whose X and Y coordinates are the same in the Z axis positive direction as robot _i and robot _i, and move one step in the X axis negative direction. Robot _id and robot _id are the same in X and Y coordinates Move all robots in the positive Z-axis direction by one step in the negative X-axis direction. Run Motion_Data_Update.

    All robots with the same X and Y coordinate values as robot_i are moved one step in the negative Z-axis direction, and Motion_Data_Update is executed. Repeat until the Z coordinate of the coordinate value becomes Zmax.

    (2-1-2) Move all robots whose X and Y coordinates are equal to robot_id and whose Z coordinate is larger than robot_id by one step in the negative direction of the X axis. Run Motion_Data_Update.

    Robot_i and all robots having the same X and Y coordinates as robot_i and in the positive Z-axis direction are moved one step in the negative Y-axis direction. Run Motion_Data_Update.

    Robot_id and all robots having the same X and Y coordinates as robot_id and in the positive Z-axis direction are moved one step in the negative X-axis direction. Run Motion_Data_Update.

    Move all robots whose X and Y coordinates are the same in the Z axis positive direction as Robot_i and Robot_i, and move in one step in the X axis positive direction. Robot_id and Robot_id are the same in X and Y coordinates Move all robots in the positive Z-axis direction by one step in the positive X-axis direction. Run Motion_Data_Update.

    All robots with the same X and Y coordinate values as robot_i are moved one step in the negative Z-axis direction, and Motion_Data_Update is executed. Repeat until the Z coordinate of the coordinate value becomes Zmax.

  (2-2) Move robot_i and all robots with the same X and Y coordinates as robot_i and in the positive Z-axis direction by one step in the negative Y-axis direction. , Move all robots with the same Y coordinate in the positive Z-axis direction by one step in the negative Y-axis direction. Run Motion_Data_Update. If the X coordinate of Robot_i is larger than the X coordinate of Robot_id, go to (2-2-1), otherwise go to (2-2-2).

    (2-2-1) Move all robots whose X and Y coordinates are equal to robot_id and whose Z coordinate is larger than robot_id by one step in the positive direction of the X axis. Run Motion_Data_Update.

    The robot_i and all robots having the same X and Y coordinates as the robot_i and in the positive Z-axis direction are moved one step in the positive Y-axis direction. Run Motion_Data_Update.

    Robot_id and all robots whose X and Y coordinates are the same as the robot_id in the positive direction of the Z axis are moved one step in the positive direction of the X axis. Run Motion_Data_Update.

    Move all robots whose X and Y coordinates are the same in the Z axis positive direction as robot _i and robot _i, and move one step in the X axis negative direction. Robot _id and robot _id are the same in X and Y coordinates Move all robots in the positive Z-axis direction by one step in the negative X-axis direction. Run Motion_Data_Update.

    All robots with the same X and Y coordinate values as robot_i are moved one step in the negative Z-axis direction, and Motion_Data_Update is executed. Repeat until the Z coordinate of the coordinate value becomes Zmax.

    (2-2-2) Move all robots whose X and Y coordinates are equal to robot_id and whose Z coordinate is larger than robot_id by one step in the negative direction of the X axis. Run Motion_Data_Update.

    The robot_i and all robots having the same X and Y coordinates as the robot_i and in the positive Z-axis direction are moved one step in the positive Y-axis direction. Run Motion_Data_Update.

    Robot_id and all robots having the same X and Y coordinates as robot_id and in the positive Z-axis direction are moved one step in the negative X-axis direction. Run Motion_Data_Update.

    Move all robots whose X and Y coordinates are the same in the Z axis positive direction as Robot_i and Robot_i, and move in one step in the X axis positive direction. Robot_id and Robot_id are the same in X and Y coordinates Move all robots in the positive Z-axis direction by one step in the positive X-axis direction. Run Motion_Data_Update.

    All robots with the same X and Y coordinate values as robot_i are moved one step in the negative Z-axis direction, and Motion_Data_Update is executed. Repeat until the Z coordinate of the coordinate value becomes Zmax.

As described above, the entire process of the third embodiment is as follows.
[Transformation_from_S_to_G_Hetero_2]
(1) Execute [Extend_Process_S].
(2) Execute [Make_Ceiling].
(3) Execute [Extend_Process_G].
(4) Execute [Translate_from_M2_to_Mobile_G].
(5) Execute [Permutation_in_M2].
(6) From t = 0 to push_time_start, the variable (transform_S_to_G_x [t] [i], transform_S_to_G_y [t] [i], transform_S_to_G_z [t] [i]) is transformed into (transform_S_to_M2_x [t] [i], transform_S_to_M2_y [t ] [i], transform_M_to_M2_z [t] [i]) are stored.
(7) From t = push_time_start + 1 to push_time_start + 1 + permutation_time, the variable (transform_S_to_G_x [t] [i], transform_S_to_G_y [t] [i], transform_S_to_G_z [t] [i]) is transformed into (transform_M2_to_M2_x [t- ( push_time_start + 1)] [i], transform_M2_to_M2_y [t- (push_time_start + 1)] [i], transform_M2_to_M2_z [t- (push_time_start + 1)] [i]) are stored.
(8) t = push_time_start + 1 + permutation_time + 1
~ Push_time_start + 1 + permutation_time + 1 + translate_time, the variable (transform_S_to_G_x [t] [i], transform_S_to_G_y [t] [i], transform_S_to_G_z [t] [i]) and (transform_M2_to_P2_x [t-(+ push_time_start permutation_time + 1)] [cube_after [i]], transform_M2_to_P2_y [t- (push_time_start + 1 + permutation_time + 1)] [cube_after [i]], transform_M2_to_P2_z [t- (push_time_start + 1 + permutation_time + 1)] [cube_after [ Stores the value of i]]).
(9) In t = push_time_start + 1 + permutation_time + 1 + translate_time + 1 to push_time_start + 1 + permutation_time + 1 + translate_time + 1 + push_time_goal, variables (transform_S_to_G_x [t] [i], transform_S_to_G_y [t] [i], transform_S_to_G_z [t] [i]) and (transform_P2_to_G_x [t- (push_time_start + 1 + permutation_time + 1 + translate_time + 1)] [i], transform_P2_to_G_y [t- (push_time_start + 1 + permutation_time + 1 + translate_time + 1) ] [i], transform_P2_to_G_z [t- (push_time_start + 1 + permutation_time + 1 + translate_time + 1)] [i]) is stored.

<Action control system 100 according to the third embodiment>
FIG. 22 is a functional block diagram of the behavior control system 100 according to the third embodiment, and FIG. 23 shows an example of the processing flow. As shown in FIG. 22, the behavior control system 100 includes a behavior selection unit 120, an adjacent state determination unit 124, a position update unit 123, a position determination unit 126, a storage unit 140, a communication unit 150, and an input unit. 160. The action selection unit 120 includes an extrusion process processing unit 120A, an intermediate transition process processing unit 120B, a final development process processing unit 120C, a position replacement unit 120D, and an intermediate position deformation unit 120E.
Except for the processing contents of the action selection unit 120, the second embodiment is the same as the second embodiment.

<Action selection unit 120>
The action selection unit 120 controls the p robots by the method described above (s120). Note that the extrusion process processing unit 120A, the intermediate transition process processing unit 120B, the final development process processing unit 120C, the position replacement unit 120D, and the intermediate position deformation unit 120E change the order and direction of the operation of each robot before starting the robot operation. Calculated in advance and stored in the storage unit 140. The action selection unit 120 extracts the operation of each robot at each time from the storage unit 140, transmits a control signal indicating the moving direction to the robot to be moved at each time, and each robot operates according to the control signal.

(Intermediate transition process processor 120B)
The intermediate transition process processing unit 120B of the action selection unit 120 takes out a set G of q target positions, and (1) the coordinate value in the first direction is large so as to be equal to or less than a certain coordinate value O ₁ in the first direction. In the order from the position included in the set of target positions, if the coordinate value in the first direction is small, and if it is adjacent to the position included in the set of target positions, it is translated in the third direction together with the adjacent position. (Compress), (2) a position included in a set of target positions whose coordinate values in the first direction are not coordinate value O ₁ so that a position included in a set of target positions adjacent in the first direction exists. , is translated in a first direction (compressing), (3) such that one coordinate value O ₂ or less in the second direction, it is greater coordinate values in the second direction, in order from the position in the set target position , Small coordinate value in the second direction, target Together with its adjacent position when adjacent to the position in the set of location is moved parallel to the fourth direction (compression), (4) target coordinate value in the second direction is not the coordinate value O ₂ The position included in the set of positions is translated in the second direction so that the position included in the set of target positions adjacent in the second direction exists, and (5) the coordinate value in the fifth direction is the coordinate value O. _A shape 2 at the end of extrusion is formed by translating a position included in the set of target positions other than 3 in the sixth direction so that a position included in the set of adjacent target positions in the fifth direction exists. Find the position of the robot. For example, the first direction, the second direction, the third direction, the fourth direction, the fifth direction, and the sixth direction are respectively the x-axis positive direction, the y-axis positive direction, the x-axis negative direction, the y-axis negative direction, and the z-axis positive direction. By executing the above [Extend_Process_G] when the direction and z-axis negative direction are set, the coordinate value O ₁ is x = 0, the coordinate value O ₂ is y = 0, and the coordinate value O ₃ is z = Zmin, The position of the robot forming the shape 2 at the end of extrusion can be obtained. The order and direction of movement of each robot when obtaining the position of the robot that forms the end-of-extrusion shape 2 from the position included in the set G of target positions is output to the final development process processing unit 120C.

  The intermediate transition process processing unit 120B of the action selection unit 120 can obtain the position of the robot that forms the end-of-extrusion shape 1 by taking out a set S of q start positions and executing the above [Extend_Process_S]. . The order and direction of movement of each robot when obtaining the position of the robot forming the shape 1 at the end of extrusion from the positions included in the set S of target positions is output to the final development process processing unit 120C.

(Intermediate position deformation part 120E)
The intermediate position deformation unit 120E receives the position of the robot that forms the shape 1 at the end of extrusion, and executes the above-mentioned [Make_Ceiling] to obtain the position of the robot that forms the set M2 of intermediate positions, and the shape 1 at the end of extrusion The order and direction of movement of each robot when it is transformed into the set M2 of intermediate positions are obtained.

(Extrusion process processor 120A)
The extrusion process processing unit 120A of the action selection unit 120 receives the position of the robot that forms the set M2 of intermediate positions, and executes the above-described [Translate_from_M2_to_Mobile_G] to obtain the position of the robot that forms the shape 2 at the end of extrusion, The order and direction of movement of each robot when the position set M2 is transformed into the shape 2 at the end of extrusion is obtained.

The shape 2 at the end of extrusion is a shape in which the robot forms a plane at the coordinate value O ₁ and the coordinate value O ₂ . The shape 2 at the end of extrusion corresponds to a formation formed by the robot obtained by the above-described [Translate_from_M2_to_Mobile_G] when the coordinate value O ₁ is x = 0 and the coordinate value O ₂ is y = 0. By setting the shape at the end of extrusion to such a shape, the movement path of the robot can be secured when the shape is changed from the set M2 at the intermediate position to the shape 2 at the end of extrusion.

(Final development process processor 120C)
The final development process processing unit 120C of the action selecting unit 120 acquires the position of each robot in the extrusion end shape 2 from the extrusion process processing unit 120A, and from the positions included in the set G of target positions from the intermediate transition process processing unit 120B. The order and direction of movement of each robot when obtaining the position of the robot forming the shape 2 at the end of extrusion is acquired. Then, the final development process processing unit 120C reverses the order of obtaining the position of the robot forming the end-of-extrusion shape 2 from the position included in the target position set G for the robot forming the end-of-extrusion shape 2. In this order, by moving the robot in a direction opposite to the parallel movement direction when the position of the robot forming the end shape 2 from the position included in the set G of target positions is obtained, the end shape 2 at the end of extrusion is obtained. Move the robot to the set G of target positions.

(Position changing part 120D)
The position replacing unit 120D acquires the position in the extrusion end shape 2 of the robot i from the extrusion process processing unit 120A when the shape is changed from the target position set G to the extrusion end shape 2.

  In addition, the position changing unit 120D transforms from the set S of the start positions into the set M2 at the intermediate position through the shape 1 at the end of extrusion, and the shape at the end of extrusion of the robot i when transformed from the M2 to the shape 2 at the end of extrusion. 2 is acquired from the extrusion intermediate position deforming unit 120E. The position swapping unit uses the acquired values of those positions to transform the robot i from the position in the set M2 of the intermediate positions of the robot i when transformed from the set S of the start positions to the set M2 of the intermediate positions. When the target position set G is transformed into the intermediate position set M2, the correspondence relationship between the positions of the robots for moving the robot i to positions in the intermediate position set M2 is calculated.

  The position exchanging unit 120D executes the process [Permutation_in_M2] to change the robot i from the position in the set M2 of the intermediate positions of the robot i to the target position by changing from the set S of the start positions to the set of intermediate positions M2. The order and direction of movement of each robot for moving to the position in the set M2 of the intermediate positions of the robot i when the set G is transformed into the set M2 of the intermediate positions is acquired.

<Effect>
With such a configuration, the same effect as that of the second embodiment can be obtained. In the first embodiment, the shape of the intermediate position set M is a rectangular or L-shaped flat plate made up of 2 × 2 × 2 8 square robot units, but in the third embodiment, the intermediate position The condition of the shape of the set M2 only needs to have a rectangular ceiling or floor composed of 2 x 2 4-mass robot units (in short, the position where the maximum or minimum value in the Z-axis direction is reached) It is sufficient that the robot is arranged so as to form a rectangular flat plate configured by the robot unit on the plane passing through), and accordingly, the deformation process can be simplified. In addition, the same deformation | transformation as the modification of 2nd embodiment is possible.

<Other variations>
The present invention is not limited to the above-described embodiments and modifications. For example, the various processes described above are not only executed in time series according to the description, but may also be executed in parallel or individually as required by the processing capability of the apparatus that executes the processes. In addition, it can change suitably in the range which does not deviate from the meaning of this invention.

<Program and recording medium>
In addition, various processing functions in each device described in the above embodiments and modifications may be realized by a computer. In that case, the processing contents of the functions that each device should have are described by a program. Then, by executing this program on a computer, various processing functions in each of the above devices are realized on the computer.

  The program describing the processing contents can be recorded on a computer-readable recording medium. As the computer-readable recording medium, for example, any recording medium such as a magnetic recording device, an optical disk, a magneto-optical recording medium, and a semiconductor memory may be used.

  The program is distributed by selling, transferring, or lending a portable recording medium such as a DVD or CD-ROM in which the program is recorded. Further, the program may be distributed by storing the program in a storage device of the server computer and transferring the program from the server computer to another computer via a network.

  A computer that executes such a program first stores, for example, a program recorded on a portable recording medium or a program transferred from a server computer in its storage unit. When executing the process, this computer reads the program stored in its own storage unit and executes the process according to the read program. As another embodiment of this program, a computer may read a program directly from a portable recording medium and execute processing according to the program. Further, each time a program is transferred from the server computer to the computer, processing according to the received program may be executed sequentially. Also, the program is not transferred from the server computer to the computer, and the above-described processing is executed by a so-called ASP (Application Service Provider) type service that realizes the processing function only by the execution instruction and result acquisition. It is good. Note that the program includes information provided for processing by the electronic computer and equivalent to the program (data that is not a direct command to the computer but has a property that defines the processing of the computer).

  In addition, although each device is configured by executing a predetermined program on a computer, at least a part of these processing contents may be realized by hardware.

Claims (13)

The q-number of the start position q stand control object arranged set of a behavior control system for performing action control for moving a set of q target position,
Direction not parallel to the first direction and a second direction, the opposite direction to the first direction and the third direction, a direction opposite to the second direction and the fourth direction, wherein the starting position and wherein each target location is adjacent at least one of direction of each of the first direction to fourth direction and the other start position and the target position, the set and any of their respective set lump of the starting position of the target position Shape,
The control object includes a first position adjacent in the first direction on the two-dimensional plane of the control object, a second position adjacent in the second direction, a third position adjacent in the third direction, and a fourth position. It is assumed that the fourth position is adjacent in the direction and is controlled to move to any one of the first to fourth positions on the two-dimensional plane.
An intermediate transition process processing unit for determining the position of the control object forming the intermediate form train by translating each of the target positions in a direction parallel to the first direction ;
For the control objects forming the intermediate formations, the target positions of the target positions are reversed in the order in which the positions of the control objects forming the intermediate formations are obtained from the positions included in the set of target positions. look including the said intermediate final form the translation direction for obtaining the position of the control object constituting the platoon moves the controlled object in the opposite direction expansion process unit from a position in the set,
The intermediate formation platoon is arranged such that each position included in the set of target positions is the order of the target positions in the first direction, with an axis perpendicular to the first direction passing through a certain position in the first direction as a reference axis. It is a convoy obtained by translating in the direction approaching the reference axis as much as possible while maintaining it,
The step of obtaining the position of the control object constituting the intermediate form train in the intermediate transition process processing unit,
The target position having the longest distance from the reference axis in the direction parallel to the first direction and the target position continuing from the target position in a direction parallel to the first direction are parallel to the first direction. A behavior control system that sequentially repeats the step of translating in the direction until the intermediate formation row is obtained . The behavior control system according to claim 1,
The number of control objects located at the same position in the second direction is the same as that of the intermediate form train, and all the control objects located at the same position in the second direction are adjacent to each other in the first direction. Including an extrusion process processing unit for controlling the formation to form an extrusion formation, wherein the formation is an extrusion formation and at least q control objects are moved.
The intermediate transition process processing unit transforms the extruded formation into the intermediate form formation by translating in the first direction for each position in the second direction.
Behavior control system. The behavior control system according to claim 2,
The pushing platoon includes a number n [i_y] of control objects located at a position i_y in the second direction and a number n [i_y] of control objects located at a position i_y-1 adjacent to the position i_y in the second direction. -1] in the first direction at the position i_y-1 and the control object at one end or the other end of the control object that is continuously adjacent in the first direction at the position i_y. It is a formation in which the control objects at one end or the other end of the control objects adjacent to each other are aligned in the second direction,
The extrusion process processing unit moves the control object in the second direction from the set of start positions by the number of the control objects located at the same position in the first direction of the extrusion row, and thereafter, the start position Repeat the process of moving all the control objects outside the set in the first direction, and then move in the second direction to form an extruded platoon,
Behavior control system. The behavior control system according to claim 2,
The extrusion process processing unit moves the control object from the set of start positions so that the control object forms a line parallel to the second direction, and then moves along the line parallel to the second direction. The control object is moved in the second direction to a position in the second direction in the intermediate form row, and then moved in the first direction to form an extrusion row.
Behavior control system. The q-number of the start position q stand control object arranged set of a behavior control method for performing action control for moving a set of q target position,
Direction not parallel to the first direction and a second direction, the opposite direction to the first direction and the third direction, a direction opposite to the second direction and the fourth direction, wherein the starting position and wherein each target location is adjacent at least one of direction of each of the first direction to fourth direction and the other start position and the target position, the set and any of their respective set lump of the starting position of the target position Shape,
The control object includes a first position adjacent in the first direction on the two-dimensional plane of the control object, a second position adjacent in the second direction, a third position adjacent in the third direction, and a fourth position. It is assumed that the fourth position is adjacent in the direction and is controlled to move to any one of the first to fourth positions on the two-dimensional plane.
An intermediate transition process processing unit that translates each of the target positions in a direction parallel to the first direction to obtain a position of a control object that forms an intermediate form train; and
The final development process processing unit reverses the order in which the position of the control object forming the intermediate formation row is obtained from the position included in the set of target positions for the control object forming the intermediate formation row. In order, a final deployment process step of moving the control object in a direction opposite to the parallel movement direction when obtaining the position of the control object that forms the intermediate formation from the position included in the set of target positions. seen including,
The intermediate formation platoon is arranged such that each position included in the set of target positions is the order of the target positions in the first direction, with an axis perpendicular to the first direction passing through a certain position in the first direction as a reference axis. It is a convoy obtained by translating in the direction approaching the reference axis as much as possible while maintaining it,
The step of obtaining the position of the control object forming the intermediate form train in the intermediate transition process step is:
The target position having the longest distance from the reference axis in the direction parallel to the first direction and the target position continuing from the target position in a direction parallel to the first direction are parallel to the first direction. A behavior control method in which the step of translating in a direction is sequentially repeated until the intermediate formation row is obtained .   A program for causing a computer to function as the behavior control system according to claim 1. A behavior control system that performs behavior control for moving q control objects from a set of q start positions to a set of q target positions,
The direction that is not parallel to the first direction is the second direction, the direction opposite to the first direction is the third direction, the direction opposite to the second direction is the fourth direction, the first direction and the first direction The direction that is not parallel to the plane formed by the two directions is the fifth direction, the opposite direction to the fifth direction is the sixth direction, and each start position and each target position are the first to sixth directions, respectively. Adjacent to other start positions and target positions in at least one of the directions, the set of target positions and the set of start positions each form an arbitrary shape of a lump,
The control object includes a first position adjacent in the first direction on the three-dimensional space of the control object, a second position adjacent in the second direction, a third position adjacent in the third direction, and a fourth direction. Adjacent fourth position, fifth position adjacent in the fifth direction, sixth position adjacent in the sixth direction, either stationary, or any of the first to sixth positions in the three-dimensional space Shall be controlled to move,
The position of the control object that forms the shape at the end of extrusion by translating each position included in the set of target positions in a direction parallel to the first direction and / or a direction parallel to the second direction. Intermediate transition process processing unit for obtaining
For the control object that forms the end-of-extrusion shape, the target in a reverse order to the order in which the position of the control object that forms the end-of-extrusion shape is determined from the positions included in the set of target positions. look including the final expansion process unit for moving a control object in a direction opposite to the translation direction for obtaining the position of the control object from a position in the set position forming said extrusion end shape,
The shape at the end of the extrusion has an axis perpendicular to the first direction passing through a certain position in the first direction as a first reference axis and an axis perpendicular to the second direction passing through a position in the second direction as a second reference. As an axis
Each position included in the set of target positions is parallel to the direction approaching the first reference axis and the second reference axis as much as possible while maintaining the order of the target positions in the first direction and the second direction. It is a convoy obtained by moving,
The step of obtaining the position of the control object that forms the shape at the end of extrusion in the intermediate transition process processing unit,
(1) The target position having the longest distance from the first reference axis in the direction parallel to the first direction, and the target position continuous in the direction parallel to the first direction from the target position, Translating in a direction parallel to one direction;
(2) The target position having the longest distance from the second reference axis in the direction parallel to the second direction and the target position continuous from the target position in the direction parallel to the second direction are Translating in a direction parallel to the two directions;
An action control system that repeats until the shape at the end of extrusion is obtained . The behavior control system according to claim 7,
The intermediate transition process processing unit, the control object in the coordinate values O ₁ and the coordinate value O ₂ to seek the position of the controlled object so as to form a plane,
Behavior control system. The behavior control system according to claim 7 or claim 8,
p> q, move p control objects from a set of q start positions to a set of p intermediate positions, and move from a set of p intermediate positions to a set of q target positions. ,
M, N, and Q are each an integer of 2 or more, and in the set of intermediate positions, the p control objects constitute one control object unit for each M × N × Q units, and 1 M × N × Q control objects constituting one control object unit are adjacent to other control objects constituting the control object unit in three or more directions,
R is any integer greater than or equal to 3, p = M × N × Q × R, and the set of intermediate positions passes through a certain position in the fifth direction, the first direction formed by the first direction and the second direction. 2 control object units are L on 2 planes
It is a shape arranged to form a letter or rectangular flat plate shape,
Behavior control system. The behavior control system according to claim 9,
A virtual existence that occurs with the movement of the control object or moves in the direction opposite to the direction in which the control object moves is defined as a void, and p control objects are extracted from a set of p intermediate positions. When deforming to the shape at the end of extrusion, the voids generated in the intermediate position set when moving the control object out of the intermediate position set from the position unit where the void was generated, to the intermediate position set Control to move to the control object at the farthest position of
Behavior control system. The behavior control system according to claim 7 or claim 8,
p> q, move p control objects from a set of q start positions to a set of p intermediate positions, and move from a set of p intermediate positions to a set of q target positions. ,
Each of M and N is an integer of 2 or more, and in the set of intermediate positions, one control object unit is configured for each M × N units, R is any of an integer of 1 or more, and the intermediate position The set is such that R control object units form a rectangular flat plate shape on the first or second plane formed by the first direction and the second direction that passes through the maximum or minimum position in the fifth direction. Is the shape placed in the
Behavior control system. A behavior control method for performing behavior control for moving q control objects from a set of q start positions to a set of q target positions,
The direction that is not parallel to the first direction is the second direction, the direction opposite to the first direction is the third direction, the direction opposite to the second direction is the fourth direction, the first direction and the first direction The direction that is not parallel to the plane formed by the two directions is the fifth direction, the opposite direction to the fifth direction is the sixth direction, and each start position and each target position are the first to sixth directions, respectively. Adjacent to other start positions and target positions in at least one of the directions, the set of target positions and the set of start positions each form an arbitrary shape of a lump,
The control object includes a first position adjacent in the first direction on the three-dimensional space of the control object, a second position adjacent in the second direction, a third position adjacent in the third direction, and a fourth direction. Adjacent fourth position, fifth position adjacent in the fifth direction, sixth position adjacent in the sixth direction, either stationary, or any of the first to sixth positions in the three-dimensional space Shall be controlled to move,
The position of the control object that forms the shape at the end of extrusion by translating each position included in the set of target positions in a direction parallel to the first direction and / or a direction parallel to the second direction. Intermediate transition process processing step for obtaining
For the control object that forms the end-of-extrusion shape, the target in a reverse order to the order in which the position of the control object that forms the end-of-extrusion shape is determined from the positions included in the set of target positions. look including the final expansion step process step of moving a control object in a direction opposite to the translation direction when the from the position in the set position determining the position of the controlled object forming the extrusion end shape,
The shape at the end of the extrusion has an axis perpendicular to the first direction passing through a certain position in the first direction as a first reference axis and an axis perpendicular to the second direction passing through a position in the second direction as a second reference. As an axis
Each position included in the set of target positions is parallel to the direction approaching the first reference axis and the second reference axis as much as possible while maintaining the order of the target positions in the first direction and the second direction. It is a convoy obtained by moving,
The step of obtaining the position of the control object that forms the shape at the end of extrusion in the intermediate transition process processing step,
(1) The target position having the longest distance from the first reference axis in the direction parallel to the first direction, and the target position continuous in the direction parallel to the first direction from the target position, Translating in a direction parallel to one direction;
(2) The target position having the longest distance from the second reference axis in the direction parallel to the second direction and the target position continuous from the target position in the direction parallel to the second direction are Translating in a direction parallel to the two directions;
A behavior control method that repeats until the shape at the end of extrusion is obtained .   The program for functioning a computer as an action control system in any one of Claims 7-11.