Dudas acerca de Módulos

[Vindictus]

Hola que tal, bueno ante nada si hay alguien por aquí blendereño para responderme con esa generosidad que tienen se lo agradeceré y dios lo bendiga.

Bueno antes que nada aclaro que no soy ningún experto en programación python.
El problema que tengo es el siguiente:
Estoy dando clases de desarrollo de videojuegos RTS en blender, ya lo llevo muy bien. Me he encontrado con el siguiente obstáculo:
¿Como puedo pasar el valor de una variable objeto de un módulo a otro?
Estoy usando Windows 7 64bit| Blender 2.76b |

Mis módulos son los siguientes -> squadron.py | grid.py

El squadron.py es el siguiente:

Código: Seleccionar todo

from bge import logic
from math import *
import grid

######################################################
#
# Demo Script by: Diego Hiroshi | VindictuS HD@2016
#
######################################################
# Este script es un sistema de generación de Guerreros
# Los guerreros se crean en un limite de 6 a 8 unidades
# a lo largo de una matriz de 8x2 | Objeto: Estandarte
# Los NPC pasan a ser fieles seguidores a su Capitán 
# durante toda la partida o se los abandone/elmine
# Juegos Moba y RTS | DEV | Aplicado en Ingenieria
######################################################
 
######################################################
# No divulgues este script sin el consentimiento de
# preservar derechos de firma e información del Author
# Assets DEV-MOBA|RTS Update v0.6 Beta
######################################################

escena = logic.getCurrentScene()



class Banner:
    
    
    def __init__(self, controlador):
        
        self.own = controlador.owner
        self.target = escena.objects["Squadron"]        
        self.C02 = escena.objects["C02"]
        
        
    def getPosition_Hero (self):
        
        targetX = self.target.worldPosition[0]
        targetY = self.target.worldPosition[1]

        C02X = self.C02.worldPosition[0]
        C02Y = self.C02.worldPosition[1]
     

        self.own["targetX"] = targetX
        self.own["targetY"] = targetY
        
        self.own["C02X"] = C02X 
        self.own["C02Y"] = C02Y
        
        return self.own["C02X"], self.own["C02Y"]
    
           
    def main(self):
        
        # Obtiene el valor X,Y Hero Position y se lo aplica al Estandarte "Squadron"
        self.target.worldPosition.x, self.target.worldPosition.y = self.getPosition_Hero()
        
           
alliedBannerRuntime = Banner(logic.getCurrentController())


