Conception qui peut réduire le degré de connexion avec les instructions if du côté serveur de Soshage

• Cet article est juste une considération de la conception interne du jeu. Cela n'a rien à voir avec le jeu réel.

Vue commune

Considérez une boîte cadeau pour un jeu commun.

Le schéma de cette base de données est-il comme celui-ci?

Les objets, l'argent, etc. sont distingués par type_élément. Supposons que ce soit le cas.

Quel est le code lorsque je reçois ceci (lorsque je le déplace de la boîte cadeau à ma main)?

def acquire_present(user, present):
  if present.item_type == 1:
    """Traitement pour recevoir de l'argent"""
  elif present.item_type == 2:
　  """Traitement pour recevoir des articles"""
  elif present.item_type == 3:
    """Traitement pour recevoir des personnages"""
  ...
  else:
     raise Exception()

si phrase enfer. De plus, il existe une forte possibilité de faire diverses choses dans chaque processus de réception (confirmation manuelle, journal, etc.) Dans ce cas, la fonction acquis_present et chaque classe de données auront une connexion plus étroite.

De plus, ce sera encore plus long si item_type augmente en raison de l'expansion future du jeu. Les déclarations longues et les couplages serrés ne sont pas faciles à maintenir, alors j'aimerais faire quelque chose.

Séparation du processus de réception

Par conséquent, envisagez une classe qui délègue le processus de réception des cadeaux.

class AqruireDalegatorBase(object):
  """Recevoir la classe de base de délégation de traitement"""
  @classmethod
  def acquire(user, present):
     raise NotImplementedError()

Vous avez défini une interface commune pour la réception. Héritez et implémentez chaque classe de délégation de traitement de réception.

class MoneyAqruireDalegator(AqruireDalegatorBase):
　"""Classe de délégation de traitement des reçus d'argent"""
  @classmethod
  def acquire(user, present):
     user.add_money(present.item_quantity)

class ItemAqruireDalegator(AqruireDalegatorBase):
　"""Classe de délégation de traitement des réceptions d'articles"""
  @classmethod
  def acquire(user, present):
     user.add_item(present.item_id, present.item_quantity)

...Suivez les autres

Incorporons-le réellement dans la fonction de réception.

def acquire_present(user, present):
  if present.type == 1:
    MoneyAqruireDalegator.acquire(user, present)
  elif present.type == 2:
    ItemAqruireDalegator.acquire(user, present)
  elif ...

En supprimant la logique de réception pour chaque type, une sensation de couplage lâche est ressortie!

Essayez de faciliter l'expansion

Mais l'instruction if est encore longue et je dois modifier cette fonction à chaque fois qu'un type est ajouté, donc

DELEGATOR_MAP = {
  1: MoneyAqruireDalegator,
  2: ItemAqruireDalegator,
  ...
}

Et mappage de classe de type et de délégation.

def acquire_present(user, present):
  delegator_class = DELEGATOR.get(present.item_type)
  delegator_class.acquire_present(user, present)

C'est beaucoup plus court! Et même si cela augmente les types

0. Implémentez une classe de délégation de réception qui hérite d'AqruireDalegatorBase
1. Ajouter à DELEGATOR_MAP

Il est extensible avec. Pas besoin de modifier la fonction Acquérir_Present! Tout ce que vous avez à faire est la classe de délégation avec le test ajouté!

Résumé (?)

Une longue déclaration est gênante à la fois lors de l'enquête sur les défauts et lors de l'expansion, donc si elle se sent mal couplée, elle sera gentille avec les gens maintenant et dans le futur!

(Est-ce un motif de façade ...? On dirait un peu DI)