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