Use of matrix calculation may improve performance when the number of particles is getting larger.

• replace Vec2d with numpy vector

• rewrite ParticleGroup to support calculation of physical state iteration in batches

• change the way particle history data is stored in ParticleContainers

Support battle online through frame synchronization algorithm.

• rewrite all value calculation using fixed-point numbers

• synchronize event input at every logic frame

• bridge terminals with sockets

Now the buffer is maintained with simple lists of data from different moments. Several ways to improve:

• set up a sample rate, like 1 sampling for every 10 frames

• compress the history data using more complicated(and efficient) data structure

Now the layer rendering uses a lot of surface blitting to another surface (and most of them are of screen size, which means the blitting will be time consuming). Here are some possible ways to improve:

• register callback rendering functions to the LayerManager and let LayerManager to determine whether, when and where to render.

Currently renderers acquire surfaces they need from the LayerManager and do whatever they want. Then LayerManager just piles up surfaces from different layers and renders them to provided screen. The problem is: to ensure rendering of different layers won't mix up, LayerManager needs to maintain different surfaces so as to provide them to objects using different layers. But piling up surfaces of screen size costs a lot of time.

• maintain dirty rects to reduce time cost of screen.update()

Updating the whole screen is quite time-consuming. Pygame supports partial update, that is, update pixels only in specified regions (rectangles, actually). One possible way to implement this is to leave this work to renderers. Renderers are responsible for maintaining all regions they modify in a frame, and provide them to the LayerManager (as returning value of callback rendering functions, for instance). In this way the LayerManager will know where to update when it's rendering the screen.

Implement the logic to monitor and decide who is the winner. Now the number of particles owned by a player can be queried through the ParticleManager(statistics).

make game interface more friendly with buttons, texts and bars