Tối ưu hóa tính toán trọng lực


23

Tôi đã có một loạt các vật thể có kích thước và vận tốc khác nhau hấp dẫn về phía nhau. Trên mỗi bản cập nhật, tôi phải đi qua mọi đối tượng và cộng các lực do trọng lực của mọi đối tượng khác. Nó không có quy mô rất tốt, là một trong hai nút thắt lớn mà tôi đã tìm thấy trong trò chơi của mình và tôi không biết phải làm gì để cải thiện hiệu suất.

cảm thấy như tôi sẽ có thể cải thiện hiệu suất. Tại bất kỳ thời điểm nào, có thể 99% các đối tượng trong hệ thống sẽ chỉ có ảnh hưởng không đáng kể đến một đối tượng. Tất nhiên tôi không thể sắp xếp các vật thể theo khối lượng và chỉ xem xét 10 vật thể lớn nhất hoặc thứ gì đó, bởi vì lực thay đổi theo khoảng cách nhiều hơn so với khối lượng (phương trình nằm dọc theo đường thẳng force = mass1 * mass2 / distance^2). Tôi nghĩ rằng một sự gần đúng tốt sẽ là xem xét các vật thể lớn nhất các vật thể gần nhất, bỏ qua hàng trăm mảnh đá nhỏ ở phía bên kia của thế giới không thể ảnh hưởng đến bất cứ điều gì - nhưng để tìm ra những vật thể nào gần nhất tôi phải lặp đi lặp lại trên tất cả các đối tượng và vị trí của chúng thay đổi liên tụcVì vậy, nó không giống như tôi chỉ có thể làm một lần.

Hiện tại tôi đang làm một cái gì đó như thế này:

private void UpdateBodies(List<GravitatingObject> bodies, GameTime gameTime)
{
    for (int i = 0; i < bodies.Count; i++)
    {
        bodies[i].Update(i);
    }
}

//...

public virtual void Update(int systemIndex)
{
    for (int i = systemIndex + 1; i < system.MassiveBodies.Count; i++)
    {
        GravitatingObject body = system.MassiveBodies[i];

        Vector2 force = Gravity.ForceUnderGravity(body, this);
        ForceOfGravity += force;
        body.ForceOfGravity += -force;
    }

    Vector2 acceleration = Motion.Acceleration(ForceOfGravity, Mass);
    ForceOfGravity = Vector2.Zero;

    Velocity += Motion.Velocity(acceleration, elapsedTime);
    Position += Motion.Position(Velocity, elapsedTime);
}

(lưu ý rằng tôi đã xóa rất nhiều mã - ví dụ: các thử nghiệm va chạm, tôi không lặp lại các đối tượng lần thứ hai để phát hiện va chạm).

Vì vậy, tôi không phải lúc nào cũng lặp đi lặp lại trong toàn bộ danh sách - Tôi chỉ làm điều đó cho đối tượng đầu tiên và mỗi khi đối tượng tìm thấy lực mà nó cảm thấy đối với một đối tượng khác, thì đối tượng khác lại cảm thấy cùng một lực, vì vậy nó chỉ cập nhật cả hai chúng - và sau đó đối tượng đầu tiên đó không phải được xem xét lại cho phần còn lại của bản cập nhật.

Các hàm Gravity.ForceUnderGravity(...)Motion.Velocity(...), v.v. chỉ sử dụng một chút toán học vectơ tích hợp của XNA.

Khi hai vật thể va chạm, chúng tạo ra các mảnh vỡ không khối lượng. Nó được giữ trong một danh sách riêng biệt và các vật thể lớn không lặp đi lặp lại trên các mảnh vỡ như là một phần của tính toán vận tốc của chúng, nhưng mỗi mảnh vỡ phải lặp đi lặp lại trên các hạt lớn.

Điều này không phải mở rộng đến giới hạn đáng kinh ngạc. Thế giới không giới hạn, nó chứa một đường viền phá hủy các vật thể đi ngang qua nó - tôi muốn có thể xử lý khoảng một nghìn vật thể, hiện tại trò chơi bắt đầu nghẹt thở khoảng 200.

