2016-08-23 2 views
0

이 말은 나를 괴롭혔습니다.초보자 그리드 기반 게임에서 모든 개체가 한 목록에서 다른 목록으로 이동하는 것은 아닙니다.

게임용 그리드 기반 이동 엔진을 개발하고 있습니다. 캐릭터 인스턴스는 매번 move_left 변수를 1 씩 줄이는 "move"함수를 사용하여 움직입니다.

def move(self, direction):  #how characters move around 
     if self.collision_check(direction) == True: 
      print("Collision") 
      return 
     if self.moves_left == 0: 
      print("No more moves left") 
      Map.update() 
      return 

     elif direction == "UP":      
       self.internal_row -= 1    
     elif direction == "LEFT": 
       self.internal_column -= 1 
     elif direction == "RIGHT": 
       self.internal_column += 1 
     elif direction == "DOWN": 
       self.internal_row += 1 

     self.moves_left = self.moves_left -1 
     Map.update() 

이 변수가 0에 도달

는, 그들은 이동을 중지하고 문자의 "아니오 이동"목록에 문자 "이동할 수 있습니다"목록에서 전송되어있다. 이 검사는 Map.update() 함수에 있습니다.

for characterobject in range(0, len(Map.no_moves)-1): #This moves any characters with moves to the can move list 
    if len(Map.no_moves) > 0: 
     if Map.no_moves[characterobject].moves_left > 0: 
      print("character moved from no moves to moves") 
      Map.can_move.append(Map.no_moves[characterobject]) 
      Map.no_moves.remove(Map.no_moves[characterobject]) 

for characterobject in range(0, len(Map.can_move)-1): 
    if len(Map.can_move) == 0: 
     break 
    elif Map.can_move[characterobject].moves_left == 0:  #This moves any characters with 0 moves from the can't move list to the can move list 
     print("character moved from moves to no moves") 
     Map.no_moves.append(Map.can_move[characterobject]) 
     Map.can_move.remove(Map.can_move[characterobject]) 

내가 가지고있는 문제는 수표가 만들어지지 않고 있다는 것입니다. 움직이는 문자가 moves_left = 0에 도달하면 move 함수는 "no moves left"를 인쇄하고 Map.update()가 호출되지만 문자 객체는 목록에 남아 no_moves 목록으로 전송되지 않습니다.

여기에 전체 코드입니다 : 그것으로 주위

import random 
import pygame 
import math 

pygame.init()         
Clock = pygame.time.Clock()     
Screen = pygame.display.set_mode([650, 650]) 
DONE = False         
MAPSIZE = 50 #how many tiles 


TILEWIDTH = 10  #pixel size of tile        
TILEHEIGHT = 10 
TILEMARGIN = 2 

BLACK = (0, 0, 0)        
WHITE = (255, 255, 255) 
GREEN = (0, 255, 0) 
RED = (255, 0, 0) 
BLUE = (0, 0, 255) 
BROWN = (123, 123, 0) 
MOVECOLOR = (150, 250, 150) 

ITEMS = ["Sword", "Helmet", "Shield", "Coin"] #just a test 

KeyLookup = { 
    pygame.K_LEFT: "LEFT", 
    pygame.K_RIGHT: "RIGHT", 
    pygame.K_DOWN: "DOWN", 
    pygame.K_UP: "UP" 
} 


class MapTile(object):      #The main class for stationary things that inhabit the grid ... grass, trees, rocks and stuff. 
    def __init__(self, name, internal_column, internal_row): 
     self.name = name 
     self.internal_column = internal_column 
     self.internal_row = internal_row 


class Item(object): 
    def __init__(self, name, weight): 
     self.name = name 
     self.weight = weight 