class Warriors:
    
    # La matriz 4x2 añade 4 objetos de frente (f) y 2 de soporte (s) secuencialmente
    def __init__ (self,controlador):
        
        self.own = controlador.owner
        self.banner = escena.objects["Squadron"]
        self.hero = escena.objects["C02"] # |Obtiene el objecto actual en escena|
        self.warriors = [[],[]]
        self.increment = 4
        self.RADAR = 5 # |Campo de detección de lejanía| Master Key
      
        
        
        
    def getList_Unit(self):
        
        self.unit = escena.objectsInactive["Unit"]
        return self.unit
    
    def getDistance_Hero(self):
        
        self.heroPosition_x = self.hero.worldPosition[0]
        self.heroPosition_y = self.hero.worldPosition[1]
        
        return int(self.heroPosition_x),int(self.heroPosition_y)
    
    
    def getCalculate_Distance(self):
        
        self.w01Position_x = self.s04.worldPosition[0]
        self.w01Position_y = self.s04.worldPosition[1]
        self.w02Position_x = self.s03.worldPosition[0]
        self.w02Position_y = self.s03.worldPosition[1]
        self.w03Position_x = self.s02.worldPosition[0]
        self.w03Position_y = self.s02.worldPosition[1]
        self.w04Position_x = self.s01.worldPosition[0]
        self.w04Position_y = self.s01.worldPosition[1]
        
        return int(self.w01Position_x),int(self.w01Position_y),int(self.w02Position_x),int(self.w02Position_y),int(self.w03Position_x),int(self.w03Position_y),int(self.w04Position_x),int(self.w04Position_y)

    
    def getRadar_System(self):
        
        x1,y1 = self.getDistance_Hero()
        w01x,w01y,w02x,w02y,w03x,w03y,w04x,w04y = self.getCalculate_Distance()
        
        #d = sqrt((x2-x1)**2 + (y2-y1)**2)
        d01 = sqrt((w01x-x1)**2 + (w01y-y1)**2)
        d02 = sqrt((w02x-x1)**2 + (w02y-y1)**2)
        d03 = sqrt((w03x-x1)**2 + (w03y-y1)**2)
        d04 = sqrt((w04x-x1)**2 + (w04y-y1)**2)
        
        
        return d01,d02,d03,d04

    
    def main(self):
        
        if self.own["cont"] < 1:
            self.s04 = escena.addObject(self.getList_Unit(),self.banner,0)
            self.s03 = escena.addObject(self.getList_Unit(),self.banner,0)
            self.s02 = escena.addObject(self.getList_Unit(),self.banner,0)
            self.s01 = escena.addObject(self.getList_Unit(),self.banner,0)
            self.own["cont"] +=1
 
            
        hx,hy = self.getDistance_Hero()
        w01x,w01y,w02x,w02y,w03x,w03y,w04x,w04y = self.getCalculate_Distance()
        d01,d02,d03,d04 = self.getRadar_System()
        
        # DEBUG PROPERTYS DISTANCE RADAR|HERO|UNIT
        #self.own["hx"] = hx
        #self.own["ux"] = ux
        #self.own["hy"] = hy
        #self.own["uy"] = uy     
        #print (d)
        
            # Radar coontrolará que si tanto la posición X e Y de ambos son iguales pero superan el límite establecido, no se aplicará la orden: Detenerse
        
        try:
            
           
            grid = escena.objects["Grid"]
            
            if d01 <= self.RADAR and not int(self.s04.worldPosition[0]) == int(grid.worldPosition[0]) or int(self.s04.worldPosition[1]) == int(grid.worldPosition[1]): 
                self.s04.applyMovement([0.0, -0.04, 0.0], True)
            if d02 <= self.RADAR and not int(self.s03.worldPosition[0]) == int(grid.worldPosition[0]) or int(self.s03.worldPosition[1]) == int(grid.worldPosition[1]):    
                self.s03.applyMovement([0.0, 0.04, 0.0], True)
            if d03 <= self.RADAR and not int(self.s02.worldPosition[0]) == int(grid.worldPosition[0]) or int(self.s02.worldPosition[1]) == int(grid.worldPosition[1]):    
                self.s02.applyMovement([0.0, -0.04, 0.0], True)
            if d04 <= self.RADAR and not int(self.s01.worldPosition[0]) == int(grid.worldPosition[0]) or int(self.s01.worldPosition[1]) == int(grid.worldPosition[1]):    
                self.s01.applyMovement([0.0, 0.04, 0.0], True)
            
            
           
            
            # Radar siempre va a querer que ambos no superen su límite establecido es por eso que Radar genera una segunda clausula indicando que la distancia entre ambos no superen su perímetro de control.
      
            if d01 > self.RADAR:
                self.s04.applyMovement([0.07, 0.0, 0.0], True)
            if d02 > self.RADAR:
                self.s03.applyMovement([0.07, 0.0, 0.0], True)
            if d03 > self.RADAR:     
                self.s02.applyMovement([0.07, 0.0, 0.0], True)
            if d04 > self.RADAR:
                self.s01.applyMovement([0.07, 0.0, 0.0], True)
                    
          
        except:
               
            controlador = logic.getCurrentController()
            #quit = controlador.actuators["Game"]
            #print ("Error Inesperado: RADAR", self.RADAR) 
            #controlador.activate(quit)
     
warriorsRuntime = Warriors(logic.getCurrentController())

# --------------------------------------------------------------------
# End Class 


######################################################
# Executer Program Runtime 
######################################################
        
def main():
    
    alliedBannerRuntime.main()
    warriorsRuntime.main()
       
# --------------------------------------------------------------------
# End Executer  


######################################################
# Acciones del Objeto padre: Unit
# Unit se encarga de generar unidades militares, magos
# arqueros y jinetes en base a una Matriz de 4x2
# Si la clase Banner existe generará un tipo de estandarte
# Si el estandarte no carga durante el Runtime
# los guerreros e instacia (Atributos) no se generarán
######################################################

        
  
def inteligentCollisionSytem():
    
    controlador = logic.getCurrentController()
    escena = logic.getCurrentScene()
    own = controlador.owner
    
    trackTo = controlador.actuators["trackTo"]
    colision = controlador.sensors["Collision"]
    SCI = controlador.sensors["SCI"]
    
    if SCI.positive:
        controlador.deactivate(trackTo)
        
    else:
        controlador.activate(trackTo)  
    
    
# --------------------------------------------------------------------
# End Script: squadron
#
# Author(s): DEV-Hiroshi <hiroshidaigh@gmail.com>  