Bất kỳ suy nghĩ về cách tôi có thể cải thiện điều này? Một số heuristic tôi có thể sử dụng để cạo chiều dài vòng lặp từ hàng trăm xuống chỉ một vài? Một số mã tôi có thể thực thi ít thường xuyên hơn mọi bản cập nhật? Tôi có nên đa luồng cho đến khi nó đủ nhanh để cho phép một thế giới có kích thước phù hợp? Tôi có nên cố gắng giảm tải các tính toán vận tốc cho GPU không? Nếu vậy, làm thế nào tôi kiến ​​trúc sư? Tôi có thể giữ dữ liệu tĩnh, chia sẻ trên GPU không? Tôi có thể tạo các chức năng HLSL trên GPU và gọi chúng một cách tùy tiện (sử dụng XNA) hay chúng có phải là một phần của quy trình vẽ không?


1
Chỉ cần một lưu ý, bạn đã nói "các vật thể lớn không lặp đi lặp lại trên các mảnh vỡ như là một phần của tính toán vận tốc của chúng, nhưng mỗi mảnh vỡ phải lặp đi lặp lại trên các hạt lớn." Tôi có ấn tượng từ đó, rằng bạn cho rằng nó hiệu quả hơn. Tuy nhiên, lặp lại 100 đối tượng mảnh vỡ mỗi lần 10 lần, vẫn giống như lặp lại 10 đối tượng lớn 100 lần. Có lẽ, sẽ là một ý tưởng tốt khi lặp lại từng đối tượng mảnh vỡ trong vòng lặp đối tượng lớn để bạn không làm điều đó lần thứ hai.
Richard Marskell - Drackir

Làm thế nào chính xác một mô phỏng bạn cần? Bạn có thực sự cần mọi thứ tăng tốc về phía nhau? Và bạn có thực sự cần phải sử dụng một phép tính trọng lực thực sự? Hay bạn có thể khởi hành từ những quy ước đó cho những gì bạn đang cố gắng thực hiện?
chaosTechnician

@Drackir Tôi nghĩ bạn đúng. Một phần lý do khiến chúng bị tách ra là do toán học khác với các vật thể không có khối lượng và một phần là do ban đầu chúng không tuân theo trọng lực, vì vậy sẽ không hiệu quả hơn nếu không bao gồm chúng. Vì vậy, đó là dấu tích
Carson Myers

@chaosT kỹ thuật viên không cần phải rất chính xác - thực tế nếu nó chỉ chiếm một vài lực lượng thống trị nhất thì một hệ thống sẽ ổn định hơn, đó là lý tưởng. Nhưng nó đang tìm ra lực lượng nào chiếm ưu thế nhất theo cách hiệu quả mà tôi gặp khó khăn. Ngoài ra, phép tính trọng lực đã gần đúng, chỉ là G * m1 * m2 / r^2, trong đó G chỉ là để điều chỉnh hành vi. (mặc dù tôi không thể có chúng theo một con đường, bởi vì người dùng có thể làm phiền hệ thống)
Carson Myers

Tại sao mỗi mảnh vụn phải lặp đi lặp lại trên các hạt lớn nếu nó không có khối lượng? Va chạm?
sam hocevar

Câu trả lời:


26

Điều này nghe có vẻ như một công việc cho một lưới. Chia không gian trò chơi của bạn thành một lưới và cho mỗi ô lưới giữ một danh sách các đối tượng hiện có trong đó. Khi các đối tượng di chuyển qua một ranh giới ô, hãy cập nhật danh sách chúng đang ở. Khi cập nhật một đối tượng và tìm kiếm các đối tượng khác để tương tác, bạn có thể chỉ nhìn vào ô lưới hiện tại và một vài ô lân cận. Bạn có thể điều chỉnh kích thước của lưới để có hiệu suất tốt nhất (cân bằng chi phí cập nhật các ô lưới - cao hơn khi các ô lưới quá nhỏ - với chi phí thực hiện các tìm kiếm, cao hơn khi các ô lưới quá lớn).

Tất nhiên, điều này sẽ khiến các vật thể cách xa nhau hơn một vài ô lưới hoàn toàn không tương tác, đây có thể là một vấn đề vì sự tích lũy khối lượng lớn (có thể là một vật thể lớn hoặc một cụm nhiều vật thể nhỏ) , như bạn đã đề cập, có một vùng ảnh hưởng lớn hơn.

