home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / Pascal / Snippets / PNL Libraries / Libraries / SpriteWorld / SpriteWorld files / Sources / SpriteLayer.c < prev    next >
Encoding:
Text File  |  1996-10-30  |  11.9 KB  |  368 lines  |  [TEXT/KAHL]
  1. teP != NULL );
  2.  
  3.     if (tailSpriteP != NULL)
  4.     {
  5.             // doubly link the new sprite
  6.         tailSpriteP->nextSpriteP = newSpriteP;
  7.         newSpriteP->prevSpriteP = tailSpriteP;
  8.         newSpriteP->nextSpriteP = NULL;
  9.     }    
  10.     else
  11.     {
  12.         newSpriteP->prevSpriteP = NULL;
  13.         newSpriteP->nextSpriteP = NULL;
  14.  
  15.             // make the new sprite the head
  16.         spriteLayerP->headSpriteP = newSpriteP;
  17.     }
  18.  
  19.         // make the new sprite the tail
  20.     spriteLayerP->tailSpriteP = newSpriteP;
  21.     
  22.     newSpriteP->spriteRemoval = kSWDontRemoveSprite;
  23. }
  24.  
  25.  
  26. ///--------------------------------------------------------------------------------------
  27. //    SWRemoveSprite
  28. ///--------------------------------------------------------------------------------------
  29.  
  30. SW_FUNC void SWRemoveSprite(
  31.     SpriteLayerPtr spriteLayerP,
  32.     SpritePtr oldSpriteP)
  33. {
  34.     SWAssert( spriteLayerP != NULL && oldSpriteP != NULL );
  35.  
  36.         // is this not the tail sprite?
  37.     if (oldSpriteP->nextSpriteP != NULL)
  38.     {
  39.             // link the next sprite to the prev sprite
  40.         oldSpriteP->nextSpriteP->prevSpriteP = oldSpriteP->prevSpriteP;
  41.     }
  42.     else
  43.     {
  44.             // make the prev sprite the tail
  45.         spriteLayerP->tailSpriteP = oldSpriteP->prevSpriteP;
  46.     }
  47.  
  48.         // is this not the head sprite?
  49.     if (oldSpriteP->prevSpriteP != NULL)
  50.     {
  51.             // link the prev sprite to the next sprite
  52.         oldSpriteP->prevSpriteP->nextSpriteP = oldSpriteP->nextSpriteP;
  53.     }
  54.     else
  55.     {
  56.             // make the next sprite the first sprite
  57.         spriteLayerP->headSpriteP = oldSpriteP->nextSpriteP;
  58.     }
  59. }
  60.  
  61.  
  62. ///--------------------------------------------------------------------------------------
  63. //    SWRemoveAllSpritesFromLayer
  64. ///--------------------------------------------------------------------------------------
  65.  
  66. SW_FUNC void SWRemoveAllSpritesFromLayer(
  67.     SpriteLayerPtr srcSpriteLayerP)
  68. {
  69.     SpritePtr curSpriteP;
  70.  
  71.     SWAssert( srcSpriteLayerP != NULL );
  72.  
  73.     while ((curSpriteP = SWGetNextSprite(srcSpriteLayerP, NULL)) != NULL)
  74.     {
  75.         SWRemoveSprite(srcSpriteLayerP, curSpriteP);
  76.     }
  77. }
  78.  
  79.  
  80. ///--------------------------------------------------------------------------------------
  81. //    SWSwapSprite
  82. ///--------------------------------------------------------------------------------------
  83.  
  84. SW_FUNC void SWSwapSprite(
  85.     SpriteLayerPtr spriteLayerP,
  86.     SpritePtr srcSpriteP,
  87.     SpritePtr dstSpriteP)
  88. {
  89.     register SpritePtr swapSpriteP;
  90.     
  91.     SWAssert( spriteLayerP != NULL && srcSpriteP != NULL && dstSpriteP != NULL );
  92.     
  93.         // adjacent Sprites are a special case
  94.         
  95.     if ( srcSpriteP->nextSpriteP == dstSpriteP ||
  96.         dstSpriteP->nextSpriteP == srcSpriteP )
  97.     {
  98.         if ( srcSpriteP->nextSpriteP == dstSpriteP )
  99.         {
  100.             if ( srcSpriteP->prevSpriteP != NULL )
  101.                 (srcSpriteP->prevSpriteP)->nextSpriteP = dstSpriteP;
  102.             if ( dstSpriteP->nextSpriteP != NULL )
  103.                 (dstSpriteP->nextSpriteP)->prevSpriteP = srcSpriteP;
  104.             
  105.             dstSpriteP->prevSpriteP = srcSpriteP->prevSpriteP;
  106.             srcSpriteP->nextSpriteP = dstSpriteP->nextSpriteP;
  107.             
  108.             dstSpriteP->nextSpriteP = srcSpriteP;
  109.             srcSpriteP->prevSpriteP = dstSpriteP;
  110.         }
  111.         else
  112.         {
  113.             if ( dstSpriteP->prevSpriteP != NULL )
  114.                 (dstSpriteP->prevSpriteP)->nextSpriteP = srcSpriteP;
  115.             if ( srcSpriteP->nextSpriteP != NULL )
  116.                 (srcSpriteP->nextSpriteP)->prevSpriteP = dstSpriteP;
  117.             
  118.             srcSpriteP->prevSpriteP = dstSpriteP->prevSpriteP;
  119.             dstSpriteP->nextSpriteP = srcSpriteP->nextSpriteP;
  120.             
  121.             srcSpriteP->nextSpriteP = dstSpriteP;
  122.             dstSpriteP->prevSpriteP = srcSpriteP;
  123.         }
  124.     }
  125.     else
  126.     {
  127.         if ( srcSpriteP->prevSpriteP != NULL && dstSpriteP->prevSpriteP != NULL )
  128.         {
  129.             swapSpriteP = (srcSpriteP->prevSpriteP)->nextSpriteP;
  130.             (srcSpriteP->prevSpriteP)->nextSpriteP = 
  131.                     (dstSpriteP->prevSpriteP)->nextSpriteP;
  132.             (dstSpriteP->prevSpriteP)->nextSpriteP = swapSpriteP;
  133.         }
  134.         if ( srcSpriteP->nextSpriteP != NULL && dstSpriteP->nextSpriteP != NULL )
  135.         {
  136.             swapSpriteP = (srcSpriteP->nextSpriteP)->prevSpriteP;
  137.             (srcSpriteP->nextSpriteP)->prevSpriteP = 
  138.                     (dstSpriteP->nextSpriteP)->prevSpriteP;
  139.             (dstSpriteP->nextSpriteP)->prevSpriteP = swapSpriteP;
  140.         }
  141.         
  142.         swapSpriteP = srcSpriteP->nextSpriteP;
  143.         srcSpriteP->nextSpriteP = dstSpriteP->nextSpriteP;
  144.         dstSpriteP->nextSpriteP = swapSpriteP;
  145.  
  146.         swapSpriteP = srcSpriteP->prevSpriteP;
  147.         srcSpriteP->prevSpriteP = dstSpriteP->prevSpriteP;
  148.         dstSpriteP->prevSpriteP = swapSpriteP;
  149.     }
  150.  
  151.  
  152.     if (srcSpriteP->nextSpriteP == NULL)
  153.     {
  154.         spriteLayerP->tailSpriteP = srcSpriteP;
  155.     }
  156.     else if (srcSpriteP->prevSpriteP == NULL)
  157.     {
  158.         spriteLayerP->headSpriteP = srcSpriteP;
  159.     }
  160.  
  161.     if (dstSpriteP->nextSpriteP == NULL)
  162.     {
  163.         spriteLayerP->tailSpriteP = dstSpriteP;
  164.     }
  165.     else if (dstSpriteP->prevSpriteP == NULL)
  166.     {
  167.         spriteLayerP->headSpriteP = dstSpriteP;
  168.     }
  169. }
  170.  
  171.  
  172. ///--------------------------------------------------------------------------------------
  173. //    SWInsertSpriteAfterSprite
  174. ///--------------------------------------------------------------------------------------
  175.  
  176. SW_FUNC void SWInsertSpriteAfterSprite(
  177.     SpriteLayerPtr spriteLayerP,
  178.     SpritePtr newSpriteP,
  179.     SpritePtr dstSpriteP)
  180. {
  181.     SWAssert( spriteLayerP != NULL && newSpriteP != NULL && dstSpriteP != NULL );
  182.  
  183.     if ( dstSpriteP->nextSpriteP != NULL )
  184.         (dstSpriteP->nextSpriteP)->prevSpriteP = newSpriteP;
  185.     
  186.     newSpriteP->nextSpriteP = dstSpriteP->nextSpriteP;
  187.     dstSpriteP->nextSpriteP = newSpriteP;
  188.     newSpriteP->prevSpriteP = dstSpriteP;
  189.     
  190.     if (newSpriteP->nextSpriteP == NULL)
  191.     {
  192.         spriteLayerP->tailSpriteP = newSpriteP;
  193.     }
  194. }
  195.  
  196.  
  197. ///--------------------------------------------------------------------------------------
  198. //    SWInsertSpriteBeforeSprite
  199. ///--------------------------------------------------------------------------------------
  200.  
  201. SW_FUNC void SWInsertSpriteBeforeSprite(
  202.     SpriteLayerPtr spriteLayerP,
  203.     SpritePtr newSpriteP,
  204.     SpritePtr dstSpriteP)
  205. {
  206.     SWAssert( spriteLayerP != NULL && newSpriteP != NULL && dstSpriteP != NULL );
  207.     
  208.     if ( dstSpriteP->prevSpriteP != NULL )
  209.         (dstSpriteP->prevSpriteP)->nextSpriteP = newSpriteP;
  210.     
  211.     newSpriteP->prevSpriteP = dstSpriteP->prevSpriteP;
  212.     dstSpriteP->prevSpriteP = newSpriteP;
  213.     newSpriteP->nextSpriteP = dstSpriteP;
  214.     
  215.     if (newSpriteP->prevSpriteP == NULL)
  216.     {
  217.         spriteLayerP->headSpriteP = newSpriteP;
  218.     }
  219. }
  220.  
  221.  
  222. ///--------------------------------------------------------------------------------------
  223. //    SWGetNextSprite
  224. ///--------------------------------------------------------------------------------------
  225.  
  226. SW_FUNC SpritePtr SWGetNextSprite(
  227.     SpriteLayerPtr spriteLayerP,
  228.     SpritePtr curSpriteP)
  229. {
  230.     SWAssert( spriteLayerP != NULL );
  231.     
  232.     return (curSpriteP == NULL) ? spriteLayerP->headSpriteP : curSpriteP->nextSpriteP;
  233. }
  234.  
  235.  
  236. ///--------------------------------------------------------------------------------------
  237. //    SWLockSpriteLayer
  238. ///--------------------------------------------------------------------------------------
  239.  
  240. SW_FUNC void SWLockSpriteLayer(
  241.     SpriteLayerPtr spriteLayerP)
  242. {
  243.     SpritePtr curSpriteP;
  244.  
  245.     SWAssert( spriteLayerP != NULL );
  246.     
  247.     curSpriteP = spriteLayerP->headSpriteP;
  248.  
  249.     while (curSpriteP != NULL)
  250.     {
  251.         SWLockSprite(curSpriteP);
  252.  
  253.         curSpriteP = curSpriteP->nextSpriteP;
  254.     }
  255. }
  256.  
  257.  
  258. ///--------------------------------------------------------------------------------------
  259. //    SWUnlockSpriteLayer
  260. ///--------------------------------------------------------------------------------------
  261.  
  262. SW_FUNC void SWUnlockSpriteLayer(
  263.     SpriteLayerPtr spriteLayerP)
  264. {
  265.     SpritePtr curSpriteP;
  266.  
  267.     SWAssert( spriteLayerP != NULL );
  268.     
  269.     curSpriteP = spriteLayerP->headSpriteP;
  270.  
  271.     while (curSpriteP != NULL)
  272.     {
  273.         SWUnlockSprite(curSpriteP);
  274.  
  275.         curSpriteP = curSpriteP->nextSpriteP;
  276.     }
  277. }
  278.  
  279.  
  280. ///--------------------------------------------------------------------------------------
  281. //    SWCollideSpriteLayer
  282. ///--------------------------------------------------------------------------------------
  283.  
  284. SW_FUNC void SWCollideSpriteLayer(
  285.     SpriteWorldPtr    spriteWorldP,
  286.     SpriteLayerPtr srcSpriteLayerP,
  287.     SpriteLayerPtr dstSpriteLayerP)
  288. {
  289.     SpritePtr srcSpriteP, nextSrcSpriteP;
  290.     SpritePtr dstSpriteP, nextDstSpriteP;
  291.     Rect sectRect;
  292.     
  293.     SWAssert( spriteWorldP != NULL && srcSpriteLayerP != NULL && dstSpriteLayerP != NULL );
  294.     
  295.         // Don't check for collisions unless the frame has been processed!
  296.     if (!spriteWorldP->frameHasOccured)
  297.         return;
  298.  
  299.     srcSpriteP = srcSpriteLayerP->headSpriteP;
  300.  
  301.     while (srcSpriteP != NULL)
  302.     {
  303.         dstSpriteP = dstSpriteLayerP->headSpriteP;
  304.         nextSrcSpriteP = srcSpriteP->nextSpriteP;
  305.  
  306.         while (dstSpriteP != NULL)
  307.         {
  308.             nextDstSpriteP = dstSpriteP->nextSpriteP;
  309.  
  310.             if (srcSpriteP != dstSpriteP)
  311.             {
  312.                     // are the sprite’s rectangles overlapping?
  313.                 if ((srcSpriteP->destFrameRect.top < dstSpriteP->destFrameRect.bottom) &&
  314.                     (srcSpriteP->destFrameRect.bottom > dstSpriteP->destFrameRect.top) &&
  315.                     (srcSpriteP->destFrameRect.left < dstSpriteP->destFrameRect.right) &&
  316.                     (srcSpriteP->destFrameRect.right > dstSpriteP->destFrameRect.left))
  317.                 {
  318.                         // call the source sprite’s collision routine
  319.                     if (srcSpriteP->spriteCollideProc != NULL)
  320.                     {
  321.                         sectRect.left =
  322.                             SW_MAX(srcSpriteP->destFrameRect.left, dstSpriteP->destFrameRect.left);
  323.                         sectRect.top =
  324.                             SW_MAX(srcSpriteP->destFrameRect.top, dstSpriteP->destFrameRect.top);
  325.                         sectRect.right =
  326.                             SW_MIN(srcSpriteP->destFrameRect.right, dstSpriteP->destFrameRect.right);
  327.                         sectRect.bottom =
  328.                             SW_MIN(srcSpriteP->destFrameRect.bottom, dstSpriteP->destFrameRect.bottom);
  329.  
  330.                         (*srcSpriteP->spriteCollideProc)(srcSpriteP, dstSpriteP, §Rect);
  331.                     }
  332.                 }
  333.             }
  334.             
  335.             dstSpriteP = nextDstSpriteP;
  336.         }
  337.         
  338.         srcSpriteP = nextSrcSpriteP;
  339.     }
  340. }
  341.  
  342.  
  343. ///--------------------------------------------------------------------------------------
  344. //    SWFindSpriteByPoint
  345. ///--------------------------------------------------------------------------------------
  346.  
  347. SW_FUNC SpritePtr SWFindSpriteByPoint(
  348.     SpriteLayerPtr spriteLayerP,
  349.     SpritePtr startSpriteP,
  350.     Point testPoint)
  351. {
  352.     SpritePtr curSpriteP;
  353.  
  354.     SWAssert( spriteLayerP != NULL );
  355.  
  356.     curSpriteP = (startSpriteP == NULL) ? spriteLayerP->tailSpriteP : startSpriteP;
  357.  
  358.         // note that we traverse the sprites in reverse order
  359.         // since this will make the most sense if we are
  360.         // looking for a sprite that was clicked
  361.     while ((curSpriteP != NULL) && !SWIsPointInSprite(curSpriteP, testPoint))
  362.     {
  363.         curSpriteP = curSpriteP->prevSpriteP;
  364.     }
  365.  
  366.     return curSpriteP;
  367. }
  368.