Posted to tcl by hypnotoad at Wed Dec 10 20:05:59 GMT 2014view raw

  1.  
  2. /*
  3. ** This file is machine generated. Changes will
  4. ** be overwritten on the next run of cstruct.tcl
  5. */
  6. #include "sim.h"
  7.  
  8.  
  9. void compartment_export_nmalloc(Tcl_Interp *interp) {
  10. #if IRM_MEM_DEBUG
  11. Tcl_LinkVar(interp, "module_malloc(cstruct_compartment)", (char*)&nMalloc,
  12. TCL_LINK_INT | TCL_LINK_READ_ONLY);
  13. #endif
  14. }
  15.  
  16.  
  17. /* Structure Compartment */
  18.  
  19. const struct IrmParamNameMap Compartment_paramNameMap[] = {
  20. { "accessible", CSTRUCT_COMPARTMENT_ACCESSIBLE, PTYPE_INT },
  21. { "agent_suppression", CSTRUCT_COMPARTMENT_AGENT_SUPPRESSION, PTYPE_INT },
  22. { "airlock_open", CSTRUCT_COMPARTMENT_AIRLOCK_OPEN, PTYPE_INT },
  23. { "chrr", CSTRUCT_COMPARTMENT_CHRR, PTYPE_FLOAT },
  24. { "collapse", CSTRUCT_COMPARTMENT_COLLAPSE, PTYPE_FLOAT },
  25. { "cten", CSTRUCT_COMPARTMENT_CTEN, PTYPE_INT },
  26. { "ctrans", CSTRUCT_COMPARTMENT_CTRANS, PTYPE_INT },
  27. { "cvis", CSTRUCT_COMPARTMENT_CVIS, PTYPE_FLOAT },
  28. { "fire_size", CSTRUCT_COMPARTMENT_FIRE_SIZE, PTYPE_FLOAT },
  29. { "flooding", CSTRUCT_COMPARTMENT_FLOODING, PTYPE_FLOAT },
  30. { "has_abandon", CSTRUCT_COMPARTMENT_HAS_ABANDON, PTYPE_INT },
  31. { "has_debris", CSTRUCT_COMPARTMENT_HAS_DEBRIS, PTYPE_INT },
  32. { "has_exception", CSTRUCT_COMPARTMENT_HAS_EXCEPTION, PTYPE_INT },
  33. { "has_fire", CSTRUCT_COMPARTMENT_HAS_FIRE, PTYPE_INT },
  34. { "has_flood", CSTRUCT_COMPARTMENT_HAS_FLOOD, PTYPE_INT },
  35. { "has_hot", CSTRUCT_COMPARTMENT_HAS_HOT, PTYPE_INT },
  36. { "has_investigation", CSTRUCT_COMPARTMENT_HAS_INVESTIGATION, PTYPE_INT },
  37. { "has_pda", CSTRUCT_COMPARTMENT_HAS_PDA, PTYPE_INT },
  38. { "has_smoke", CSTRUCT_COMPARTMENT_HAS_SMOKE, PTYPE_INT },
  39. { "has_steam", CSTRUCT_COMPARTMENT_HAS_STEAM, PTYPE_INT },
  40. { "has_suppression", CSTRUCT_COMPARTMENT_HAS_SUPPRESSION, PTYPE_INT },
  41. { "inescapable", CSTRUCT_COMPARTMENT_INESCAPABLE, PTYPE_INT },
  42. { "is_airlock", CSTRUCT_COMPARTMENT_IS_AIRLOCK, PTYPE_INT },
  43. { "is_passage", CSTRUCT_COMPARTMENT_IS_PASSAGE, PTYPE_INT },
  44. { "is_void", CSTRUCT_COMPARTMENT_IS_VOID, PTYPE_INT },
  45. { "is_weather", CSTRUCT_COMPARTMENT_IS_WEATHER, PTYPE_INT },
  46. { "soot", CSTRUCT_COMPARTMENT_SOOT, PTYPE_FLOAT },
  47. { "suppression_junction", CSTRUCT_COMPARTMENT_SUPPRESSION_JUNCTION, PTYPE_INT },
  48. { "temperature", CSTRUCT_COMPARTMENT_TEMPERATURE, PTYPE_FLOAT },
  49. };
  50. const struct IrmParamNameMap Compartment_canonicalNameMap[] = {
  51. { "accessible", CSTRUCT_COMPARTMENT_ACCESSIBLE, PTYPE_INT },
  52. { "agent_suppression", CSTRUCT_COMPARTMENT_AGENT_SUPPRESSION, PTYPE_INT },
  53. { "airlock_open", CSTRUCT_COMPARTMENT_AIRLOCK_OPEN, PTYPE_INT },
  54. { "chrr", CSTRUCT_COMPARTMENT_CHRR, PTYPE_FLOAT },
  55. { "collapse", CSTRUCT_COMPARTMENT_COLLAPSE, PTYPE_FLOAT },
  56. { "cten", CSTRUCT_COMPARTMENT_CTEN, PTYPE_INT },
  57. { "ctrans", CSTRUCT_COMPARTMENT_CTRANS, PTYPE_INT },
  58. { "cvis", CSTRUCT_COMPARTMENT_CVIS, PTYPE_FLOAT },
  59. { "exception", CSTRUCT_COMPARTMENT_HAS_EXCEPTION, PTYPE_INT },
  60. { "fire_size", CSTRUCT_COMPARTMENT_FIRE_SIZE, PTYPE_FLOAT },
  61. { "flooding", CSTRUCT_COMPARTMENT_FLOODING, PTYPE_FLOAT },
  62. { "has_abandon", CSTRUCT_COMPARTMENT_HAS_ABANDON, PTYPE_INT },
  63. { "has_debris", CSTRUCT_COMPARTMENT_HAS_DEBRIS, PTYPE_INT },
  64. { "has_exception", CSTRUCT_COMPARTMENT_HAS_EXCEPTION, PTYPE_INT },
  65. { "has_fire", CSTRUCT_COMPARTMENT_HAS_FIRE, PTYPE_INT },
  66. { "has_flood", CSTRUCT_COMPARTMENT_HAS_FLOOD, PTYPE_INT },
  67. { "has_hot", CSTRUCT_COMPARTMENT_HAS_HOT, PTYPE_INT },
  68. { "has_investigation", CSTRUCT_COMPARTMENT_HAS_INVESTIGATION, PTYPE_INT },
  69. { "has_pda", CSTRUCT_COMPARTMENT_HAS_PDA, PTYPE_INT },
  70. { "has_smoke", CSTRUCT_COMPARTMENT_HAS_SMOKE, PTYPE_INT },
  71. { "has_steam", CSTRUCT_COMPARTMENT_HAS_STEAM, PTYPE_INT },
  72. { "has_suppression", CSTRUCT_COMPARTMENT_HAS_SUPPRESSION, PTYPE_INT },
  73. { "inescapable", CSTRUCT_COMPARTMENT_INESCAPABLE, PTYPE_INT },
  74. { "is_airlock", CSTRUCT_COMPARTMENT_IS_AIRLOCK, PTYPE_INT },
  75. { "is_passage", CSTRUCT_COMPARTMENT_IS_PASSAGE, PTYPE_INT },
  76. { "is_void", CSTRUCT_COMPARTMENT_IS_VOID, PTYPE_INT },
  77. { "is_weather", CSTRUCT_COMPARTMENT_IS_WEATHER, PTYPE_INT },
  78. { "soot", CSTRUCT_COMPARTMENT_SOOT, PTYPE_FLOAT },
  79. { "suppression_junction", CSTRUCT_COMPARTMENT_SUPPRESSION_JUNCTION, PTYPE_INT },
  80. { "temperature", CSTRUCT_COMPARTMENT_TEMPERATURE, PTYPE_FLOAT },
  81. };
  82.  
  83.  
  84. /*
  85. ** Code for managing compartments in the simulator. This information
  86. ** is used to compute crew escape.
  87. */
  88.  
  89. /*
  90. ** Routines from simnode.c that we need access to
  91. */
  92. int SimLink_CalculateThermalEndurance(Roid id,double rTemp,double rFire);
  93.  
  94. /*
  95. ** All compartments indexed by Compartment.id
  96. */
  97.  
  98. static inline int ifHigher(int oldvalue,int newvalue) {
  99. if(newvalue>oldvalue) {
  100. return newvalue;
  101. }
  102. return oldvalue;
  103. }
  104.  
  105. static void CompartmentComputeAccessible(Compartment *p) {
  106. int lastAccess = p->public_accessible;
  107. p->public_accessible=0;
  108. /* If a compartment is not passable, it accessible = 3 */
  109. /*
  110. ** RULE: compartment-has_pda-0001
  111. ** A [cstruct compartment] in state [cstruct compartment field has_pda]=1 is
  112. ** considered to be on fire and it's decking destroyed. This is intended to model
  113. ** a strike from a missile or other explosive.
  114. **
  115. ** RULE: compartment-has_pda-0002
  116. ** A [cstruct compartment] in state [cstruct compartment field has_pda]=2 is
  117. ** is in the area that would be affected by a shock event, and while likely to
  118. ** contain damaged equipment, will not impede crew movement
  119. */
  120. if (p->public_has_pda==1) {
  121. p->public_accessible=ifHigher(p->public_accessible,CurrentSim->public_crew_trans_pda);
  122. }
  123. if (p->public_has_flood) {
  124. p->public_accessible=ifHigher(p->public_accessible,CurrentSim->public_crew_trans_flood);
  125. }
  126. if (p->public_has_abandon) {
  127. p->public_accessible=ifHigher(p->public_accessible,CurrentSim->public_crew_trans_abandon);
  128. }
  129. if (p->public_has_smoke) {
  130. p->public_accessible=ifHigher(p->public_accessible,CurrentSim->public_crew_trans_smoke);
  131. }
  132. if (p->public_has_fire) {
  133. p->public_accessible=ifHigher(p->public_accessible,CurrentSim->public_crew_trans_fire);
  134. } else if (p->public_has_hot==2) {
  135. p->public_accessible=ifHigher(p->public_accessible,2);
  136. } else if (p->public_has_hot==3) {
  137. p->public_accessible=ifHigher(p->public_accessible,3);
  138. }
  139.  
  140. /* If FSSMIX is running use its scores for cten and ctrans */
  141. if(p->public_cten || p->public_ctrans) {
  142. if(p->public_ctrans > 1) {
  143. p->public_accessible=ifHigher(p->public_accessible,1);
  144. }
  145. if (p->public_cten > 1) {
  146. p->public_accessible=ifHigher(p->public_accessible,p->public_cten);
  147. }
  148. }
  149. if(lastAccess != p->public_accessible) {
  150. p->changed=1;
  151. }
  152. }
  153.  
  154. /*
  155. ** Functions provided by the template
  156. */
  157. Compartment *Compartment_ById(Roid id, int createFlag) {
  158. /*
  159. ** Return a pointer to a Compartment with the given ID. Return NULL
  160. ** if there is no such portal. Create a new one if the createFlag
  161. ** is true and the portal does not previously exist.
  162. */
  163. Tcl_HashEntry *pEntry;
  164. int isNew;
  165. Compartment *p;
  166.  
  167. pEntry=Tcl_FindHashEntry(&CurrentSim->CompartmentIdSet,(char *)id);
  168. if(pEntry) {
  169. return (Compartment*)Tcl_GetHashValue(pEntry);
  170. }
  171. if(!createFlag) {
  172. return NULL;
  173. }
  174.  
  175. pEntry = Tcl_CreateHashEntry(&CurrentSim->CompartmentIdSet,(char *)id, &isNew);
  176. p = (Compartment *)local_Alloc( sizeof(*p) );
  177. p->id = id;
  178. p->public_cvis = 2000.0;
  179. if(!CurrentSim->GlobalSim) {
  180. p->pType=Entity_ById('c',p->id,1);
  181. } else {
  182. p->pType=Entity_ById('c',p->id,0);
  183. }
  184. Tcl_SetHashValue(pEntry,(ClientData)p);
  185. Compartment_StructAlloc(p);
  186. Compartment_Index(CurrentSim,p);
  187. return p;
  188. }
  189.  
  190. Compartment *Compartment_ByName(char *idstring, int createFlag) {
  191. Roid i=-1;
  192. i=Irm_RoidFromString(idstring,'c');
  193.  
  194. if(i<0) {
  195. return NULL;
  196. }
  197. return Compartment_ById(i,createFlag);
  198. }
  199.  
  200. Tcl_HashEntry *Compartment_First(Simulator *sim,Tcl_HashSearch *search) {
  201. /*
  202. ** Return the first compartment in a list of them all
  203. */
  204. return Tcl_FirstHashEntry(&CurrentSim->CompartmentIdSet,search);
  205. }
  206.  
  207. Tcl_Obj *Compartment_GroupToTclObj(Compartment *pNode) {
  208. Roid groupid;
  209. if(!pNode) {
  210. return Tcl_NewBooleanObj(0);
  211. }
  212. groupid=Compartment_StructGetGroup(pNode);
  213. if(!groupid) {
  214. return Tcl_NewBooleanObj(0);
  215. }
  216. return Tcl_NewWideIntObj(groupid);
  217. }
  218.  
  219. Tcl_Obj *Compartment_Identify(Compartment *pNode) {
  220. if(!pNode) {
  221. return Tcl_NewWideIntObj(0);
  222. }
  223. return Tcl_NewWideIntObj(pNode->id);
  224. }
  225.  
  226. Compartment *Compartment_Index_First(Simulator *sim) {
  227. return sim->Compartment_IndexAll;
  228. }
  229.  
  230. Tcl_Obj *Compartment_PublicId(Compartment *pNode) {
  231. char idstring[64];
  232. if(!pNode) {
  233. return Tcl_NewWideIntObj(0);
  234. }
  235. if(pNode->pType) {
  236. if(pNode->pType->name) {
  237. return Irm_NewStringObj(pNode->pType->name);
  238. }
  239. }
  240. sprintf(idstring,"c%d",pNode->id);
  241. return Irm_NewStringObj(idstring);
  242. }
  243.  
  244. Tcl_Obj *Compartment_StructDictGet(Compartment *p,Tcl_Obj* key,int nulltype) {
  245. return Entity_ExportField(p->pType,NULL,Tcl_GetString(key),nulltype);
  246. }
  247.  
  248. Tcl_Obj *Compartment_StructGet(
  249. Compartment *pNode,
  250. int field
  251. ) {
  252. switch (field) {
  253. case CSTRUCT_COMPARTMENT_ACCESSIBLE: return Tcl_NewIntObj(pNode->public_accessible);
  254. case CSTRUCT_COMPARTMENT_HAS_EXCEPTION: return Tcl_NewIntObj(pNode->public_has_exception);
  255. case CSTRUCT_COMPARTMENT_IS_PASSAGE: return Tcl_NewIntObj(pNode->public_is_passage);
  256. case CSTRUCT_COMPARTMENT_COLLAPSE: {
  257. return IRM_NewFuzzyObj(pNode->public_collapse);
  258. }
  259.  
  260. case CSTRUCT_COMPARTMENT_IS_VOID: return Tcl_NewIntObj(pNode->public_is_void);
  261. case CSTRUCT_COMPARTMENT_CHRR: {
  262. return IRM_NewFuzzyObj(pNode->public_chrr);
  263. }
  264.  
  265. case CSTRUCT_COMPARTMENT_FLOODING: {
  266. return IRM_NewFuzzyObj(pNode->public_flooding);
  267. }
  268.  
  269. case CSTRUCT_COMPARTMENT_CVIS: {
  270. return IRM_NewFuzzyObj(pNode->public_cvis);
  271. }
  272.  
  273. case CSTRUCT_COMPARTMENT_INESCAPABLE: return Tcl_NewIntObj(pNode->public_inescapable);
  274. case CSTRUCT_COMPARTMENT_IS_WEATHER: return Tcl_NewIntObj(pNode->public_is_weather);
  275. case CSTRUCT_COMPARTMENT_IS_AIRLOCK: return Tcl_NewIntObj(pNode->public_is_airlock);
  276. case CSTRUCT_COMPARTMENT_CTEN: return Tcl_NewIntObj(pNode->public_cten);
  277. case CSTRUCT_COMPARTMENT_HAS_SUPPRESSION: return Tcl_NewIntObj(pNode->public_has_suppression);
  278. case CSTRUCT_COMPARTMENT_HAS_INVESTIGATION: return Tcl_NewIntObj(pNode->public_has_investigation);
  279. case CSTRUCT_COMPARTMENT_SOOT: {
  280. return IRM_NewFuzzyObj(pNode->public_soot);
  281. }
  282.  
  283. case CSTRUCT_COMPARTMENT_SUPPRESSION_JUNCTION: return Tcl_NewIntObj(pNode->public_suppression_junction);
  284. case CSTRUCT_COMPARTMENT_HAS_ABANDON: return Tcl_NewIntObj(pNode->public_has_abandon);
  285. case CSTRUCT_COMPARTMENT_CTRANS: return Tcl_NewIntObj(pNode->public_ctrans);
  286. case CSTRUCT_COMPARTMENT_AGENT_SUPPRESSION: return Tcl_NewIntObj(pNode->public_agent_suppression);
  287. case CSTRUCT_COMPARTMENT_HAS_FIRE: return Tcl_NewIntObj(pNode->public_has_fire);
  288. case CSTRUCT_COMPARTMENT_HAS_DEBRIS: return Tcl_NewIntObj(pNode->public_has_debris);
  289. case CSTRUCT_COMPARTMENT_HAS_PDA: return Tcl_NewIntObj(pNode->public_has_pda);
  290. case CSTRUCT_COMPARTMENT_HAS_STEAM: return Tcl_NewIntObj(pNode->public_has_steam);
  291. case CSTRUCT_COMPARTMENT_HAS_HOT: return Tcl_NewIntObj(pNode->public_has_hot);
  292. case CSTRUCT_COMPARTMENT_AIRLOCK_OPEN: return Tcl_NewIntObj(pNode->public_airlock_open);
  293. case CSTRUCT_COMPARTMENT_TEMPERATURE: {
  294. return IRM_NewFuzzyObj(pNode->public_temperature);
  295. }
  296.  
  297. case CSTRUCT_COMPARTMENT_FIRE_SIZE: {
  298. return IRM_NewFuzzyObj(pNode->public_fire_size);
  299. }
  300.  
  301. case CSTRUCT_COMPARTMENT_HAS_FLOOD: return Tcl_NewIntObj(pNode->public_has_flood);
  302. case CSTRUCT_COMPARTMENT_HAS_SMOKE: return Tcl_NewIntObj(pNode->public_has_smoke);
  303. }
  304.  
  305. return NULL;
  306. }
  307.  
  308. Entity *Compartment_StructGetType(Compartment *p) {
  309. if(p->pType) {
  310. return Entity_StructGetType(p->pType);
  311. }
  312. return NULL;
  313. }
  314.  
  315. Tcl_Obj *Compartment_StructToDict(Tcl_Interp *interp,Compartment *p,int virtual) {
  316. Tcl_Obj *pResult=NULL;
  317. int i;
  318. if (virtual) {
  319. pResult=Entity_GetDict(p->pType,NULL);
  320. }
  321. if(!pResult) {
  322. pResult=Tcl_NewObj();
  323. }
  324. /* Finaly, Add the Tcl Data */
  325. for(i=0;i<CSTRUCT_COMPARTMENT_Count;i++) {
  326. Tcl_Obj *newElement=Compartment_StructGet(p,i);
  327. Irm_DictObjPut(interp,pResult,Compartment_paramNameMap[i].zName,newElement);
  328. }
  329. if(virtual) {
  330. Compartment_StructAddLocation(interp,p,pResult);
  331. }
  332. return pResult;
  333. }
  334.  
  335. Tcl_Obj *Compartment_TypeToTclObj(Compartment *pNode) {
  336. Entity *pType;
  337. if(!pNode) {
  338. return Tcl_NewBooleanObj(0);
  339. }
  340. pType=Compartment_StructGetType(pNode);
  341. if(!pType) {
  342. return Tcl_NewBooleanObj(0);
  343. }
  344. return Tcl_NewWideIntObj(pType->id);
  345. }
  346.  
  347. void Compartment_ApplySettings(Compartment *p) {
  348. int exception=0;
  349. double tempC;
  350. p->changed=0;
  351.  
  352. if (p->public_is_void) {
  353. p->public_accessible=3;
  354. p->public_has_exception=exception;
  355. return;
  356. }
  357. if(p->public_fire_size > 0.0 && p->public_has_fire < 1) {
  358. int fueltype=TypeSpec_GetInt(p->pType,"fssim_fuel_type");
  359. if(fueltype<0) {
  360. p->public_has_fire=0;
  361. } else if (fueltype>0) {
  362. p->public_has_fire=2;
  363. } else {
  364. p->public_has_fire=1;
  365. }
  366. }
  367. if(p->public_flooding > 0.2) {
  368. p->public_has_flood=1;
  369. }
  370. if(p->public_cvis < CurrentSim->public_crew_detect_smoke) {
  371. p->public_has_smoke=1;
  372. } else {
  373. p->public_has_smoke=0;
  374. }
  375. tempC=p->public_temperature-273.15;
  376. if(tempC > CurrentSim->public_crew_detect_hot_3) {
  377. p->public_has_hot=3;
  378. exception=1;
  379. } else if (tempC > CurrentSim->public_crew_detect_hot_2) {
  380. p->public_has_hot=2;
  381. exception=1;
  382. } else if (tempC > CurrentSim->public_crew_detect_hot_1) {
  383. p->public_has_hot=1;
  384. exception=1;
  385. } else {
  386. p->public_has_hot=0;
  387. }
  388.  
  389. CompartmentComputeAccessible(p);
  390.  
  391. if(p->public_accessible != p->delta->public_accessible) {
  392. p->changed=1;
  393. }
  394. if(p->public_temperature != p->delta->public_temperature) {
  395. p->changed=1;
  396. }
  397. if(p->public_fire_size != p->delta->public_fire_size) {
  398. p->changed=1;
  399. }
  400. if(p->public_cvis != p->delta->public_cvis) {
  401. p->changed=1;
  402. }
  403. if(p->changed) {
  404. exception=1;
  405. }
  406. if(!p->public_is_void && p->public_accessible) {
  407. exception=1;
  408. }
  409. if(p->public_inescapable) exception=1;
  410. if(p->public_has_pda) exception=1;
  411. if(p->public_has_flood) exception=1;
  412. if(p->public_has_fire) exception=1;
  413. if(p->public_has_smoke) exception=1;
  414. if(p->public_has_abandon) exception=1;
  415. if(p->public_has_investigation) exception=1;
  416. if(p->public_has_steam) exception=1;
  417.  
  418. if(p->public_cten > 0) exception=1;
  419. if(p->public_ctrans > 0) exception=1;
  420. if(p->public_chrr > 0.0 ) exception=1;
  421.  
  422. if(p->public_has_suppression) exception=1;
  423. p->public_has_exception=exception;
  424. }
  425.  
  426. int Compartment_Compare(Compartment *a,Compartment *b) {
  427. if(!a && !b) {
  428. return 0;
  429. }
  430. if(!b) {
  431. return 1;
  432. }
  433. if(!a) {
  434. return -1;
  435. }
  436. if(b->id>a->id) {
  437. return -1;
  438. }
  439. if(a->id>b->id) {
  440. return 1;
  441. }
  442. return 0;
  443. }
  444.  
  445. int Compartment_FromTclObj(Tcl_Interp *interp, Tcl_Obj *pObj, Compartment **ppCompartment) {
  446. /*
  447. ** Find a Compartment given a Tcl_Obj that contains the Compartment ID.
  448. ** Leave an error message in interp and return TCL_ERROR if anything
  449. ** goes wrong.
  450. */
  451. Roid i=-1;
  452. i=Irm_RoidFromString(Tcl_GetString(pObj),'c');
  453.  
  454. if(i<0) {
  455. if(interp) {
  456. Tcl_AppendResult(interp, "no such Compartment: ",
  457. Tcl_GetStringFromObj(pObj, 0), 0);
  458. }
  459. }
  460. *ppCompartment = Compartment_ById(i, 0);
  461. if( *ppCompartment==0 ){
  462. if(interp) {
  463. Tcl_AppendResult(interp, "no such Compartment: ",
  464. Tcl_GetStringFromObj(pObj, 0), 0);
  465. }
  466. return TCL_ERROR;
  467. }
  468. return TCL_OK;
  469. }
  470.  
  471. void Compartment_Index(Simulator *sim,Compartment *p) {
  472. Compartment *i,*iPrev;
  473. p->pNextAll=NULL;
  474. /*
  475. ** Index the node
  476. */
  477. if(!sim->Compartment_IndexAll) {
  478. /*
  479. ** Perform a head insertion if the list is empty
  480. */
  481. p->pNextAll=sim->Compartment_IndexAll;
  482. sim->Compartment_IndexAll=p;
  483. return;
  484. }
  485. if(Compartment_Compare(p,sim->Compartment_IndexAll)<0) {
  486. /*
  487. ** Perform a head insertion if this node
  488. ** is less than the head node
  489. */
  490. p->pNextAll=sim->Compartment_IndexAll;
  491. sim->Compartment_IndexAll=p;
  492. return;
  493. }
  494. iPrev=sim->Compartment_IndexAll;
  495. for(i=iPrev;i;i=i->pNextAll) {
  496. if(Compartment_Compare(i,p)>0) {
  497. p->pNextAll=i;
  498. iPrev->pNextAll=p;
  499. return;
  500. }
  501. iPrev=i;
  502. }
  503. /*
  504. ** If we have gotten this far, do a tail
  505. ** insertion
  506. */
  507. iPrev->pNextAll=p;
  508. }
  509.  
  510. void Compartment_Index_Rebuild(Simulator *sim) {
  511. Tcl_HashSearch search;
  512. Tcl_HashEntry *i;
  513. CurrentSim->Compartment_IndexAll=NULL;
  514. for(i=Compartment_First(CurrentSim,&search); i ; i = Tcl_NextHashEntry(&search)) {
  515. Compartment *p = (Compartment *)Tcl_GetHashValue(i);
  516. p->pNextAll=NULL;
  517. }
  518. for(i=Compartment_First(CurrentSim,&search); i ; i = Tcl_NextHashEntry(&search)) {
  519. Compartment *p = (Compartment *)Tcl_GetHashValue(i);
  520. Compartment_Index(CurrentSim,p);
  521. }
  522. }
  523.  
  524. void Compartment_Module_Advance(Simulator *ActiveSim,int clocktime) {
  525. Tcl_HashSearch search;
  526. Tcl_HashEntry *i;
  527.  
  528. for(i=Compartment_First(ActiveSim,&search); i ; i = Tcl_NextHashEntry(&search)) {
  529. Compartment *p = (Compartment *)Tcl_GetHashValue(i);
  530. memcpy(p->delta,p,sizeof(*p));
  531. }
  532. }
  533.  
  534. void Compartment_Module_Free(Simulator *sim) {
  535. /*
  536. ** Reset the compartment map
  537. */
  538. Tcl_HashSearch searchPtr;
  539. Tcl_HashEntry *i;
  540.  
  541. if(!sim->module_compartment) return;
  542.  
  543. for(i=Compartment_First(sim,&searchPtr); i ; i = Tcl_NextHashEntry(&searchPtr)) {
  544. Compartment *p = (Compartment*)Tcl_GetHashValue(i);
  545. if(p->kidlist) {
  546. local_Free((char *)p->kidlist);
  547. }
  548. Compartment_StructFree(p);
  549. local_Free((char *)p);
  550. }
  551. for(i=Portal_First(sim,&searchPtr); i ; i = Tcl_NextHashEntry(&searchPtr)) {
  552. Portal *p = (Portal*)Tcl_GetHashValue(i);
  553. Portal_StructFree(p);
  554. local_Free((char *)p);
  555. }
  556. Tcl_DeleteHashTable(&sim->PortalIdSet);
  557. Tcl_DeleteHashTable(&sim->CompartmentIdSet);
  558. sim->Compartment_IndexAll=NULL;
  559. sim->module_compartment=0;
  560. }
  561.  
  562. void Compartment_Module_Init(Simulator *sim) {
  563. Compartment *external;
  564.  
  565. if(sim->module_compartment) return;
  566.  
  567. Tcl_InitHashTable(&sim->CompartmentIdSet, TCL_ONE_WORD_KEYS);
  568. /* Build an entry for external */
  569. Tcl_InitHashTable(&sim->PortalIdSet, TCL_ONE_WORD_KEYS);
  570. sim->NextHoleId=SYNTHETIC_START;
  571. sim->pSubcompt = 0;
  572. sim->Compartment_IndexAll=NULL;
  573. external=Compartment_ById(-1,1);
  574. external->public_is_weather=1;
  575. sim->module_compartment=0;
  576. }
  577.  
  578. void Compartment_Module_Rewind(Simulator *sim) {
  579. Tcl_HashSearch searchPtr;
  580. Tcl_HashEntry *i;
  581. Compartment *pCompt;
  582.  
  583. for(i=Portal_First(sim,&searchPtr); i ; i = Tcl_NextHashEntry(&searchPtr)) {
  584. Portal *p = (Portal*)Tcl_GetHashValue(i);
  585. Portal_Repair(p,1);
  586. }
  587. Compartment_Index_Rebuild(sim);
  588.  
  589. for(pCompt=sim->Compartment_IndexAll; pCompt ; pCompt=pCompt->pNextAll) {
  590. Compartment_Repair(pCompt,1);
  591. }
  592. }
  593.  
  594. void Compartment_Node_GetLink(Tcl_Obj *pResult,Compartment *pNode,char *linktype) {
  595. if(linktype==NULL) {
  596. if(pNode->pType->pType) {
  597. Tcl_ListObjAppendElement(NULL, pResult, Irm_NewStringObj("type"));
  598. Tcl_ListObjAppendElement(NULL, pResult, Entity_Identify(pNode->pType->pType));
  599. }
  600. if(pNode->pType->gType) {
  601. Tcl_ListObjAppendElement(NULL, pResult, Irm_NewStringObj("group"));
  602. Tcl_ListObjAppendElement(NULL, pResult, Entity_Identify(pNode->pType->gType));
  603. }
  604. }
  605. }
  606.  
  607. int Compartment_nodeeval(Tcl_Interp *interp,Compartment *p,Tcl_Obj *body,int writeback) {
  608. Tcl_Obj *id;
  609. int i;
  610. Tcl_Obj *varv[CSTRUCT_COMPARTMENT_Count*2];
  611. int varc,result,priorLen;
  612.  
  613. if(writeback) {
  614. Compartment_StructWith(interp,p,1,varv);
  615. } else {
  616. Compartment_StructWith(interp,p,1,NULL);
  617. }
  618. id=Compartment_Identify(p);
  619. Tcl_ObjSetVar2(interp,Irm_NewStringObj("id"),NULL,id,0);
  620. Tcl_ObjSetVar2(interp,Irm_NewStringObj("typeid"),NULL,Compartment_TypeToTclObj(p),0);
  621. Tcl_ObjSetVar2(interp,Irm_NewStringObj("groupid"),NULL,Compartment_GroupToTclObj(p),0);
  622.  
  623. result=Tcl_EvalObjEx(interp, body, 0);
  624.  
  625. if(result!=TCL_OK) {
  626. return result;
  627. }
  628. if(writeback){
  629. /*
  630. ** Read values back into the dict
  631. ** For now, we limit writeback to state variables
  632. ** And we don't care about garbage values
  633. */
  634. int changed=0;
  635. for(i=0;i<CSTRUCT_COMPARTMENT_Count*2;i+=2) {
  636. Tcl_Obj *newValue;
  637. int offset;
  638. int type;
  639. newValue=Tcl_ObjGetVar2(interp,varv[i],(Tcl_Obj*)NULL,0);
  640. if(newValue==varv[i+1]) {
  641. /* Undocumented, unsanctioned, but it works in practice
  642. ** If the pointer hasn't changed, neither has the value
  643. */
  644. continue;
  645. }
  646. if(!newValue) {
  647. /* Variable must have been unset... move along */
  648. continue;
  649. }
  650. if( Compartment_StructValueOffset(0, varv[i], &offset, &type) == TCL_OK ) {
  651. Compartment_StructSet(interp,p,offset,newValue);
  652. changed++;
  653. }
  654. }
  655. if(changed) {
  656. Compartment_ApplySettings(p);
  657. }
  658. }
  659. return TCL_OK;
  660. }
  661.  
  662. void Compartment_Repair(Compartment *p, int revert) {
  663. p->public_airlock_open=0;
  664. p->public_chrr=0.0;
  665. p->public_collapse=0.0;
  666. p->public_ctrans=0;
  667. p->public_cten=0;
  668. p->public_cvis=2000;
  669. p->public_fire_size=0.0;
  670. p->public_flooding=0.0;
  671. p->public_has_abandon=0;
  672. p->public_has_fire=0;
  673. p->public_has_flood=0;
  674. p->public_has_hot=0;
  675. p->public_has_investigation=0;
  676. p->public_has_pda=0;
  677. p->public_inescapable=0;
  678. p->public_has_smoke=0;
  679. p->public_has_suppression=0;
  680. p->public_has_steam=0;
  681. p->public_soot=0.0;
  682. p->public_suppression_junction=0;
  683. p->public_temperature=300.0;
  684. CompartmentComputeAccessible(p);
  685. }
  686.  
  687. void Compartment_Rewind(Compartment *p, int revert) {
  688. }
  689.  
  690. void Compartment_SpecDictClear(Compartment *p,Tcl_Obj *key,Tcl_Obj *value) {
  691. if(p->pType) {
  692. Irm_DictFree(p->pType->infoDict);
  693. p->pType->infoDict=NULL;
  694. }
  695. }
  696.  
  697. void Compartment_SpecDictPut(Compartment *p,Tcl_Obj *key,Tcl_Obj *value) {
  698. if(p->pType) {
  699. Irm_DictPut(&p->pType->infoDict,Tcl_GetString(key),value);
  700. }
  701. }
  702.  
  703.  
  704. /*
  705. ** Add a key/value list describing the location of this object
  706. */
  707. IRM_INLINE void Compartment_StructAddLocation(
  708. Tcl_Interp *interp,Compartment *pNode, Tcl_Obj *pValueDict
  709. ) {
  710. /* Default empty implementation from generic template */
  711. }
  712.  
  713. void Compartment_StructAlloc(Compartment *p) {
  714. if (!p->delta) {
  715. p->delta=(Compartment *) local_Alloc(sizeof(*p));
  716. memcpy(p->delta,p,sizeof(*p));
  717. }
  718. }
  719.  
  720. int Compartment_StructChanged(Compartment *pNode,int field, int embargo, int force) {
  721.  
  722. if(field < 0) return 0;
  723. if(field > CSTRUCT_COMPARTMENT_Count)
  724. return 0;
  725. if(!pNode->delta) force=1;
  726. /* No Photo, no comment */
  727.  
  728. switch (field) {
  729. case CSTRUCT_COMPARTMENT_ACCESSIBLE:
  730.  
  731. if (force || pNode->public_accessible != pNode->delta->public_accessible) {
  732. return 1;
  733. }
  734. return 0;
  735.  
  736. case CSTRUCT_COMPARTMENT_IS_PASSAGE:
  737.  
  738. if (force || pNode->public_is_passage != pNode->delta->public_is_passage) {
  739. return 1;
  740. }
  741. return 0;
  742.  
  743. case CSTRUCT_COMPARTMENT_COLLAPSE:
  744. if(force) {
  745. return !IRM_Real_Is_Zero(pNode->public_collapse);
  746. } else {
  747. if(pNode->public_collapse != pNode->delta->public_collapse) {
  748. return 1;
  749. }
  750. return 0;
  751. }
  752.  
  753. case CSTRUCT_COMPARTMENT_IS_VOID:
  754.  
  755. if (force || pNode->public_is_void != pNode->delta->public_is_void) {
  756. return 1;
  757. }
  758. return 0;
  759.  
  760. case CSTRUCT_COMPARTMENT_CHRR:
  761. if(force) {
  762. return !IRM_Real_Is_Zero(pNode->public_chrr);
  763. } else {
  764. if(pNode->public_chrr != pNode->delta->public_chrr) {
  765. return 1;
  766. }
  767. return 0;
  768. }
  769.  
  770. case CSTRUCT_COMPARTMENT_FLOODING:
  771. if(force) {
  772. return !IRM_Real_Is_Zero(pNode->public_flooding);
  773. } else {
  774. if(pNode->public_flooding != pNode->delta->public_flooding) {
  775. return 1;
  776. }
  777. return 0;
  778. }
  779.  
  780. case CSTRUCT_COMPARTMENT_CVIS:
  781. if(force) {
  782. return !IRM_Real_Is_Zero(pNode->public_cvis);
  783. } else {
  784. if(pNode->public_cvis != pNode->delta->public_cvis) {
  785. return 1;
  786. }
  787. return 0;
  788. }
  789.  
  790. case CSTRUCT_COMPARTMENT_INESCAPABLE:
  791.  
  792. if (force || pNode->public_inescapable != pNode->delta->public_inescapable) {
  793. return 1;
  794. }
  795. return 0;
  796.  
  797. case CSTRUCT_COMPARTMENT_IS_WEATHER:
  798.  
  799. if (force || pNode->public_is_weather != pNode->delta->public_is_weather) {
  800. return 1;
  801. }
  802. return 0;
  803.  
  804. case CSTRUCT_COMPARTMENT_IS_AIRLOCK:
  805.  
  806. if (force || pNode->public_is_airlock != pNode->delta->public_is_airlock) {
  807. return 1;
  808. }
  809. return 0;
  810.  
  811. case CSTRUCT_COMPARTMENT_CTEN:
  812.  
  813. if (force || pNode->public_cten != pNode->delta->public_cten) {
  814. return 1;
  815. }
  816. return 0;
  817.  
  818. case CSTRUCT_COMPARTMENT_HAS_SUPPRESSION:
  819.  
  820. if (force || pNode->public_has_suppression != pNode->delta->public_has_suppression) {
  821. return 1;
  822. }
  823. return 0;
  824.  
  825. case CSTRUCT_COMPARTMENT_HAS_INVESTIGATION:
  826.  
  827. if (force || pNode->public_has_investigation != pNode->delta->public_has_investigation) {
  828. return 1;
  829. }
  830. return 0;
  831.  
  832. case CSTRUCT_COMPARTMENT_SOOT:
  833. if(force) {
  834. return !IRM_Real_Is_Zero(pNode->public_soot);
  835. } else {
  836. if(pNode->public_soot != pNode->delta->public_soot) {
  837. return 1;
  838. }
  839. return 0;
  840. }
  841.  
  842. case CSTRUCT_COMPARTMENT_SUPPRESSION_JUNCTION:
  843.  
  844. if (force || pNode->public_suppression_junction != pNode->delta->public_suppression_junction) {
  845. return 1;
  846. }
  847. return 0;
  848.  
  849. case CSTRUCT_COMPARTMENT_HAS_ABANDON:
  850.  
  851. if (force || pNode->public_has_abandon != pNode->delta->public_has_abandon) {
  852. return 1;
  853. }
  854. return 0;
  855.  
  856. case CSTRUCT_COMPARTMENT_CTRANS:
  857.  
  858. if (force || pNode->public_ctrans != pNode->delta->public_ctrans) {
  859. return 1;
  860. }
  861. return 0;
  862.  
  863. case CSTRUCT_COMPARTMENT_AGENT_SUPPRESSION:
  864.  
  865. if (force || pNode->public_agent_suppression != pNode->delta->public_agent_suppression) {
  866. return 1;
  867. }
  868. return 0;
  869.  
  870. case CSTRUCT_COMPARTMENT_HAS_FIRE:
  871.  
  872. if (force || pNode->public_has_fire != pNode->delta->public_has_fire) {
  873. return 1;
  874. }
  875. return 0;
  876.  
  877. case CSTRUCT_COMPARTMENT_HAS_DEBRIS:
  878.  
  879. if (force || pNode->public_has_debris != pNode->delta->public_has_debris) {
  880. return 1;
  881. }
  882. return 0;
  883.  
  884. case CSTRUCT_COMPARTMENT_HAS_PDA:
  885.  
  886. if (force || pNode->public_has_pda != pNode->delta->public_has_pda) {
  887. return 1;
  888. }
  889. return 0;
  890.  
  891. case CSTRUCT_COMPARTMENT_HAS_STEAM:
  892.  
  893. if (force || pNode->public_has_steam != pNode->delta->public_has_steam) {
  894. return 1;
  895. }
  896. return 0;
  897.  
  898. case CSTRUCT_COMPARTMENT_HAS_HOT:
  899.  
  900. if (force || pNode->public_has_hot != pNode->delta->public_has_hot) {
  901. return 1;
  902. }
  903. return 0;
  904.  
  905. case CSTRUCT_COMPARTMENT_AIRLOCK_OPEN:
  906.  
  907. if (force || pNode->public_airlock_open != pNode->delta->public_airlock_open) {
  908. return 1;
  909. }
  910. return 0;
  911.  
  912. case CSTRUCT_COMPARTMENT_TEMPERATURE:
  913. if(force) {
  914. return !IRM_Real_Is_Zero(pNode->public_temperature);
  915. } else {
  916. if(pNode->public_temperature != pNode->delta->public_temperature) {
  917. return 1;
  918. }
  919. return 0;
  920. }
  921.  
  922. case CSTRUCT_COMPARTMENT_FIRE_SIZE:
  923. if(force) {
  924. return !IRM_Real_Is_Zero(pNode->public_fire_size);
  925. } else {
  926. if(pNode->public_fire_size != pNode->delta->public_fire_size) {
  927. return 1;
  928. }
  929. return 0;
  930. }
  931.  
  932. case CSTRUCT_COMPARTMENT_HAS_FLOOD:
  933.  
  934. if (force || pNode->public_has_flood != pNode->delta->public_has_flood) {
  935. return 1;
  936. }
  937. return 0;
  938.  
  939. case CSTRUCT_COMPARTMENT_HAS_SMOKE:
  940.  
  941. if (force || pNode->public_has_smoke != pNode->delta->public_has_smoke) {
  942. return 1;
  943. }
  944. return 0;
  945.  
  946. }
  947. return 0;
  948. }
  949.  
  950. void Compartment_StructFree(Compartment *p) {
  951. if (p->delta) {
  952. IRM_Free((char *)p->delta);
  953. p->delta=NULL;
  954. }
  955. }
  956.  
  957.  
  958. /*
  959. ** Free memory the was allocated internally by the data
  960. ** structure
  961. */
  962. IRM_INLINE void Compartment_StructFree_Private(
  963. Compartment *p
  964. ) {
  965.  
  966. }
  967.  
  968. Roid Compartment_StructGetGroup(Compartment *p) {
  969. if(p->pType) {
  970. return Entity_StructGetGroup(p->pType);
  971. }
  972. return 0;
  973. }
  974.  
  975. void Compartment_StructLocation(Irm_Location *lstruct,Compartment *p) {
  976. CrewRoute_ComptCenter(p->id,0,lstruct);
  977. }
  978.  
  979. int Compartment_StructSet(
  980. Tcl_Interp *interp,
  981. Compartment *pNode,
  982. int field,
  983. Tcl_Obj *value
  984. ) {
  985.  
  986. if(field < 0 ) {
  987. return TCL_ERROR;
  988. }
  989.  
  990. switch (field) {
  991. case CSTRUCT_COMPARTMENT_ACCESSIBLE: {
  992. int intValue;
  993. double floatValue;
  994. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  995. Tcl_ResetResult(interp);
  996. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  997. intValue=(int)floatValue;
  998. }
  999. pNode->public_accessible=intValue;
  1000. return TCL_OK;
  1001. }
  1002. case CSTRUCT_COMPARTMENT_HAS_EXCEPTION: {
  1003. int intValue;
  1004. double floatValue;
  1005. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1006. Tcl_ResetResult(interp);
  1007. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1008. intValue=(int)floatValue;
  1009. }
  1010. pNode->public_has_exception=intValue;
  1011. return TCL_OK;
  1012. }
  1013. case CSTRUCT_COMPARTMENT_IS_PASSAGE: {
  1014. int intValue;
  1015. double floatValue;
  1016. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1017. Tcl_ResetResult(interp);
  1018. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1019. intValue=(int)floatValue;
  1020. }
  1021. pNode->public_is_passage=intValue;
  1022. return TCL_OK;
  1023. }
  1024. case CSTRUCT_COMPARTMENT_COLLAPSE: {
  1025. double floatValue;
  1026. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1027. pNode->public_collapse=(IrmReal)floatValue;
  1028. return TCL_OK;
  1029. }
  1030. case CSTRUCT_COMPARTMENT_IS_VOID: {
  1031. int intValue;
  1032. double floatValue;
  1033. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1034. Tcl_ResetResult(interp);
  1035. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1036. intValue=(int)floatValue;
  1037. }
  1038. pNode->public_is_void=intValue;
  1039. return TCL_OK;
  1040. }
  1041. case CSTRUCT_COMPARTMENT_CHRR: {
  1042. double floatValue;
  1043. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1044. pNode->public_chrr=(IrmReal)floatValue;
  1045. return TCL_OK;
  1046. }
  1047. case CSTRUCT_COMPARTMENT_FLOODING: {
  1048. double floatValue;
  1049. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1050. pNode->public_flooding=(IrmReal)floatValue;
  1051. return TCL_OK;
  1052. }
  1053. case CSTRUCT_COMPARTMENT_CVIS: {
  1054. double floatValue;
  1055. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1056. pNode->public_cvis=(IrmReal)floatValue;
  1057. return TCL_OK;
  1058. }
  1059. case CSTRUCT_COMPARTMENT_INESCAPABLE: {
  1060. int intValue;
  1061. double floatValue;
  1062. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1063. Tcl_ResetResult(interp);
  1064. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1065. intValue=(int)floatValue;
  1066. }
  1067. pNode->public_inescapable=intValue;
  1068. return TCL_OK;
  1069. }
  1070. case CSTRUCT_COMPARTMENT_IS_WEATHER: {
  1071. int intValue;
  1072. double floatValue;
  1073. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1074. Tcl_ResetResult(interp);
  1075. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1076. intValue=(int)floatValue;
  1077. }
  1078. pNode->public_is_weather=intValue;
  1079. return TCL_OK;
  1080. }
  1081. case CSTRUCT_COMPARTMENT_IS_AIRLOCK: {
  1082. int intValue;
  1083. double floatValue;
  1084. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1085. Tcl_ResetResult(interp);
  1086. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1087. intValue=(int)floatValue;
  1088. }
  1089. pNode->public_is_airlock=intValue;
  1090. return TCL_OK;
  1091. }
  1092. case CSTRUCT_COMPARTMENT_CTEN: {
  1093. int intValue;
  1094. double floatValue;
  1095. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1096. Tcl_ResetResult(interp);
  1097. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1098. intValue=(int)floatValue;
  1099. }
  1100. pNode->public_cten=intValue;
  1101. return TCL_OK;
  1102. }
  1103. case CSTRUCT_COMPARTMENT_HAS_SUPPRESSION: {
  1104. int intValue;
  1105. double floatValue;
  1106. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1107. Tcl_ResetResult(interp);
  1108. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1109. intValue=(int)floatValue;
  1110. }
  1111. pNode->public_has_suppression=intValue;
  1112. return TCL_OK;
  1113. }
  1114. case CSTRUCT_COMPARTMENT_HAS_INVESTIGATION: {
  1115. int intValue;
  1116. double floatValue;
  1117. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1118. Tcl_ResetResult(interp);
  1119. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1120. intValue=(int)floatValue;
  1121. }
  1122. pNode->public_has_investigation=intValue;
  1123. return TCL_OK;
  1124. }
  1125. case CSTRUCT_COMPARTMENT_SOOT: {
  1126. double floatValue;
  1127. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1128. pNode->public_soot=(IrmReal)floatValue;
  1129. return TCL_OK;
  1130. }
  1131. case CSTRUCT_COMPARTMENT_SUPPRESSION_JUNCTION: {
  1132. Tcl_WideInt wideValue;
  1133. if(Tcl_GetWideIntFromObj(interp,value,&wideValue)) return TCL_ERROR;
  1134. pNode->public_suppression_junction=(Roid)wideValue;
  1135. return TCL_OK;
  1136. }
  1137. case CSTRUCT_COMPARTMENT_HAS_ABANDON: {
  1138. int intValue;
  1139. double floatValue;
  1140. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1141. Tcl_ResetResult(interp);
  1142. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1143. intValue=(int)floatValue;
  1144. }
  1145. pNode->public_has_abandon=intValue;
  1146. return TCL_OK;
  1147. }
  1148. case CSTRUCT_COMPARTMENT_CTRANS: {
  1149. int intValue;
  1150. double floatValue;
  1151. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1152. Tcl_ResetResult(interp);
  1153. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1154. intValue=(int)floatValue;
  1155. }
  1156. pNode->public_ctrans=intValue;
  1157. return TCL_OK;
  1158. }
  1159. case CSTRUCT_COMPARTMENT_AGENT_SUPPRESSION: {
  1160. int intValue;
  1161. double floatValue;
  1162. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1163. Tcl_ResetResult(interp);
  1164. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1165. intValue=(int)floatValue;
  1166. }
  1167. pNode->public_agent_suppression=intValue;
  1168. return TCL_OK;
  1169. }
  1170. case CSTRUCT_COMPARTMENT_HAS_FIRE: {
  1171. int intValue;
  1172. double floatValue;
  1173. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1174. Tcl_ResetResult(interp);
  1175. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1176. intValue=(int)floatValue;
  1177. }
  1178. pNode->public_has_fire=intValue;
  1179. return TCL_OK;
  1180. }
  1181. case CSTRUCT_COMPARTMENT_HAS_DEBRIS: {
  1182. int intValue;
  1183. double floatValue;
  1184. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1185. Tcl_ResetResult(interp);
  1186. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1187. intValue=(int)floatValue;
  1188. }
  1189. pNode->public_has_debris=intValue;
  1190. return TCL_OK;
  1191. }
  1192. case CSTRUCT_COMPARTMENT_HAS_PDA: {
  1193. int intValue;
  1194. double floatValue;
  1195. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1196. Tcl_ResetResult(interp);
  1197. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1198. intValue=(int)floatValue;
  1199. }
  1200. pNode->public_has_pda=intValue;
  1201. return TCL_OK;
  1202. }
  1203. case CSTRUCT_COMPARTMENT_HAS_STEAM: {
  1204. int intValue;
  1205. double floatValue;
  1206. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1207. Tcl_ResetResult(interp);
  1208. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1209. intValue=(int)floatValue;
  1210. }
  1211. pNode->public_has_steam=intValue;
  1212. return TCL_OK;
  1213. }
  1214. case CSTRUCT_COMPARTMENT_HAS_HOT: {
  1215. int intValue;
  1216. double floatValue;
  1217. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1218. Tcl_ResetResult(interp);
  1219. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1220. intValue=(int)floatValue;
  1221. }
  1222. pNode->public_has_hot=intValue;
  1223. return TCL_OK;
  1224. }
  1225. case CSTRUCT_COMPARTMENT_AIRLOCK_OPEN: {
  1226. int intValue;
  1227. double floatValue;
  1228. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1229. Tcl_ResetResult(interp);
  1230. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1231. intValue=(int)floatValue;
  1232. }
  1233. pNode->public_airlock_open=intValue;
  1234. return TCL_OK;
  1235. }
  1236. case CSTRUCT_COMPARTMENT_TEMPERATURE: {
  1237. double floatValue;
  1238. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1239. pNode->public_temperature=(IrmReal)floatValue;
  1240. return TCL_OK;
  1241. }
  1242. case CSTRUCT_COMPARTMENT_FIRE_SIZE: {
  1243. double floatValue;
  1244. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1245. pNode->public_fire_size=(IrmReal)floatValue;
  1246. return TCL_OK;
  1247. }
  1248. case CSTRUCT_COMPARTMENT_HAS_FLOOD: {
  1249. int intValue;
  1250. double floatValue;
  1251. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1252. Tcl_ResetResult(interp);
  1253. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1254. intValue=(int)floatValue;
  1255. }
  1256. pNode->public_has_flood=intValue;
  1257. return TCL_OK;
  1258. }
  1259. case CSTRUCT_COMPARTMENT_HAS_SMOKE: {
  1260. int intValue;
  1261. double floatValue;
  1262. if(Tcl_GetIntFromObj(interp,value,&intValue)) {
  1263. Tcl_ResetResult(interp);
  1264. if(Tcl_GetDoubleFromObj(interp,value,&floatValue)) return TCL_ERROR;
  1265. intValue=(int)floatValue;
  1266. }
  1267. pNode->public_has_smoke=intValue;
  1268. return TCL_OK;
  1269. }
  1270. }
  1271. return TCL_OK;
  1272. }
  1273.  
  1274. void Compartment_StructSetGroup(Compartment *p,Roid groupid) {
  1275. Entity_StructSetGroup(p->pType,groupid);
  1276. }
  1277.  
  1278. void Compartment_StructSetType(Compartment *p,Entity *pType) {
  1279. if(!p->pType) {
  1280. return;
  1281. }
  1282. Entity_StructSetType(p->pType,pType);
  1283. }
  1284.  
  1285. IRM_INLINE int Compartment_StructValueOffset(
  1286. Tcl_Interp *interp,
  1287. Tcl_Obj *pObj,
  1288. int *pIndex,
  1289. int *pType
  1290. ) {
  1291. /*
  1292. ** Given the name of one of the arState[] values in the Compartment structure,
  1293. ** return the index of the particular arState[]. Return TCL_OK.
  1294. **
  1295. ** Leave an error message in interp and return TCL_ERROR if
  1296. ** anything goes wrong.
  1297. */
  1298.  
  1299. int lo, hi, mid, c, max, i;
  1300. int nName;
  1301. const char *zName;
  1302. const struct IrmParamNameMap *aParam = Compartment_canonicalNameMap;
  1303.  
  1304. lo = 0;
  1305. hi = max = CSTRUCT_COMPARTMENT_AliasCount - 1;
  1306. zName = Tcl_GetStringFromObj(pObj, &nName);
  1307. mid = (lo+hi)/2;
  1308. if(nName>32) {
  1309. nName=32;
  1310. }
  1311. while( lo<=hi ){
  1312. mid = (lo+hi)/2;
  1313. c = strncmp(zName, aParam[mid].zName, nName);
  1314. if( c<0 ){
  1315. hi = mid-1;
  1316. }else if( c>0 ){
  1317. lo = mid+1;
  1318. }else if(
  1319. (mid>0 && strncmp(zName, aParam[mid-1].zName, nName)==0) ||
  1320. (mid<max && strncmp(zName, aParam[mid+1].zName, nName)==0)
  1321. ){
  1322. i = mid;
  1323. while( i>0 && strncmp(zName, aParam[i-1].zName, nName)==0 ){
  1324. i--;
  1325. }
  1326. if( strlen(aParam[i].zName)==nName ){
  1327. *pIndex = aParam[i].iCode;
  1328. *pType = aParam[i].pType;
  1329. return TCL_OK;
  1330. }
  1331. if(interp) {
  1332. Tcl_AppendResult(interp, "ambiguous parameter:", 0);
  1333. do{
  1334. Tcl_AppendResult(interp, " ", aParam[i++].zName, 0);
  1335. }while( i<=max && strncmp(zName, aParam[i].zName, nName)==0 );
  1336. }
  1337. return TCL_ERROR;
  1338. }else{
  1339. *pIndex = aParam[mid].iCode;
  1340. *pType = aParam[mid].pType;
  1341. return TCL_OK;
  1342. }
  1343. }
  1344. if(interp) {
  1345. Tcl_AppendResult(interp, "unknown parameter \"", zName,
  1346. "\" - nearby choices:", 0);
  1347. for(i=mid-3; i<mid+3; i++){
  1348. if( i<0 || i>max ) continue;
  1349. Tcl_AppendResult(interp, " ", aParam[i].zName, 0);
  1350. }
  1351. }
  1352. return TCL_ERROR;
  1353. }
  1354.  
  1355. void Compartment_StructWith(Tcl_Interp *interp,Compartment *p,int virtual,Tcl_Obj **objvPtr) {
  1356. int i;
  1357. if (virtual) {
  1358. Entity_With(interp,p->pType,NULL);
  1359. }
  1360. /* Finaly, Add the Tcl Data */
  1361. for(i=0;i<CSTRUCT_COMPARTMENT_Count;i++) {
  1362. Tcl_Obj *newElement=Compartment_StructGet(p,i);
  1363. Tcl_Obj *fieldName=Irm_NewStringObj(Compartment_paramNameMap[i].zName);
  1364. if(objvPtr) {
  1365. objvPtr[i*2]=fieldName;
  1366. objvPtr[i*2+1]=newElement;
  1367. }
  1368. Tcl_ObjSetVar2(interp,fieldName,NULL,newElement,0);
  1369. }
  1370. if(virtual) {
  1371. Compartment_StructWithLocation(interp,p);
  1372. }
  1373. }
  1374.  
  1375. IRM_INLINE void Compartment_StructWithLocation(
  1376. Tcl_Interp *interp,Compartment *pNode
  1377. ) {
  1378. /* Default empty implementation from generic template */
  1379. }
  1380.  
  1381. static int Compartment_method_add (
  1382. ClientData *simulator,
  1383. Tcl_Interp *interp,
  1384. int objc,
  1385. Tcl_Obj *CONST objv[]
  1386. ) {
  1387.  
  1388. CurrentSim=(Simulator *)simulator;
  1389.  
  1390. local_interp=interp;
  1391. Roid id;
  1392. Compartment *p;
  1393. Entity *pType=NULL;
  1394.  
  1395. if( objc!=2 && objc!=3 ){
  1396. Tcl_WrongNumArgs(interp, 1, objv, "ID ?typeid?");
  1397. return TCL_ERROR;
  1398. }
  1399. if( Tcl_GetIntFromObj(interp, objv[1], &id) ) return TCL_ERROR;
  1400. if( id<=0 ){
  1401. Tcl_AppendResult(interp, "compartment ID must be 1 or greater", 0);
  1402. return TCL_ERROR;
  1403. }
  1404. p=Compartment_ById(id,1);
  1405. if(objc==3) {
  1406. if( SimType_FromTclObj(interp, objv[2], &pType) ) return TCL_ERROR;
  1407. Compartment_StructSetType(p,pType);
  1408. }
  1409. Compartment_Repair(p,1);
  1410. return TCL_OK;
  1411. }
  1412.  
  1413. static int Compartment_method_cid (
  1414. ClientData *simulator,
  1415. Tcl_Interp *interp,
  1416. int objc,
  1417. Tcl_Obj *CONST objv[]
  1418. ) {
  1419.  
  1420. CurrentSim=(Simulator *)simulator;
  1421.  
  1422. local_interp=interp;
  1423. Compartment *p;
  1424. if( objc!=2 ) {
  1425. Tcl_WrongNumArgs(interp, 1, objv, "ID");
  1426. return TCL_ERROR;
  1427. }
  1428. if( Compartment_FromTclObj(interp, objv[1], &p) ) {
  1429. Tcl_ResetResult(interp);
  1430. Tcl_SetObjResult(interp, Tcl_NewIntObj(0));
  1431. return TCL_OK;
  1432. }
  1433. Tcl_SetObjResult(interp, Tcl_NewIntObj(p->id));
  1434. return TCL_OK;
  1435. }
  1436.  
  1437. static int Compartment_method_condition (
  1438. ClientData *simulator,
  1439. Tcl_Interp *interp,
  1440. int objc,
  1441. Tcl_Obj *CONST objv[]
  1442. ) {
  1443.  
  1444. CurrentSim=(Simulator *)simulator;
  1445.  
  1446. local_interp=interp;
  1447. Compartment *p;
  1448. Tcl_Obj *pResult;
  1449. if( objc!=2 ) {
  1450. Tcl_WrongNumArgs(interp, 1, objv, "ID");
  1451. return TCL_ERROR;
  1452. }
  1453. if( Compartment_FromTclObj(interp, objv[1], &p) ) return TCL_ERROR;
  1454. pResult=Tcl_NewObj();
  1455. CompartmentComputeAccessible(p);
  1456.  
  1457. Tcl_ListObjAppendElement(interp,pResult,Tcl_NewIntObj(p->public_accessible));
  1458. if(p->public_is_void) {
  1459. Tcl_ListObjAppendElement(interp, pResult, Irm_NewStringObj("void"));
  1460. }
  1461. if(p->public_has_pda) {
  1462. Tcl_ListObjAppendElement(interp, pResult, Irm_NewStringObj("pda"));
  1463. }
  1464. if(p->public_has_flood) {
  1465. Tcl_ListObjAppendElement(interp, pResult, Irm_NewStringObj("flood"));
  1466. }
  1467. if(p->public_has_fire>0 && p->public_has_fire<8 ) {
  1468. Tcl_ListObjAppendElement(interp, pResult, Irm_NewStringObj("fire"));
  1469. }
  1470. if(p->public_has_smoke) {
  1471. Tcl_ListObjAppendElement(interp, pResult, Irm_NewStringObj("smoke"));
  1472. }
  1473. if(p->public_has_abandon) {
  1474. Tcl_ListObjAppendElement(interp, pResult, Irm_NewStringObj("abandon"));
  1475. }
  1476. if(p->public_cten > 1) {
  1477. Tcl_ListObjAppendElement(interp, pResult, Irm_NewStringObj("cten"));
  1478. }
  1479. if(p->public_ctrans > 1) {
  1480. Tcl_ListObjAppendElement(interp, pResult, Irm_NewStringObj("ctrans"));
  1481. }
  1482. Tcl_SetObjResult(interp, pResult);
  1483. return TCL_OK;
  1484. }
  1485.  
  1486. static int Compartment_method_count (
  1487. ClientData *simulator,
  1488. Tcl_Interp *interp,
  1489. int objc,
  1490. Tcl_Obj *CONST objv[]
  1491. ) {
  1492.  
  1493. CurrentSim=(Simulator *)simulator;
  1494.  
  1495. local_interp=interp;
  1496. Tcl_HashSearch search;
  1497. Tcl_HashEntry *i;
  1498. int count=0;
  1499. for(i=Compartment_First(CurrentSim,&search); i ; i = Tcl_NextHashEntry(&search)) {
  1500. count++;
  1501. }
  1502. Tcl_SetObjResult(interp, Tcl_NewIntObj(count));
  1503. return TCL_OK;
  1504. }
  1505.  
  1506. static int Compartment_method_exists (
  1507. ClientData *simulator,
  1508. Tcl_Interp *interp,
  1509. int objc,
  1510. Tcl_Obj *CONST objv[]
  1511. ) {
  1512.  
  1513. CurrentSim=(Simulator *)simulator;
  1514.  
  1515. local_interp=interp;
  1516. Compartment *p;
  1517. Tcl_Obj *pResult;
  1518. char name[64];
  1519.  
  1520. if( objc!=2 && objc!=3 && objc!=4 ) {
  1521. Tcl_WrongNumArgs(interp, 1, objv, "ID ?idvar? ?namevar?");
  1522. return TCL_ERROR;
  1523. }
  1524. if( Compartment_FromTclObj(interp, objv[1], &p) ) {
  1525. Tcl_ResetResult(interp);
  1526. Tcl_SetObjResult(interp, Tcl_NewBooleanObj(0));
  1527. return TCL_OK;
  1528. }
  1529. sprintf(name,"c%d",p->id);
  1530. pResult=Tcl_NewStringObj(name,-1);
  1531. if(objc>2) {
  1532. Tcl_ObjSetVar2(interp, objv[2], NULL, Tcl_NewIntObj(p->id), 0);
  1533. }
  1534. if(objc==4) {
  1535. Tcl_ObjSetVar2(interp, objv[3], NULL, pResult, 0);
  1536. }
  1537. Tcl_SetObjResult(interp, Tcl_NewBooleanObj(1));
  1538. return TCL_OK;
  1539. }
  1540.  
  1541. static int Compartment_method_flooding (
  1542. ClientData *simulator,
  1543. Tcl_Interp *interp,
  1544. int objc,
  1545. Tcl_Obj *CONST objv[]
  1546. ) {
  1547.  
  1548. CurrentSim=(Simulator *)simulator;
  1549.  
  1550. local_interp=interp;
  1551. double rFlow = 0.0;
  1552. int comptid_valid = 0;
  1553. Roid comptid=-1;
  1554. Roid min_comptid;
  1555. SimNode *pNode;
  1556.  
  1557. if( objc!=2 ){
  1558. Tcl_WrongNumArgs(interp, 1, objv, "COMPTID");
  1559. return TCL_ERROR;
  1560. }
  1561. if( Tcl_GetIntFromObj(interp, objv[1], &min_comptid) ) return TCL_ERROR;
  1562. for(pNode=SimNode_Index_First(CurrentSim); pNode; pNode=pNode->pNextAll) {
  1563. if( pNode->public_compartment<min_comptid ||
  1564. (comptid_valid && pNode->public_compartment>comptid) ) continue;
  1565. if( pNode->public_compartment!=comptid ){
  1566. comptid = pNode->public_compartment;
  1567. comptid_valid = 1;
  1568. rFlow = 0.0;
  1569. }
  1570. rFlow += pNode->public_water_to_deck;
  1571. rFlow += pNode->public_fuel_to_deck;
  1572. }
  1573. if( comptid_valid && rFlow != 0.0){
  1574. Tcl_Obj *pResult = Tcl_NewObj();
  1575. Tcl_ListObjAppendElement(0, pResult, Tcl_NewWideIntObj(comptid));
  1576. Tcl_ListObjAppendElement(0, pResult, Tcl_NewDoubleObj(rFlow));
  1577. Tcl_SetObjResult(interp, pResult);
  1578. }
  1579. return TCL_OK;
  1580. }
  1581.  
  1582. static int Compartment_method_for (
  1583. ClientData *simulator,
  1584. Tcl_Interp *interp,
  1585. int objc,
  1586. Tcl_Obj *CONST objv[]
  1587. ) {
  1588.  
  1589. CurrentSim=(Simulator *)simulator;
  1590.  
  1591. local_interp=interp;
  1592. Tcl_HashSearch *searchPtr;
  1593. Tcl_HashEntry *i;
  1594. int searchresult=TCL_OK;
  1595.  
  1596. Tcl_Obj *keyvar;
  1597. Tcl_Obj *infovar=NULL;
  1598. Tcl_Obj *body;
  1599.  
  1600. if( objc != 3 && objc != 4){
  1601. Tcl_WrongNumArgs(interp, 1, objv, "keyvar ?valvar? body");
  1602. return TCL_ERROR;
  1603. }
  1604.  
  1605. keyvar=objv[1];
  1606. if (objc == 4) {
  1607. infovar=objv[2];
  1608. body=objv[3];
  1609. } else {
  1610. body=objv[3];
  1611. }
  1612. Tcl_IncrRefCount(keyvar);
  1613. Tcl_IncrRefCount(body);
  1614. if(infovar) {
  1615. Tcl_IncrRefCount(infovar);
  1616. }
  1617. searchresult=TCL_OK;
  1618. searchPtr=(Tcl_HashSearch *)local_Alloc(sizeof(Tcl_HashSearch));
  1619. for(i=Compartment_First(CurrentSim,searchPtr); i ; i = Tcl_NextHashEntry(searchPtr)) {
  1620. Compartment *p = (Compartment *)Tcl_GetHashValue(i);
  1621. Tcl_ObjSetVar2(interp, keyvar, (Tcl_Obj *)NULL, Compartment_Identify(p), 0);
  1622. if(infovar) {
  1623. Tcl_ObjSetVar2(interp, infovar, (Tcl_Obj *)NULL, Compartment_StructToDict(interp,p,1), 0);
  1624. }
  1625. searchresult=Tcl_EvalObjEx(interp,body,0);
  1626. if (searchresult !=TCL_OK && searchresult!=TCL_CONTINUE) {
  1627. break;
  1628. }
  1629. }
  1630. Tcl_DecrRefCount(keyvar);
  1631. if(infovar) {
  1632. Tcl_DecrRefCount(infovar);
  1633. }
  1634. Tcl_DecrRefCount(body);
  1635. Tcl_Free((char *)searchPtr);
  1636. return searchresult;
  1637. }
  1638.  
  1639. static int Compartment_method_foreach (
  1640. ClientData *simulator,
  1641. Tcl_Interp *interp,
  1642. int objc,
  1643. Tcl_Obj *CONST objv[]
  1644. ) {
  1645.  
  1646. CurrentSim=(Simulator *)simulator;
  1647.  
  1648. local_interp=interp;
  1649. Tcl_HashSearch *searchPtr;
  1650. Tcl_HashEntry *i;
  1651. int searchresult=TCL_OK;
  1652. Tcl_Obj *body;
  1653.  
  1654. if( objc != 2){
  1655. Tcl_WrongNumArgs(interp, 1, objv, "body");
  1656. return TCL_ERROR;
  1657. }
  1658. body=objv[1];
  1659. searchPtr=(Tcl_HashSearch *)local_Alloc(sizeof(Tcl_HashSearch));
  1660. for(i=Compartment_First(CurrentSim,searchPtr); i ; i = Tcl_NextHashEntry(searchPtr)) {
  1661. Compartment *p = (Compartment *)Tcl_GetHashValue(i);
  1662. searchresult=Compartment_nodeeval(interp,p,body,0);
  1663. if (searchresult !=TCL_OK && searchresult!=TCL_CONTINUE) {
  1664. Tcl_Free((char *)searchPtr);
  1665. return searchresult;
  1666. }
  1667. }
  1668. Tcl_Free((char *)searchPtr);
  1669. return TCL_OK;
  1670. }
  1671.  
  1672. static int Compartment_method_groupid (
  1673. ClientData *simulator,
  1674. Tcl_Interp *interp,
  1675. int objc,
  1676. Tcl_Obj *CONST objv[]
  1677. ) {
  1678.  
  1679. CurrentSim=(Simulator *)simulator;
  1680.  
  1681. local_interp=interp;
  1682. Compartment *p;
  1683. Roid groupid=0;
  1684. if( objc!=2 && objc != 3 ){
  1685. Tcl_WrongNumArgs(interp, 1, objv, "ID ?groupid?");
  1686. return TCL_ERROR;
  1687. }
  1688. if( Compartment_FromTclObj(interp, objv[1], &p) ) {
  1689. Tcl_ResetResult(interp);
  1690. Tcl_SetObjResult(interp, Tcl_NewBooleanObj(0));
  1691. return TCL_OK;
  1692. }
  1693. if(objc==3) {
  1694. if(Tcl_GetIntFromObj(interp,objv[2],&groupid)) {
  1695. return TCL_ERROR;
  1696. }
  1697. Compartment_StructSetGroup(p,groupid);
  1698. }
  1699. groupid=Compartment_StructGetGroup(p);
  1700. if(groupid>0) {
  1701. Tcl_SetObjResult(interp, Tcl_NewWideIntObj(groupid));
  1702. } else {
  1703. Tcl_SetObjResult(interp, Tcl_NewBooleanObj(0));
  1704. }
  1705. return TCL_OK;
  1706. }
  1707.  
  1708. static int Compartment_method_kidlist (
  1709. ClientData *simulator,
  1710. Tcl_Interp *interp,
  1711. int objc,
  1712. Tcl_Obj *CONST objv[]
  1713. ) {
  1714.  
  1715. CurrentSim=(Simulator *)simulator;
  1716.  
  1717. local_interp=interp;
  1718. Compartment *p;
  1719.  
  1720. if( objc!=2 && objc!=3 ){
  1721. Tcl_WrongNumArgs(interp, 1, objv, "ID ?LISTOFKIDS?");
  1722. return TCL_ERROR;
  1723. }
  1724. if( Compartment_FromTclObj(interp, objv[1], &p) ) return TCL_ERROR;
  1725. /* Ensure we have a list of integers */
  1726.  
  1727. if(objc==2 && p->kidlist) {
  1728. Tcl_Obj *pResult=Tcl_NewObj();
  1729. int i;
  1730. for(i=1;i<=p->kidlist[0];i++) {
  1731. Tcl_ListObjAppendList(interp,pResult,Tcl_NewIntObj(p->kidlist[i]));
  1732. }
  1733. Tcl_SetObjResult(interp, pResult);
  1734. return TCL_OK;
  1735. }
  1736. if(objc==3) {
  1737. int i,n;
  1738. Tcl_Obj *element;
  1739. if(Tcl_ListObjLength(interp,objv[2],&n)) return TCL_ERROR;
  1740. if(n==0) {
  1741. /* If zero, empty our list */
  1742. if(p->kidlist) {
  1743. local_Free((char *)p->kidlist);
  1744. p->kidlist=NULL;
  1745. }
  1746. return TCL_OK;
  1747. }
  1748. if(p->kidlist) {
  1749. p->kidlist=(Roid *)Tcl_Realloc((char *)p->kidlist,sizeof(Roid)*(n+1));
  1750. } else {
  1751. p->kidlist=(Roid *)local_Alloc(sizeof(Roid)*(n+1));
  1752. }
  1753. p->kidlist[0]=n;
  1754. for(i=0;i<n;i++) {
  1755. int j=i+1;
  1756. int value;
  1757. if(Tcl_ListObjIndex(interp, objv[2], i, &element)) return TCL_ERROR;
  1758. if(Tcl_GetIntFromObj(interp,element,&value)) return TCL_ERROR;
  1759. p->kidlist[j]=(Roid)value;
  1760. }
  1761. Tcl_SetObjResult(interp, Tcl_NewIntObj(n));
  1762. }
  1763. return TCL_OK;
  1764. }
  1765.  
  1766. static int Compartment_method_list (
  1767. ClientData *simulator,
  1768. Tcl_Interp *interp,
  1769. int objc,
  1770. Tcl_Obj *CONST objv[]
  1771. ) {
  1772.  
  1773. CurrentSim=(Simulator *)simulator;
  1774.  
  1775. local_interp=interp;
  1776. Tcl_Obj *pResult = Tcl_NewObj();
  1777. Tcl_HashSearch search;
  1778. Tcl_HashEntry *i;
  1779. for(i=Compartment_First(CurrentSim,&search); i ; i = Tcl_NextHashEntry(&search)) {
  1780. Compartment *p = (Compartment *)Tcl_GetHashValue(i);
  1781. Tcl_ListObjAppendElement(interp, pResult, Compartment_Identify(p));
  1782. }
  1783. Tcl_SetObjResult(interp, pResult);
  1784. return TCL_OK;
  1785. }
  1786.  
  1787. static int Compartment_method_list_changed (
  1788. ClientData *simulator,
  1789. Tcl_Interp *interp,
  1790. int objc,
  1791. Tcl_Obj *CONST objv[]
  1792. ) {
  1793.  
  1794. CurrentSim=(Simulator *)simulator;
  1795.  
  1796. local_interp=interp;
  1797. Tcl_HashSearch searchPtr;
  1798. Tcl_HashEntry *i;
  1799. Tcl_Obj *pResult=Tcl_NewObj();
  1800.  
  1801. for(i=Compartment_First(CurrentSim,&searchPtr); i ; i = Tcl_NextHashEntry(&searchPtr)) {
  1802. Compartment *p = (Compartment*)Tcl_GetHashValue(i);
  1803. if(p->changed) {
  1804. Tcl_ListObjAppendElement(interp, pResult, Compartment_Identify(p));
  1805. }
  1806. }
  1807. Tcl_SetObjResult(interp, pResult);
  1808. return TCL_OK;
  1809. }
  1810.  
  1811. static int Compartment_method_list_crew (
  1812. ClientData *simulator,
  1813. Tcl_Interp *interp,
  1814. int objc,
  1815. Tcl_Obj *CONST objv[]
  1816. ) {
  1817.  
  1818. CurrentSim=(Simulator *)simulator;
  1819.  
  1820. local_interp=interp;
  1821. Compartment *p;
  1822. Roid comptid;
  1823. Tcl_HashSearch searchPtr;
  1824. Tcl_HashEntry *i;
  1825. int exception=0;
  1826. Tcl_Obj *pResult=Tcl_NewObj();
  1827.  
  1828. if( objc!=2 && objc!=3 ){
  1829. Tcl_WrongNumArgs(interp, 1, objv, "COMPTID ?only_exceptional?");
  1830. return TCL_ERROR;
  1831. }
  1832. if( Compartment_FromTclObj(interp, objv[1], &p) ) {
  1833. return TCL_ERROR;
  1834. }
  1835. comptid=p->id;
  1836. if(objc==3) {
  1837. if( Tcl_GetIntFromObj(interp, objv[2], &exception) ) return TCL_ERROR;
  1838. }
  1839. for(i=Crew_First(CurrentSim,&searchPtr); i ; i = Tcl_NextHashEntry(&searchPtr)) {
  1840. Crew *pNode = (Crew*)Tcl_GetHashValue(i);
  1841. if( pNode->public_compartment != comptid && pNode->public_compartment_entering != comptid) continue;
  1842. if( exception && !pNode->public_has_exception ) {
  1843. continue;
  1844. }
  1845. Tcl_ListObjAppendElement(interp, pResult, Tcl_NewWideIntObj(pNode->id));
  1846. }
  1847. Tcl_SetObjResult(interp, pResult);
  1848. return TCL_OK;
  1849. }
  1850.  
  1851. static int Compartment_method_list_detectors (
  1852. ClientData *simulator,
  1853. Tcl_Interp *interp,
  1854. int objc,
  1855. Tcl_Obj *CONST objv[]
  1856. ) {
  1857.  
  1858. CurrentSim=(Simulator *)simulator;
  1859.  
  1860. local_interp=interp;
  1861. Roid comptid;
  1862. Compartment *p;
  1863. SimNode *pNode;
  1864. Tcl_Obj *pResult=Tcl_NewObj();
  1865. if( objc!=2 ){
  1866. Tcl_WrongNumArgs(interp, 1, objv, "COMPTID");
  1867. return TCL_ERROR;
  1868. }
  1869. if( Compartment_FromTclObj(interp, objv[1], &p) ) {
  1870. return TCL_ERROR;
  1871. }
  1872. comptid=p->id;
  1873. for(pNode=SimNode_Index_First(CurrentSim); pNode; pNode=pNode->pNextAll) {
  1874. if( !pNode->isDetector || pNode->public_compartment != comptid ) continue;
  1875. Tcl_ListObjAppendElement(interp, pResult, Tcl_NewWideIntObj(pNode->id));
  1876. }
  1877. Tcl_SetObjResult(interp, pResult);
  1878. return TCL_OK;
  1879. }
  1880.  
  1881. static int Compartment_method_list_eqpt (
  1882. ClientData *simulator,
  1883. Tcl_Interp *interp,
  1884. int objc,
  1885. Tcl_Obj *CONST objv[]
  1886. ) {
  1887.  
  1888. CurrentSim=(Simulator *)simulator;
  1889.  
  1890. local_interp=interp;
  1891. int exception=0;
  1892. Roid comptid;
  1893. Compartment *p;
  1894. SimNode *pNode;
  1895.  
  1896. Tcl_Obj *pResult=Tcl_NewObj();
  1897. if( objc!=2 && objc!=3 ){
  1898. Tcl_WrongNumArgs(interp, 1, objv, "COMPTID ?only_exceptional?");
  1899. return TCL_ERROR;
  1900. }
  1901. if( Compartment_FromTclObj(interp, objv[1], &p) ) {
  1902. return TCL_ERROR;
  1903. }
  1904. comptid=p->id;
  1905. if(objc==3) {
  1906. if( Tcl_GetIntFromObj(interp, objv[1], &exception) ) return TCL_ERROR;
  1907. }
  1908. for(pNode=SimNode_Index_First(CurrentSim); pNode; pNode=pNode->pNextAll) {
  1909. if( pNode->public_compartment != comptid ) continue;
  1910. if( exception && !pNode->public_has_exception ) continue;
  1911. Tcl_ListObjAppendElement(interp, pResult, Tcl_NewWideIntObj(pNode->id));
  1912. }
  1913. Tcl_SetObjResult(interp, pResult);
  1914. return TCL_OK;
  1915. }
  1916.  
  1917. static int Compartment_method_list_exception (
  1918. ClientData *simulator,
  1919. Tcl_Interp *interp,
  1920. int objc,
  1921. Tcl_Obj *CONST objv[]
  1922. ) {
  1923.  
  1924. CurrentSim=(Simulator *)simulator;
  1925.  
  1926. local_interp=interp;
  1927. Tcl_HashSearch searchPtr;
  1928. Tcl_HashEntry *i;
  1929. Tcl_Obj *pResult=Tcl_NewObj();
  1930.  
  1931. for(i=Compartment_First(CurrentSim,&searchPtr); i ; i = Tcl_NextHashEntry(&searchPtr)) {
  1932. Compartment *p = (Compartment*)Tcl_GetHashValue(i);
  1933. if(p->public_has_exception || p->public_accessible!=p->delta->public_accessible) {
  1934. Tcl_ListObjAppendElement(interp, pResult, Compartment_Identify(p));
  1935. }
  1936. }
  1937. Tcl_SetObjResult(interp, pResult);
  1938. return TCL_OK;
  1939. }
  1940.  
  1941. static int Compartment_method_list_portal (
  1942. ClientData *simulator,
  1943. Tcl_Interp *interp,
  1944. int objc,
  1945. Tcl_Obj *CONST objv[]
  1946. ) {
  1947.  
  1948. CurrentSim=(Simulator *)simulator;
  1949.  
  1950. local_interp=interp;
  1951. Compartment *pCompt,*pComptTo=NULL;
  1952. int from, to=0;
  1953. Tcl_Obj *pResult=Tcl_NewObj();
  1954. Tcl_HashSearch searchPtr;
  1955. Tcl_HashEntry *i;
  1956.  
  1957. if( objc !=2 && objc !=3 ){
  1958. Tcl_WrongNumArgs(interp, 1, objv, "CID ?CID2?");
  1959. return TCL_ERROR;
  1960. }
  1961. if( Compartment_FromTclObj(interp, objv[1], &pCompt) ) return TCL_ERROR;
  1962. from=pCompt->id;
  1963. if( objc==3 ) {
  1964. if( Compartment_FromTclObj(interp, objv[2], &pComptTo) ) return TCL_ERROR;
  1965. to=pComptTo->id;
  1966. }
  1967.  
  1968. for(i=Portal_First(CurrentSim,&searchPtr); i ; i = Tcl_NextHashEntry(&searchPtr)) {
  1969. Portal *p = (Portal*)Tcl_GetHashValue(i);
  1970. if(p->public_fromid==p->public_toid) continue;
  1971. if( p->public_fromid!=from && p->public_toid!=from ) continue;
  1972. if(objc==3) {
  1973. if( p->public_fromid!=to && p->public_toid!=to ) continue;
  1974. Tcl_ListObjAppendElement(interp, pResult, Portal_Identify(p));
  1975. } else {
  1976. Tcl_ListObjAppendElement(interp, pResult, Portal_Identify(p));
  1977. if(p->public_fromid==from) {
  1978. Tcl_ListObjAppendElement(interp, pResult, Tcl_NewIntObj(p->public_toid));
  1979. } else {
  1980. Tcl_ListObjAppendElement(interp, pResult, Tcl_NewIntObj(p->public_fromid));
  1981. }
  1982. }
  1983. }
  1984. Tcl_SetObjResult(interp, pResult);
  1985. return TCL_OK;
  1986. }
  1987.  
  1988. static int Compartment_method_list_sorted (
  1989. ClientData *simulator,
  1990. Tcl_Interp *interp,
  1991. int objc,
  1992. Tcl_Obj *CONST objv[]
  1993. ) {
  1994.  
  1995. CurrentSim=(Simulator *)simulator;
  1996.  
  1997. local_interp=interp;
  1998. Tcl_Obj *pResult = Tcl_NewObj();
  1999. Compartment *p;
  2000.  
  2001. if(!CurrentSim->Compartment_IndexAll) {
  2002. Compartment_Index_Rebuild(CurrentSim);
  2003. }
  2004. for(p=CurrentSim->Compartment_IndexAll;p;p=p->pNextAll) {
  2005. Tcl_ListObjAppendElement(interp, pResult, Compartment_Identify(p));
  2006. }
  2007. Tcl_SetObjResult(interp, pResult);
  2008. return TCL_OK;
  2009.  
  2010. }
  2011.  
  2012. static int Compartment_method_list_weather (
  2013. ClientData *simulator,
  2014. Tcl_Interp *interp,
  2015. int objc,
  2016. Tcl_Obj *CONST objv[]
  2017. ) {
  2018.  
  2019. CurrentSim=(Simulator *)simulator;
  2020.  
  2021. local_interp=interp;
  2022. Tcl_HashSearch searchPtr;
  2023. Tcl_HashEntry *i;
  2024. Tcl_Obj *pResult=Tcl_NewObj();
  2025.  
  2026. for(i=Compartment_First(CurrentSim,&searchPtr); i ; i = Tcl_NextHashEntry(&searchPtr)) {
  2027. Compartment *p = (Compartment*)Tcl_GetHashValue(i);
  2028. if(p->public_is_weather) {
  2029. Tcl_ListObjAppendElement(interp, pResult, Compartment_Identify(p));
  2030. }
  2031. }
  2032. Tcl_SetObjResult(interp, pResult);
  2033. return TCL_OK;
  2034. }
  2035.  
  2036. static int Compartment_method_nodedelta (
  2037. ClientData *simulator,
  2038. Tcl_Interp *interp,
  2039. int objc,
  2040. Tcl_Obj *CONST objv[]
  2041. ) {
  2042.  
  2043. CurrentSim=(Simulator *)simulator;
  2044.  
  2045. local_interp=interp;
  2046. Compartment *p;
  2047. Tcl_Obj *pResult;
  2048. int i;
  2049. int embargo=(CurrentSim->SimCurrentTime % 10);
  2050.  
  2051. if( objc!=2 && objc!=3 ){
  2052. Tcl_WrongNumArgs(interp, 1, objv, "ID ?field?");
  2053. return TCL_ERROR;
  2054. }
  2055. if( Compartment_FromTclObj(interp, objv[1], &p) ) return TCL_ERROR;
  2056. if(objc==3) {
  2057. /* Test if a specific field has changed */
  2058. int offset=-1,err,type;
  2059. int changevalue=0;
  2060. err=Compartment_StructValueOffset(interp, objv[2], &offset,&type);
  2061. if(err == TCL_OK ) {
  2062. if(Compartment_StructChanged(p,offset,embargo,0)) {
  2063. changevalue=1;
  2064. }
  2065. }
  2066. pResult=Tcl_NewBooleanObj(changevalue);
  2067. } else {
  2068. pResult=Tcl_NewDictObj();
  2069. for(i=0;i<CSTRUCT_COMPARTMENT_Count;i++) {
  2070. if(!Compartment_StructChanged(p,i,embargo,0)) continue;
  2071. Tcl_Obj *newElement=Compartment_StructGet(p,i);
  2072. Irm_DictObjPut(interp,pResult,Compartment_paramNameMap[i].zName,newElement);
  2073. }
  2074. }
  2075. Tcl_SetObjResult(interp, pResult);
  2076. return TCL_OK;
  2077. }
  2078.  
  2079. static int Compartment_method_nodeget (
  2080. ClientData *simulator,
  2081. Tcl_Interp *interp,
  2082. int objc,
  2083. Tcl_Obj *CONST objv[]
  2084. ) {
  2085.  
  2086. CurrentSim=(Simulator *)simulator;
  2087.  
  2088. local_interp=interp;
  2089. Compartment *p;
  2090. if( objc!=2 && objc != 3){
  2091. Tcl_WrongNumArgs(interp, 1, objv, "ID ?field?");
  2092. return TCL_ERROR;
  2093. }
  2094. if( Compartment_FromTclObj(interp, objv[1], &p) ) return TCL_ERROR;
  2095.  
  2096. if(objc==3) {
  2097. Tcl_Obj *result;
  2098. int offset=-1,err,type;
  2099. err=Compartment_StructValueOffset(interp, objv[2], &offset,&type);
  2100. if(err == TCL_OK ) {
  2101. result=Compartment_StructGet(p,offset);
  2102. Tcl_SetObjResult(interp,result);
  2103. return TCL_OK;
  2104. }
  2105. /* Pull the value from extended dict */
  2106. result=Compartment_StructDictGet(p,objv[2],IRM_NULL_EMPTY);
  2107. Tcl_SetObjResult(interp,result);
  2108. } else {
  2109. Tcl_SetObjResult(interp,Compartment_StructToDict(interp,p,1));
  2110. }
  2111. return TCL_OK;
  2112. }
  2113.  
  2114. static int Compartment_method_nodeprior (
  2115. ClientData *simulator,
  2116. Tcl_Interp *interp,
  2117. int objc,
  2118. Tcl_Obj *CONST objv[]
  2119. ) {
  2120.  
  2121. CurrentSim=(Simulator *)simulator;
  2122.  
  2123. local_interp=interp;
  2124. Compartment *p;
  2125. Tcl_Obj *pResult;
  2126. int i;
  2127.  
  2128. if( objc!=2 && objc!=3 ){
  2129. Tcl_WrongNumArgs(interp, 1, objv, "ID ?field?");
  2130. return TCL_ERROR;
  2131. }
  2132. if( Compartment_FromTclObj(interp, objv[1], &p) ) return TCL_ERROR;
  2133.  
  2134. if(objc==3) {
  2135. /* Test if a specific field has changed */
  2136. int offset=-1,err,type;
  2137. err=Compartment_StructValueOffset(interp, objv[2], &offset,&type);
  2138. if(err == TCL_OK ) {
  2139. pResult=Compartment_StructGet(p,offset);
  2140. } else {
  2141. pResult=Tcl_NewObj();
  2142. }
  2143. } else {
  2144. pResult=Tcl_NewDictObj();
  2145. for(i=0;i<CSTRUCT_COMPARTMENT_Count;i++) {
  2146. Tcl_Obj *newElement=Compartment_StructGet(p,i);
  2147. Irm_DictObjPut(interp,pResult,Compartment_paramNameMap[i].zName,newElement);
  2148. }
  2149. }
  2150. Tcl_SetObjResult(interp, pResult);
  2151. return TCL_OK;
  2152.  
  2153. }
  2154.  
  2155. static int Compartment_method_nodeput (
  2156. ClientData *simulator,
  2157. Tcl_Interp *interp,
  2158. int objc,
  2159. Tcl_Obj *CONST objv[]
  2160. ) {
  2161.  
  2162. CurrentSim=(Simulator *)simulator;
  2163.  
  2164. local_interp=interp;
  2165. Compartment *p;
  2166. Tcl_DictSearch search;
  2167. Tcl_Obj *key, *value, *objPtr;
  2168. int done;
  2169. int offset,type,err=TCL_OK;
  2170.  
  2171. if( objc!=3 ){
  2172. Tcl_WrongNumArgs(interp, 1, objv, "ID infoDict");
  2173. return TCL_ERROR;
  2174. }
  2175.  
  2176. if( Compartment_FromTclObj(interp, objv[1], &p) ) return TCL_ERROR;
  2177. objPtr=objv[2];
  2178. if (Tcl_DictObjFirst(interp, objPtr, &search,
  2179. &key, &value, &done) != TCL_OK) {
  2180. return TCL_ERROR;
  2181. }
  2182. for (; !done ; Tcl_DictObjNext(&search, &key, &value, &done)) {
  2183. if( Compartment_StructValueOffset(interp, key, &offset, &type) == TCL_OK ) {
  2184. err=Compartment_StructSet(interp,p,offset,value);
  2185. if(err != TCL_OK) {
  2186. break;
  2187. }
  2188. } else {
  2189. Compartment_SpecDictPut(p,key,value);
  2190. Tcl_SetObjResult(interp, value);
  2191. }
  2192. }
  2193. Tcl_DictObjDone(&search);
  2194. if(err==TCL_OK) {
  2195. Compartment_ApplySettings(p);
  2196. }
  2197. return err;
  2198. }
  2199.  
  2200. static int Compartment_method_nodewith (
  2201. ClientData *simulator,
  2202. Tcl_Interp *interp,
  2203. int objc,
  2204. Tcl_Obj *CONST objv[]
  2205. ) {
  2206.  
  2207. CurrentSim=(Simulator *)simulator;
  2208.  
  2209. local_interp=interp;
  2210. Compartment *p;
  2211. if( objc != 3){
  2212. Tcl_WrongNumArgs(interp, 1, objv, "ID body");
  2213. return TCL_ERROR;
  2214. }
  2215. if( Compartment_FromTclObj(interp, objv[1], &p) ) return TCL_ERROR;
  2216. return Compartment_nodeeval(interp,p,objv[2],1);
  2217. }
  2218.  
  2219. static int Compartment_method_passage (
  2220. ClientData *simulator,
  2221. Tcl_Interp *interp,
  2222. int objc,
  2223. Tcl_Obj *CONST objv[]
  2224. ) {
  2225.  
  2226. CurrentSim=(Simulator *)simulator;
  2227.  
  2228. local_interp=interp;
  2229. Compartment *p;
  2230. if( objc!=2 ) {
  2231. Tcl_WrongNumArgs(interp, 1, objv, "ID");
  2232. return TCL_ERROR;
  2233. }
  2234. if( Compartment_FromTclObj(interp, objv[1], &p) ) {
  2235. /* Treat non-existent comptid as a non passage */
  2236. Tcl_ResetResult(interp);
  2237. Tcl_SetObjResult(interp, Tcl_NewBooleanObj(0));
  2238. return TCL_OK;
  2239. }
  2240. if(p->public_is_weather) {
  2241. Tcl_SetObjResult(interp, Tcl_NewBooleanObj(0));
  2242. } else {
  2243. Tcl_SetObjResult(interp, Tcl_NewBooleanObj(p->public_is_passage));
  2244. }
  2245. return TCL_OK;
  2246. }
  2247.  
  2248. static int Compartment_method_redraw (
  2249. ClientData *simulator,
  2250. Tcl_Interp *interp,
  2251. int objc,
  2252. Tcl_Obj *CONST objv[]
  2253. ) {
  2254.  
  2255. CurrentSim=(Simulator *)simulator;
  2256.  
  2257. local_interp=interp;
  2258. Compartment *p;
  2259. if( objc!=2 ) {
  2260. Tcl_WrongNumArgs(interp, 1, objv, "ID");
  2261. return TCL_ERROR;
  2262. }
  2263. if( Compartment_FromTclObj(interp, objv[1], &p) ) return TCL_ERROR;
  2264. Tcl_SetObjResult(interp, Tcl_NewBooleanObj(p->redraw));
  2265. p->redraw=0;
  2266. return TCL_OK;
  2267. }
  2268.  
  2269. static int Compartment_method_repair (
  2270. ClientData *simulator,
  2271. Tcl_Interp *interp,
  2272. int objc,
  2273. Tcl_Obj *CONST objv[]
  2274. ) {
  2275.  
  2276. CurrentSim=(Simulator *)simulator;
  2277.  
  2278. local_interp=interp;
  2279. Compartment *p;
  2280.  
  2281. if( objc != 2 ){
  2282. Tcl_WrongNumArgs(interp, 1, objv, "ID");
  2283. return TCL_ERROR;
  2284. }
  2285. if( Compartment_FromTclObj(interp, objv[1], &p) ) return TCL_ERROR;
  2286. Compartment_Repair(p,1);
  2287. return TCL_OK;
  2288. }
  2289.  
  2290. static int Compartment_method_reset (
  2291. ClientData *simulator,
  2292. Tcl_Interp *interp,
  2293. int objc,
  2294. Tcl_Obj *CONST objv[]
  2295. ) {
  2296.  
  2297. CurrentSim=(Simulator *)simulator;
  2298.  
  2299. local_interp=interp;
  2300. Compartment_Module_Free(CurrentSim);
  2301. Compartment_Module_Init(CurrentSim);
  2302. Tcl_ResetResult(interp);
  2303. return TCL_OK;
  2304. }
  2305.  
  2306. static int Compartment_method_setting (
  2307. ClientData *simulator,
  2308. Tcl_Interp *interp,
  2309. int objc,
  2310. Tcl_Obj *CONST objv[]
  2311. ) {
  2312.  
  2313. CurrentSim=(Simulator *)simulator;
  2314.  
  2315. local_interp=interp;
  2316. int offset,type,rcode;
  2317. /* If given a new value, act like a stylized set */
  2318. Compartment *p;
  2319.  
  2320. if( objc!=3 && objc!=4 ){
  2321. Tcl_WrongNumArgs(interp, 1, objv, "ID FIELD ?VALUE?");
  2322. return TCL_ERROR;
  2323. }
  2324. if( Compartment_FromTclObj(interp, objv[1], &p) ) return TCL_ERROR;
  2325.  
  2326. if(objc == 4) {
  2327. if( Compartment_StructValueOffset(interp, objv[2], &offset, &type) != TCL_OK ) {
  2328. return TCL_ERROR;
  2329. }
  2330. rcode=Compartment_StructSet(interp,p,offset,objv[3]);
  2331. if(rcode==TCL_OK) {
  2332. Compartment_ApplySettings(p);
  2333. }
  2334. return rcode;
  2335. } else {
  2336. Tcl_Obj *result;
  2337. int offset=-1,err,type;
  2338. err=Compartment_StructValueOffset(interp, objv[2], &offset,&type);
  2339. if(err == TCL_OK ) {
  2340. result=Compartment_StructGet(p,offset);
  2341. Tcl_SetObjResult(interp,result);
  2342. return TCL_OK;
  2343. }
  2344. /* Pull the value from extended dict */
  2345. result=Compartment_StructDictGet(p,objv[2],IRM_NULL_ZERO);
  2346. Tcl_SetObjResult(interp,result);
  2347. return TCL_OK;
  2348. }
  2349. }
  2350.  
  2351. static int Compartment_method_spec_get (
  2352. ClientData *simulator,
  2353. Tcl_Interp *interp,
  2354. int objc,
  2355. Tcl_Obj *CONST objv[]
  2356. ) {
  2357.  
  2358. CurrentSim=(Simulator *)simulator;
  2359.  
  2360. local_interp=interp;
  2361. Compartment *p;
  2362. Tcl_Obj *pResult=NULL;
  2363. if( objc!=2 && objc != 3){
  2364. Tcl_WrongNumArgs(interp, 1, objv, "ID ?field?");
  2365. return TCL_ERROR;
  2366. }
  2367. if( Compartment_FromTclObj(interp, objv[1], &p) ) return TCL_ERROR;
  2368.  
  2369. if(objc==3) {
  2370. /* Pull the value from extended dict */
  2371. pResult=Compartment_StructDictGet(p,objv[2],IRM_NULL_EMPTY);
  2372. } else {
  2373. pResult=Entity_GetDict(p->pType,NULL);
  2374. }
  2375. if(pResult) {
  2376. Tcl_SetObjResult(interp,pResult);
  2377. }
  2378. return TCL_OK;
  2379. }
  2380.  
  2381. static int Compartment_method_spec_put (
  2382. ClientData *simulator,
  2383. Tcl_Interp *interp,
  2384. int objc,
  2385. Tcl_Obj *CONST objv[]
  2386. ) {
  2387.  
  2388. CurrentSim=(Simulator *)simulator;
  2389.  
  2390. local_interp=interp;
  2391. Compartment *p;
  2392. Tcl_DictSearch search;
  2393. Tcl_Obj *key, *value, *objPtr;
  2394. int done;
  2395.  
  2396. if( objc!=3 ){
  2397. Tcl_WrongNumArgs(interp, 1, objv, "ID infoDict");
  2398. return TCL_ERROR;
  2399. }
  2400.  
  2401. if( Compartment_FromTclObj(interp, objv[1], &p) ) return TCL_ERROR;
  2402. objPtr=objv[2];
  2403. if (Tcl_DictObjFirst(interp, objPtr, &search,
  2404. &key, &value, &done) != TCL_OK) {
  2405. return TCL_ERROR;
  2406. }
  2407. for (; !done ; Tcl_DictObjNext(&search, &key, &value, &done)) {
  2408. Compartment_SpecDictPut(p,key,value);
  2409. Tcl_SetObjResult(interp, value);
  2410. }
  2411. Tcl_DictObjDone(&search);
  2412. return TCL_OK;
  2413. }
  2414.  
  2415. static int Compartment_method_spec_replace (
  2416. ClientData *simulator,
  2417. Tcl_Interp *interp,
  2418. int objc,
  2419. Tcl_Obj *CONST objv[]
  2420. ) {
  2421.  
  2422. CurrentSim=(Simulator *)simulator;
  2423.  
  2424. local_interp=interp;
  2425. Compartment *p;
  2426. Tcl_DictSearch search;
  2427. Tcl_Obj *key, *value, *objPtr;
  2428. int done;
  2429.  
  2430. if( objc!=3 ){
  2431. Tcl_WrongNumArgs(interp, 1, objv, "ID infoDict");
  2432. return TCL_ERROR;
  2433. }
  2434.  
  2435. if( Compartment_FromTclObj(interp, objv[1], &p) ) return TCL_ERROR;
  2436. objPtr=objv[2];
  2437. if (Tcl_DictObjFirst(interp, objPtr, &search,
  2438. &key, &value, &done) != TCL_OK) {
  2439. return TCL_ERROR;
  2440. }
  2441. for (; !done ; Tcl_DictObjNext(&search, &key, &value, &done)) {
  2442. Compartment_SpecDictPut(p,key,value);
  2443. Tcl_SetObjResult(interp, value);
  2444. }
  2445. Tcl_DictObjDone(&search);
  2446. return TCL_OK;
  2447. }
  2448.  
  2449. static int Compartment_method_step (
  2450. ClientData *simulator,
  2451. Tcl_Interp *interp,
  2452. int objc,
  2453. Tcl_Obj *CONST objv[]
  2454. ) {
  2455.  
  2456. CurrentSim=(Simulator *)simulator;
  2457.  
  2458. local_interp=interp;
  2459. Tcl_Obj *pResult = Tcl_NewObj();
  2460. Tcl_HashSearch searchPtr;
  2461. Tcl_HashEntry *i;
  2462.  
  2463. for(i=Compartment_First(CurrentSim,&searchPtr); i ; i = Tcl_NextHashEntry(&searchPtr)) {
  2464. Compartment *p = (Compartment*)Tcl_GetHashValue(i);
  2465. double tempC;
  2466. int ki;
  2467.  
  2468. Compartment_ApplySettings(p);
  2469. if(p->public_is_weather) continue;
  2470. //if(!p->public_has_exception) continue;
  2471.  
  2472. /*
  2473. ** The compartment stores temperature in K
  2474. ** convert to C
  2475. */
  2476. tempC=p->public_temperature-273.15;
  2477.  
  2478. if(CurrentSim->public_fire_damage_conduit && p->kidlist) {
  2479. for(ki=1;ki <= p->kidlist[0];ki++) {
  2480. if(SimLink_CalculateThermalEndurance((Roid)p->kidlist[ki],tempC,p->public_fire_size)) {
  2481. Tcl_ListObjAppendList(interp,pResult,Irm_NewStringObj("conduit_rupture"));
  2482. Tcl_ListObjAppendList(interp,pResult,Tcl_NewIntObj((int)p->id));
  2483. Tcl_ListObjAppendList(interp,pResult,Tcl_NewIntObj(p->kidlist[ki]));
  2484. }
  2485. }
  2486. }
  2487. /*
  2488. ** Notify equipment of the cabin temperature
  2489. ** in the surrounding compartment
  2490. */
  2491. SimNode *pNode;
  2492. Roid comptid=p->id;
  2493.  
  2494. for(pNode=SimNode_Index_First(CurrentSim); pNode; pNode=pNode->pNextAll) {
  2495. if( pNode->public_compartment==0 || pNode->public_compartment!=comptid ) {
  2496. continue;
  2497. }
  2498. /*
  2499. ** Kick off the coil calculations
  2500. */
  2501. SimNode_ComputeThermalEndurance(pNode,tempC,p->public_fire_size,p->public_cvis);
  2502. }
  2503. }
  2504. Tcl_SetObjResult(interp, pResult);
  2505. return TCL_OK;
  2506. }
  2507.  
  2508. static int Compartment_method_struct_get (
  2509. ClientData *simulator,
  2510. Tcl_Interp *interp,
  2511. int objc,
  2512. Tcl_Obj *CONST objv[]
  2513. ) {
  2514.  
  2515. CurrentSim=(Simulator *)simulator;
  2516.  
  2517. local_interp=interp;
  2518. Compartment *p;
  2519. if( objc!=2 && objc != 3){
  2520. Tcl_WrongNumArgs(interp, 1, objv, "ID ?field?");
  2521. return TCL_ERROR;
  2522. }
  2523. if( Compartment_FromTclObj(interp, objv[1], &p) ) return TCL_ERROR;
  2524.  
  2525. if(objc==3) {
  2526. Tcl_Obj *result;
  2527. int offset=-1,err,type;
  2528. err=Compartment_StructValueOffset(interp, objv[2], &offset,&type);
  2529. if(err == TCL_OK ) {
  2530. result=Compartment_StructGet(p,offset);
  2531. Tcl_SetObjResult(interp,result);
  2532. return TCL_OK;
  2533. }
  2534. return TCL_ERROR;
  2535. } else {
  2536. Tcl_SetObjResult(interp,Compartment_StructToDict(interp,p,0));
  2537. }
  2538. return TCL_OK;
  2539. }
  2540.  
  2541. static int Compartment_method_struct_put (
  2542. ClientData *simulator,
  2543. Tcl_Interp *interp,
  2544. int objc,
  2545. Tcl_Obj *CONST objv[]
  2546. ) {
  2547.  
  2548. CurrentSim=(Simulator *)simulator;
  2549.  
  2550. local_interp=interp;
  2551. Compartment *p;
  2552. Tcl_DictSearch search;
  2553. int done;
  2554. int offset,type,err=TCL_OK;
  2555.  
  2556. if( objc!=3 && objc!=4 ){
  2557. Tcl_WrongNumArgs(interp, 1, objv, "ID infoDict");
  2558. return TCL_ERROR;
  2559. }
  2560.  
  2561. if( Compartment_FromTclObj(interp, objv[1], &p) ) return TCL_ERROR;
  2562. if(objc==4) {
  2563. if( Compartment_StructValueOffset(interp, objv[2], &offset, &type) == TCL_OK ) {
  2564. err=Compartment_StructSet(interp,p,offset,objv[3]);
  2565. if(err != TCL_OK) {
  2566. return TCL_ERROR;
  2567. }
  2568. } else {
  2569. return TCL_ERROR;
  2570. }
  2571. } else {
  2572. Tcl_Obj *key, *value;
  2573. Tcl_Obj *objPtr=objv[2];
  2574. if (Tcl_DictObjFirst(interp, objPtr, &search,
  2575. &key, &value, &done) != TCL_OK) {
  2576. return TCL_ERROR;
  2577. }
  2578. for (; !done ; Tcl_DictObjNext(&search, &key, &value, &done)) {
  2579. if( Compartment_StructValueOffset(interp, key, &offset, &type) == TCL_OK ) {
  2580. err=Compartment_StructSet(interp,p,offset,value);
  2581. if(err != TCL_OK) {
  2582. break;
  2583. }
  2584. } else {
  2585. return TCL_ERROR;
  2586. }
  2587. }
  2588. Tcl_DictObjDone(&search);
  2589. }
  2590. if(err==TCL_OK) {
  2591. Compartment_ApplySettings(p);
  2592. }
  2593. return err;
  2594. }
  2595.  
  2596. static int Compartment_method_suppressors (
  2597. ClientData *simulator,
  2598. Tcl_Interp *interp,
  2599. int objc,
  2600. Tcl_Obj *CONST objv[]
  2601. ) {
  2602.  
  2603. CurrentSim=(Simulator *)simulator;
  2604.  
  2605. local_interp=interp;
  2606. Roid comptid=0;
  2607. SimNode *pNode;
  2608.  
  2609. Tcl_Obj *pResult=Tcl_NewObj();
  2610. if( objc!=1 && objc!=2 ){
  2611. Tcl_WrongNumArgs(interp, 1, objv, "COMPTID");
  2612. return TCL_ERROR;
  2613. }
  2614. if(objc==2) {
  2615. if( Tcl_GetIntFromObj(interp, objv[1], &comptid) ) return TCL_ERROR;
  2616. }
  2617. for(pNode=SimNode_Index_First(CurrentSim); pNode; pNode=pNode->pNextAll) {
  2618. int stype=TypeSpec_GetInt(pNode->pType,SPEC_SUPPRESSOR_STYPE);
  2619. int lastop=0,op=0;
  2620. if (stype==9||stype==8) {
  2621. stype=10;
  2622. }
  2623. if( !pNode->isSuppressor ) continue;
  2624. if(objc==2) {
  2625. if(pNode->public_compartment != comptid ) continue;
  2626. Tcl_ListObjAppendElement(interp, pResult, Tcl_NewWideIntObj(pNode->id));
  2627. } else {
  2628. Tcl_ListObjAppendElement(interp, pResult, Tcl_NewWideIntObj(pNode->id));
  2629. Tcl_ListObjAppendElement(interp, pResult, Tcl_NewWideIntObj(pNode->public_compartment));
  2630. }
  2631. Tcl_ListObjAppendElement(interp, pResult, Tcl_NewIntObj(stype));
  2632. if((pNode->delta->public_operational==1) && (pNode->delta->public_onoff == 1)) {
  2633. lastop=1;
  2634. }
  2635. if((pNode->public_operational==1) && (pNode->public_onoff == 1)) {
  2636. op=1;
  2637. }
  2638. Tcl_ListObjAppendElement(interp, pResult, Tcl_NewBooleanObj(op==lastop));
  2639. Tcl_ListObjAppendElement(interp, pResult, Tcl_NewBooleanObj(op));
  2640. }
  2641. Tcl_SetObjResult(interp, pResult);
  2642. return TCL_OK;
  2643. }
  2644.  
  2645. static int Compartment_method_type (
  2646. ClientData *simulator,
  2647. Tcl_Interp *interp,
  2648. int objc,
  2649. Tcl_Obj *CONST objv[]
  2650. ) {
  2651.  
  2652. CurrentSim=(Simulator *)simulator;
  2653.  
  2654. local_interp=interp;
  2655. Compartment *p;
  2656. Entity *pType;
  2657. if( objc != 2 && objc != 3 ){
  2658. Tcl_WrongNumArgs(interp, 1, objv, "NODEID field");
  2659. return TCL_ERROR;
  2660. }
  2661. if( Compartment_FromTclObj(interp, objv[1], &p) ) return TCL_ERROR;
  2662. pType=Compartment_StructGetType(p);
  2663. if(!pType) {
  2664. if(objc==2) {
  2665. Tcl_SetObjResult(interp, Tcl_NewBooleanObj(0));
  2666. }
  2667. return TCL_OK;
  2668. }
  2669. if(objc==2) {
  2670. Tcl_SetObjResult(interp, SimType_Identify(pType));
  2671. }
  2672. if(objc==3) {
  2673. Tcl_Obj *pResult;
  2674. pResult=Entity_ExportField(pType,NULL,Tcl_GetString(objv[2]),IRM_NULL_EMPTY);
  2675. Tcl_SetObjResult(interp,pResult);
  2676. }
  2677. return TCL_OK;
  2678. }
  2679.  
  2680. static int Compartment_method_typeid (
  2681. ClientData *simulator,
  2682. Tcl_Interp *interp,
  2683. int objc,
  2684. Tcl_Obj *CONST objv[]
  2685. ) {
  2686.  
  2687. CurrentSim=(Simulator *)simulator;
  2688.  
  2689. local_interp=interp;
  2690. Compartment *p;
  2691. Entity *pType;
  2692. if( objc!=2 && objc != 3 ){
  2693. Tcl_WrongNumArgs(interp, 1, objv, "ID ?typeid?");
  2694. return TCL_ERROR;
  2695. }
  2696. if( Compartment_FromTclObj(interp, objv[1], &p) ) return TCL_ERROR;
  2697. if(objc==3) {
  2698. if( SimType_FromTclObj(interp, objv[2], &pType) ) {
  2699. /* Translate a ZERO length list to null */
  2700. int len;
  2701. if(Tcl_ListObjLength(NULL,objv[2],&len)) {
  2702. return TCL_ERROR;
  2703. }
  2704. if(len) {
  2705. int intval;
  2706. if(Tcl_GetIntFromObj(NULL,objv[2],&intval)==TCL_ERROR) {
  2707. return TCL_ERROR;
  2708. }
  2709. if(intval>0) {
  2710. return TCL_ERROR;
  2711. }
  2712. }
  2713. Tcl_ResetResult(interp);
  2714. pType=NULL;
  2715. }
  2716. Compartment_StructSetType(p,pType);
  2717. /* Reset the group pointer so it's recalculated */
  2718. Compartment_StructSetGroup(p,-1);
  2719. }
  2720. pType=Compartment_StructGetType(p);
  2721. if(pType) {
  2722. Tcl_SetObjResult(interp, SimType_Identify(pType));
  2723. } else {
  2724. Tcl_SetObjResult(interp, Tcl_NewBooleanObj(0));
  2725. }
  2726. return TCL_OK;
  2727. }
  2728.  
  2729. static int Compartment_method_weather (
  2730. ClientData *simulator,
  2731. Tcl_Interp *interp,
  2732. int objc,
  2733. Tcl_Obj *CONST objv[]
  2734. ) {
  2735.  
  2736. CurrentSim=(Simulator *)simulator;
  2737.  
  2738. local_interp=interp;
  2739. Compartment *p;
  2740. if( objc!=2 ) {
  2741. Tcl_WrongNumArgs(interp, 1, objv, "ID");
  2742. return TCL_ERROR;
  2743. }
  2744. if( Compartment_FromTclObj(interp, objv[1], &p) ) {
  2745. /* Treat non-existent comptid as weather */
  2746. Tcl_ResetResult(interp);
  2747. Tcl_SetObjResult(interp, Tcl_NewBooleanObj(1));
  2748. return TCL_OK;
  2749. }
  2750. Tcl_SetObjResult(interp, Tcl_NewBooleanObj(p->public_is_weather));
  2751. return TCL_OK;
  2752. }
  2753.  
  2754. static int Compartment_method_witheach (
  2755. ClientData *simulator,
  2756. Tcl_Interp *interp,
  2757. int objc,
  2758. Tcl_Obj *CONST objv[]
  2759. ) {
  2760.  
  2761. CurrentSim=(Simulator *)simulator;
  2762.  
  2763. local_interp=interp;
  2764. Tcl_HashSearch *searchPtr;
  2765. Tcl_HashEntry *i;
  2766. int searchresult=TCL_OK;
  2767. Tcl_Obj *body;
  2768.  
  2769. if( objc != 2){
  2770. Tcl_WrongNumArgs(interp, 1, objv, "body");
  2771. return TCL_ERROR;
  2772. }
  2773. body=objv[1];
  2774. searchPtr=(Tcl_HashSearch *)local_Alloc(sizeof(Tcl_HashSearch));
  2775. for(i=Compartment_First(CurrentSim,searchPtr); i ; i = Tcl_NextHashEntry(searchPtr)) {
  2776. Compartment *p = (Compartment *)Tcl_GetHashValue(i);
  2777. searchresult=Compartment_nodeeval(interp,p,body,1);
  2778. if (searchresult !=TCL_OK && searchresult!=TCL_CONTINUE) {
  2779. Tcl_Free((char *)searchPtr);
  2780. return searchresult;
  2781. }
  2782. }
  2783. Tcl_Free((char *)searchPtr);
  2784. return TCL_OK;
  2785. }
  2786.  
  2787. int compartment_Ensemble(Tcl_Interp *interp,Simulator *simPtr,Tcl_Namespace *nsPtr) {
  2788.  
  2789. char zAppend[256];
  2790. char yAppend[256];
  2791. Tcl_Namespace *modPtr;
  2792.  
  2793.  
  2794. /*
  2795. ** Implement compartment
  2796. */
  2797.  
  2798.  
  2799. modPtr=Tcl_FindNamespace(interp,"compartment",nsPtr,TCL_NAMESPACE_ONLY);
  2800. if(!modPtr) {
  2801. strcpy(zAppend,nsPtr->fullName);
  2802. strcat(zAppend,"::compartment");
  2803. modPtr = Tcl_CreateNamespace(interp, zAppend, NULL, NULL);
  2804. Tcl_CreateEnsemble(interp, modPtr->fullName, modPtr, TCL_ENSEMBLE_PREFIX);
  2805. Tcl_Export(interp, modPtr, "[a-z]*", 1);
  2806. } else {
  2807. strcpy(zAppend,modPtr->fullName);
  2808. }
  2809.  
  2810. strcpy(yAppend,zAppend); strcat(yAppend,"::add");
  2811. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_add,(ClientData)simPtr,NULL);
  2812. strcpy(yAppend,zAppend); strcat(yAppend,"::create");
  2813. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_add,(ClientData)simPtr,NULL);
  2814. strcpy(yAppend,zAppend); strcat(yAppend,"::cid");
  2815. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_cid,(ClientData)simPtr,NULL);
  2816. strcpy(yAppend,zAppend); strcat(yAppend,"::condition");
  2817. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_condition,(ClientData)simPtr,NULL);
  2818. strcpy(yAppend,zAppend); strcat(yAppend,"::count");
  2819. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_count,(ClientData)simPtr,NULL);
  2820. strcpy(yAppend,zAppend); strcat(yAppend,"::exists");
  2821. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_exists,(ClientData)simPtr,NULL);
  2822. strcpy(yAppend,zAppend); strcat(yAppend,"::flooding");
  2823. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_flooding,(ClientData)simPtr,NULL);
  2824. strcpy(yAppend,zAppend); strcat(yAppend,"::for");
  2825. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_for,(ClientData)simPtr,NULL);
  2826. strcpy(yAppend,zAppend); strcat(yAppend,"::foreach");
  2827. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_foreach,(ClientData)simPtr,NULL);
  2828. strcpy(yAppend,zAppend); strcat(yAppend,"::groupid");
  2829. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_groupid,(ClientData)simPtr,NULL);
  2830. strcpy(yAppend,zAppend); strcat(yAppend,"::group");
  2831. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_groupid,(ClientData)simPtr,NULL);
  2832. strcpy(yAppend,zAppend); strcat(yAppend,"::kidlist");
  2833. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_kidlist,(ClientData)simPtr,NULL);
  2834. strcpy(yAppend,zAppend); strcat(yAppend,"::list");
  2835. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_list,(ClientData)simPtr,NULL);
  2836. strcpy(yAppend,zAppend); strcat(yAppend,"::list_changed");
  2837. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_list_changed,(ClientData)simPtr,NULL);
  2838. strcpy(yAppend,zAppend); strcat(yAppend,"::list_crew");
  2839. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_list_crew,(ClientData)simPtr,NULL);
  2840. strcpy(yAppend,zAppend); strcat(yAppend,"::list_detectors");
  2841. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_list_detectors,(ClientData)simPtr,NULL);
  2842. strcpy(yAppend,zAppend); strcat(yAppend,"::list_eqpt");
  2843. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_list_eqpt,(ClientData)simPtr,NULL);
  2844. strcpy(yAppend,zAppend); strcat(yAppend,"::list_exception");
  2845. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_list_exception,(ClientData)simPtr,NULL);
  2846. strcpy(yAppend,zAppend); strcat(yAppend,"::list_portal");
  2847. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_list_portal,(ClientData)simPtr,NULL);
  2848. strcpy(yAppend,zAppend); strcat(yAppend,"::list_sorted");
  2849. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_list_sorted,(ClientData)simPtr,NULL);
  2850. strcpy(yAppend,zAppend); strcat(yAppend,"::list_weather");
  2851. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_list_weather,(ClientData)simPtr,NULL);
  2852. strcpy(yAppend,zAppend); strcat(yAppend,"::nodedelta");
  2853. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_nodedelta,(ClientData)simPtr,NULL);
  2854. strcpy(yAppend,zAppend); strcat(yAppend,"::delta");
  2855. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_nodedelta,(ClientData)simPtr,NULL);
  2856. strcpy(yAppend,zAppend); strcat(yAppend,"::nodeget");
  2857. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_nodeget,(ClientData)simPtr,NULL);
  2858. strcpy(yAppend,zAppend); strcat(yAppend,"::get");
  2859. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_nodeget,(ClientData)simPtr,NULL);
  2860. strcpy(yAppend,zAppend); strcat(yAppend,"::nodeprior");
  2861. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_nodeprior,(ClientData)simPtr,NULL);
  2862. strcpy(yAppend,zAppend); strcat(yAppend,"::nodeput");
  2863. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_nodeput,(ClientData)simPtr,NULL);
  2864. strcpy(yAppend,zAppend); strcat(yAppend,"::put");
  2865. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_nodeput,(ClientData)simPtr,NULL);
  2866. strcpy(yAppend,zAppend); strcat(yAppend,"::nodewith");
  2867. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_nodewith,(ClientData)simPtr,NULL);
  2868. strcpy(yAppend,zAppend); strcat(yAppend,"::with");
  2869. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_nodewith,(ClientData)simPtr,NULL);
  2870. strcpy(yAppend,zAppend); strcat(yAppend,"::passage");
  2871. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_passage,(ClientData)simPtr,NULL);
  2872. strcpy(yAppend,zAppend); strcat(yAppend,"::redraw");
  2873. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_redraw,(ClientData)simPtr,NULL);
  2874. strcpy(yAppend,zAppend); strcat(yAppend,"::repair");
  2875. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_repair,(ClientData)simPtr,NULL);
  2876. strcpy(yAppend,zAppend); strcat(yAppend,"::reset");
  2877. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_reset,(ClientData)simPtr,NULL);
  2878. strcpy(yAppend,zAppend); strcat(yAppend,"::setting");
  2879. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_setting,(ClientData)simPtr,NULL);
  2880. strcpy(yAppend,zAppend); strcat(yAppend,"::spec_get");
  2881. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_spec_get,(ClientData)simPtr,NULL);
  2882. strcpy(yAppend,zAppend); strcat(yAppend,"::spec_put");
  2883. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_spec_put,(ClientData)simPtr,NULL);
  2884. strcpy(yAppend,zAppend); strcat(yAppend,"::spec_replace");
  2885. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_spec_replace,(ClientData)simPtr,NULL);
  2886. strcpy(yAppend,zAppend); strcat(yAppend,"::step");
  2887. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_step,(ClientData)simPtr,NULL);
  2888. strcpy(yAppend,zAppend); strcat(yAppend,"::struct_get");
  2889. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_struct_get,(ClientData)simPtr,NULL);
  2890. strcpy(yAppend,zAppend); strcat(yAppend,"::struct_put");
  2891. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_struct_put,(ClientData)simPtr,NULL);
  2892. strcpy(yAppend,zAppend); strcat(yAppend,"::suppressors");
  2893. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_suppressors,(ClientData)simPtr,NULL);
  2894. strcpy(yAppend,zAppend); strcat(yAppend,"::type");
  2895. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_type,(ClientData)simPtr,NULL);
  2896. strcpy(yAppend,zAppend); strcat(yAppend,"::typeid");
  2897. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_typeid,(ClientData)simPtr,NULL);
  2898. strcpy(yAppend,zAppend); strcat(yAppend,"::weather");
  2899. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_weather,(ClientData)simPtr,NULL);
  2900. strcpy(yAppend,zAppend); strcat(yAppend,"::witheach");
  2901. Tcl_CreateObjCommand(interp,yAppend,(Tcl_ObjCmdProc *)Compartment_method_witheach,(ClientData)simPtr,NULL);
  2902. return TCL_OK;
  2903. }
  2904.