Một điều bạn có thể làm là theo dõi tổng khối lượng trong mỗi ô lưới và coi toàn bộ ô là một đối tượng cho các mục đích tương tác xa hơn. Đó là: khi bạn tính toán lực tác dụng lên một vật thể, hãy tính gia tốc đối tượng trực tiếp cho các đối tượng trong một vài ô lưới gần đó, sau đó thêm gia tốc từ ô này sang ô khác cho mỗi ô lưới xa hơn (hoặc có thể chỉ là những người có khối lượng không đáng kể trong đó). Bằng cách tăng tốc từ tế bào đến tế bào, ý tôi là một vectơ được tính bằng cách sử dụng tổng khối lượng của hai ô và khoảng cách giữa tâm của chúng. Điều đó sẽ đưa ra một xấp xỉ hợp lý của trọng lực tổng hợp từ tất cả các đối tượng trong ô lưới đó, nhưng rẻ hơn nhiều.

Nếu thế giới trò chơi rất rộng lớn, bạn thậm chí có thể sử dụng lưới phân cấp , như hình tứ giác (2D) hoặc octree (3D) và áp dụng các nguyên tắc tương tự. Tương tác khoảng cách dài hơn sẽ tương ứng với các cấp bậc cao hơn.


1
+1 cho ý tưởng lưới. Tôi cũng đề nghị theo dõi trung tâm khối lượng cho lưới cũng để giữ cho các phép tính tinh khiết hơn một chút (nếu cần).
chaosTechnician

Tôi thích ý tưởng này rất nhiều. Tôi đã cân nhắc việc chứa các vật thể trong các tế bào, nhưng đã bỏ rơi nó khi xem xét hai vật thể gần đó về mặt kỹ thuật trong các tế bào khác nhau - nhưng tôi đã không thực hiện bước nhảy vọt về mặt tinh thần để xem xét một vài tế bào liền kề, cũng như xem xét khối lượng kết hợp của các tế bào khác tế bào. Tôi nghĩ rằng điều này sẽ làm việc thực sự tốt nếu tôi làm đúng.
Carson Myers

8
Đây thực chất là thuật toán Barnes-Hut: en.wikipedia.org/wiki/Barnes ChuyệnHut_simulation
Russell Borogove

Nó thậm chí nghe có vẻ giống như cách lực hấp dẫn được cho là hoạt động trong vật lý - sự bẻ cong của không-thời gian.
Zan Lynx

Tôi thích ý tưởng này - nhưng tôi thành thật nghĩ rằng nó cần một chút tinh tế hơn một chút - điều gì xảy ra nếu hai đối tượng rất gần nhau nhưng trong các ô riêng biệt? Tôi có thể thấy đoạn thứ ba của bạn có thể giúp ích như thế nào - nhưng tại sao không chỉ thực hiện một vòng tròn trên các đối tượng tương tác?
Jonathan Dickinson

16

Thuật toán Barnes-Hut là cách để đi với thuật toán này. Nó được sử dụng trong các mô phỏng siêu máy tính để giải quyết vấn đề chính xác của bạn. Nó không quá khó để viết mã, và nó rất hiệu quả. Tôi thực sự đã viết một applet Java cách đây không lâu để giải quyết vấn đề này.

Truy cập http://mathandcode.com/programs/javagrav/ và nhấn "bắt đầu" và "hiển thị quadtree".

Trong tab tùy chọn, bạn có thể thấy rằng số hạt có thể lên tới 200.000. Trên máy tính của tôi, phép tính kết thúc sau khoảng 2 giây (bản vẽ 200.000 điểm mất khoảng 1 giây, nhưng phép tính chạy trên một luồng riêng biệt).

Đây là cách applet của tôi hoạt động:

  1. Tạo một danh sách các hạt ngẫu nhiên, với khối lượng ngẫu nhiên, vị trí và vận tốc bắt đầu.
  2. Xây dựng một tứ giác từ các hạt này. Mỗi nút tứ giác chứa tâm khối lượng của mỗi mã con. Về cơ bản, đối với mỗi nút, bạn có ba giá trị: massx, massy và mass. Mỗi khi bạn thêm một hạt vào một nút nhất định, bạn sẽ tăng khối lượng và khối lượng theo từng hạt.x * partic.mass và partic.y * partic.mass. Vị trí (khối lượng / khối lượng, khối lượng / khối lượng) sẽ kết thúc là trung tâm khối lượng của nút.
  3. Đối với mỗi hạt, tính toán các lực (mô tả đầy đủ ở đây ). Điều này được thực hiện bằng cách bắt đầu tại nút trên cùng và đệ quy qua từng mã con của tứ giác cho đến khi mã con đã cho đủ nhỏ. Khi bạn dừng đệ quy, bạn có thể tính khoảng cách từ hạt đến tâm khối lượng của nút và sau đó bạn có thể tính toán lực bằng cách sử dụng khối lượng của nút và khối lượng của hạt.

