オブジェクト指向で必ず必要なリソースの受け渡しの好ましい設計パターンを知りたい

自己解決というか、少し進展。
オブジェクト指向だから、作ったオブジェクトにはつい、何でも動きをつけたくなる。
なので、キャラクターやMAPにも、draw関数をつけたくなる。
これが間違いで、キャラクターやMAPは論理上の構造や、論理上の現在位置を
取り扱うべきで、やっぱり描画自体はスクリーンクラスに設けるべきだと思った。

スクリーンクラスにキャラクターをレジストし、キャラクターはキー入力で
論理的に歩く。それをもとにスクリーンクラスは実座標にフレーム毎描画する。

そんな感じなのかな。

まだ過渡期ですが、こんなコードになりました。

#!/usr/bin/env python3
import copy
import os
import sys
import pygame
from pygame import Rect
from image import Image
from image import CharacterImage
from pygame.locals import QUIT
from pygame.locals import KEYDOWN
from pygame.locals import K_DOWN
from pygame.locals import K_LEFT
from pygame.locals import K_RIGHT
from pygame.locals import K_UP


class GridScreen(object):
    SCREEN_RECT = Rect(0, 0, 640, 480)
    ROW, COL = 15, 20
    GRID_SIZE = 32

    def __init__(self, screen, world_map):
        self._screen = screen

        self._world_map = world_map
        self._characters = []

    def _draw_screen(self, image, pos):
        # pos[0] = column(列) = x
        # pos[1] = row(行) = y
        # 直接スクリーンに描画(surface越しでなく)
        self._screen.blit(
            image,
            (pos[0] * GridScreen.GRID_SIZE,
             pos[1] * GridScreen.GRID_SIZE))

    def _draw_world_map(self):
        for y in range(GridScreen.ROW):
            for x in range(GridScreen.COL):
                self._draw_screen(
                    self._world_map.image(y, x).image(),
                    [x, y])

    def regist_character(self, character):
        self._characters.append(character)

    def draw(self, frame_no):
        # self._draw_world_map()

        offset = [self._characters[0].address().topleft[0] -
                  GridScreen.SCREEN_RECT.width / 2,
                  self._characters[0].address().topleft[1] -
                  GridScreen.SCREEN_RECT.height / 2]
        self._world_map.draw(self._screen, offset)
        for character in self._characters:
            character.draw(self._screen, frame_no)
            # self._draw_screen(
            #    character.image(int(direction * 4 + frame / 24 % 4)), pos)


class WorldMap(object):
    def __init__(self, name):
        self._map = []
        file = os.path.join('data', name + '.map')
        fp = open(file)
        lines = fp.readlines()
        row_str, col_str = lines[0].split()
        self._row, self._col = int(row_str), int(col_str)
        for line in lines[1:]:
            line = line.rstrip()
            self._map.append([int(x) for x in list(line)])
        fp.close()
        self._image_list = {0: Image('grass.png'), 1: Image('water.png')}

    def map(self):
        return self._map

    def image(self, row, column):
        return self._image_list[self._map[row][column]]

    def draw(self, screen, offset):
        start_x = int(offset[0] / 32)
        end_x = int(start_x + GridScreen.SCREEN_RECT.width / 32 + 1)
        start_y = int(offset[1] / 32)
        end_y = int(start_y + GridScreen.SCREEN_RECT.height / 32 + 1)
        for y in range(start_y, end_y):
            for x in range(start_x, end_x):
                if x < 0 or y < 0 or x > self._col - 1 or y > self._row - 1:
                    screen.blit(self._image_list[1].image(),
                                (x * 32 - offset[0], y * 32 - offset[1]))
                else:
                    screen.blit(self._image_list[self._map[y][x]].image(),
                                (x * 32 - offset[0], y * 32 - offset[1]))


class Character(object):
    def __init__(self, name):
        self._image = CharacterImage(name)
        # pos:グリッド座標
        self._walk = [0, 0]
        self._direction = 0
        # 実アドレス。キャラクター自身は実際には動かないので仮想アドレス
        self._virtual_address = self._image.image(0).get_rect(
            topleft=(self._walk[0] * 32, self._walk[1] * 32))

    def image(self, no):
        return self._image.image(no)

    def move(self, direction, delta_walk):
        self._direction = direction
        self._walk[0] += delta_walk[0]
        self._walk[1] += delta_walk[1]
        self._virtual_address.top += delta_walk[1] * 32
        self._virtual_address.left += delta_walk[0] * 32
        print('walk   ={}'.format(self._walk))
        # print('address={}'.format(self._address))

    def walk(self):
        return self._direction, self._walk

    def address(self):
        return self._virtual_address

    def draw(self, screen, frame_no):
        no = int(self._direction * 4 + frame_no / 24 % 4)
        screen.blit(self.image(no),
                    (self._virtual_address[0] - offset[0],
                    self._draw_address[1] - offset[1]))

pygame.init()
screen = pygame.display.set_mode(GridScreen.SCREEN_RECT.size)
pygame.display.set_caption('test')
world_map = WorldMap('test')
grid_screen = GridScreen(screen, world_map)
player = Character('player')
grid_screen.regist_character(player)

clock = pygame.time.Clock()
frame = 0
keymap = {K_DOWN:0, K_LEFT:1, K_RIGHT:2, K_UP:3}
movetable = {K_DOWN:[0, 1], K_LEFT:[-1, 0], K_RIGHT:[1, 0], K_UP:[0, -1]}

while True:
    clock.tick(60)  # 60fps
    frame += 1
    grid_screen.draw(frame)
    pygame.display.update()
    for event in pygame.event.get():
        if event.type == QUIT:
            sys.exit()
        if event.type == KEYDOWN:
            try:
                player.move(keymap[event.key], movetable[event.key])
            except KeyError:
                pass