Por otro lado el módulo grid.py es el siguiente:

Código: Seleccionar todo

from bge import logic
import squadron

escena = logic.getCurrentScene()

class systemFormation:
    
    def __init__(self,controlador):
        
        self.own = controlador.owner
        self.squadron = escena.objects["Squadron"]
        self.grid = escena.objectsInactive["Grid"]
        self.banner = escena.objects["Squadron"]
        self.c = escena.objects["C02"]
        self.distance = 3 # Distancia de formación
        self.rotation = [[1.0, 0.0, 0.0], [ 0.0, 1.0, 0.0], [0.0, 0.0, 1.0]] # Orientación de baldosas

        
    def getPosition_Owner(self):
        
        s_position_x = self.squadron.worldPosition[0]
        s_position_y = self.squadron.worldPosition[1]
        return s_position_x, s_position_y
    
    def createGrid(self):
        
        if self.own["grid_count"] < 1:
            
            self.grid01 = escena.addObject(self.grid,self.banner,0)
            self.grid02 = escena.addObject(self.grid,self.banner,0)
            self.grid03 = escena.addObject(self.grid,self.banner,0)
            self.grid04 = escena.addObject(self.grid,self.banner,0)
            
            s_position_x, s_position_y = self.getPosition_Owner()
            self.grid01.worldPosition.x,self.grid01.worldPosition.y,self.grid01.worldPosition.z= s_position_x+self.distance, s_position_y+self.distance,0.1 
            self.grid01.worldOrientation = self.rotation
            self.grid02.worldPosition.x,self.grid02.worldPosition.y,self.grid02.worldPosition.z= s_position_x+self.distance-2, s_position_y+self.distance,0.1 
            self.grid02.worldOrientation = self.rotation
            self.grid03.worldPosition.x,self.grid03.worldPosition.y,self.grid03.worldPosition.z= s_position_x+self.distance-4, s_position_y+self.distance,0.1 
            self.grid03.worldOrientation = self.rotation
            self.grid04.worldPosition.x,self.grid04.worldPosition.y,self.grid04.worldPosition.z= s_position_x+self.distance-6, s_position_y+self.distance,0.1 
            self.grid04.worldOrientation = self.rotation
            
            self.own["grid_count"] += 1
            
            self.grid01.setParent(self.c, 1, 1)
            self.grid02.setParent(self.c, 1, 1)
            self.grid03.setParent(self.c, 1, 1)
            self.grid04.setParent(self.c, 1, 1)
            
           
    def functionTiles(self):
        
        tile01,tile02,tile03,tile04 = self.grid01,self.grid02,self.grid03,self.grid04 
        print (tile01)
          
        
    def main(self):
       
        
        self.createGrid()
        self.functionTiles()
             
systemFormation_Runtime = systemFormation(logic.getCurrentController())


def main ():
    
    systemFormation_Runtime.main()
    
        
        

Bueno chicos o chicas blendereñas, ustedes saben más que yo. ¿Como hago para pasar la variable self.grid01, self.grid02, self.grid03 y self.grid04 del módulo: grid.py al otro módulo de: squadron.py para usarlo dentro? saludos y espero respuestas gente.

[soliman]

Uf... como no aparezca el gran jefe, lo tienes crudo... je, je.
Si sabes ingles, te recomiendo que vayas a la página oficial de Blender donde tienen un apartado de código.

http://blenderartists.org/forum/forumdi ... ?47-Coding

Saludos

[Vindictus]

Hola que tal Señor Soliman, no entendí su respuesta. En lo referido a Inglés, entiendo a nivel intermedio aunque ya había posteado pero no he recibido respuestas.

[soliman]

Me refería a que es una página en ingles.....
Quien lleva esta página si sabe de Python bastante, pero a veces tarda días en pasarse.

Saludos

[juani]

Buenas, no soy experto en python , estoy intentando aprender. He visto tu consulta y me da la sensación de que estás utilizando esos scripts en el juego en modo "script".El controlador python tiene dos modos de uso("Scripts" y "Module").En modo script , el script es ejecutado de principio a fin.En modo "Module" el controlador solo ejecuta las funciones que son llamadas.
En modo "module" puedes llamar a cualquier función que te de la gana de cualquier script que haya en el juego.Si lo que quieres es usar la función createGrid() en el objeto que está usando
el script squadron.py, solo tienes que llamar desde un controlador python en modo module a la función createGrid() que seria poniendo en el controlador (Grid.createGrid), se pone el nombre del script sin .py y a continuación se llama a la función llamada createGrid que es el nombre de la función sin parentesis.
Espero que sea de tu ayuda, si es esto lo que buscabas agradeceria que comentases si te fue bien para afianzar los conocimientos.
Un saludo.

