python基础----以面向对象的思想编写游戏技能系统

Posted 2020-12-01 jeffrey04118110

1. 许多程序员对面向对象的思想都很了解，并且也能说得头头是道，但是在工作运用中却用的并不顺手。

　　当然，我也是其中之一。

　　不过最近我听了我们老师的讲课，对于面向对象的思想有了更深的理解，今天决定用一个实例跟大家分享一下。

　　欢迎各位前辈评论指正。

2.面向对象的三大特征：封装、继承、多态

　　　         六大原则：　开闭原则，单一职责，依赖倒置，组合复用，里氏替换，迪米特法则

3. 可是这三大特征和六大原则具体如何运用，又从哪里才能体现出我应用到了呢？

　　下面我就以一个游戏技能项目的代码实例，来讨论一下。

4. 首先，抛出题目：

　　写一个技能系统，具体技能效果如下：

　　降龙十八掌：1.伤害：造成100点伤害，2.眩晕：使对方眩晕3秒，3.降低防御：降低对方30点防御力，持续时间3,秒

　　六脉神剑：   1.伤害：造成90点伤害，2.震退：震退对方3丈以外，  3.减速：减速30，持续2秒

　　北冥神功：   1.伤害：造成99点伤害， 2.降低防御：降低对方20点防御力，持续时间2秒， 3 减速：减速20，持续2秒

 

　　可能有些朋友会说，这很简单，按照每个技能创建一个类就行了，这就是面向对象的思想嘛。事实上却是很错误的。

　　明眼人都能看到，每个技能虽有不同，但其效果都大同小异，如果每个技能创建一个类，就会产生大量的重复代码，

　　比如伤害这个效果，上面三个技能都有。

　　还有，若是项目经理告诉你，眩晕这个效果不行，改成在眩晕的同时，降低10点防御力，

　　那岂不是每个包含眩晕效果的技能，都要改一遍？

5.事实上，以面向对象思想编写以上代码的话，我们完全可以把每个效果提取出来，单独做成一个类，而每个技能含有多少效果，

　　在技能类的下面直接调用效果类就可以了。

6.废话不多说，直接上代码：

　　```

sikll_file = {
            ‘降龙十八掌‘: [‘DamageEffect(100)‘,‘DizzinessEffect(3)‘, ‘LowerDeffence(30,3)‘],
            ‘六脉神剑‘: [‘DamageEffect(90)‘, ‘Knockback(3)‘, ‘LowerSpeed(30, 2)‘],
            ‘北冥神功‘: [‘DamageEffect(99)‘, ‘LowerDeffence(20,2)‘, ‘LowerSpeed(20,2)‘]
        }

class SkillImpactEffect:
    """
        效果父类
        作为父类，供技能调取，具体实现靠子类重写方法
    """
    def impact(self):
        raise NotImplementedError()

class DamageEffect(SkillImpactEffect):
    """
        效果：伤害
    """
    def __init__(self,value):
        self.value = value
    def impact(self):
        print(‘减少血量%d点‘%self.value)

class LowerDeffence(SkillImpactEffect):
    """
        效果：降低防御力
    """
    def __init__(self, value, time):
        self.value = value
        self.time = time
    def impact(self):
        print("降低%d防御力，持续%d秒"%(self.value, self.time))

class DizzinessEffect(SkillImpactEffect):
    """
       效果： 眩晕
    """
    def __init__(self, time):
        self.time = time
    def impact(self):
        print(‘眩晕%d秒‘% self.time)

class Knockback(SkillImpactEffect):
    """
        效果：震退
    """
    def __init__(self, value):
        self.value = value
    def impact(self):
        print(‘震退敌人到%d丈之外！‘)

class LowerSpeed(SkillImpactEffect):
    """
        效果：减速
    """
    def __init__(self, value, time):
        self.value = value
        self.time = time
    def impact(self):
        print(‘减速%d,持续时间%d‘ % (self.value, self.time))

class SkillDeployer:
    """
        技能释放器
    """
    # 生成技能（执行效果）
    def __init__(self,name):
        self.name = name
        # 加载配置文件{技能：[效果1，效果2.。。]}
        self.__dict_skill_config = self.load_config_file()
        # 创建效果对象
        self.__effect_object = self.create_effect_objects()
    def load_config_file(self):
        # 加载技能文件。
        return sikll_file

    def create_effect_objects(self):
        # 根据name创建相应的技能对象
        list_effect_name = self.__dict_skill_config[self.name]
        list_effect_object = []
        for item in list_effect_name:
            # 效果对象，加入技能列表
            effect_object = eval(item)
            list_effect_object.append(effect_object)
        return list_effect_object

    def generate_skill(self):
        print(‘%s释放‘%self.name)
        for item in self.__effect_object:
            item.impact()


xlsbz = SkillDeployer(‘降龙十八掌‘)
xlsbz.generate_skill()
lmsj = SkillDeployer(‘六脉神剑‘)
lmsj.generate_skill()
bmsg = SkillDeployer(‘北冥神功‘)
bmsg.generate_skill()

　　```

 7.有了上面这种形式的代码，再也不怕项目经理随便改东西了，把skill_file作为一个静态文件，要添加技能的时候，只需在技能文件sikll_file里添加就可以了，完全不用改代码。

　　要修改增加效果，也只需把对应效果的类修改一下，操作十分简单。

8.接下来，分析一下以上代码的面向对象思想：

三大特征：
    封装：将每种影响效果单独封装成类.
    继承：将各种影响效果抽象为SkillImpactEffect
          隔离技能释放器与各种影响效果的变化。
    多态：各种影响效果在重写SkillImpactEffect类中impact方法.
         释放器调用SkillImpactEffect执行各种效果。
六大原则：
    开闭原则：增加新(技能/影响效果)，不修改释放器代码.
    单一职责：SkillImpactEffect 负责 隔离变化
             DamageEffect.. 负责定义具体的效果
             SkillDeployer 负责释放技能
    依赖倒置：(1)释放器没有调用具体影响效果，而是调用SkillImpactEffect。
            (2)抽象的不依赖于具体的。
              具体做法：
              释放器通过"依赖注入"(读取配置文件，
              创建影响效果对象),使释放器不依赖具体影响效果.
    组合复用：释放器与影响效果是组合关系.
            可以灵活的选择各种影响效果。
    里氏替换：(1)父类出现的地方可以被子类替换
             释放器存储影响效果列表,实际可以将各种子类存入进来.
    迪米特法则：所有类之间的耦合度都很低.