need help with basic java game programming , class and interfaces constructs

I am a first year programming student. I have coved the basics of precedual programming in c++. I am now fairly new to Java.

Recently i have taken a keen interest into game programming.

my situation:

my situation:

I have a hero class and a rival class. each with thier own members and methods. how can i make it possible for the hero to interact with the rival, do i do this through the use of interfaces? for example an interface with an undefined attack method and have both the class implement that interface?

if so

what should the code look like in the attack method of both classes

something likes this

example:

      // 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)
      }

Please hel开发者_如何学Gop me understanding why we use interefaces and , the anwser to my question

any help or suggestions will be greatly appreciated :) .

---

I would say you should not use an interface. A better approach would be to use a superclass. With a superclass you can avoid redefining many of the methods that will, presumably, be shared by both the rival and the hero. Here is an example implementation:

Superclass:

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;
    }
}

Subclasses:

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);
    }

}

The side effect of this system is that it requires a fourth class to actually play the game:

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;
            }
        }
    }
}

Now this might seem a bit complicated but it illustrates a very important concept: separation of concerns. Separation of concerns involves putting code and making classes that make sense. A player should not know who it’s rival is, player might not even know that enemies exist or what sort of terrain it’s standing on. But a player should know how to manage it's health, it's name, how to take damage, etc. In contrast a Game object would need to know about all the players and enemies so it can tell them to fight and move around on the screen. This is an informal definition of seperation of concerns, for more accurate information read the wikipedia page. In this example I separated the hero and the rival so that, later, you can add more enemies without having to modify your hero code every time. This system also allows you to expand on the game's UI without affecting the player or rival. If you wanted to add a GUI to your game you could add an initialize() method in ExampleGame that setup the GUI. Then in the game loop you could call methods to draw images and graphics onto the GUI. With seperation of concerns you can make the system far more modular and easy to use.

Your second question is: why do we use interfaces? Interfaces are a way of making sure that other classes have a behavior you need them to have, without specifying exactly how they should do it. A classic example of the use of interfaces is the Comparable interface. The Comparable interface has one method that it’s must be implemented: compareTo(). The purpose of this method is to allow a ranking of value objects (think String or File) that cannot use the standard boolean mathematical operations (<, >, ==, etc.) You can think of it as like signing a contract. You (the class implementing the interface) agree to have a certain set of functionality however you make that functionality is up to you. For more information read the java tutorial

I should add a caveat to this answer: Inheritance is not the best option. If you want to know how to do it right you should look up MVC (Model View Controller) and Component Based Design. Even these may not the best choice for what you're doing but they're good starting points.

---

I think you're going to want to break it up into a Fighter class and a FightController class. Then the Fighter would be assigned to either the hero or the rival in the FightController.

So, it would essentially be something like the following (don't mind the sloppy rudimentary code, I haven't written Java in ~2 years, I just slapped this together and I'm not sure it will compile):

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;
        }
    }
}

Then you can do something like:

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

on and on until the game is over.

---

You need to think in terms of a framework for java gaming.

Here's another post addressing the issue,

Game programming in Java?

---

Objects interact by sending messages. Look at it this way: when a player attacks, then he sends it's violent message to another players reveiveHit method.

Or, to implement it with a common design pattern: a player could send out attacks and other players observe it's behaviour and determine, if they have been hit.

What you shouldn't do: make one player depend on another one (like in your example). If you want to model a match, then add some sort of manager/referee that does the bookkeeping of attacks and effects.

---

Please help me understanding why we use interfaces

Implementing an interface allows a class to become more formal about the behavior it promises to provide also they form a contract between the class and the outside world, and this contract is enforced at build time by the compiler. If your class claims to implement an interface, all methods defined by that interface must appear in its source code before the class will successfully compile.

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

and , the anwser to my question

Since your code has common attack( ) method in both the classes i.e Rival and Hero, best way would be to declare the method in an interface.

Remember, following is just a code-snippet, not the complete code. You can complete it yourself.

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);
        }  
  }

---

This is the interface for the character in the game which interact with each other.

public interface Character{ ... }

This is the interface if the character is able to attack or not.

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

These are the two classes in your game which implements both the interfaces.

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);
    }
}