【问题标题】:need help with basic java game programming , class and interfaces constructs在基本的java游戏编程、类和接口结构方面需要帮助
【发布时间】:2011-06-08 04:39:11
【问题描述】:

我是一年级的编程学生。我已经涵盖了 C++ 中前置编程的基础知识。我现在对 Java 还很陌生。

最近我对游戏编程产生了浓厚的兴趣。

我的情况:

我的情况:

我有一个英雄职业和一个对手职业。每个都有自己的成员和方法。 我怎样才能让英雄与对手互动,我是通过使用界面来做到这一点的吗?例如具有未定义攻击方法的接口 并且两个类都实现了该接口?

如果是这样

这两个类的攻击方法中的代码应该是什么样子的

类似的东西

示例:

      // heros version of implemented method

      public int attack()
      {
             // idealy when hero attacks, the health value will be reduced by 15 of what it is.

             rival1.getHealth(- 15)
      }



      // rival version of implemented method

      public int attack()
      {
             // idealy when rival attacks, the health value will be reduced by 15 of what it is.

             hero1.getHealth(- 15)
      }

请帮助我理解为什么我们使用接口和回答我的问题

任何帮助或建议将不胜感激:)。

【问题讨论】:

    标签: java


    【解决方案1】:

    我会说你不应该使用接口。更好的方法是使用超类。使用超类,您可以避免重新定义许多可能由对手和英雄共享的方法。这是一个示例实现:

    超类:

    public abstract class ExampleFighter {
        private String name;
        private int health;
        private boolean isDead = false;
    
        public ExampleFighter(String name, int health) {
            this.name = name;
            this.health = health;
        }
    
        public void attack(ExampleFighter ef) {
            int damage = 0; 
            //calculate damage dealt
            damage = 10;
            ef.takeDamage(damage);
        }
    
        public void takeDamage(int damage) {
            //manipulate the amount of damage taken
            if(health - damage <= 0) {
                health = 0;
                isDead = true;
            } else {
                health -= damage;
            }
        }
    
        public boolean isDead() {
            return isDead;
        }
    }
    

    子类:

    public class ExampleHero extends ExampleFighter {
    
        int reputation; //the general opinion of the hero
    
        public ExampleHero() {
            super("Hero Oreh of Herosville", 100);
            reputation = 0;
        }
    
        public void improveReputation() {
            reputation++;
        }
    
    }
    
    
    public class ExampleRival extends ExampleFighter {
    
        public ExampleRival() {
            super("Your greatest rival", 101);
        }
    
    }
    

    这个系统的副作用是它需要第四个班级才能真正玩游戏:

    public class ExampleGame {
    
        private ExampleHero hero;
        private ExampleRival rival;
    
        public static void main(String... args) {
            ExampleGame game = new ExampleGame();
            game.start();
        }
    
        public ExampleGame() {
             hero = new ExampleHero();
             rival = new ExampleRival();
             //what ever other game setup you need to do.
             //alternately you could have a load() method
             //that takes care of most of this.          
        }
    
        private void start() {
            //make your run loop or query the user for input
            //or whatever you need to do. I will create an 
            //example run loop
            boolean running = true;
            while(running) {
                //this whole block should be moved
                //to another method called gameUpdate()
                //or something similar but since this
                //is a quick example I'll just leave it
                //here
                hero.attack(rival);
                rival.attack(hero);
                if(rival.isDead()) {
                    hero.improveReputation();
                    System.out.println(“Your rival is dead!");
                    running = false;
                } else if(hero.isDead()) {
                    System.out.println("you died :(");
                    running = false;
                }
            }
        }
    }
    

    现在这可能看起来有点复杂,但它说明了一个非常重要的概念:关注点分离。关注点分离包括放置代码和制作有意义的类。玩家不应该知道它的对手是谁,玩家甚至可能不知道敌人的存在或者它站在什么样的地形上。但是玩家应该知道如何管理它的生命值、它的名字、如何受到伤害等。相比之下,一个游戏对象需要知道所有玩家和敌人,这样它才能告诉他们在屏幕上战斗和移动。这是关注点分离的非正式定义,有关更准确的信息,请阅读wikipedia page。在这个例子中,我将英雄和对手分开,这样以后你就可以添加更多的敌人,而不必每次都修改你的英雄代码。该系统还允许您在不影响玩家或对手的情况下扩展游戏的 UI。如果你想为你的游戏添加一个 GUI,你可以在 ExampleGame 中添加一个用于设置 GUI 的 initialize() 方法。然后在游戏循环中,您可以调用方法将图像和图形绘制到 GUI 上。通过分离关注点,您可以使系统更加模块化和易于使用。

    您的第二个问题是:我们为什么要使用接口?接口是一种确保其他类具有您需要它们具有的行为的方法,而无需具体指定它们应该如何做。使用接口的一个经典例子是 Comparable 接口。 Comparable 接口有一个必须实现的方法:compareTo()。此方法的目的是允许对不能使用标准布尔数学运算(、== 等)的值对象(想想 String 或 File)进行排名。您可以将其视为签署合同。您(实现该接口的类)同意拥有一组特定的功能,但是您是否决定该功能取决于您。更多信息请阅读java tutorial

    我应该在这个答案中添加一个警告:继承不是 最佳 选项。如果您想知道如何正确操作,您应该查找MVC (Model View Controller)Component Based Design。即使这些可能不是您正在做的事情的最佳选择,但它们是很好的起点。

    【讨论】:

      【解决方案2】:

      我想你会想把它分解成一个 Fighter 类和一个 FightController 类。然后在 FightController 中将 Fighter 分配给英雄或对手。

      所以,它基本上类似于以下内容(不要介意草率的基本代码,我已经有 2 年没有写过 Java 了,我只是把它放在一起,我不确定它是否会编译):

      public class Fighter {
          private int health;
          private boolean isTheHero;
      
          public Fighter(int startHealth, boolean hero) {
              health = startHealth;
              isTheHero = hero;
          }
      
          public void adjustHealth(int change) {
              if (change > health) {
                  return 0;
              }
              health -= change;
              return health;
          }
      
          public boolean isHero() {
              return is_hero;
          }
      
          public boolean wasBeaten() {
              return health <= 0;
          }
      }
      
      public class FightController {
          private Fighter hero;
          private Fighter rival;
          private boolean isHerosTurn;
      
          public FightController() {
              hero = new Fighter(startHealth, true);
              rival = new Fighter(startHealth, false);
              isHerosTurn = true;
          }
      
          public void takeATurn() {
              int hitValue = 15; //Do something to figure out the hit
              remainder = 0;
              if (hero.wasBeaten() or rival.wasBeaten()) {
                  sys.out.println("This match is already over");
              } else {
                  if (isHerosTurn) {
                      remainder = rival.adjustHealth(hitValue);
                      if (remainder == 0) {
                          sys.out.println("The HERO wins!!!");
                      }
                  } else {
                      remainder = hero.adjustHealth(hitValue);
                      if (remainder == 0) {
                          sys.out.println("The Rival wins. Boo!");
                      }
                  }
                  isHerosTurn = !isHerosTurn;
              }
          }
      }
      

      然后你可以这样做:

      controller = new FightController();
      controller.takeATurn();
      controller.takeATurn();
      controller.takeATurn();
      controller.takeATurn();
      

      一直持续到游戏结束。

      【讨论】:

        【解决方案3】:

        您需要从 Java 游戏框架的角度进行思考。

        这是另一个解决问题的帖子,

        Game programming in Java?

        【讨论】:

          【解决方案4】:

          对象通过发送消息进行交互。这么看:当一个玩家attacks,然后他将它的暴力信息发送给另一个玩家reveiveHit方法。

          或者,用一个通用的设计模式来实现它:一个玩家可以发出攻击,其他玩家观察它的行为并确定他们是否被击中。

          你不应该做的事:让一名球员依赖另一名球员(就像你的例子一样)。如果您想为比赛建模,请添加某种类型的经理/裁判来记录攻击和效果。

          【讨论】:

            【解决方案5】:

            请帮助我理解为什么我们 使用接口

            实现一个接口可以让一个类在它承诺提供的行为方面变得更加正式,并且它们在类和外部世界之间形成一个契约,并且这个契约在编译时由编译器强制执行。如果您的类声称实现了一个接口,则该接口定义的所有方法都必须出现在其源代码中,然后该类才能成功编译。

            1 . Why we are implementing interfaces ?
            2.Why do we need interfaces in Java?

            我的问题的答案

            由于您的代码在两个类(即 Rival 和 Hero)中都有共同的攻击()方法,因此最好的方法是在接口中声明该方法。

            请记住,以下只是一个代码-sn-p,不是完整的代码。您可以自己完成。

            public interface Fight {
                 public int attack(); 
                }
            
            public class Hero implements Fight { 
                public int attack() {  
                    rival1.getHealth(-15);
                    }
              }
            
            public class Rival implements Fight {
                 public int attack() {  
                   hero1.getHealth(-15);
                    }  
              }
            

            【讨论】:

              【解决方案6】:

              这是游戏中角色相互交互的界面。

              public interface Character{ ... }
              

              这是角色是否可以攻击的界面。

              public interface Fightable{
                  public void attack(Character character);
              }
              

              这些是游戏中实现这两个接口的两个类。

              public class Hero implements Character, Fightable
              {
                  // heros version of implemented method
              
                  public int attack(Character character)
                  {
                      // idealy when hero attacks, the health value will be reduced by 15 of what it is.
                      character.setHealth(-15);
                  }
              }
              
              public class Villon implements Character, Fightable
              {
                  // rival version of implemented method
                  public int attack(Character character)
                  {
                      // idealy when rival attacks, the health value will be reduced by 15 of what it is.
                      character.setHealth(- 15);
                  }
              }
              

              【讨论】:

              • -1 .. 两个类应以“class”和小写public为前缀。
              猜你喜欢
              • 2014-06-20
              • 1970-01-01
              • 2015-05-21
              • 1970-01-01
              • 2011-10-04
              • 1970-01-01
              • 1970-01-01
              • 2013-12-12
              • 1970-01-01
              相关资源
              最近更新 更多