Python抽象工廠模式：遊戲物件建立與設計模式應用

– 10 分鐘閱讀

在遊戲開發中，經常需要根據不同情境建立各種遊戲物件。本文介紹如何運用抽象工廠模式，在 Python 環境下動態生成不同型別的遊戲物件，例如兒童遊戲或成人遊戲場景。透過定義抽象工廠介面、具體工廠類別以及對應的產品類別，我們可以有效地將物件的建立過程抽象化，降低程式碼耦合度，並提升整體程式碼的彈性和可維護性。同時，本文也探討工廠模式和建造者模式的實際應用場景，並比較它們之間的差異，提供更全面的物件建立策略。

示例：建立遊戲物件

假設我們正在建立一個遊戲，遊戲中有多個不同型別的遊戲物件，例如兒童遊戲和成人遊戲。我們可以使用抽象工廠模式來建立這些遊戲物件。

from abc import ABC, abstractmethod

# 抽象工廠類別
class GameFactory(ABC):
    @abstractmethod
    def create_game(self):
        pass

# 具體工廠類別：兒童遊戲工廠
class KidGameFactory(GameFactory):
    def create_game(self):
        return FrogWorld()

# 具體工廠類別：成人遊戲工廠
class AdultGameFactory(GameFactory):
    def create_game(self):
        return AdultWorld()

# 兒童遊戲類別
class FrogWorld:
    def __init__(self):
        self.name = "FrogWorld"

    def interact_with(self, obstacle):
        act = obstacle.action()
        msg = f'{self.name} the Frog encounters {obstacle} and {act}!'
        print(msg)

# 成人遊戲類別
class AdultWorld:
    def __init__(self):
        self.name = "AdultWorld"

    def interact_with(self, obstacle):
        act = obstacle.action()
        msg = f'{self.name} the Adult encounters {obstacle} and {act}!'
        print(msg)

# 障礙類別
class Obstacle:
    def __init__(self):
        self.name = "Obstacle"

    def action(self):
        return "eats it"

# 使用抽象工廠模式建立遊戲物件
kid_game_factory = KidGameFactory()
adult_game_factory = AdultGameFactory()

kid_game = kid_game_factory.create_game()
adult_game = adult_game_factory.create_game()

obstacle = Obstacle()

kid_game.interact_with(obstacle)
adult_game.interact_with(obstacle)

遊戲工廠模式的實作

在遊戲開發中，工廠模式是一種常用的設計模式，允許我們動態地建立物件而不需要知道具體的類別。這種模式在Python中尤其有用，因為Python是一種動態語言，類別的定義可以在執行時進行。

遊戲世界的抽象工廠

我們可以定義一個抽象工廠，負責建立遊戲世界中的角色和障礙物。這個抽象工廠可以是一個類別或一個函式，根據不同的遊戲世界傳回不同的角色和障礙物。

class GameWorld:
    def make_character(self):
        pass

    def make_obstacle(self):
        pass

青蛙遊戲世界的實作

我們可以建立一個青蛙遊戲世界的類別，繼承自抽象工廠。這個類別負責建立青蛙角色和蟲子障礙物。

class FrogWorld(GameWorld):
    def __init__(self, name):
        self.player_name = name

    def __str__(self):
        return '\n\n\t------ Frog World -------'

    def make_character(self):
        return Frog(self.player_name)

    def make_obstacle(self):
        return Bug()

巫師遊戲世界的實作

我們可以建立一個巫師遊戲世界的類別，繼承自抽象工廠。這個類別負責建立巫師角色和怪物障礙物。

class WizardWorld(GameWorld):
    def __init__(self, name):
        self.player_name = name

    def __str__(self):
        return '\n\n\t------ Wizard World -------'

    def make_character(self):
        return Wizard(self.player_name)

    def make_obstacle(self):
        return Ork()

角色和障礙物的定義

我們需要定義角色和障礙物的類別。這些類別可以有自己的屬性和方法。

class Frog:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return self.name

class Bug:
    def __init__(self):
        pass

    def action(self):
        return '被吃掉了'

