当一个物体与另一个物体碰撞时，从矩阵中减去值

Question

现在，我有一个类，它创建一个网格，将对象与网格对齐，然后当对象在网格上移动时，它会计算对象与特定单元格重叠的次数。

我的目标是从N值中减去重叠的数量，而不是计算重叠的数量。例如，当hitGrid中的值为10时，程序将从10中减去并在hitGrid为0时结束，而不是结束程序。

这是我的代码：

WIDTH, HEIGHT, MARGIN = 10, 10, 1
Object = [[1]]
class GridObject(pg.sprite.Sprite):
def __init__(self, pos, grid, *groups):
super().__init__(groups)
# create image from grid
self.grid = grid
self.gridsize = (len(grid[0]), len(grid))
imgsize = self.gridsize[0] * (WIDTH+MARGIN), self.gridsize[1] * (HEIGHT+MARGIN)
self.image = pg.Surface(imgsize, flags = pg.SRCALPHA)
self.image.fill((0, 0, 0, 0))
col = BLACK
for c in range(self.gridsize[0]):
for r in range(self.gridsize[1]):
if self.grid[r][c] == 1:
rect = [(MARGIN + WIDTH) * c + MARGIN, (MARGIN + HEIGHT) * r + MARGIN, WIDTH, HEIGHT]
pg.draw.rect(self.image, col, rect)
self.rect = self.image.get_rect(center=pos)
self.vel = pg.math.Vector2(8, 0).rotate(randrange(360))
self.pos = pg.math.Vector2(pos)
def update(self, boundrect, hitGrid, hitList):
self.pos += self.vel
self.rect.center = self.pos
if self.rect.left <= boundrect.left or self.rect.right >= boundrect.right:
self.vel.x *= -1                            
if self.rect.top <= boundrect.top or self.rect.bottom >= boundrect.bottom:
self.vel.y *= -1     
# align rect to grid
gridpos = round(self.rect.x / (WIDTH+MARGIN)), round(self.rect.y / (HEIGHT+MARGIN))
self.rect.topleft = gridpos[0] * (WIDTH+MARGIN), gridpos[1] * (HEIGHT+MARGIN)
# increment touched filled
global max_hit
max_hit = 0

oldHitList = hitList[:]
hitList.clear()
for c in range(self.gridsize[0]):
for r in range(self.gridsize[1]):
p = gridpos[1] + r, gridpos[0] + c                
if p in oldHitList:
hitList.append(p)
elif self.grid[r][c] == 1:
if p[0] < len(hitGrid) and p[1] < len(hitGrid[p[0]]):
hitList.append(p)
if p not in oldHitList:
hitGrid[p[0]][p[1]] +=1
max_hit = max(max_hit, hitGrid[p[0]][p[1]])
print(hitGrid[p[0]][p[1]])

Answer 1

这里并不完全清楚您的意图，因为上面的代码在一些方面不完整。。。也就是说，你应该考虑几个策略。而你现在正试图计算的块正处于"0"的轨道上；年度丑陋代码块"；奖励，所以我们需要做一些的事情。

有几件事需要考虑。。。

1. 您希望如何处理对象在同一个网格正方形中保持多个时间步长的情况？也许你需要跟踪"；最后一个方格"；并且只有在发生更改时才进行更新

在伪代码中。。。

old_gridpos = None  <- set at start of game
# compute new pos in update()
if current_gridpos != old_gridpos:
check for grid square usage (see below)
old_gridpos = current_gridpos

2. 我看到你有一个二维的速度角矢量。。。如果物体在对角线上或任何方向上移动得足够快；跳过"；正方形的一角？(这很难。(
3. 你的追踪系统现在显示为一个网格命中列表。这在计算上很难处理。你应该把它翻转过来，使用二维索引，并对每个点进行计数。Wayyy更容易。您可以使用dictionary、二维列表或numpy数组。对于一个简单的游戏来说，它们中的任何一个都足够快，所以使用任何你觉得舒服的东西。这个跟踪数据结构应该是游戏的一个属性，并在开始时初始化，等等。下面是一个缩略图，说明如何使用字典来实现这一点，这可能是最简单的

In [12]: grid_count = {}                                                        
In [13]: max_hits = 3                                                           
In [14]: def check_max_hits(position): 
...:     grid_count[position] = grid_count.get(position, 0) + 1 
...:     if grid_count[position] >= max_hits: 
...:         return True 
...:     return False 
...:      
...:                                                                        
In [15]: check_max_hits((1,2))                                                  
Out[15]: False
In [16]: check_max_hits((2,4))                                                  
Out[16]: False
In [17]: check_max_hits((1,2))                                                  
Out[17]: False
In [18]: grid_count                                                             
Out[18]: {(1, 2): 2, (2, 4): 1}
In [19]: check_max_hits((1,2))                                                  
Out[19]: True

您可以创建一个类似的函数，并在计算完gridpos后从update函数中调用它