def _iniciar_pilas(self):
        pilas = pilasengine.iniciar(640, 400)
        pilas.definir_iniciado_desde_asistente(True)

        scope = {"pilas": pilas, "self": self, "colores": pilasengine.colores, "pilasengine": pilasengine}

        self.canvas.addWidget(pilas.widget)

        return scope
    def _iniciar_pilas(self):
        pilas = pilasengine.iniciar(640, 400)
        pilas.definir_iniciado_desde_asistente(True)

        scope = {'pilas': pilas,
                 'self': self,
                 'colores': pilasengine.colores,
                 'pilasengine': pilasengine}

        self.canvas.addWidget(pilas.widget)

        return scope
Beispiel #3
0
def main():
    app = QtGui.QApplication(sys.argv)
    ventana = VentanaAsistente()

    # similar a la funcion "iniciar" pero simplemente
    # arma el widget para utilizar dentro de una aplicacion.
    pilas = pilasengine.iniciar()

    widget_de_pilas = pilas.obtener_widget()
    ventana.agregar_widget(widget_de_pilas)
    widget_de_pilas.show()

    pilas.actores.Aceituna()

    sys.exit(app.exec_())
    def _insertar_ventana_principal_de_pilas(self):
        pilas = pilasengine.iniciar(640, 400)
        pilas.definir_iniciado_desde_asistente(True)

        scope = {'pilas': pilas,
                 'self': self,
                 'pilasengine': pilasengine
                 }
        ventana = pilas.obtener_widget()

        self.cargando = QtGui.QLabel("Cargando ...")
        self.cargando.setAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter)
        self.canvas.addWidget(self.cargando)
        self.canvas.setCurrentWidget(self.cargando)

        self.ventana_pilas = ventana

        self.stimer = QtCore.QTimer()

        return scope
Beispiel #5
0
import pilasengine
import sys

pilas = pilasengine.iniciar()
pizarra = pilas.actores.Pizarra()

def dibujar_en_la_pizarra(evento):
    pizarra.dibujar_punto(evento.x, evento.y, pilas.colores.negro)

pilas.escena_actual().mueve_mouse.conectar(dibujar_en_la_pizarra)

pilas.avisar("Usa el mouse para dibujar circulos.")
pilas.ejecutar()
Beispiel #6
0
 def setUp(self):
     import pilasengine
     self.pilas = pilasengine.iniciar()
Beispiel #7
0
 def setUp(self):
     self.pilas = pilasengine.iniciar(modo_test=True)
# coding: utf-8
import pilasengine
from ruedolph import Ruedolph
pilas = pilasengine.iniciar(alto=900,ancho=1600)

pilas.actores.vincular(Ruedolph)
ruedolph = Ruedolph(pilas)
c = pilas.fisica.Circulo(y=-300, x=-748, radio=50, amortiguacion=0,restitucion=0,)
ruedolph.imitar(c)
xs = []
#for i in range(0,30):
  #  xs.append(pilas.fisica.Rectangulo(ancho=200,alto=2, y=-190-20*i, x=500-150*i,
    #    plataforma=1, dinamica=False,amortiguacion=1))
for i in range(-30,9):
    xs.append(pilas.fisica.Rectangulo(ancho=40,dinamica=0,plataforma=1,amortiguacion=1,
    x=i*25-150,y=i*5-290))
for j in range(1,40):
    xs.append(pilas.fisica.Rectangulo(ancho=40,dinamica=0,plataforma=1,amortiguacion=1,
    x=j*25,y=j*-5-245))
pilas.fisica.definir_gravedad_y(-100)

pilas.ejecutar()
Beispiel #9
0
#! /usr/bin/env python

from ChessBoard import ChessBoard

import pilasengine

import virtkeyboard
import OpeningBook

TCASILLA = 80

pilas = pilasengine.iniciar(titulo='ChessBoard Client',
                            ancho=1024, alto=TCASILLA * 8)

tCasilla = 80