[Vindictus]

Hola que tal señor Juani. Le explico: Lo que me ha respondido no es lo que yo quiero o sea no es la solución a mi pregunta. Vuelvo a repetir: Lo que yo quiero saber es que manera, o cual es la forma de poder pasar variables que estan dentro de una clase y por consiguiente una función de un archivo python a otro archivo python y reutilizar esa variable. Me explico? Bueno he posteado dos veces en el foro de G-blend pero sigo sin tener respuestas en idioma ingles

[Vindictus]

ME RESPONDO A MI MISMO A LA SOLUCIÓN!

Hola Gente de LA comunidad de GBLENDE y a XVE y Juani gracias por tu tiempo se los agradezco de corazón y al Foro del la Web del Programador. Antes que nada quiero deciros a los demás que estén en la misma situación que mi consulta anterior que para pasar valores en Python/Blender de un archivo.py a otro desde Blender durante la ejecución BGE es muy sencillo pero supersencillo, a veces cosas realmente tontas son difíciles de saber hasta que practicas, buscas en los foros y encuentras la solución. Se que Muchos dirán que ya lo sabían, que es pan comido por que me ha sucedido en varios foros pero después de haber encontrado la solución por mi cuenta, pero que sepa que acá estuve esperando esa respuesta que XVE, Juani entre otros del foro la Web del Programador y De Blender tuvo la gentileza de ayudarme. Como dije anteriormente no soy ningún experto en programación pero vamos al asunto:

Supongamos que nosotros queremos pasar un valor objeto del archivo PythonManda.py hacia el otro archivo llamado PythonRecibe.py

En el archivo PythonManda.py como ejemplo tenemos:

Código: Seleccionar todo

from bge import logic
import  PythonRecibe
 
def functionText():
        f01 = text01
        f02 = text02
        f03 = text03
        f04 = text04
 
        PythonManda.test(  f01,  f02,  f03,  f04)
 
functionText()

Importante chicos y chicas!!!: Siempre tenemos que importar el modulo al cual queremos pasar el valor sin la extensión.py


Por otro lado tenemos el archivo PythonRecibe.py quien va a recibir los valores:

Código: Seleccionar todo

from bge import logic
def test(f01,f02,f03,f04):
        print (f01,f02,f03,f04)

Conclusión: Siempre que uno quiera pasar parámetros de un archivo python dentro de BGE tienes que llamar al módulo seguido de la Clase si la hay y seguido de la función, dentro de los paréntesis los valores (No olvidarte te importar). Para usar el objeto alojado en la variable solo tenemos que hacer un Return desde la función que recibe los parámetros y de esa forma podemos reutilizarlo externamente :') Arigatou

La otra solución es del usuario XVE de la Web del Programador:

Código: Seleccionar todo

archivo.py varlo1 valor2 valor3

y capturar los valores con la variable os.sys.argv que te devuelve una lista con todos los parámetros recibidos.



Saludos. Tema Cerrrado! y gracias.

[juani]

Buenas, perdona pero no te entendí bien al principio, no entendí que lo que necesitabas era saber como funciona una variable global.Pues bien es mas sencillo aún de lo que tu comentas.
Lo que has hecho funciona pero con mucho rodeo e importando todo el módulo donde está la variable que quieres hacer global(para que sea utilizada en cualquier script del juego).
En el Game Engine de Blender ya existe una variable global llamada 'globalDict' pensada para guardar variables globales pero esta 'globaDict' es a su vez una variable del módulo 'logic', por tanto si yo quiero que una variable pueda ser utilizada por todos los scripts del juego, solo tengo que definirla en el módulo de la lógica.Te dejo un script con el modelo que tu has puesto.
Creo que lo entenderás.
Si tienes alguna duda y yo la se, la contestaré con agrado.
Saludos

[La extensión blend ha sido desactivada y no se mostrará en adelante]

[Vindictus]

Sinceramente AKLOKO la manera de programar en python esas semanas que ya ni me acuerdo para que servía el script que había hecho jajajajajaja

En respues a Juani pues entendí y muchas gracias Ahora quiero que me ayuden con el otro tema esto esto es básico para ustedes pero para mi con el temo de alpha texture y eso estoy perdido
http://www.g-blender.org/foro/viewtopic.php?f=3&t=7724