Comment changer de façon permanente une variable dans une boucle de jeu Python

Question

J'ai ce script dans un jeu que je fais. Il sera utilisé dans le moteur de jeu de Blender. Blender exécute des scripts sur et au-dessus de haut en bas en permanence, donc si je déclare une variable au début du script, il continue à être initialisé à plusieurs reprises.

#The current location of the object
loc_x = obj.getPosition()[0]
loc_y = obj.getPosition()[1]

#The velocity of the object
velocity_x = 0.09
velocity_y = 0.03


#If the location of the object is over 5, bounce off.
if loc_x > 5:
    velocity_x = (velocity_x * -1)

if loc_y > 5:
    velocity_y = (velocity_y * -1)

#Every frame set the object's position to the old position plus the velocity
obj.setPosition([(loc_x + velocity_x),(loc_y + velocity_y),0])

En fait, mon problème est que dans le cas des boucles, je change la variable de sa valeur initiale à l'inverse de son ancienne valeur. Mais parce que je déclare au début du script de la valeur de la variable, les variables de vitesse ne restent pas sur ce que je change à.

Je besoin d'un moyen de changer la valeur de la variable permanente ou déclarer qu'une seule fois.

Merci!

Answer 1

Pour gérer la mise en boucle continue grâce à votre code de scripts vous avez besoin d'une valeur en dehors écrit ist du code. Sinon, il ne peut pas fonctionner. Comment votre savoir script qu'il a été exécuté avant? A la suite avec Blender exécute le code 2.6 et 2.7 série:

Possibilité 1:. Blenders global Dictionnaire ajouter un sous-dictionnaire (peut être vide aussi):

bge.logic.globalDict['mysubdictionaryName'] = { 'namestring' : False}

vous pouvez enregistrer des valeurs comme ceci: bge.globalDict['mysubdictionaryName'] = myValue.

Possibilité 2: OBJECTPROPERTY a) avec python:

myObject = bge.logic.getCurrentController().owner

myObject['myproperty_named_has_run_before'] = True

b) Utiliser Logicbricks et ajoutez des propriétés à l'intérieur de l'éditeur Logic

Dans votre cas, vous devez utiliser ObjectProperties, parce que le globalDict est utilisé, lorsque plusieurs objets communiquent ou si vous avez besoin de prendre des données à un autre gamescene.

Answer 2

Mettre les déclarations de velocity_x et velocity_y avant que la boucle. Si vous utilisez des classes, faites-les attributs de l'objet et les intialize juste une fois, à l'intérieur de son __init__().

EDIT: Je ne sais pas comment fonctionne le moteur de jeu de Blender, mais en plus d'avoir le script dans une grande boucle, il devrait y avoir un moyen de choses avant intialize la boucle démarre. Vraiment, c'est tout ce que je peux dire, compte tenu de ma connaissance limitée de votre situation spécifique.

Answer 3

Je cherche la réponse de la même question. il y a une façon i coould find.u doit cliquer sur le bouton « Ajouter une propriété » et ajouter une propriété dans un mélangeur UI.for exemple, Onetime = False.

puis dans l'écriture de script:

si Onetime == Faux:      Faites des événements.      Onetime = True

est la seule façon que je pouvais trouver.

Answer 4

Si votre environnement d'exécution Python est le même à chaque fois que le script est exécuté essayer de déplacer votre initialisation à un gestionnaire d'exception. Comme ceci:

try:
    velocity_x = (velocity_x * -1)
except:
    velocity_x = 0.09

Vous pouvez également essayer de bourrer la variable dans le module __main__ si cela ne fonctionne pas. Comme ceci:

try:
    __main__.velocity_x = (velocity_x * -1)
except:
    __main__.velocity_x = 0.09

Si cela ne fonctionne pas, vous aurez besoin de quelque chose et léger construit dans le module comme sqlite3. Je réécris l'ensemble de votre extrait de code:

import sqlite3

#The current location of the object
loc_x = obj.getPosition()[0]
loc_y = obj.getPosition()[1]

c = sqlite3.connect('/tmp/globals.db')
#c = sqlite3.connect('/dev/shm/globals.db')
# Using the commented connection line above instead will be
# faster on Linux. But it will not persist beyond a reboot.
# Both statements create the database if it doesn't exist.

# This will auto commit on exiting this context
with c:
    # Creates table if it doesn't exist
    c.execute('''create table if not exist vectors 
      (vector_name text primary key not null, 
       vector_value float not null,
       unique (vector_name))''')

# Try to retrieve the value from the vectors table.
c.execute('''select * from vectors''')
vector_count = 0
for vector in c:
    vector_count = vector_count + 1
    # sqlite3 always returns unicode strings
    if vector['vector_name'] == u'x':
        vector_x = vector['vector_value']
    elif vector['vector_name'] == u'y':
        vector_y = vector['vector_value']

# This is a shortcut to avoid exception logic
# Change the count to match the number of vectors
if vector_count != 2:
    vector_x = 0.09
    vector_y = 0.03
    # Insert default x vector. Should only have to do this once
    with c:
        c.executemany("""replace into stocks values 
          (?, ?)""", [('x', vector_x), ('y', vector_y)])

#If the location of the object is over 5, bounce off.
if loc_x > 5:
    velocity_x = (velocity_x * -1)
if loc_y > 5:
    velocity_y = (velocity_y * -1)

# Update stored vectors every time through the loop
with c:
    c.executemany("""update or replace stocks set vector_name = ?, 
      vector_value = ?)""", [('x', vector_x), ('y', vector_y)])

#Every frame set the object's position to the old position plus the velocity
obj.setPosition([(loc_x + velocity_x),(loc_y + velocity_y),0])

# We can also close the connection if we are done with it
c.close()

Oui, il pourrait être accordé dans des fonctions ou des classes de fantaisie mais si c'est la mesure de ce que vous faites, vous n'avez pas besoin de beaucoup plus que cela.

Answer 5

Un exemple d'utilisation globale.

#The velocity of the object
velocity_x = 0.09
velocity_y = 0.03
loc_x = 0
loc_y = 0    

def update_velocity():  
  #If the location of the object is over 5, bounce off.
  global velocity_x, velocity_y
  if loc_x > 5:
    velocity_x = (velocity_x * -1)

  if loc_y > 5:
    velocity_y = (velocity_y * -1)

def update_position():
  global loc_x, loc_y # global allows you to write to global vars
                      # otherwise you're creating locals :)
  loc_x += velocity_x
  loc_y += velocity_y     

#Every frame set the object's position to the old position plus the velocity

while True:
  update_velocity()
  update_position()
  # undoubtedly you do more than this...
  obj.setPosition([loc_x,loc_y,0])

EDIT

J'ai vu un __init__ dans certains commentaires. Si vous êtes dans une classe ne devrait pas vous écrire quelque chose comme:

self.loc_x += self.velocity_x

et ainsi de suite, pour faire référence à l'instance?