class Pieza(pilasengine.actores.Actor):

    def iniciar(self, tipo="p", color=0, fila=0, columna=0):



def mainLoop(self):

    pieces = {}
    chess = ChessBoard()
    board = chess.getBoard()
    turn = chess.getTurn()

    libro_activo = True
    libro_overwrite = False
Beispiel #10
0
# -*- encoding: utf-8 -*-
# Permite que este ejemplo funcion incluso si no has instalado pilas.
import sys
sys.path.insert(0, "..")

import pilasengine

pilas = pilasengine.iniciar(ancho=624, alto=480, audio='phonon')

class Pastilla(pilas.actores.Actor):

    def __init__(self, x, y):
        pilas.actores.Actor.__init__(self, "pastilla_1.png", x - 12, y - 12)
        self.radio_de_colision = 5


class Pacman(pilas.actores.Pacman):

    def __init__(self, mapa):
        self.mapa = mapa
        pilas.actores.Pacman.__init__(self, -12, -12)

    def actualizar(self):

        if self.control.izquierda:
            self.posicion = 0
            self.y = self.ajustar_coordenada_a_grilla(self.y)
        elif self.control.derecha:
            self.posicion = 1
            self.y = self.ajustar_coordenada_a_grilla(self.y)
        elif self.control.abajo:
Beispiel #11
0
	def agregar_widget(self):
		self.pilas = pilasengine.iniciar()
		widget_de_pilas = self.pilas.obtener_widget()
		self.canvas.addWidget(widget_de_pilas)
		self.canvas.setCurrentWidget(widget_de_pilas)
		widget_de_pilas.show()
Beispiel #12
0
# -*- coding:utf-8 -*-
# !/usr/bin/env python
"""
Autor: @Statick_ds
Objetivo del Juego: Atrapar la mayor cantidad de Tortas de Jamon que caen
y evitar tocar las fotografias de la Bruja del 71
"""

# Importamos la Biblioteca de Pilas-Engine y el módulo random
import random
import sys

import pilasengine

# Iniciando PilasEngine en un sola variable para facilitar la programación
pilas = pilasengine.iniciar(800, 490)

try:
    pilas.reiniciar_si_cambia(sys.argv[0])
except OSError:
    pilas.reiniciar_si_cambia(__file__)

# Declarando la clase Chavo


class Chavo(pilasengine.actores.Actor):

    # Creando la función iniciar del actor chavo
    def iniciar(self):
        self.imagen = "data/chavo.png"
        self.y = -144
Beispiel #13
0
import pilasengine

from config import PILAS_SCREEN_X, PILAS_SCREEN_Y

from actores import MiMono, MiBomba
from colisiones import jugador_choca_bomba
from utilidades import crear_bombas


if __name__ == "__main__":
    # Inicio el motor pilas-engine
    pilas = pilasengine.iniciar(ancho=PILAS_SCREEN_X, alto=PILAS_SCREEN_Y, pantalla_completa=True)

    # pilas.definir_pantalla_completa(True)  # Esc / Alt + f

    pilas.actores.vincular(MiBomba)
    pilas.actores.vincular(MiMono)

    mono = pilas.actores.MiMono()
    bombas = pilas.actores.Grupo()

    pilas.colisiones.agregar(mono, bombas, jugador_choca_bomba)
    pilas.tareas.siempre(2, crear_bombas, bombas, pilas.actores.MiBomba)

    pilas.ejecutar()
Beispiel #14
0
# coding: utf-8
import pilasengine
from settings import *

pilas = pilasengine.iniciar(2900, 800)


class MM(pilasengine.actores.Actor):
    def iniciar(self):
        self.imagen = SMALL_IMG_DIR+'/eslabon.png'
#        self.figura = pilas.fisica.Rectangulo(
#            alto=self.imagen.alto(),ancho=self.imagen.ancho(),
   #     friccion=0,restitucion=0,dinamica=1)

    def actualizar(self):
        pilas.fisica.gravedad_y = -10
   #     if self.y > -100:
           # self.figura.rotacion = 35
  #      self.x = self.figura.x
    #    self.y = self.figura.y

   #     self.rotacion = self.figura.rotacion
        if self.pilas.control.izquierda:
            self.figura.velocidad_x = -2
        if self.pilas.control.derecha:
            self.figura.velocida_x = 2
