Thread: Object or Class?

Classes are the blueprints for objects.

Originally Posted by mortalc

Should I use classes or objects for the characters?

there are no objects without classes and classes without objects doesn't make much sense. so the answer is: you need both.

Originally Posted by j2me64

there are no objects without classes and classes without objects doesn't make much sense. so the answer is: you need both.

Just to play the devils advocate, classes without objects could be utility classes with only static methods and a private constructor

// Json

Originally Posted by Json

Just to play the devils advocate, classes without objects could be utility classes with only static methods and a private constructor

// Json

As a note to add: if someone wants to go deeper into it, google the Singleton pattern and you'll understand

Did you read the tutorial at the link provided?

Originally Posted by Bryan

As a note to add: if someone wants to go deeper into it, google the Singleton pattern and you'll understand

A singleton isn't the same as a static-only class. A singleton (as its name suggests) is a single instance class - i.e. one that has a single object.

Best Practice these days seems to frown on singletons because they can cause trouble and encourage poor design - YMMV.

No offence but I think you should take on a few smaller easier projects before you try something too complex, just to get an understanding of Objects and Classes and all that lark.

Yes, dependency injection is a lot better.

However to go back on track with this thread, what I guess you need to do is create a class that represents a character.

// Dont mix this up with the Character wrapper class.
public class Character {
 
    private int health;
 
    private int strength;
 
    public Character() {
 
    }
 
    public int getHealth() {
        return this.health;
    }
 
    public void setHealth(final int health) {
        this.health = health;
    }
 
    public int getStrength() {
        return this.strength;
    }
 
    public void setStrength(final int strength) {
        this.strength = strength;
    }
}

Then somewhere in your code, maybe when you initialise the game code, create objects etc.

public void initialise() {
    final Character someCharacter = new Character();    
    final Character someOtherCharacter = new Character();    
 
   // Now store these somewhere
}

I'm not familiar with your framework but I take it you'd like to store the character somewhere so that you can grab it from your code whenever you want, you might have a GameState singleton or something like this to keep track of the current state including all characters and their stats as well as the objects and character inventories bla bla bla.

For instance, in my game which is an arcade style game I have different scenes, one scene is the menu another is the actual playing and there are other things like high score scene etc. as well.

When I'm in the menu of my game and I choose to start a new game, I initialise the PlayingScene which in turn creates and holds the current player object.

playingScene.newGame();

public void newGame() {
    // Reset the whole scene to the state of a new game, including the score, player, enemies etc.
    this.player = new Player(this.particleTexture);
}

The player then has a number of lives and some other basic stats on it as well as all the code for rendering the player, this might not be optimal but its the way I did it back in the days. Seeing as the player is just a small spaceship built up using two triangles I'm alright I think. Its a simple game anyway.

Some sample rendering code.

            gl.glBegin(GL.GL_TRIANGLES);
            {
                // Base
                gl.glColor4f(0.2f, 0.5f, 0.2f, 1.0f);
                gl.glVertex3f(-0.5f, 0.25f, 0.0f);
                gl.glVertex3f(-0.5f, -0.25f, 0.0f);
                gl.glColor4f(0.2f, 0.7f, 0.2f, 1.0f);
                gl.glVertex3f(0.5f, 0.0f, 0.0f);
 
                // Fin
                gl.glColor4f(0.2f, 0.7f, 0.2f, 1.0f);
                gl.glVertex3f(-0.5f, 0.0f, 0.0f);
                gl.glVertex3f(0.5f, 0.0f, 0.0f);
                gl.glColor4f(0.2f, 0.5f, 0.2f, 1.0f);
                gl.glVertex3f(-0.5f, 0.0f, 0.5f);
            }
            gl.glEnd();

Sorry for the long post, just give us a shout if you need any more help.

// Json

The calculation of the damage should not occur in the charater itself but some kind of damagehandler, or fighthandler or whatever. It ask the charaters its strength, do some math(fight) and if there is damage, reduce the health(s).

Ofcourse this is possible in Java, you just have to know how. But like Faz already said, instead of building something this complex right at the beginning is not smart. Do some smaller projects so you get used to the language and then build the game. But first design the game itself because you want to program the game without having giving it a real thought, like we see now:

By the way, for the methods question, I had an idea. Basically, both the attacker and the attacked would have a method - the attacker initiates the attack, sending variables over with different names (e.g. s instead of strength) to the attacked, where the damage calculation would occur. Would it work?

