Real-time strategic game development-rectangle application practices + Methods ignored by you in array

Last time I posted a rectangle object in the game
Development
Application in
Article
Next, we will introduce the practical application of the rectangle object in the instant strategy game. At the same time, a few methods are usually used in array objects.

Friends who have played "Red Police" or "times of Empire" should know that such games have a box selection function. Mouse
Pull a box on the screen and all the items in the box are selected.

The prototype of this example is as follows:

1. There are two options for tank selection: Box selection and click to select.
2. After a tank is selected, it will show that it is selected
3. If a tank is selected when you click the mouse on the screen, the tank moves to the vicinity of the mouse clicking position (not the mouse clicking position nearby), and the selection status is automatically canceled.
4. If a new option is selected, the selection status of the selected tank will be canceled.

Let's take a look at the effect.
, Click here


[Flash
Http://source.iflashigame.com/c&c/c&c.swf
[/Flash]
Explanation:

1. Implementation of tank selection and non-selection status

Set an attribute in our tank class
Select, implemented by the set method. When select = true, let the frame of the tank jump to 2nd frames. When select = false, let the frame of the tank jump to 1st frames.

Set a private Variable _ select in tank, and then set getter/setter

1. Public Function get select (): Boolean
   
2. {
   
3. Return _ select;
   
4. }
   
5. Public Function set select (S: Boolean)
   
6. {
   
7. _ Select = s;
   
8. This. gotoandstop (_ select = true? 2: 1)
   
9. }

Copy code

2. Implementation of tank click selection

We do not need to register mouse events for every tank.
You only need to register a mouse event for the container where the tank is placed to know which tank the user clicks.
Mouseevent has two attributes: Target and currenttarget. The two attributes are different. The target returns the interactive object that receives the click first, and the currenttarget returns the object registered by your addeventlistener. See:

3. Implementation of tank box Selection

Basically, we need to do the following steps:
A. Use the mouse's mouse_move event to pull the box.
B. Compare the drawn box with the boundary box of the object to determine whether the object has been selected.
C. Change these objects to the selected state.
D. When the mouse is clicked again, if a tank is in the selected status and is in the open space position, all tanks move to the vicinity of the target point, and cancel all selection statuses.

The implementation idea is to prepare two arrays, one to record the reference tanklist of all tanks, and one to record the reference selectlist of the selected tanks at any time.

Here, we will use the methods foreach () and filter () in the two arrays that are not frequently used. These two methods will play an important role here. There are five new methods for array objects that you may not be concerned about. For example:

Let's take a look at how we use this example:

1. Selectlist = tanklist. Filter (selecttank); // find the tank selected
   
2. Selectlist. foreach (movetank); // move all selected tanks
   
3. 
   
4. Function selecttank (element: *, index: int, arr: array)
   
5. {
   
6. // If the boundary of the tank overlaps the selected box, the tank is displayed as the selected state.
   
7. If (element. getbounds (this). intersects (REC) = true)
   
8. {
   
9. Element. Select = true;
   
10. Return true;
    
11. }
    
12. Return false;
    
13. }
    
14. 
    
15. Function movetank (element: *, index: int, arr: array)
    
16. {
    
17. Element. Select = false; // cancel the tank selection status when moving
    
18. VaR randomx = targetpoint. x + math. Random () * 150-75;
    
19. VaR randomy = targetpoint. Y + math. Random () * 150-75;
    
20. Element. moveTo (randomx, randomy); // move the tank
    
21. }

Copy code

The complete code is as follows:
========================================================== ========================================================== =
Main Program
:

1. Import tank;
   
2. 
   
3. VaR map: SPRITE = new sprite (); // defines a map
   Container
   
4. VaR tanklist: array = new array (); // defines a list Of all tanks recorded
   
5. VaR selectlist: array = new array (); // defines a list of currently selected tanks
   
6. VaR targetpoint: point; // target point
   
7. VaR REC: rectangle; // select the rectangular object in the box.
   
8. VaR shape: Shape = new shape (); // used to display the shape object of the Selection box
   
9. VaR ismove: Boolean; // select a tank or a mobile tank.
   
10. Addchild (MAP); // put the map into the display list
    
11. Addchild (SHAPE); // selection box
    
12. 
    
13. // Generate 20 tanks
    
14. For (VAR I = 0; I <20; I ++)
    
15. {
    
16. VaR tank = new tank ();
    
17. Map. addchild (tank );
    
18. Tanklist. Push (tank); // record the reference of the tank
    
19. }
    
20. 
    
21. Addeventlistener (mouseevent. mouse_down, mousedownhandler)
    
22. Addeventlistener (mouseevent. mouse_up, mouseuphandler)
    
23. 
    
24. Function mousedownhandler (EVT: mouseevent)
    
25. {
    
26. Targetpoint = new point (EVT. currenttarget. mousex, EVT. currenttarget. Mousey );
    
27. // If you click on a tank, the tank is selected. Otherwise, register a mouse movement event.
    
28. If((evt.tar get is tank) = true)
    
29. {
    
30. Selectlist. foreach (unselect); // changes all tanks in the selected linked list to unselected
    
31. Cleararray (selectlist); // clear the selectlist Array
    
32. Evt.tar get. Select = true
    
33. Selectlist.push(evt.tar get)
    
34. Ismove = false;
    
35. }
    
36. Else
    
37. {
    
38. Addeventlistener (mouseevent. mouse_move, mousemovehandler)
    
39. Ismove = true;
    
40. }
    
41. }
    
42. Function mousemovehandler (EVT: mouseevent)
    
43. {
    
44. VaR recwidth = EVT. currenttarget. mouseX-targetPoint.x;
    
45. VaR recheight = EVT. currenttarget. The mouseY-targetPoint.y;
    
46. Shape. Graphics. Clear ();
    
47. Shape. Graphics. beginfill (0x99ccff, 0.2 );
    
48. Shape. Graphics. linestyle (2, 0x000000, 0.8 );
    
49. Shape. Graphics. drawrect (targetpoint. X, targetpoint. Y, recwidth, recheight)
    
50. Shape. Graphics. endfill ();
    
51. }
    
52. Function mouseuphandler (EVT: mouseevent)
    
53. {
    
54. Removeeventlistener (mouseevent. mouse_move, mousemovehandler)
    
55. Rec = shape. getbounds (this );
    
56. Shape. Graphics. Clear ();
    
57. If (Rec. width> 0 & Rec. Height> 0) // reselect
    
58. {
    
59. Selectlist. foreach (unselect );
    
60. Cleararray (selectlist );
    
61. Selectlist = tanklist. Filter (selecttank );
    
62. Rec. width = Rec. Height = 0;
    
63. }
    
64. Else if (selectlist. length> 0 & ismove = true)
    
65. {
    
66. Selectlist. foreach (movetank)
    
67. Cleararray (selectlist );
    
68. }
    
69. }
    
70. // Used to filter which tanks are selected
    
71. Function selecttank (element: *, index: int, arr: array)
    
72. {
    
73. If (element. getbounds (this). intersects (REC) = true)
    
74. {
    
75. Element. Select = true;
    
76. Return true;
    
77. }
    
78. Return false;
    
79. }
    
80. // Method for canceling the tank selection status
    
81. Function unselect (element: *, index: int, arr: array)
    
82. {
    
83. Element. Select = false;
    
84. }
    
85. // Mobile tank Method
    
86. Function movetank (element: *, index: int, arr: array)
    
87. {
    
88. Element. Select = false;
    
89. VaR randomx = targetpoint. x + math. Random () * 150-75;
    
90. VaR randomy = targetpoint. Y + math. Random () * 150-75;
    
91. Element. moveTo (randomx, randomy );
    
92. }
    
93. Function cleararray (ARR: array)
    
94. {
    
95. While (ARR. length> 0)
    
96. {
    
97. Arr. Shift ();
    
98. }
    
99. }

Copy code

========================================================== ========================================================== =
Tanks

1. Package
   
2. {
   
3. /**
   
4. * A simple tank model
   
5. * Author: prodigal son with a flash knife
   
6. * Blog: http://hi.baidu.com/mr_ziqiang
   
7. */
   
8. Import flash. display. movieclip
   
9. Import flash. Geom. Point
   
10. Import flash. Events. event;
    
11. 
    
12. Public class tank extends movieclip
    
13. {
    
14. Private var speed: int; // tank speed
    
15. Private var targetpoint: point; // target point
    
16. Private VaR _ select: Boolean; // whether the tank is selected. If this tank is selected, the selected tank status is displayed.
    
17. /**
    
18. * Tank Constructor
    
19. * A coordinate is randomly generated during initialization.
    
20. */
    
21. Public Function tank ()
    
22. {
    
23. This. mousechildren = false; // remember to disable the mouse clicking of a sub-object.
    
24. This. x = 300 * Math. Random () + 10; // set the random size range of the class in the upper left corner when the tank appears.
    
25. This. Y = 300 * Math. Random () + 10;
    
26. This. scalex = This. scaley = 1 + math. Random (); // The largest tank in the Red Police
    
27. Speed = (3-scalex) * 4; // The greater the volume, the slower the speed.
    
28. }
    
29. Public Function moveTo (TX: Number, Ty: Number)
    
30. {
    
31. This. removeeventlistener (event. enter_frame, onmove );
    
32. Targetpoint = new point (TX, Ty );
    
33. This. addeventlistener (event. enter_frame, onmove );
    
34. }
    
35. Private function onmove (EVT: Event)
    
36. {
    
37. VaR dx = targetpoint. X-This. X;
    
38. VaR DY = targetpoint. Y-This. Y;
    
39. VaR radian = math. atan2 (dy, dx); // New Angle
    
40. Body. Rotation = radian * 180/Math. Pi; // in my tank class, there is a body MC, so that the green box does not follow the turn
    
41. If (dx * dx + dy * dy <= speed * speed)
    
42. {
    
43. This. x = targetpoint. X;
    
44. This. Y = targetpoint. Y;
    
45. This. removeeventlistener (event. enter_frame, onmove );
    
46. }
    
47. Else
    
48. {
    
49. VaR vx = math. Cos (radian) * speed; // calculates the increment.
    
50. VaR Vy = math. Sin (radian) * speed;
    
51. 
    
52. This. x + = VX;
    
53. This. Y + = Vy;
    
54. }
    
55. }
    
56. Public Function get select (): Boolean
    
57. {
    
58. Return _ select;
    
59. }
    
60. Public Function set select (isselect: Boolean)
    
61. {
    
62. _ Select = isselect;
    
63. If (_ select = true)
    
64. {
    
65. This. gotoandstop (2 );
    
66. }
    
67. Else
    
68. {
    
69. This. gotoandstop (1 );
    
70. }
    
71. }
    
72. }
    
73. }

Copy code