class Character(object):     #can_move can move around and do cool stuff 
    def __init__(self, name, HP, internal_column, internal_row): 
     self.name = name 
     self.HP = HP 
     self.internal_column = internal_column 
     self.internal_row = internal_row 

    inventory = [] 
    moves_left = 25 

    def move(self, direction):  #how characters move around 
     if self.collision_check(direction) == True: 
      print("Collision") 
      return 
     if self.moves_left == 0: 
      print("No more moves left") 
      Map.update() 
      return 

     elif direction == "UP":      
       self.internal_row -= 1    
     elif direction == "LEFT": 
       self.internal_column -= 1 
     elif direction == "RIGHT": 
       self.internal_column += 1 
     elif direction == "DOWN": 
       self.internal_row += 1 

     self.moves_left = self.moves_left - 1 
     Map.update() 

    def collision_check(self, direction):  
     if direction == "UP": 
      if self.internal_row == 0: 
       return True 
      if len(Map.Grid[self.internal_column][(self.internal_row)-1]) > 1: 
       return True 
     elif direction == "LEFT": 
      if self.internal_column == 0: 
       return True 
      if len(Map.Grid[self.internal_column-1][(self.internal_row)]) > 1: 
       return True 
     elif direction == "RIGHT": 
      if self.internal_column == MAPSIZE-1: 
       return True 
      if len(Map.Grid[self.internal_column+1][(self.internal_row)]) > 1: 
       return True 
     elif direction == "DOWN": 
      if self.internal_row == MAPSIZE-1: 
       return True 
      if len(Map.Grid[self.internal_column][(self.internal_row)+1]) > 1: 
       return True 

     return False 

    def location(self): 
     print("Coordinates:" + str(self.internal_column) + ", " + str(self.internal_row)) 

    def check_inventory(self): 
     weight = 0 
     for item in self.inventory: 
      print(item) 
      weight = weight + item.weight 
     print(weight) 



class Map(object):    #The main class; where the action happens 
    global MAPSIZE 
    can_move = [] 
    no_moves = [] 
    Grid = [] 

    for row in range(MAPSIZE):  # Creating grid 
     Grid.append([]) 
     for column in range(MAPSIZE): 
      Grid[row].append([]) 

    for row in range(MAPSIZE):  #Filling grid with grass 
     for column in range(MAPSIZE): 
      TempTile = MapTile("Grass", column, row) 
      Grid[column][row].append(TempTile) 

    for row in range(MAPSIZE):  #Putting some rocks near the top 
     for column in range(MAPSIZE): 
      TempTile = MapTile("Rock", column, row) 
      if row == 1: 
       Grid[column][row].append(TempTile) 

    for i in range(10):   #Trees in random places 
     random_row = random.randint(0, MAPSIZE - 1) 
     random_column = random.randint(0, MAPSIZE - 1) 
     TempTile = MapTile("Tree", random_column, random_row) 
     Grid[random_column][random_row].append(TempTile) 

    def generate_hero(self):   #Generate a character and place it randomly 
     random_row = random.randint(0, MAPSIZE - 1)  
     random_column = random.randint(0, MAPSIZE - 1) 
     id_number = len(Map.can_move) 
     temp_hero = Character(str(id_number), 10, random_column, random_row) 
     i = random.randint(0, len(ITEMS)-1) 
     temp_hero.inventory.append(ITEMS[i]) 

     self.Grid[random_column][random_row].append(temp_hero) 
     self.can_move.append(temp_hero) 
     Map.update() 


    def update(self):   #Important function 
     for column in range(MAPSIZE):       #These nested loops go through entire grid 
      for row in range(MAPSIZE):       #They check if any objects internal coordinates 
       for i in range(len(Map.Grid[column][row])):  #disagree with its place on the grid and update it accordingly 

        if Map.Grid[column][row][i].internal_column != column: 
         TempChar = Map.Grid[column][row][i] 
         Map.Grid[column][row].remove(Map.Grid[column][row][i]) 
         Map.Grid[int(TempChar.internal_column)][int(TempChar.internal_row)].append(TempChar) 

        elif Map.Grid[column][row][i].internal_row != row: 
         TempChar = Map.Grid[column][row][i] 
         Map.Grid[column][row].remove(Map.Grid[column][row][i]) 
         Map.Grid[int(TempChar.internal_column)][int(TempChar.internal_row)].append(TempChar) 

     for characterobject in range(0, len(Map.no_moves)-1): #This moves any characters with moves to the can move list 
      if len(Map.no_moves) > 0: 
       if Map.no_moves[characterobject].moves_left > 0: 
        print("character moved from no moves to moves") 
        Map.can_move.append(Map.no_moves[characterobject]) 
        Map.no_moves.remove(Map.no_moves[characterobject]) 

     for characterobject in range(0, len(Map.can_move)-1): 
      print(str(characterobject)) 
      if len(Map.can_move) == 0: 
       break 
      elif Map.can_move[characterobject].moves_left == 0:  #This moves any characters with 0 moves from the can't move list to the can move list 
       print("character moved from moves to no moves") 
       Map.no_moves.append(Map.can_move[characterobject]) 
       Map.can_move.remove(Map.can_move[characterobject]) 



