Posted to tcl by hypnotoad at Tue Dec 09 22:18:29 GMT 2014view raw

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