rom/graphics/docollision.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Graphics function DoCollision()
   6     Lang: english
   7 */
   8 #include <graphics/rastport.h>
   9 #include <graphics/gels.h>
  10
  11 #include "graphics_intern.h"
  12
  13 /*****************************************************************************
  14
  15     NAME */
  16 #include <proto/graphics.h>
  17
  18         AROS_LH1(void, DoCollision,
  19
  20 /*  SYNOPSIS */
  21         AROS_LHA(struct RastPort *, rp, A1),
  22
  23 /*  LOCATION */
  24         struct GfxBase *, GfxBase, 18, Graphics)
  25
  26 /*  FUNCTION
  27         Tests each gel in gel list for boundary and gel-to-gel collisions.
  28         If a collision happens the collision handling routine is called.
  29         The gel list must be sorted by y,x order.
  30
  31     INPUTS
  32         rp - pointer to RastPort
  33
  34     RESULT
  35
  36     NOTES
  37
  38     EXAMPLE
  39
  40     BUGS
  41
  42     SEE ALSO
  43
  44     INTERNALS
  45
  46     HISTORY
  47
  48
  49 ******************************************************************************/
  50 {
  51     AROS_LIBFUNC_INIT
  52
  53     struct VSprite * CurVSprite, * _CurVSprite;
  54     int shift, _shift;
  55
  56     if (NULL != rp->GelsInfo)
  57     {
  58       CurVSprite = rp->GelsInfo->gelHead->NextVSprite;
  59       if (CurVSprite->Flags & VSPRITE)
  60         shift = 1;
  61       else
  62         shift = 4;
  63
  64       while (NULL != CurVSprite->NextVSprite)
  65       {
  66         _CurVSprite = CurVSprite->NextVSprite;
  67
  68         /*
  69          * As long as they can overlap vertically..
  70          */
  71         while (NULL != _CurVSprite &&
  72                (CurVSprite->Y + CurVSprite->Height - 1) >= _CurVSprite->Y)
  73         {
  74           /*
  75            * Do these two overlap horizontally ???
  76            */
  77           if (_CurVSprite->Flags & VSPRITE)
  78             _shift = 1;
  79           else
  80             _shift = 4;
  81
  82           if (!
  83                ((CurVSprite->X>_CurVSprite->X+(_CurVSprite->Width<<_shift)-1) ||
  84                 (CurVSprite->X+(CurVSprite->Width<<shift)-1<_CurVSprite->X))
  85              )
  86           {
  87             /*
  88              * Must test the collision masks!!
  89              * Phew, this is not going to be easy.
  90              */
  91             int collision = FALSE;
  92             int dy = _CurVSprite->Y - CurVSprite->Y;
  93             UWORD *  collmask =  CurVSprite->CollMask;
  94             UWORD * _collmask = _CurVSprite->CollMask;
  95             unsigned short  wordsperline;
  96             unsigned short _wordsperline;
  97             int i = 0, _i = 0;
  98             int offset    , _offset = 0;
  99             int _scroll = 0;
 100             int line = 0;
 101             /*
 102              * I will hold the CurVSprite's collision mask still
 103              * and adjust/shift the collision mask of _CurVSprite.
 104              * If any and'ing results with non-zero, there is a
 105              * collision.
 106              */
 107             if (CurVSprite->Flags & VSPRITE)
 108               wordsperline = CurVSprite->Width >> 4; // should be 1
 109             else
 110               wordsperline = CurVSprite->Width;
 111
 112             if (_CurVSprite->Flags & VSPRITE)
 113               _wordsperline = _CurVSprite->Width >> 4; // should be 1
 114             else
 115               _wordsperline = _CurVSprite->Width;
 116
 117             if (dy > 0)
 118             {
 119                /*
 120                 * _CurVSprite is lower than CurVSprite
 121                 */
 122                i =  wordsperline * dy;
 123                line = _CurVSprite->Y;
 124             }
 125             else
 126             {
 127               _i = _wordsperline * dy;
 128               line = CurVSprite->Y;
 129             }
 130
 131             offset = _CurVSprite->X - CurVSprite->X;
 132             if (offset < 0)
 133             {
 134               _offset = (-offset) >> 4;
 135               _scroll = (-offset) & 0xf;
 136               offset = 0;
 137             }
 138             else
 139             {
 140               /*
 141                * _CurVSprite is further to the right than
 142                * CurVSprite.
 143                */
 144               _scroll = -(offset & 0xf);
 145               offset >>= 4;
 146             }
 147
 148             /*
 149              * _scroll > 0 means shift the bits to the RIGHT!
 150              */
 151             while ((line < ( CurVSprite->Height+ CurVSprite->Y)) &&
 152                    (line < (_CurVSprite->Height+_CurVSprite->Y))   )
 153             {
 154               int  curindex =  offset;
 155               int _curindex = _offset;
 156               while ( curindex <  wordsperline &&
 157                      _curindex < _wordsperline)
 158               {
 159                 if (_scroll > 0)
 160                 {
 161                   if (collmask[curindex+i] & (_collmask[_curindex+_i] >> _scroll) )
 162                   {
 163                     collision = TRUE;
 164                     break;
 165                   }
 166                   curindex++;
 167                   if (curindex > wordsperline)
 168                     break;
 169
 170                   if (collmask[curindex+i] & (_collmask[_curindex+_i] << (16-_scroll)))
 171                   {
 172                     collision = TRUE;
 173                     break;
 174                   }
 175                   _curindex++;
 176                 }
 177                 else
 178                 if (0 == _scroll)
 179                 {
 180                   if (collmask[curindex+i] & _collmask[_curindex+_i])
 181                   {
 182                     collision = TRUE;
 183                     break;
 184                   }
 185                   _curindex++;
 186                    curindex++;
 187                 }
 188                 else
 189                 {
 190                   if (collmask[curindex+i] & (_collmask[_curindex+_i] << (-_scroll)))
 191                   {
 192                     collision = TRUE;
 193                     break;
 194                   }
 195                   _curindex++;
 196                   if (_curindex > _wordsperline)
 197                     break;
 198
 199                   if (collmask[curindex+i] & (_collmask[_curindex+_i] >> (16+_scroll)))
 200                   {
 201                     collision = TRUE;
 202                     break;
 203                   }
 204                   curindex++;
 205                 }
 206               }
 207                i+= wordsperline;
 208               _i+=_wordsperline;
 209               line++;
 210             }
 211
 212             if (collision)
 213             {
 214               UWORD mask = CurVSprite->MeMask & _CurVSprite->HitMask;
 215               int i = 0;
 216               while (i < 16 && 0 != mask)
 217               {
 218                 if (mask & 0x01)
 219                 {
 220                   if (rp->GelsInfo->collHandler &&
 221                       rp->GelsInfo->collHandler->collPtrs[i])
 222                     rp->GelsInfo->collHandler->collPtrs[i]( CurVSprite,
 223                                                            _CurVSprite);
 224                   break;
 225                 }
 226                 i++;
 227                 mask >>= 1;
 228               }
 229             }
 230           }
 231           _CurVSprite = _CurVSprite->NextVSprite;
 232         }
 233         CurVSprite = CurVSprite->NextVSprite;
 234       }
 235     }
 236
 237     AROS_LIBFUNC_EXIT
 238 } /* DoCollision */