home *** CD-ROM | disk | FTP | other *** search
/ PC Format (South-Africa) 2001 June / PCFJune.iso / Xenon / XenonSource.exe / demo2 / scene.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-09-13  |  7.8 KB  |  324 lines
  1. //-------------------------------------------------------------
  2. //
  3. // Class:    CScene
  4. //
  5. // Author:    John M Phillips
  6. //
  7. // Started:    06/05/00
  8. //
  9. // Base:    None
  10. //
  11. // Derived:    None
  12. //
  13. //-------------------------------------------------------------
  14.  
  15. #include "demo2.h"
  16.  
  17. //-------------------------------------------------------------
  18.  
  19. CScene::CScene()
  20. {
  21.     m_frame_count = 0;
  22.     m_checkpoint_active = false;
  23.     m_is_warping = false;
  24. }
  25.  
  26. //-------------------------------------------------------------
  27.  
  28. CScene::~CScene()
  29. {
  30. }
  31.  
  32. //-------------------------------------------------------------
  33.  
  34. gsCTiledImage *CScene::getImage(const char *filename)
  35. {
  36.     if (filename == 0)
  37.         return 0;
  38.  
  39.     for (int i = 0; i < m_image_list.getSize(); i++) {
  40.         if (strcmp(m_image_list[i]->m_filename,filename) == 0)
  41.             return &m_image_list[i]->m_image;
  42.         }
  43.  
  44.     ImageEntry *image_entry = new ImageEntry;
  45.  
  46.     strcpy(image_entry->m_filename,filename);
  47.  
  48.     gsCFile::setDirectory(DIRECTORY_GRAPHICS);
  49.  
  50.     if (image_entry->m_image.load(filename)) {
  51.         m_image_list.addItem(image_entry);
  52.         return &image_entry->m_image;
  53.         }
  54.     else {
  55.         delete image_entry;
  56.         return 0;
  57.         }
  58. }
  59.  
  60. //-------------------------------------------------------------
  61.  
  62. bool CScene::loadImages()
  63. {
  64.     for (int i = 0; i < INFO_TOTAL; i++) {
  65.         gsCTiledImage *image = getImage(ActorInfoList[i].m_filename);
  66.  
  67.         if (image) {
  68.             image->setTileSize(gsCPoint(ActorInfoList[i].m_tile_width,
  69.                                         ActorInfoList[i].m_tile_height));
  70.  
  71.             image->enableColourKey(gsCColour(gsMAGENTA));
  72.             }
  73.         }
  74.  
  75.     return true;
  76. }
  77.  
  78. //-------------------------------------------------------------
  79.  
  80. void CScene::addToCollisionList(CActor *actor,const gsCRect& rect)
  81. {
  82.     switch (actor->getActorInfo().m_type) {
  83.         case ACTOR_TYPE_SHIP:
  84.             if (m_ship_is_cloaked)
  85.                 break;
  86.             m_collision_list.addObject((void *) actor,
  87.                                       rect,
  88.                                       (1 << ACTOR_TYPE_SHIP),
  89.                                       (1 << ACTOR_TYPE_PICKUP) | (1 << ACTOR_TYPE_ALIEN));
  90.             break;
  91.         case ACTOR_TYPE_UPGRADE:
  92.             if (m_ship_is_cloaked)
  93.                 break;
  94.             m_collision_list.addObject((void *) actor,
  95.                                       rect,
  96.                                       (1 << ACTOR_TYPE_UPGRADE),
  97.                                       (1 << ACTOR_TYPE_PICKUP) | (1 << ACTOR_TYPE_ALIEN));
  98.             break;
  99.         case ACTOR_TYPE_BULLET:
  100.             m_collision_list.addObject((void *) actor,
  101.                                       rect,
  102.                                       (1 << ACTOR_TYPE_BULLET),
  103.                                       (1 << ACTOR_TYPE_ALIEN) | (1 << ACTOR_TYPE_ALIENBULLET));
  104.             break;
  105.         case ACTOR_TYPE_ALIENBULLET:
  106.             m_collision_list.addObject((void *) actor,
  107.                                       rect,
  108.                                       (1 << ACTOR_TYPE_ALIENBULLET),
  109.                                       (1 << ACTOR_TYPE_SHIP));
  110.             break;
  111.         case ACTOR_TYPE_ALIEN:
  112.             m_collision_list.addObject((void *) actor,
  113.                                       rect,
  114.                                       (1 << ACTOR_TYPE_ALIEN),
  115.                                       0);
  116.             break;
  117.         case ACTOR_TYPE_PICKUP:
  118.             m_collision_list.addObject((void *) actor,
  119.                                       rect,
  120.                                       (1 << ACTOR_TYPE_PICKUP),
  121.                                       0);
  122.             break;
  123.         case ACTOR_TYPE_WEAPON:
  124.         case ACTOR_TYPE_ENGINE:
  125.         case ACTOR_TYPE_LABEL:
  126.         case ACTOR_TYPE_EFFECT:
  127.             // no collision detection
  128.             break;
  129.         }
  130. }
  131.  
  132. //-------------------------------------------------------------
  133.  
  134. void CScene::updateActorsOfType(ActorType type,Controls *controls)
  135. {
  136.     for (int j = 0; j < m_actor_list.getSize(); j++) {
  137.         CActor *obj = m_actor_list[j];
  138.         if (obj->isActive() &&
  139.             obj->getActorInfo().m_type == type)
  140.             obj->update(controls);
  141.         }
  142. }
  143.  
  144. //-------------------------------------------------------------
  145.  
  146. void CScene::updateAllActors(Controls *controls)
  147. {
  148.     updateActorsOfType(ACTOR_TYPE_SHIP,controls);
  149.     updateActorsOfType(ACTOR_TYPE_UPGRADE,controls);
  150.     updateActorsOfType(ACTOR_TYPE_ALIEN,controls);
  151.     updateActorsOfType(ACTOR_TYPE_WEAPON,controls);
  152.     updateActorsOfType(ACTOR_TYPE_ENGINE,controls);
  153.     updateActorsOfType(ACTOR_TYPE_ALIENBULLET,controls);
  154.     updateActorsOfType(ACTOR_TYPE_BULLET,controls);
  155.     updateActorsOfType(ACTOR_TYPE_PICKUP,controls);
  156.     updateActorsOfType(ACTOR_TYPE_LABEL,controls);
  157.     updateActorsOfType(ACTOR_TYPE_EFFECT,controls);
  158. }
  159.  
  160. //-------------------------------------------------------------
  161.  
  162. void CScene::drawActorsOfType(ActorType type,int total)
  163. {
  164.     for (int j = 0; j < total; j++) {
  165.         CActor *actor = m_actor_list[j];
  166.         if (actor->isActive() &&
  167.             actor->getActorInfo().m_type == type)
  168.             actor->draw();
  169.         }
  170. }
  171.  
  172. //-------------------------------------------------------------
  173.  
  174. void CScene::actorCollisionCallback(void *object1,void *object2)
  175. {
  176.     gsASSERT(object1);
  177.     gsASSERT(object2);
  178.     
  179.     CActor *actor1 = (CActor *) object1;
  180.     CActor *actor2 = (CActor *) object2;
  181.  
  182.     if (!actor1->isActive() ||
  183.         !actor2->isActive())
  184.         return;
  185.  
  186.     actor1->onCollisionWithActor(actor2);
  187. }
  188.  
  189. //-------------------------------------------------------------
  190. // Draw all active game actors - prioritized
  191.  
  192. void CScene::drawAllActors()
  193. {
  194.     m_frame_count++;
  195.     
  196.     m_collision_list.clear();
  197.  
  198.     int total = m_actor_list.getSize();
  199.  
  200.     CShip *ship = findShip();
  201.  
  202.     drawActorsOfType(ACTOR_TYPE_EFFECT,total);
  203.     drawActorsOfType(ACTOR_TYPE_PICKUP,total);
  204.     drawActorsOfType(ACTOR_TYPE_ALIEN,total);
  205.     drawActorsOfType(ACTOR_TYPE_ALIENBULLET,total);
  206.     drawActorsOfType(ACTOR_TYPE_BULLET,total);
  207.     drawActorsOfType(ACTOR_TYPE_ENGINE,total);
  208.     drawActorsOfType(ACTOR_TYPE_SHIP,total);
  209.     drawActorsOfType(ACTOR_TYPE_UPGRADE,total);
  210.     drawActorsOfType(ACTOR_TYPE_WEAPON,total);
  211.     drawActorsOfType(ACTOR_TYPE_LABEL,total);
  212. }
  213.  
  214. //-------------------------------------------------------------
  215.  
  216. void CScene::checkActorCollisions()
  217. {
  218.     m_collision_list.scan(actorCollisionCallback);
  219.  
  220.     for (int i = 0; i < m_actor_list.getSize(); i++) {
  221.         if (m_actor_list[i]->isActive())
  222.             m_actor_list[i]->postProcessCollision();
  223.         }
  224. }
  225.  
  226. //-------------------------------------------------------------
  227.  
  228. void CScene::removeDeadActors()
  229. {
  230.     for (int i = m_actor_list.getSize() - 1; i >= 0; i--) {
  231.         if (!m_actor_list[i]->isActive()) {
  232.             delete m_actor_list[i];
  233.             m_actor_list.removeIndex(i);
  234.             }
  235.         }
  236. }
  237.  
  238. //-------------------------------------------------------------
  239.  
  240. void CScene::killAllActors()
  241. {
  242.     int i;
  243.     
  244.     for (i = 0; i < m_actor_list.getSize(); i++)
  245.         m_actor_list[i]->kill();
  246.  
  247.     for (i = 0; i < m_actor_list.getSize(); i++)
  248.         delete m_actor_list[i];
  249.  
  250.     m_actor_list.clear();
  251. }
  252.  
  253. //-------------------------------------------------------------
  254.  
  255. void CScene::destroyAll()
  256. {
  257.     int i;
  258.  
  259.     for (i = 0; i < m_actor_list.getSize(); i++)
  260.         delete m_actor_list[i];
  261.  
  262.     m_actor_list.clear();
  263.  
  264.     for (i = 0; i < m_image_list.getSize(); i++) {
  265.         m_image_list[i]->m_image.destroy();
  266.         delete m_image_list[i];
  267.         }
  268.     
  269.     m_image_list.clear();
  270. }
  271.  
  272. //-------------------------------------------------------------
  273.  
  274. CShip *CScene::findShip()
  275. {
  276.     for (int i = 0; i < m_actor_list.getSize(); i++) {
  277.         if (m_actor_list[i]->getActorInfo().m_type == ACTOR_TYPE_SHIP)
  278.             return (CShip *) m_actor_list[i];
  279.         }
  280.  
  281.     return 0;
  282. }
  283.  
  284. //-------------------------------------------------------------
  285.  
  286. CActor *CScene::getActor(int index)
  287. {
  288.     return m_actor_list[index];
  289. }
  290.  
  291. //-------------------------------------------------------------
  292.  
  293. CActor *CScene::findNearestActor(ActorType type,const gsCVector& position,int dir)
  294. {
  295.     CActor *nearest_actor = 0;
  296.     float nearest_distance = 99999.f;
  297.  
  298.     for (int i = 0; i < m_actor_list.getSize(); i++) {
  299.         CActor *actor = m_actor_list[i];
  300.         if (actor->isActive() &&
  301.             actor->getActorInfo().m_type == type) {
  302.             if (dir != 0) {
  303.                 float sy = position.getY();
  304.                 float ay = actor->getPosition().getY();
  305.                 if (dir < 0 && sy < ay)
  306.                     continue;
  307.                 if (dir > 0 && sy > ay)
  308.                     continue;
  309.                 }
  310.             float d = (actor->getPosition() - position).length();
  311.             if (nearest_actor == 0 ||
  312.                 d < nearest_distance) {
  313.                 nearest_actor = actor;
  314.                 nearest_distance = d;
  315.                 }
  316.             }
  317.         }
  318.  
  319.     return nearest_actor;
  320. }
  321.  
  322. //-------------------------------------------------------------
  323.  
  324.