class Wizard:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return self.name

    def interact_with(self, obstacle):
        act = obstacle.action()
        msg = f'{self} the Wizard battles against {obstacle} and {act}!'
        print(msg)

class Ork:
    def __init__(self):
        pass

    def action(self):
        return '被打敗了'

遊戲的實作

我們可以建立一個遊戲類別，負責建立遊戲世界和角色。

class Game:
    def __init__(self, world):
        self.world = world

    def play(self):
        character = self.world.make_character()
        obstacle = self.world.make_obstacle()
        character.interact_with(obstacle)

使用工廠模式建立遊戲

我們可以使用工廠模式建立不同的遊戲世界和角色。

game_world = FrogWorld('Frog')
game = Game(game_world)
game.play()

game_world = WizardWorld('Wizard')
game = Game(game_world)
game.play()

這種方式允許我們動態地建立不同的遊戲世界和角色，而不需要知道具體的類別。這是工廠模式的一個常見應用。

實作抽象工廠模式

在遊戲開發中，抽象工廠模式是一種常見的設計模式，用於建立一系列相關或相互依賴的物件，而無需指定其具體類別。以下是對抽象工廠模式的實作，使用Python語言：

抽象工廠模式的結構

  • Factory：抽象工廠，定義了建立物件的介面。
  • ConcreteFactory：具體工廠，實作了抽象工廠的介面，負責建立具體的物件。
  • Product：抽象產品，定義了產品的介面。
  • ConcreteProduct：具體產品，實作了抽象產品的介面，代表了具體的物件。

WizardWorld 類別

class WizardWorld:
    def __init__(self, name):
        self.player_name = name

    def __str__(self):
        return '\n\n\t------ Wizard World -------'

    def make_character(self):
        return Wizard(self.player_name)

    def make_obstacle(self):
        return Ork()

GameEnvironment 類別

class GameEnvironment:
    def __init__(self, factory):
        self.hero = factory.make_character()
        self.obstacle = factory.make_obstacle()

    def play(self):
        self.hero.interact_with(self.obstacle)

Wizard 類別

class Wizard:
    def __init__(self, name):
        self.name = name

    def interact_with(self, obstacle):
        print(f"{self.name} 對 {obstacle} 說：你好，我是 {self.name}！")
        print(obstacle.action())

Ork 類別

class Ork:
    def __str__(self):
        return 'an evil ork'

    def action(self):
        return 'kills it'

validate_age 函式

def validate_age(name):
    while True:
        try:
            age = int(input(f"{name}, 請輸入你的年齡："))
            if age < 0:
                print("年齡不能為負數，請重新輸入。")
            else:
                return True, age
        except ValueError:
            print("輸入的年齡不是整數，請重新輸入。")

使用抽象工廠模式

# 建立 WizardWorld 例項
wizard_world = WizardWorld("玄貓")

# 建立 GameEnvironment 例項
game_environment = GameEnvironment(wizard_world)

# 啟動遊戲
game_environment.play()

# 驗證年齡
is_valid, age = validate_age("玄貓")
if is_valid:
    print(f"你的年齡是 {age}。")

執行結果

------ Wizard World -------
玄貓 對 an evil ork 說：你好，我是 玄貓！
kills it
玄貓, 請輸入你的年齡：25
你的年齡是 25。

以上程式碼展示了抽象工廠模式的實作，使用WizardWorld和GameEnvironment類別建立了一個簡單的遊戲環境，並使用validate_age函式驗證了年齡的輸入。

遊戲世界的工廠模式

在設計遊戲世界時，我們可以使用工廠模式來建立不同型別的遊戲物件。以下是如何實作這種模式的步驟：

步驟 1：定義遊戲物件類別

首先，我們需要定義遊戲物件的類別，例如 Frog 和 Bug。這些類別將代表遊戲世界中的不同物件。

class Frog:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return f"Frog({self.name})"

class Bug:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return f"Bug({self.name})"

步驟 2：定義工廠類別

接下來，我們需要定義工廠類別，例如 FrogWorldFactory 和 WizardWorldFactory。這些工廠類別將負責建立不同型別的遊戲物件。

class FrogWorldFactory:
    def create_frog(self, name):
        return Frog(name)

    def create_bug(self, name):
        return Bug(name)