Trò chơi của bạn sẽ dễ dàng có thể xử lý hàng ngàn đối tượng thu hút lẫn nhau. Nếu mỗi đối tượng là "câm" (như các hạt xương trần trong applet của tôi), bạn sẽ có thể nhận được 8000 đến 9000 hạt, có thể nhiều hơn nữa. Và đây là giả định đơn luồng. Với các ứng dụng điện toán đa luồng hoặc song song, bạn có thể nhận được nhiều hạt hơn so với cập nhật trong thời gian thực.

Xem thêm: http://www.youtube.com/watch?v=XAlzniN6L94 để có kết xuất lớn về điều này


Liên kết đầu tiên đã chết. Là applet được lưu trữ ở nơi khác?
Anko

1
Đã sửa! xin lỗi, đã quên trả tiền thuê cho tên miền đó và ai đó đã tự động mua nó: \ Ngoài ra, 3 phút là thời gian phản hồi khá tốt trên một bài đăng cũ 8 năm 8D

Và tôi nên thêm: Tôi không có mã nguồn. Nếu bạn đang tìm kiếm một số mã nguồn, hãy xem phần thứ hai (viết bằng c). Tôi chắc chắn có những người khác ở ngoài đó, quá.

3

Nathan Reed có một câu trả lời tuyệt vời. Phiên bản ngắn của nó là sử dụng kỹ thuật broadphase phù hợp với cấu trúc liên kết mô phỏng của bạn và chỉ chạy các phép tính trọng lực trên các cặp đối tượng sẽ có tác động rõ rệt với nhau. Nó thực sự không khác gì những gì bạn làm đối với broadphase phát hiện va chạm thường xuyên.

Tuy nhiên, tiếp tục từ đó, một khả năng khác là chỉ cập nhật các đối tượng không liên tục. Về cơ bản, mỗi bước thời gian (khung) chỉ cập nhật một phần của tất cả các đối tượng và để tốc độ (hoặc gia tốc, tùy theo sở thích của bạn) giống nhau cho các đối tượng khác. Người dùng không thể nhận thấy bất kỳ sự chậm trễ nào trong các bản cập nhật từ điều này miễn là khoảng thời gian không quá dài. Điều này sẽ giúp bạn tăng tốc độ tuyến tính của thuật toán, do đó, chắc chắn hãy xem xét các kỹ thuật broadphase như Nathan đã đề xuất, điều này có thể giúp tăng tốc đáng kể hơn nhiều nếu bạn có hàng tấn đối tượng. Mặc dù không được mô hình hóa giống nhau trong một chút, đây là loại giống như có "sóng trọng lực". :)

Ngoài ra, bạn cũng có thể tạo trường trọng lực trong một lần, sau đó cập nhật các đối tượng trong lần thứ hai. Vượt qua đầu tiên về cơ bản bạn đang lấp đầy một lưới (hoặc một cấu trúc dữ liệu không gian phức tạp hơn) với các ảnh hưởng trọng lực của từng đối tượng. Kết quả bây giờ là một trường trọng lực mà bạn thậm chí có thể kết xuất (trông khá tuyệt) để xem gia tốc nào sẽ được áp dụng cho một đối tượng tại bất kỳ vị trí nào. Sau đó, bạn lặp lại các đối tượng và chỉ cần áp dụng các hiệu ứng của trường trọng lực cho đối tượng đó. Thậm chí, bạn có thể thực hiện điều này trên GPU bằng cách hiển thị các đối tượng dưới dạng hình tròn / hình cầu thành kết cấu, sau đó đọc kết cấu (hoặc sử dụng một chuyển đổi phản hồi khác trên GPU) để sửa đổi vận tốc của đối tượng.


Phân tách quá trình thành các đường chuyền là một ý tưởng tuyệt vời, vì khoảng thời gian cập nhật là (theo như tôi biết) một phần rất nhỏ của một giây. Kết cấu trường trọng lực là TUYỆT VỜI nhưng có lẽ hơi xa tầm với của tôi ngay bây giờ.
Carson Myers

