home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1995 August / NEBULA.mdf / SourceCode / GameKit / Headers / gamekit / GKStage.h < prev    next >
Encoding:
Text File  |  1994-06-07  |  3.5 KB  |  89 lines
  1.  
  2. #import <gamekit/gamekit.h>
  3.  
  4. // This object controls the main animation loop and handles
  5. // things like which buffer gets drawn into an when.  You do
  6. // not _have_ to use the intermediate buffers; if one is missing,
  7. // then the drawing at that level is done in the next higher
  8. // buffer level.  You _must_ have the top level (the gameView)
  9. // buffer set up, though, or nothing will ever get drawn!  If
  10. // you do not have a background buffer set up, then the DirtPile
  11. // for the next level up will use a solid color...see DirtPile
  12. // class for details.  (If you want a solid color, make _sure_
  13. // that you set it in the right DirtPile!)
  14.  
  15. // How many levels of beffering are used
  16. #define GK_BUFFER_TYPES            4
  17. #define GK_BACKGROUND_BUFFER    0
  18. #define GK_STATIC_BUFFER        1
  19. #define GK_DYNAMIC_BUFFER        2
  20. #define GK_SCREEN_BUFFER        3    // MUST be isKindOf:[GameView class]!!!
  21.  
  22. // There are several types of actors which you might use
  23. #define GK_ACTOR_TYPES        GK_BUFFER_TYPES
  24. #define GK_NO_ACTOR            0    // NULL actor
  25.  
  26. // STATIC:  actors that draw in the static buffer, if it
  27. // exists; these move or change appearance rarely (the power dots
  28. // and onscreen text messages in PacMan, for example...)
  29. #define GK_STATIC_ACTOR        GK_STATIC_BUFFER
  30.  
  31. // DYNAMIC:  actors that draw in the dynamicBuffer (most actors are this)
  32. #define GK_DYNAMIC_ACTOR    GK_DYNAMIC_BUFFER
  33.  
  34. // RETAINED:  actors that draw directly on gameView w/o buffer
  35. // things like stars, explosion particles, and so on.
  36. #define GK_RETAINED_ACTOR    GK_SCREEN_BUFFER
  37.  
  38. @interface GKStage:Object
  39. {
  40.     id actors[GK_ACTOR_TYPES];
  41.     id addActors[GK_ACTOR_TYPES];        // actors to add for next cycle
  42.     id removeActors[GK_ACTOR_TYPES];    // actors to remove before next cycle
  43.     id collisionGroups, addCollisionGroups, removeCollisionGroups;
  44.         // Lists of GKCollisionGroup objects
  45.     id stageManager;    // where to send "dead" actors
  46.     id drawingBuffers[GK_BUFFER_TYPES];
  47.     id dirtPiles[GK_BUFFER_TYPES];  // dirtPile #1 goes between buff. 0&1, etc
  48.     // DirtPiles are created automatically when a buffer/gameView are set up
  49. }
  50.  
  51. - init;
  52.  
  53. - actorListForType:(int)type; // return the List object with the actors in it
  54. - dirtPileType:(int)anInt;    // returns DirtPile for buffer of type anInt
  55. - bufferType:(int)anInt;    // returns buffer of type anInt
  56. - setBufferType:(int)anInt to:aBuffer;    // change buffer that we use to aBuffer
  57. - makeDirtPileForBuffer:(int)anInt;        // returns a new dirtPile for buffer
  58.     // override if you want to fine tune the DirtPiles in any way...
  59.  
  60. - stageManager;
  61. - setStageManager:aManager;    // where to send old actors to (free them if nil)
  62.  
  63. // add and delete actors; action is delayed until -doAddsAndRemoves is called
  64. // so we don't change the Lists while we are traversing them.  The same goes
  65. // for collision groups.
  66. - addActor:anActor ofType:(int)type;
  67. - removeActor:anActor ofType:(int)type;
  68. - addCollisionGroup:aGroup;
  69. - removeCollisionGroup:aGroup;
  70. - collisionGroups;
  71. - findCollisionGroupWithTag:(int)anInt;
  72. - doAddsAndRemoves;    // called at the end of a frame to update the actor Lists
  73.  
  74. - doOneFrame;    // does one frame of animation/calculation (game cycle)
  75.  
  76. // the steps taken for each frame of calculation and animation (game cycle)
  77. // these are separate to make subclassing easier to do...
  78. - calculateMoves;
  79. - calculateCollisions;
  80. - render;
  81.  
  82. - (BOOL)doRender;    // decides whether or not to actually do a render for
  83.         // this particular game cycle... currently, always returns a YES.
  84.         // you can override to make some cycles not get rendered (which will
  85.         // make the game _appear_ to move faster, but it still calculates
  86.         // all the unseen frames...)
  87.  
  88. @end
  89.