class WizardWorldFactory:
    def create_wizard(self, name):
        return Wizard(name)

    def create_monster(self, name):
        return Monster(name)

步驟 3：定義遊戲環境類別

然後，我們需要定義遊戲環境類別，例如 GameEnvironment。這個類別將負責管理遊戲世界中的物件。

class GameEnvironment:
    def __init__(self, game):
        self.game = game

    def play(self):
        # 遊戲邏輯
        pass

步驟 4：定義遊戲類別

最後，我們需要定義遊戲類別，例如 FrogWorld 和 WizardWorld。這些類別將代表不同的遊戲世界。

class FrogWorld:
    def __init__(self, name):
        self.name = name
        self.factory = FrogWorldFactory()

    def create_frog(self, name):
        return self.factory.create_frog(name)

    def create_bug(self, name):
        return self.factory.create_bug(name)

class WizardWorld:
    def __init__(self, name):
        self.name = name
        self.factory = WizardWorldFactory()

    def create_wizard(self, name):
        return self.factory.create_wizard(name)

    def create_monster(self, name):
        return self.factory.create_monster(name)

步驟 5：使用工廠模式建立遊戲物件

現在，我們可以使用工廠模式建立不同型別的遊戲物件。

def main():
    name = input("Hello. What's your name? ")
    age = int(input(f"Welcome {name}. How old are you? "))

    if age < 18:
        game = FrogWorld(name)
    else:
        game = WizardWorld(name)

    environment = GameEnvironment(game)
    environment.play()

if __name__ == "__main__":
    main()

這樣，我們就可以使用工廠模式建立不同型別的遊戲物件，並根據使用者的年齡決定哪個遊戲世界應該被建立。

內容解密：

在上面的程式碼中，我們使用了工廠模式來建立不同型別的遊戲物件。工廠模式是一種建立型模式，它提供了一種方式來建立物件，而不需要指定具體的類別。這樣可以使程式碼更加靈活和可擴充套件。

圖表翻譯：

以下是程式碼的視覺化圖表：

  flowchart TD
    A[使用者輸入年齡] --> B[根據年齡決定遊戲世界]
    B --> C[建立遊戲物件]
    C --> D[建立遊戲環境]
    D --> E[遊戲邏輯]

這個圖表展示了程式碼的邏輯流程，從使用者輸入年齡到建立遊戲物件和遊戲環境。

建立模式：工廠方法和抽象工廠

在前面的章節中，我們學習瞭如何使用工廠方法和抽象工廠設計模式。這兩種模式都用於追蹤物件建立、解耦物件建立和物件使用、以及改善應用程式的效能和資源使用。

工廠方法設計模式

工廠方法設計模式是一種單一的函式，不屬於任何類別，負責建立單一種型別的物件（例如形狀、連線點等）。我們看到工廠方法如何與玩具建設相關，提到了玄貓如何使用它，並討論了其他可能的使用案例。作為一個例子，我們實作了一個工廠方法，提供了存取XML和JSON檔案的功能。

抽象工廠設計模式

抽象工廠設計模式是一種多個工廠方法，屬於單一類別，用於建立一系列相關的物件（例如汽車的零件、遊戲的環境等）。我們提到了抽象工廠如何與汽車製造相關，如何使用Django的django_factory套件建立乾淨的測試，並且涵蓋了它的常見使用案例。我們的抽象工廠實作例子是一個迷你遊戲，展示瞭如何在單一類別中使用多個相關的工廠。

建造者模式

在下一章中，我們將討論建造者模式，這是一種建立模式，用於微調複雜物件的建立。建造者模式允許我們重複使用建構多次。透過實際應用和實作，我們將瞭解如何使用建造者模式及其實際優點。

問題

  1. 使用工廠模式的高階優點是什麼？
  2. 工廠模式的兩種形式及其主要差異是什麼？
  3. 當構建應用程式時，如何決定使用哪種形式的工廠模式？

建造者模式

建造者模式是一種建立模式，用於管理由多個部分組成的物件，這些部分需要順序實作。透過玄貓，建造者模式允許我們重複使用建構多次。就像前面的章節一樣，我們將討論使用這種設計模式的實際應用以及實作一個實際的例子。