1
Đừng quên nhân các lực lượng ứng dụng với bao nhiêu lát cắt thời gian đã bị bỏ qua kể từ lần cập nhật cuối cùng.
Zan Lynx

@seanmiddlemitch: Bạn có thể nói rõ hơn về kết cấu trường trọng lực hơn một chút không? Tôi xin lỗi, tôi không phải là một lập trình viên đồ họa, nhưng điều này nghe có vẻ rất thú vị; Tôi chỉ không hiểu làm thế nào nó hoạt động. Và / hoặc có thể bạn có một liên kết đến một mô tả về kỹ thuật?
Felix Dombek

@FelixDombek: Kết xuất các đối tượng của bạn dưới dạng các vòng tròn đại diện cho khu vực ảnh hưởng. Mảnh shader mảnh viết một vectơ chỉ vào tâm của vật thể và với cường độ thích hợp (dựa trên khoảng cách từ tâm và khối lượng của vật thể). Trộn phần cứng có thể xử lý tổng các vectơ này trong chế độ phụ gia. Kết quả sẽ không phải là trường trọng lực chính xác, nhưng gần như chắc chắn sẽ đủ tốt cho nhu cầu của trò chơi. Là một cách tiếp cận khác sử dụng GPU, hãy xem kỹ thuật mô phỏng trọng lực cơ thể N dựa trên CUDA này: http.developer.nvidia.com/GPUGems3/gpugems3_ch31.html
Sean Middleditch

3

Tôi khuyên bạn nên sử dụng Quad Tree. Chúng cho phép bạn tìm kiếm nhanh chóng và hiệu quả tất cả các đối tượng trong một khu vực hình chữ nhật tùy ý. Đây là bài viết wiki về họ: http://en.wikipedia.org/wiki/Quadtree

Và một liên kết không biết xấu hổ đến dự án XNA Quad Tree của riêng tôi trên SourceForge: http://sourceforge.net/projects/quadtree/

Tôi cũng sẽ duy trì một danh sách tất cả các vật thể lớn để chúng có thể tương tác với mọi thứ bất kể khoảng cách.


0

Chỉ cần một chút đầu vào (có thể ngây thơ). Tôi không làm lập trình trò chơi, nhưng điều tôi cảm thấy là nút cổ chai cơ bản của bạn là phép tính trọng lực do trọng lực. Thay vì lặp qua từng đối tượng X và sau đó tìm hiệu ứng hấp dẫn từ mỗi đối tượng Y và thêm nó, bạn có thể lấy từng cặp X, Y và tìm lực giữa chúng. Điều đó sẽ cắt số lượng tính toán trọng lực từ O (n ^ 2). Sau đó, bạn sẽ thực hiện rất nhiều phép cộng (O (n ^ 2)), nhưng điều này thường ít tốn kém hơn.

Ngoài ra, tại thời điểm này, bạn có thể thực hiện các quy tắc như "nếu lực hấp dẫn sẽ nhỏ hơn \ epsilon vì các vật thể này quá nhỏ, hãy đặt lực về 0". Có thể có lợi khi có cấu trúc này cho các mục đích khác (bao gồm cả phát hiện va chạm).


Đây là những gì tôi đang làm. Sau khi tôi nhận được tất cả các cặp liên quan đến X, tôi không lặp lại X nữa. Tôi tìm thấy lực giữa X và Y, X và Z, v.v. và áp dụng lực đó cho cả hai đối tượng trong cặp. Sau khi vòng lặp hoàn thành, ForceOfGravityvectơ là tổng của tất cả các lực và sau đó được chuyển thành vận tốc và vị trí mới. Tôi không chắc chắn rằng việc tính toán trọng lực đặc biệt tốn kém và việc kiểm tra xem nó có vượt quá ngưỡng đầu tiên không sẽ tiết kiệm được một khoảng thời gian đáng chú ý, tôi không nghĩ
Carson Myers

0

Khi mở rộng câu trả lời của seanmiddleditch, tôi nghĩ rằng tôi có thể làm sáng tỏ một chút (trớ trêu?) Về ý tưởng trường trọng lực.