class MM2(pilasengine.actores.Actor):
    def iniciar(self, x, y, sigue):
        self.x = sigue.x + 10
        self.sigue = sigue
        self.figura = pilas.fisica.Circulo()
Beispiel #15
0
# -*- coding: utf-8 -*-

import pilasengine
from pantallas import ANCHO, ALTO
from pantallas import PantallaInicial, PantallaJuego

# crea una instancia del motor de pilas
pilas = pilasengine.iniciar(ancho=ANCHO, alto=ALTO)

# añade las escenas al gestor de escenas
pilas.escenas.vincular(PantallaInicial)
pilas.escenas.vincular(PantallaJuego)

# seleccionar la escena inicial
pilas.escenas.PantallaInicial()

# correr motor ya configurado
pilas.ejecutar()
Beispiel #16
0
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301

# Importamos la libreira de PySerial
import serial


# Permite que este ejemplo funcion incluso si no has instalado pilas.
import sys
sys.path.insert(0, "..")

import pilasengine
pilas = pilasengine.iniciar(ancho=438, alto=360, titulo='Control ROBOT T-2')

# Abrimos el puerto del arduino a 9600
PuertoSerie = serial.Serial('/dev/ttyACM0', 9600)


# Cargo el fondo
fondo = pilas.fondos.Fondo('mifondo.png')

class ecu(pilasengine.actores.Actor):

	def iniciar(self):
		animacion = pilas.imagenes.cargar_animacion('grilla_ecualizador.png', 7)

		animacion.definir_animacion('andando', [1,2,3,4,5,6], 10)
		animacion.definir_animacion('parado', [0], 0)
Beispiel #17
0
# -*- encoding: utf-8 -*-
import pilasengine

pilas = pilasengine.iniciar(titulo='Reloj')
paso_un_segundo = pilas.evento.Evento(['x', 'y'])


class RelojDigital(pilasengine.actores.ActorInvisible):

    def iniciar(self):
        self.color = pilas.colores.negro
        self.contador = 0
        self.y = -100
        self.x = -10
        self.actor_texto = self.pilas.actores.Texto(cadena_de_texto='')

    def avanzar_segundero(self, evento):
        self.contador += 1
        self.actor_texto.texto = str(self.contador)


class RelojAnalogico(pilasengine.actores.Actor):

    def iniciar(self):
        self.imagen = 'flecha.png'
        self.centro = ("izquierda", "centro")
        self.rotacion = 90

    def avanzar_segundero(self, evento):
        self.rotacion -= 360 / 60
        pass
Beispiel #18
0
import pilasengine
import escenas

pilas = pilasengine.iniciar(1366, 768, capturar_errores=False)

escena = escenas.EscenaJuego(pilas)

pilas.definir_escena(escena)

pilas.ejecutar()
Beispiel #19
0
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import pilasengine
import random

Fin_del_juego = False
# Iniciar el motor de PilasEngine
pilas = pilasengine.iniciar(ancho=288, alto=511)
# Añadir un marcador
puntos = pilas.actores.Puntaje(x=100, y=240, color=pilas.colores.naranja)
puntos.magnitud = 40
# Añadir el conmutador de sonido
Sonido = pilas.actores.Sonido
# Variables y constantes
Tubos1 = []
Tubos2 = []
Pisos = []
Puntos = []
# Define todas las cualidades del Fondo
class FondoConMovimiento(pilasengine.fondos.Fondo):
    def iniciar(self):
        # define que imagen se usara como fondo
        self.imagen = "flappyfondo.png"
        # velocidad a la que se movera el fondo
        self.velocidad = 1

    def actualizar(self):
        # define que se movera hacia la izquierda
        self.x -= self.velocidad
        # Si el fondo llega al borde izquierdo de la pantalla entonces cambiar su posicion en X
        if self.x + self.ancho <= 0:
from __future__ import division
import pilasengine
from random import randint
from settings import IMG_DIR
from movimientos import *
from circulo_personalizado import Mi_Circulo
import math
from coordenadas import coor_esc_1, coor_esc_2, coor_cad, coor_rod_cinta, coor_rod_cinta_rota
# original (small) = 2000, 1080
# debug = 1000, 500
# GLOBAL
en_colision = False
chequear = True
# GLOBAL
r = None
pilas = pilasengine.iniciar(2000, 1080, pantalla_completa=False, con_aceleracion='OpenGL')

SMALL_IMG_DIR = IMG_DIR + 'mapa-chico-separado/'

#mapa = pilas.fondos.Fondo(imagen=
           #     SMALL_IMG_DIR+"fondo_small.jpg")


###################################################

##################### Actores ######################

####################################################
class Ruedolf(pilasengine.actores.Actor):

    def iniciar(self):
Beispiel #21
0
import pilasengine
pilas = pilasengine.iniciar(gravedad=(0,0))
mapa = pilas.actores.MapaTiled('mapa.tmx')

# Genera un personaje en movimiento.
aceituna = pilas.actores.personajes_rpg.Maton(mapa)

pilas.avisar("Use el teclado para mover al personaje.")

pilas.ejecutar()
# coding: utf-8
import pilasengine
from settings import IMG_DIR
from movimientos import *
pilas = pilasengine.iniciar(4000, 2160)

mapa = pilas.fondos.Fondo(imagen=IMG_DIR+"/mapa.jpg")
pilas.camara.escala = 1.1
pilas.camara.definir_y(60)
pilas.camara.definir_x(-150)


class RuedaGenerica(pilasengine.actores.Actor):
    def iniciar(self, x, y):
        self.x = x
        self.y = y
        self.imagen = IMG_DIR + '/metal_block.png'

pilas.actores.vincular(RuedaGenerica)
def generar_rueda():
    b = RuedaGenerica(pilas,-1550,530)
    b.escala = 1.5
    return b

pilas.comportamientos.vincular(Desaparecer)
pilas.comportamientos.vincular(Mueve_x)
pilas.comportamientos.vincular(Mueve_y)
pilas.comportamientos.vincular(Eliminar)

def mueve_x(g, stamina, img=''):
    g.hacer("Mueve_x", stamina, img)
Beispiel #23
0
 def setUp(self):
     self.pilas = pilasengine.iniciar(modo_test=True)
     self.pilas.actores.vincular(TestActoresPersonalizados.MiActor)
4# -*- encoding: utf-8 -*-
import pilasengine

pilas = pilasengine.iniciar(alto=768, ancho=1366)
class Menu(pilasengine.escenas.Escena):
    def iniciar(self):
        fondo=pilas.fondos.Fondo("menu.jpg")
        fondo.definir_escala(3)
        intro=pilas.musica.cargar("mememe.mp3")
        intro.reproducir(repetir=True)
        self.menu=pilas.actores.Menu(
            [
                ('Iniciar juego', self.Juego),
                ('Ayuda', self.ayuda),
                ('Salir', self.salir),
            ])
    def Juego(self):
        pilas.escenas.Juego()
    def ayuda(self):
        pilas.escenas.Ayuda()
    def salir(self):
        exit()

class Puerta(pilasengine.actores.Actor):
    def iniciar(self):
        self.imagen="puerta.png"


class Ayuda(pilasengine.escenas.Escena):
    def iniciar(self):
        fondo=pilas.fondos.Fondo("menu.jpg")
Beispiel #25
0
                'vaca_voladora/nube2.png',
        ]
        self.imagen = random.choice(rutas_imagenes_nubes)

    def actualizar(self):
        self.x -= self.velocidad

        if self.derecha < -320:
            self.reiniciar_posicion()

    def reiniciar_posicion(self):
        self.izquierda = 320
        self.y = random.randint(-210, 210)