A OO design should not be language dependant(else its not a OO design, imho). Sure, while programming it will become a bit more Java dependant but the design itself should not.

Originally Posted by dlorde

A singleton isn't the same as a static-only class. A singleton (as its name suggests) is a single instance class - i.e. one that has a single object.

Best Practice these days seems to frown on singletons because they can cause trouble and encourage poor design - YMMV.

I know, but I understood static-only classes better when I had read about the Singleton pattern. And also I dont think much about it, but as long as its used correctly and for the right things, I dont see the harm in it.

Yeah, so basically you would have this "FightHandler" or something and then just pass the two characters to it.

new FightHandler().attack(characterA).with(characterB);

// Json

Originally Posted by Json

Yeah, so basically you would have this "FightHandler" or something and then just pass the two characters to it.

new FightHandler().attack(characterA).with(characterB);

// Json

Exactly, and this way you can hold different kind of fights You could make FightHandler abstract and make something like GunFightHandler or MultipleFightHandler(go crazy on it!!). But if you dont have a good design of the entire game, you'll be programming for a longg... time.

zumali's post reported for link spamming

db

Not to sound too much like everyone else now but some of these questions are really making me wonder if you shouldn't try some basic tutorials first or at least make some minor things on the way to your complete game.

For instance, a double is the biggest floating point value representation in Java. I usually refer people to have a read at The Really Big Index and in this case this page is even more of a help Primitive Data Types (The Java™ Tutorials > Learning the Java Language > Language Basics)

With the initialise method what I had in mind was that when you load your game you will most likely have to initialise a lot of things, load textures, sounds etc. An initialise method is the way to go.

public class MyGame {
 
    public static void main(final String... arguments) {
        final MyGame myGame = new MyGame();
        myGame.initialise();
 
    }
 
    public void initialise() {
        // Load sounds
        // Load textures
        // Load other resources
        // Create your characters
        // etc...
    }
 
}

A simple example above.


When it comes to events, event classes are just normal classes, thats true but what happens with events is that you usually have an eventmanager of some kind and then an interface defining what an EventListener is and as your game goes on and something happens, like for instance character a being attacked by character b you can tell your eventmanager to trigger an event called AttackEvent. The event manager would then send this event out to any event listeners it has registered and then the listeners can do whatever they want with the event. In the actual event class that gets sent out you could pass in the character being attacked and the one defending for example. Like helloworld said, check out AWT or something or have a look at Lesson: Writing Event Listeners (The Java™ Tutorials > Creating a GUI With JFC/Swing)

You also asked if the FightHandler example above is an object, in a sense, in Java everything is more or less an object, here's a small example.

Fight class

public class Fight {
 
    private Character defender;
 
    private Character attacker;
 
    public void with(final Character character) {
        this.attacker = character;
        this.calculate();
    }
 
    public Fight attack(final Character character) {
        this.defender = character;
        return this;
    }
 
    private void calculate() {
        this.defender.decreaseHealth(10);
        this.attacker.increaseExperience(100);
 
        System.out.println("[" + this.attacker.getName() + "] attacks [" + this.defender.getName() + "] causing [10] damage and gains [100] experience");
    }
}

Character class

public class Character {
 
    private final String name;
 
    private int health = 100;
 
    private int experience = 0;
 
    public Character(final String name) {
        this.name = name;
    }
 
    public void decreaseHealth(final int amount) {
        this.health -= amount;
    }
 
    public void increaseExperience(final int amount) {
        this.experience += amount;
    }
 
    public int getHealth() {
        return this.health;
    }
 
    public void setHealth(final int health) {
        this.health = health;
    }
 
    public int getExperience() {
        return this.experience;
    }
 
    public void setExperience(int experience) {
        this.experience = experience;
    }
 
    public String getName() {
        return this.name;
    }
}

Game class

public class MyGame {
    public static void main(final String[] args) {
        final Character characterA = new Character("Character A");
        final Character characterB = new Character("Character B");
 
        new Fight().attack(characterA).with(characterB);
    }
}

// Json

The objects are loaded into memory before processing. The newly created object must be a newly allocated memory to hold instance variables of the object, this is done by the Java Virtual Machine (JVM). Initialization of the object is very important in programming, because it is a frequent source of error. The Java programming language provides various mechanisms included to ensure proper initialization of the memory occupied by a newly created object that helping things to get a valid state initial.