Discussion :

[nixmind]

Salut a tous!
Je bloque sur un problème depuis deux jours maintenant. En effet je développe un jeux où j'ai plusieurs types d’ennemi, et je fait la spécialisation des ennemis en lua.

J'ai donc fait un wrapper avec luabind afin de defenir une méthode virtuel en c++ qui sera appelée sur les instances lua. j'arrive a bien gérer jusque la. Maintenant.

J'aimerai que la création de chaque ennemi, on puisse en avoir une instance différente.
Pour ce faire, j'ai défini une fonction CreateEnemy en C++, que j'ai exportée en lua. J'aimerais libérer la mémoire allouée dynamiquement pour ces instances en cours de jeu.
Tout marche bien, mais lorsque j'invoque la fonction lua_close à la fin de mon programme, je segfault. Si je commente la ligne de lua_close ça marche sans souci.

J'ai fait des vérification et les objets instanciés par la fonction CreateEnemy sont bien créés sur le tas. je pense que le problème vient du fait qu'à l'appel de la fonction lua_close, le destructeur de tous les objets créés en lua sont appelés.

J'aimerais donc savoir comment libérer la mémoire allouée pour l'objet depuis le C++, et empêcher la fonction lua_close d’appeler lel destrructeur de l'objet.
J'ai lu les documentation lua sur l;'objet, les metattables et le garbage collector, mais je n'arrive pas à trouver la bonne solution.

Merci de ben vouloir m'aider et de me mettre sur la bonne voie. Ci-dessus mon code.

C++ :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
extern "C" { 
#include <lua.h> 
} 
 
#include <iostream> 
#include <lua.hpp> 
#include <luabind.hpp> 
#include <stdio.h> 
 
class Enemy { 
private: 
  std::string name; 
 
public: 
  Enemy(const std::string& n) 
    : name(n) 
  { 
    std::cout << "New enemy born with name : " << name << ".\n"; 
  } 
 
  Enemy(Enemy const & other) 
    : name(other.name) 
  { 
    std::cout << "Copy of enemy made : " << other.name << ".\n"; 
  } 
 
  const std::string& getName() const 
  { 
    std::cout << "Enamy name has been asked and given.\n"; 
    return name; 
  } 
 
  void setName(const std::string& n) { 
    name = n; 
  } 
 
  virtual int update() 
  { 
    std::cout << "Enemy::update() called.\n"; 
    return (43); 
  } 
}; 
 
class EnemyWrapper : public Enemy, public luabind::wrap_base { 
public: 
  EnemyWrapper(const std::string& n) 
    : Enemy(n) { 
  } 
 
  virtual int update() { 
    return (call<int>("update")); 
  } 
} 
 
Enemy  * CreateEnemy(std::string const &  name)                                                                                                                                                
{ 
  return new Enemy(name); 
} 
 
 
int  main()  {                                                                                                                                                          
lua_State *  L =  lua_open()                                                                                                                                                
  luabind::open(L); 
  luaL_openlibs(L); 
 
  luabind::module(L) [ 
                      luabind::class_<Enemy, EnemyWrapper>("Enemy") 
                      .def(luabind::constructor<const std::string&>()) 
                      .property("name", &Enemy::getName, &Enemy::setName) 
                      .def("update", &Enemy::update, &EnemyWrapper::default_update) 
                      .def("CreateEnemy", &CreateEnemy) 
                      ]; 
 
  if (luaL_dofile(L, "wrapping.lua") != 0) 
    std::cout  << lua_tostring(L, -1) <<  std::endl;                                                                                                              
  int i = 1; 
  for (; i <= 10; ++i) 
    { 
      std::cout << i << " " ; 
      Enemy  * e = luabind::call_function<Enemy *>(L,  "CreateEnemy",  "toto");                                                                      
      printf("%p :", e); 
      std::cout << e->update() << std::endl; 
      sleep(1); 
      delete e; 
    } 
  lua_close(L); 
}

Lua:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
 
pprint("Start the  script");  
 
class 'Zombie' (Enemy) 
 
function Zombie:__init(name) 
   Enemy.__init(self, name); 
end 
 
function Zombie:update() 
   print('Zombie:update() called.'); 
   self.talk(); 
   return (72); 
end 
 
function Zombie:talk() 
   print("Yeah I'm a monster"); 
end 
 
function CreateEnemy(name)              
return(Zombie(name)); 
end

[pierreyoda]

Salut,

donc si j'ai bien compris tu veux décharger le garbage collector de Lua de la responsabilité de l'objet? J'avais voulu faire la même chose, il faut définir une call policy de type adopt : cf. la doc..

De ce que je vois de ton code, il te faudra donc ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Enemy  * e = luabind::call_function<Enemy *>(L,  "CreateEnemy",  "toto") [ adopt(result) ];

En espérant que ça marche, luabind a tendance à être capricieux (je me tâte même pour passer à boost.python, python supportant l'unicode).

[nixmind]

Merci pierreyoda!

J'ai essaye avec ta methode et ca a marche! Merci encore, maintenant je ne vais pas encore marque le sujet comme resolu.

je vais essayer de genener mes enemies a la volee en cours de jeu, et les supprimer, si ca tient, je te tiens au courant.

A tres bientot