Grupo de actores... (¿?)

Buenas, gente!
Antes que nada mis felicitaciones a Hugo por semejante producto y a la comunidad por brindar ayuda!

Les comento lo que necesito lograr (y no me decido a cómo encararlo).

El tema es el siguiente: estoy desarrollando una especie de menú de selección que scrollea horizontalmente.
Cada elemento del menú tiene un título, una imagen y una paqueña descripción.
Adjunto una imagen de lo que busco:

La idea es que haya más elementos y que se desplacen fuera de la pantalla tipo carrusel.
Mi pregunta basicamente es sobre cómo encarar cada elemento y cómo tratarlos como grupo.

Cada elemento ¿es un actor que tiene actores adentro (texto, imagen, descripción), o es un objeto genérico con los actores adentro?
O sea ¿es correcto anidar actores? ¿después responden juntos al movimiento (ej, muevo al actor principal -> se mueven los que están dentro suyo)?

Luego el scroll:
¿Debería usar la posición de la cámara o debería mover a todos los actores al mismo tiempo?

Por ahora esas son las dudas que me surgieron.
Muchísimas gracias de antemano!!!

Hola Luciano!! a mi me parece mas interesante que el contenedor sea un actor, porque eso te permite interactuar con todos los actores como si fueran uno solo.

Pilas no agrupa los actores por si mismo, aunque podrías crearte un actor que tenga la posibilidad de contener a otros.

Por ejemplo, el actor podría llamarse Contenedor, tener un grupo, y notificar a los actores contenidos los cambios de posición:

import pilas

pilas.iniciar()

class Contenedor(pilas.actores.Actor):

	def __init__(self, x=0, y=0):
		self.grupo = pilas.grupo.Grupo()
		pilas.actores.Actor.__init__(self, 'invisible.png', x, y)

	def agregar_actor(self, actor):
		print "agregando el actor"
		self.grupo.append(actor)

	def definir_posicion(self, x, y):
		delta_x = x - self.x
		delta_y = y - self.y

		for actor in self.grupo:
			actor.x += delta_x
			actor.y += delta_y

		pilas.actores.Actor.definir_posicion(self, x, y)


a1 = pilas.actores.Aceituna()
a1.rotacion = [360]
a1.escala = 2
a1.transparencia = 50
a1.x = 20

a2 = pilas.actores.Aceituna()

contenedor = Contenedor()
contenedor.agregar_actor(a1)
contenedor.agregar_actor(a2)

contenedor.x = [100]
contenedor.y = [100]

pilas.ejecutar()

En el ejemplo tendrían que aparecer dos aceitunas, las dos pertenecen al mismo contenedor, así que el cambio de posición del contenedor los tendría que hacerse mover:

Tal vez podríamos agregar un actor así a pilas, pienso que puede ser útil para otros juegos. ¿que te parece?

Con respecto al desplazamiento, me parece que lo mejor sería mover la cámara, lo veo mas sencillo de hacer. Pero va en gustos me parece…

Grosísimo, Hugo!!!

Yo hace unos años laburaba con Actionscript por eso vengo de con la idea de anidar actores (lo que en Flash serían MovieClips), lo que me parece bastante natural.

Estoy segurísimo de que esto serviría en el core de Pilas!
Un actor que puede poseer actores anidados y que se mueven o reaccionan con su padre.
Contá conmigo para probar lo que necesites.

Por ahora voy a usar el código que pasaste pero si decidís que lo anterior puede servir, lo hago de esa manera.

Un abrazo y gracias nuevamente!