Class instances on PHP?

First of all, they're called Objects or Instances, as in Object oriented programming?

Second, nothing is stopping you from creating an array (it does not look weird) of monsters:

$monsters = array( new Monster(), new Monster(), new Monster(), new Monster() ); foreach($monsters as $monster) { $totalHP += $monster->hp; } 

About the unique ID, that one should be the responsibility of the MonsterFactory, meaning, a monster should be assigned an ID, it should not assign it to itself, rather the ID should be assigned to it. Something like this when creating a monster:

new Monster(4); //ID is 4 

Who keeps track of it? Someone else, not the Monster.

You could create a $monsters array like this:

$monsters = array(); 

Then every time you want to add a monster, you do this:

$monsters[] = new Monster(); 

You could then loop through your array to get total hitpoints like this:

$totalHP = 0; foreach($monsters as $monster) { $totalHP += $monster->getHp(); } 

Where after that loop, $totalHP would contain the total hitpoints of all the monsters in your array.

You can use an object that acts as a container for Monsters and use that to keep track for you:

class MonsterContainer { private $monsters = array(); public function __construct() { // do stuff } public function addMonster(Monster $monster) { $this->monsters[] = $monster; } public function totalMonstersHP() { $hp = 0; foreach ($this->monsters as $monster) { $hp += $monster->getHp() } return $hp; } } $monster_1 = new Monster(); $monster_2 = new Monster(); $monster_3 = new Monster(); $container = new MonsterContainer(); $container->addMonster(monster_1); $container->addMonster(monster_2); $container->addMonster(monster_3); echo $container->totalMonstersHP(); 

You could create a collection factory; it would be responsible for the creation of new monsters. Fusing two classes together is normally not my thing, but I like the fact that I can make the constructor private this way :)

It uses two static variables (glorified global I suppose), one for the monster id and one for the collection of monsters, using SplObjectStorage.

Methods that need to iterate over all monsters use the each() method, so any logic you want can be defined outside of the class.

class Monster { private $id; public $health; private static $instances; private static $nextid = 1; // private constructor private function __construct($id) { $this->id = $id; $this->health = 5; } public static function create() { if (!self::$instances) { self::$instances = new SplObjectStorage; } $o = new self(self::$nextid++); self::$instances->attach($o); return $o; } public static function remove($o) { if (!self::$instances) { return; } self::$instances->detach($o); } // iterate over all objects public static function each($cb) { if (!self::$instances) { return; } foreach (self::$instances as $o) { $cb($o); } } } 

Small usage example

$m1 = Monster::create(); $m2 = Monster::create(); $total_health = 0; Monster::each(function(Monster $m) use (&$total_health) { $total_health += $m->health; }); echo "Total health: $total_health\n"; 

I second alexn, using an array to store you class instances (yes, that's the correct term) is perfectly fine.

You can then use foreach to calculate the total HP.

Create MonstersCollection class, which will contain methods getNewMonster() and getTotalHP().

pseudo code:

class MonstersCollection { private $Monsters; public function getNewMonster() { $Monster=new Monster(); $this->monsters[]=$Monster; return $Monster; } //and you know how to write method to get total HP :) } 

It's quite common for classes to keep track of its instances.

class Monster { private $monsters = array(); public function __construct() { self::monsters[] = $this; } public function __destruct() { array_splice(self::monsters, array_search($this, self::monsters), 1 ); } public static function getTotalHp() { $total = 0; foreach(self::monsters as $monster) { $total += $monster->getHp(); } return $total; } } 

Maybe you can create a new class , or function in the same Monster class that is called in the constructor, and each time the class is created it calls a global variable that is increased.

You can create the observer pattern that could update the totalHp property in a centralized object automatically on Monster instantiation.

But a faster/easier way would be something like this in your Monster class:

class Monster { ... private $hp = 5; private static $totalHp = 0; ... public function getHp() { return $this->hp; } public function __construct(...) { ... self::totalHp += $this->getHp(); ... } public function __destruct(...) { ... self::totalHp -= $this->getHp(); ... } ... public static function getTotalHp() { return self::totalHp; } /** * Provide negative number to reduce HP or positive to increase HP. */ public function alterHp($hp) { $this->hp += $hp; self::totalHp += $hp; } } 

Then to get the current the totalHp value you would have to do the following in your client code:

$totalHp = Monster::getTotalHp();