Boa noite. Gostaria de saber se existe uma função (ou uma solução) que me
informasse se um método está sendo chamado pela instância ou por outro
método da própria ou da classe filha.

Eu sei que em princípio é a mesma coisa, a instância e a palavra $this, mas
pro PHP não é.


Pra ser mais claro:

Estou criando um jogo em php. Nesse jogo "você" pode/deve "programar" a(s)
sua(s) unidade(s) militar(es). Depois de programada ela irá "combater" com
outra unidade de alguma outra pessoa, essa também programada pelo seu
"dono". (a historinha está meio vulgar, mas não é isso que importa), esse
jogo será baseado em turnos; Supondo que você programasse um fuzileiro. Cada
turno ele tem N movimentos, enquanto anda ele os gasta. No inicio de cada
turno é recarregado seus movimentos.

A classe base de um fuzileiro seria algo parecido com:
abstract class FuzileiroBase {
private $movimentos = 10;
protected function _setMovimentos( $movimentos ) {
$this->movimentos = $movimentos;
}
protected function _getMovimentos() {
return $this->movimentos;
}
}

A classe Avançada seria algo como:
abstract class FuzileiroAdvanced extends FuzileiroBase {
protected function anda() {
$this->_setMovimentos( $this->_getMovimentos() - 1 );
}
public function _recarregaMovimentos() {
$this->_setMovimentos( 10 );
}}

Evidente que é pra desconsiderar n fotos/metodos que eu ocultei pq nao sao
relevantes. Ate aqui temos uma class (assim eu defini) base que tem os
atributos privados e metodos protegidos, somente metodos que alteram os
atributos; outra classe avançada que conterá os metodos úteis, os metodos
dessa classe serão chamados pela classe final que será a unidade mulitar em
sí. Vamos a ela:

final class Vicente extends FuzileiroAdvanced implements FuzileiroEventos {
public function _onTurnStart() {
$this->anda();
}
}

A ideia é que as açoes da unidade são implementadas "em cima" dos eventos
que acontecem a ela. Daria pra implementar uma maquina de estados etc...(nao
vem ao caso)

Agora uma batalha de 5 turnos seria seria algo como:

$vicente = new Vicente();
for( $i = 0; $i < 5; $i++ ) {
$vicente->_recarregaMovimentos();
$vicente->_onTurnStart();
}

Claro que aqui ele nao lutaria sozinho, teria outras unidades, teria um
campo de batalha, teria uma batalha especifica... (tudo isso ignorado);

Agora vem os problemas:

Pra se evitar Cheat nao pode ser permitido que o fuzileiro ande e recarregue
seus movimentos, na verdade o metodo _recaregarMovimentos nunca pode ser
chamado pela classe Vicente, somente pela instancia $vicente. Poderia-se
resolver isso usando os próprios recursos da POO (protected, private...) mas
o meu problema é que a lógica está inversa, eu preciso que a instância tenha
liberdade pra chamar determinados métodos e que a classe final não possa
chama-los. Pensei em usar "_" (underline) na frente dos métodos que não
podem ser chamados pela classe final, mas isso é muito frágil.

Pra entender melhor o jogo eu teria que explicar mais, mas até aqui eu acho
é o suficiente pra entender o que eu havia perguntado:


Preciso que os métodos que começam com "_" saibam se estão sendo chamados
pela instância ou pela classe filha, algo assim:

public function _recarregaMovimentos() {
SE NAO ESTA SENDO CHAMADA PELA INSTANCIA($vicente) RETORNA
$this->_setMovimentos( 10 );
}


Bom, era isso; Abração!


--
________________________
Dalmir da Silva
+55 55 30262038
+55 55 9925 4645


[As partes desta mensagem que não continham texto foram removidas]