Đầu tiên, đừng nghĩ về nó như một kết cấu, mà là một trường giá trị rời rạc có thể sửa đổi (một mảng hai chiều, như vậy); và độ chính xác tiếp theo của mô phỏng có thể là độ phân giải của trường đó.

Khi bạn giới thiệu một đối tượng vào trường, tiềm năng trọng lực của nó có thể được tính cho tất cả các giá trị xung quanh; qua đó tạo ra một hấp dẫn chìm trong lĩnh vực này.

Nhưng bạn nên tính toán bao nhiêu trong số những điểm này trước khi nó trở nên nhiều hơn hoặc không hiệu quả như trước? Có lẽ không nhiều, thậm chí 32x32 là một trường đáng kể để lặp lại cho từng đối tượng. Do đó, phá vỡ toàn bộ quá trình thành nhiều lượt; mỗi độ phân giải khác nhau (hoặc độ chính xác).

Tức là, đường chuyền đầu tiên có thể tính toán trọng lực của các đối tượng được biểu thị trong lưới 4 x 4, với mỗi giá trị ô biểu thị tọa độ 2D trong không gian. Đưa ra tổng độ phức tạp O (n * 4 * 4).

Đường chuyền thứ hai có thể chính xác hơn, với trường trọng lực có độ phân giải 64x64, với mỗi giá trị ô đại diện cho tọa độ 2D trong không gian. Tuy nhiên, vì độ phức tạp rất cao, bạn có thể hạn chế bán kính của các ô xung quanh bị ảnh hưởng (có lẽ, chỉ các ô 5x5 xung quanh được cập nhật).

Một đường chuyền thứ ba bổ sung có thể được sử dụng để tính toán độ chính xác cao, với độ phân giải 1024x1024. Ghi nhớ bất cứ lúc nào bạn thực sự thực hiện các phép tính riêng biệt 1024x1024, nhưng chỉ hoạt động trên các phần của trường này (có lẽ là các phần phụ 6x6).

Theo cách đó, độ phức tạp tổng thể của bạn cho bản cập nhật là O (n * (4 * 4 + 5 * 5 + 6 * 6)).

Sau đó, để tính toán sự thay đổi vận tốc cho từng đối tượng của bạn, đối với từng trường trọng lực (4x4, 64x64, 1024x1024), bạn chỉ cần ánh xạ vị trí khối lượng điểm vào một ô lưới, áp dụng vectơ tiềm năng hấp dẫn tổng thể của ô đó vào một vectơ mới; lặp lại cho mỗi "lớp" hoặc "vượt qua"; sau đó thêm chúng lại với nhau Điều này sẽ cung cấp cho bạn một vectơ lực hấp dẫn kết quả tốt.

Do đó, độ phức tạp tổng thể là: O (n * (4 * 4 + 5 * 5 + 6 * 6) + n). Điều thực sự quan trọng (về độ phức tạp) là có bao nhiêu tế bào xung quanh bạn cập nhật khi tính toán tiềm năng hấp dẫn trong các đường chuyền, chứ không phải độ phân giải tổng thể của các trường trọng lực.

Lý do cho các trường có độ phân giải thấp (lần đầu tiên vượt qua) rõ ràng là bao gồm toàn bộ vũ trụ và đảm bảo khối lượng xa xôi bị thu hút đến các khu vực dày đặc hơn bất chấp khoảng cách. Sau đó sử dụng các trường có độ phân giải cao hơn làm các lớp riêng biệt để tăng độ chính xác cho các hành tinh lân cận.

Tôi hy vọng điều này có ý nghĩa.


0

Làm thế nào về một cách tiếp cận khác:

Chỉ định một vùng ảnh hưởng cho các đối tượng dựa trên khối lượng của chúng - chúng chỉ đơn giản là quá nhỏ để có tác động có thể đo được ngoài phạm vi đó.

Bây giờ chia thế giới của bạn thành một lưới và đặt từng đối tượng vào một danh sách tất cả các ô mà nó có ảnh hưởng.

Chỉ tính toán trọng lực của bạn trên các đối tượng trong danh sách được gắn vào ô mà một đối tượng đang ở.

Bạn chỉ phải cập nhật danh sách khi một đối tượng di chuyển vào một ô lưới mới.

Các ô lưới càng nhỏ, bạn sẽ thực hiện ít phép tính hơn cho mỗi lần cập nhật nhưng bạn sẽ thực hiện càng nhiều công việc cập nhật danh sách.

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.