Starling Spatial Deactivator

AS3 / Starling - Desativador espacial

Essa extensão Starling é uma abordagem para resolver a ativação espacial / desativação 2D de objetos de jogo. Ele deve cuidar de mostrar / ocultar elementos de jogo que estão fora da tela, por exemplo, mas não apenas ... você poderá fazer basicamente o que quiser com um objeto de jogo quando considerado ativo ou inativo.

Esta biblioteca pode ser útil para você se:

• Seus objetos de jogo podem deixar uma área ativa definida (visualização da câmera, por exemplo) e, portanto, eles precisam ser desativados.
• Seus objetos de jogo podem interagir entre si e você precisa garantir que os objetos de jogo em colisão sejam "com segurança" desativados.

Para mais detalhes sobre a implementação, dê uma olhada na página de demonstração.

▶ Demoção ao vivo

Experimente aqui!

Como usá -lo?

No seu GameManager :

 private var _deactivator : SpatialDeactivator ;
private var _activeAreaAABB : Rectangle = new Rectangle ( 0 , 0 , 120 , 80 ) ;

public function MyGameManager()
{
	// Create the spatial deactivator
	_deactivator = new SpatialDeactivator(_activeAreaAABB.width * 0.25, _activeAreaAABB.height * 0.25);
	Starling.current.juggler.add(_deactivator);
}

// Called at each frame...
public function update () : void
{
	// Update active area when needed
	_activeAreaAABB.x = ...; // Your complex stuff here
	_activeAreaAABB.y = ...; // Your complex stuff here
	_activeAreaAABB.width = ...; // Your complex stuff here
	_activeAreaAABB.height = ...; // Your complex stuff here

	// IMPORTANT TIP: Update only if AABB has changed!
	_deactivator.updateActiveArea(_activeAreaAABB);
}

public function get deactivator() : SpatialDeactivator
{
	return _deactivator;
}

No seu GameObject :

 private var _spatialElement : SpatialElement ;

public function MyGameObject(gameManager : MyGameManager)
{
	// Setup game object core components
	_mySprite = ...;
	_myPhysicalBody = ...;

	// IMPORTANT: Make sure that the object starts inactive!
	// The deactivator will take care of activating it right away if needed.
	onSpatialElementActivityChanged(false);

	// Create spatial element
	_spatialElement = new SpatialElement(gameManager.deactivator);
	_spatialElement.activityChangedCallback = onSpatialElementActivityChanged;

	// Initial position update
	updatePosition();
}

// Called during frame update...
public function updatePosition() : void
{
	// Update game object position & size
	x = ...; // Your complex stuff here
	y = ...; // Your complex stuff here
	width = ...; // Your complex stuff here
	height = ...; // Your complex stuff here

	// IMPORTANT TIP: Update only if AABB has changed!
	_spatialElement.updateAABB(x, y, width, height);
}

private function onSpatialElementActivityChanged( active : Boolean ) : void
{
	// Activate / deactivate your object as you want.
	_mySprite.visible = active;
	_myPhysicalBody.enable = active;
	...
}

Notas importantes:

• Seus objetos de jogo devem começar inativos.
• Atualize os elementos espaciais somente quando o AABB foi alterado.

Ativando o modo de depuração

O modo de depuração ajudará você a ver se você escolheu a configuração correta (consulte aspectos importantes abaixo).

Você pode ativá -lo simplesmente assim:

 _deactivator = new SpatialDeactivator( 32 , 32 , true ) ;

if ( _deactivator . debugSprite)
	addChild ( _deactivator . debugSprite) ; 

⌨ Como instalar?

Basta clonar ou baixar o repositório e copiar/colar a pasta src/ch no diretório src ou adicionar a pasta src/ ao caminho da sua classe.

Aspectos importantes

1. Encontre o tamanho certo

Um ponto importante para tornar essa ferramenta eficiente para você é encontrar o tamanho correto do pedaço para melhor se adequar às suas necessidades.

• Muito grandes pedaços cobrirão muitos objetos de jogo e, portanto, ativam muito deles ao mesmo tempo.
• Pedaços muito pequenos exigem muitos pedaços de processamento por nada.

Você pode testar e ver qual é o melhor para você, ativando o modo de depuração (consulte a seção).

Pessoalmente, uso uma proporção de 0.25 em comparação com o tamanho da área ativa.

 new SpatialDeactivator( _activeAreaAABB . width * 0.25 , _activeAreaAABB . height * 0.25 ) ;

2. Encontre o tamanho da área ativa correta

Se sua área ativa corresponder à visualização da câmera, o uso da margem pode ser útil para antecipar a ativação dos próximos objetos de jogo.

 private var _margin : Number = 20 ;
private var _activeAreaAABB : Rectangle = new Rectangle ( 0 , 0 , 120 + _margin , 80 + _margin ) ;
...
_activeAreaAABB . x = x - _margin * 0.5 ;
_activeAreaAABB . y = y - _margin * 0.5 ;
deactivator . updateActiveArea( _activeAreaAABB ) ;

3. Encontre o tamanho certo do elemento espacial

O tamanho de um elemento espacial deve cobrir todo o tamanho do seu objeto de jogo para garantir que o objeto do jogo não se torne inativo muito cedo ou ativo ultimamente. Se necessário, o tamanho dos seus elementos espaciais pode ser um pouco maior do que os limites dos objetos do seu jogo:

 _spatialElement . updateAABB( x - margin * 0.5 , y - margin * 0.5 , width + margin, height + margin) ;