pilas = pilasengine.iniciar(capturar_errores=False)

fondo = pilas.fondos.Fondo('vaca_voladora/nubes.png')
puntos = pilas.actores.Puntaje(x=-290, y=210)
vaca = Vaca(pilas)
items = []
enemigos = []

def crear_item():
    un_item = Item(pilas)
    items.append(un_item)
    return True

pilas.tareas.agregar(2, crear_item)

# coding: utf-8
import pilasengine
import time
import random
pilas = pilasengine.iniciar(alto=640,ancho=800)
puntajeJ1=0
puntajeJ2=0


class Menu(pilasengine.escenas.Escena):
    
    def iniciar(self):
        fondo=pilas.fondos.Fondo("fondo.jpg")
        fondo.definir_escala(4)
        intro = pilas.musica.cargar("Battle City (NES) Music - Game Start.mp3")
        intro.reproducir()
        self.menu=pilas.actores.Menu([("Iniciar Juego",self.iniciar_juego), ("Instrucciones",self.instrucciones),("Salir",self.salir)])

    def iniciar_juego(self):
        self.menu.eliminar()
        pilas.escenas.Juego()

    def salir(self):
        exit()

    def instrucciones(self):
        self.menu.eliminar()
        pilas.escenas.Instr()

class Instr(pilasengine.escenas.Escena):
    
Beispiel #27
0
#!/usr/bin/env python
# -*- coding: utf-8
import pilasengine
from globales import *
from emisorHUMO import *
from pantalla_config import *
from pantallas_juego import *
from juego_tierraluna import *
#from juego_tierraluna_DEMO import *
from juego_tierraluna_DEMO import *

# Inicializamos PILAS-ENGINE
# pasando como parámetros la resolución gráfica de la ventana y el título de la misma:

pilas = pilasengine.iniciar(ancho=900, alto=550, titulo='TierraLuna')


# Habilitando el Audio en PILAS: 

try:
  pilas.forzar_habilitacion_de_audio()
except AttributeError:
  print u"Omitiendo Habilitación forzada de audio, version anterior a 1.4.8".encode('utf-8')


pilas.escenas.vincular(PantallaJuego)
pilas.escenas.vincular(PantallaMenu)
pilas.escenas.vincular(PantallaDemo)
pilas.escenas.vincular(PantallaConfig)
pilas.escenas.vincular(PantallaFinal)
pilas.escenas.PantallaMenu(tema_actual_init, tema_sprites_init, tema_fondos_init, tema_textos_init)
Beispiel #28
0
# -*- encoding: utf-8 -*-
import pilasengine

import escena_menu

pilas = pilasengine.iniciar(titulo="Tres en raya")
pilas.escenas.definir_escena(escena_menu.EscenaMenu(pilas))
pilas.ejecutar()
Beispiel #29
0
 def setUp(self):
     self.pilas = pilasengine.iniciar()
Beispiel #30
0
#coding: utf-8

from __future__ import division
import pilasengine
from settings  import IMG_DIR
from movimientos import *
from circulo_personalizado import Mi_Circulo
import math
import pickle
from coordenadas import *

# GLOBAL
en_colision = False

pilas = pilasengine.iniciar(2000, 1080, pantalla_completa=False)

SMALL_IMG_DIR = IMG_DIR + 'mapa-chico-separado/'
cam = pilas.camara
class Ruedolph(pilasengine.actores.Actor):

    def iniciar(self):
        self.imagen = SMALL_IMG_DIR + 'ruedolph.png'
        self.radio_de_colision = 20
        self.figura = pilas.fisica.Circulo(-780,-389, 50,
            friccion=0, restitucion=0, dinamica=1)
        self.figura_encaje = pilas.fisica.Circulo(self.x, self.y, 20,
            friccion=0, restitucion=0, dinamica=0, sensor=1)
        self.imantado = False
        self.se_puede_mover = False
        self.figura.sin_rotacion = True
        self.figura.escala_de_gravedad = 3