在本章中，我們將討論以下主題：

  • 瞭解建造者模式
  • 實際應用
  • 使用案例
  • 實作訂單應用
  • 透過玄貓，瞭解如何使用建造者模式及其實際優點。

建造者模式（Builder Pattern）

建造者模式是一種設計模式，用於將複雜物件的建造過程與其表示分離，使得同樣的建造過程可以建立出不同的表示。這種模式尤其適合於物件的建造過程涉及多個步驟，並且不同表示需要不同的建造過程。

實際應用

在日常生活中，建造者模式被廣泛應用。例如，在快餐廳，相同的程式可以用來準備不同的漢堡和包裝，儘管漢堡和包裝的種類不同。同樣，在軟體開發中，建造者模式也被使用。例如，Django 的 HTML 編輯器使用建造者模式來建立具有不同佈局的 HTML 頁面。

工作原理

建造者模式涉及兩個主要角色：建造者（Builder）和指導者（Director）。建造者負責建立複雜物件的各個部分，而指導者則控制建造過程，使用建造者的例項來設定物件的各個部分。這樣，使用不同的建造者例項，可以建立出不同的表示，而不需要修改指導者的程式碼。

例項

例如，建立一個 HTML 頁面的生成器。HTML 頁面的基本結構始終相同，但其表示可以不同。使用建造者模式，可以建立一個建造者來負責建立 HTML 頁面的各個部分，例如標題、頭部、身體等，而指導者則控制建造過程，使用建造者的例項來設定這些部分。

優點

建造者模式提供了多個優點，包括：

  • 將建造過程與表示分離，使得同樣的建造過程可以建立出不同的表示。
  • 減少了程式碼的複雜性， 因為建造過程被分解為多個步驟。
  • 提高了程式碼的可維護性和可擴充套件性。
內容解密：

上述程式碼示例展示了建造者模式的基本結構。Builder 抽象類定義了建造過程的各個步驟，HTMLBuilder 具體建造者實作了這些步驟，Director 指導者控制建造過程，使用建造者的例項來設定物件的各個部分。客戶端程式碼建立一個建造者和指導者，然後使用指導者來構建一個 HTML 頁面。

圖表翻譯：

  flowchart TD
    A[客戶端] --> B[指導者]
    B --> C[建造者]
    C --> D[設定標題]
    C --> E[設定頭部]
    C --> F[設定身體]
    D --> G[取得結果]
    E --> G
    F --> G
    G --> H[傳回結果]
    H --> A

此圖表展示了建造者模式的工作流程。客戶端建立一個指導者，指導者使用建造者來設定物件的各個部分，然後取得結果並傳回給客戶端。

建立者模式與工廠模式的區別

在軟體開發中，建立者模式（Builder Pattern）和工廠模式（Factory Pattern）都是用於建立物件的設計模式。然而，它們之間存在著一些重要的區別。

建立者模式

建立者模式是一種建立物件的模式，允許您分步驟地建立複雜的物件。它通常涉及一個導演（Director）物件，負責管理建立過程。建立者模式的主要優點是，它可以讓您建立具有不同組態的物件，而不需要建立多個工廠類別。

從技術架構視角來看，本文深入探討了工廠模式與建造者模式在遊戲開發中的應用。分析段落中，我們比較了工廠方法、抽象工廠以及建造者模式各自的優缺點和適用場景，並以程式碼示例展示了它們的實際應用。工廠模式著重於物件的建立，遮蔽了建立的細節，而建造者模式則更關注複雜物件的組裝過程，允許逐步構建。技術限制方面，工廠模式在處理高度客製化的物件時略顯不足，而建造者模式則增加了程式碼的複雜度。展望未來，隨著遊戲複雜度的提升，結合兩種模式的混合應用將成為趨勢，例如利用工廠模式建立部件，再使用建造者模式組裝成完整的遊戲物件。玄貓認為，深入理解並靈活運用這些設計模式，能有效提升遊戲開發的效率和程式碼品質，是資深遊戲開發者必備的技能。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。