Map = Map() 
Map.generate_hero() 

while not DONE:  #Main pygame loop 

    for event in pygame.event.get():   #catching events 
     if event.type == pygame.QUIT: 
      DONE = True  

     elif event.type == pygame.MOUSEBUTTONDOWN: 
      Pos = pygame.mouse.get_pos() 
      column = Pos[0] // (TILEWIDTH + TILEMARGIN) #Translating the position of the mouse into rows and columns 
      row = Pos[1] // (TILEHEIGHT + TILEMARGIN) 
      print(str(row) + ", " + str(column)) 

      for i in range(len(Map.Grid[column][row])): 
       print(str(Map.Grid[column][row][i].name)) #print stuff that inhabits that square 

     elif event.type == pygame.KEYDOWN: 
      if event.key == 97:  # Keypress: a 
       print("new turn") 
       for characterobject in range(0, len(Map.no_moves)-1): 
        Map.no_moves[characterobject].moves_left = 25 
       Map.update() 

      elif event.key == 115: # Keypress: s 
       print("boop") 
       Map.generate_hero() 
       Map.update() 

      elif len(Map.can_move) > 0: 
       Map.can_move[0].move(KeyLookup[event.key]) 

      else: 
       print("invalid") 

    Screen.fill(BLACK) 



    for row in range(MAPSIZE):   # Drawing grid 
     for column in range(MAPSIZE): 
      for i in range(0, len(Map.Grid[column][row])): 
       Color = WHITE 

       if len(Map.can_move) > 0: # Creating colored area around character showing his move range 
        if (math.sqrt((Map.can_move[0].internal_column - column)**2 + (Map.can_move[0].internal_row - row)**2)) <= Map.can_move[0].moves_left: 
         Color = MOVECOLOR 

       if len(Map.Grid[column][row]) > 1: 
        Color = RED 
       if Map.Grid[column][row][i].name == "Tree": 
        Color = GREEN 
       if str(Map.Grid[column][row][i].__class__.__name__) == "Character": 
        Color = BROWN 



      pygame.draw.rect(Screen, Color, [(TILEMARGIN + TILEWIDTH) * column + TILEMARGIN, 
              (TILEMARGIN + TILEHEIGHT) * row + TILEMARGIN, 
              TILEWIDTH, 
              TILEHEIGHT]) 

    Clock.tick(30)  
    pygame.display.flip()  


pygame.quit() 

재생과 무슨 뜻인지 참조하십시오. "s"를 눌러 새 문자를 추가 할 수 있습니다. 문자가 움직일 수 없을 때 셸에서 어떤 일이 발생하는지 주목하십시오. "a"를 눌러 no_moves 목록에있는 문자를 더 많이 움직일 수 있어야합니다.하지만 그 중 하나는 작동하지 않습니다.

감사합니다.

답변

2

이 문제의 원인이되는 배열을 반복하지 말아야합니다. 대신 :

그것은 당신의 도구 상자에서이 패턴을 유지하는 것이 좋다 그래서이 개념은 거의 모든 언어에 적용
arr = Map.no_moves[:] # copy 
for item in arr: 
    if item.moves_left == 0: 
     Map.no_moves.remove(item) 
     Map.can_move.append(item) 

참고.

+0

감사합니다. – Kos

관련 문제