2500 라인 Character클래스가 있습니다.

• 게임에서 캐릭터의 내부 상태를 추적합니다.
• 해당 상태를로드하고 유지합니다.
• ~ 30 개의 들어오는 명령을 처리합니다 (보통 =는 명령을 전달 Game하지만 일부 읽기 전용 명령은 즉시 응답합니다).
• Game취한 조치 및 타인의 관련 조치와 관련하여 ~ 80 개의 전화를받습니다 .

Character캐릭터의 상태를 관리하고 들어오는 명령과 게임을 중재하는 것은 하나의 책임이있는 것 같습니다 .

이미 해결 된 몇 가지 다른 책임이 있습니다.

• Character가지고 Outgoing는 클라이언트 응용 프로그램에 대한 나가는 업데이트를 생성하기로 호출하는합니다.
• Character있다 Timer가 다음에 뭔가를 허용 할 때 어떤 트랙. 들어오는 명령은 이것에 대해 검증됩니다.

그래서 제 질문은 SRP와 유사한 원칙에 따라 그러한 큰 클래스를 갖는 것이 허용됩니까? 번거롭지 않게 만드는 모범 사례가 있습니까 (예 : 방법을 별도의 파일로 분할)? 아니면 뭔가 빠졌습니까? 분할 좋은 방법이 있습니까? 나는 이것이 매우 주관적이며 다른 사람들의 피드백을 원한다는 것을 알고 있습니다.

다음은 샘플입니다.

class Character(object):
    def __init__(self):
        self.game = None
        self.health = 1000
        self.successful_attacks = 0
        self.points = 0
        self.timer = Timer()
        self.outgoing = Outgoing(self)

    def load(self, db, id):
        self.health, self.successful_attacks, self.points = db.load_character_data(id)

    def save(self, db, id):
        db.save_character_data(self, health, self.successful_attacks, self.points)

    def handle_connect_to_game(self, game):
        self.game.connect(self)
        self.game = game
        self.outgoing.send_connect_to_game(game)

    def handle_attack(self, victim, attack_type):
        if time.time() < self.timer.get_next_move_time():
            raise Exception()
        self.game.request_attack(self, victim, attack_type)

    def on_attack(victim, attack_type, points):
        self.points += points
        self.successful_attacks += 1
        self.outgoing.send_attack(self, victim, attack_type)
        self.timer.add_attack(attacker=True)

    def on_miss_attack(victim, attack_type):
        self.missed_attacks += 1
        self.outgoing.send_missed_attack()
        self.timer.add_missed_attack()

    def on_attacked(attacker, attack_type, damage):
        self.start_defenses()
        self.take_damage(damage)
        self.outgoing.send_attack(attacker, self, attack_type)
        self.timer.add_attack(victim=True)

    def on_see_attack(attacker, victim, attack_type):
        self.outgoing.send_attack(attacker, victim, attack_type)
        self.timer.add_attack()


class Outgoing(object):
    def __init__(self, character):
        self.character = character
        self.queue = []

    def send_connect_to_game(game):
        self._queue.append(...)

    def send_attack(self, attacker, victim, attack_type):
        self._queue.append(...)

class Timer(object):
    def get_next_move_time(self):
        return self._next_move_time

    def add_attack(attacker=False, victim=False):
        if attacker:
            self.submit_move()
        self.add_time(ATTACK_TIME)
        if victim:
            self.add_time(ATTACK_VICTIM_TIME)

class Game(object):
    def connect(self, character):
        if not self._accept_character(character):
           raise Exception()
        self.character_manager.add(character)

    def request_attack(character, victim, attack_type):
        if victim.has_immunity(attack_type):
            character.on_miss_attack(victim, attack_type)
        else:
            points = self._calculate_points(character, victim, attack_type)
            damage = self._calculate_damage(character, victim, attack_type)
            character.on_attack(victim, attack_type, points)
            victim.on_attacked(character, attack_type, damage)
            for other in self.character_manager.get_observers(victim):
                other.on_see_attack(character, victim, attack_type)

답변

 void AttackAction(CharacterModel) { ... }
 void ReloadAction(CharacterModel) { ... }
 void RunAction(CharacterModel) { ... }
 void DuckAction(CharacterModel) { ... }
 // etc.

self.game = None
self.health = 1000
self.successful_attacks = 0
self.points = 0
self.timer = Timer()

def on_attack(victim, attack_type, points):
    self.points += points
    self.successful_attacks += 1
    self.outgoing.send_attack(self, victim, attack_type)
    self.timer.add_attack(attacker=True)