barrier.cpp

[游戏开发参考书-用DirectX编写RPG游戏]这是一个系列的丛书如果你都看并且懂的话你就可以你工作啦！

  Barrier->Prev = NULL;
  if((Barrier->Next = m_BarrierParent) != NULL)
    m_BarrierParent->Prev = Barrier;
  m_BarrierParent = Barrier;

  // Set Barrier Type, ID, and Enabled flag
  Barrier->Type = Type;
  Barrier->ID = ID;
  Barrier->Enabled = Enabled;
  Barrier->XPos = XPos;
  Barrier->YPos = YPos;
  Barrier->ZPos = ZPos;
  Barrier->XRot = XRot;
  Barrier->YRot = YRot;
  Barrier->ZRot = ZRot;

  // Increase Barrier count
  m_NumBarriers++;

  return Barrier;
}

BOOL cBarrier::AddSphere(long ID, BOOL Enabled,               \
               float XPos,  float YPos,  float ZPos,          \
               float XRot,  float YRot,  float ZRot,          \
               float CXPos, float CYPos, float CZPos,         \
               float Radius)
{
  // Create a new Barrier structure and link in 
  sBarrier *Barrier = AddBarrier(Barrier_Sphere, ID, Enabled, \
                                 XPos, YPos, ZPos,            \
                                 XRot, YRot, ZRot);

  // Setup Barrier data
  Barrier->x1 = CXPos;
  Barrier->y1 = CYPos;
  Barrier->z1 = CZPos;
  Barrier->Radius = Radius * Radius;

  return TRUE;
}

BOOL cBarrier::AddBox(long ID, BOOL Enabled,                  \
                      float XPos,  float YPos,  float ZPos,   \
                      float XRot,  float YRot,  float ZRot,   \
                      float XMin, float YMin, float ZMin,     \
                      float XMax, float YMax, float ZMax)
{
  // Create a new Barrier structure and link in 
  sBarrier *Barrier = AddBarrier(Barrier_Box, ID, Enabled,    \
                                 XPos, YPos, ZPos,            \
                                 XRot, YRot, ZRot);

  // Setup Barrier data (fix for min/max values)
  Barrier->x1 = min(XMin, XMax);
  Barrier->y1 = min(YMin, YMax);
  Barrier->z1 = min(ZMin, ZMax);
  Barrier->x2 = max(XMin, XMax);
  Barrier->y2 = max(YMin, YMax);
  Barrier->z2 = max(ZMin, ZMax);

  return TRUE;
}

BOOL cBarrier::AddCylinder(long ID, BOOL Enabled,             \
                       float XPos,  float YPos,  float ZPos,  \
                       float XRot,  float YRot,  float ZRot,  \
                       float CXPos, float CYPos, float CZPos, \
                       float Radius, float Height)
{
  // Create a new Barrier structure and link in 
  sBarrier *Barrier = AddBarrier(Barrier_Cylinder,ID,Enabled, \
                                 XPos, YPos, ZPos,            \
                                 XRot, YRot, ZRot);
            
  // Setup Barrier data
  Barrier->x1     = XPos;
  Barrier->y1     = YPos;
  Barrier->z1     = ZPos;
  Barrier->Radius = Radius * Radius;
  Barrier->y2     = Height;

  return TRUE;
}

BOOL cBarrier::AddTriangle(long ID, BOOL Enabled,             \
                     float XPos,  float YPos,  float ZPos,    \
                     float XRot,  float YRot,  float ZRot,    \
                     float x1, float z1,                      \
                     float x2, float z2,                      \
                     float x3, float z3,                      \
                     float CYPos, float Height)
{
  // Create a new Barrier structure and link in 
  sBarrier *Barrier = AddBarrier(Barrier_Triangle,ID,Enabled, \
                                 XPos, YPos, ZPos,            \
                                 XRot, YRot, ZRot);

  // Setup Barrier data
  Barrier->x1 = x1;
  Barrier->z1 = z1;
  Barrier->x2 = x2;
  Barrier->z2 = z2;
  Barrier->x3 = x3;
  Barrier->z3 = z3;
  Barrier->y1 = YPos;
  Barrier->y2 = Height;

  return TRUE;
}

BOOL cBarrier::Remove(long ID)
{
  sBarrier *BarrierPtr, *NextBarrier;
  long Count = 0;

  // Scan through list of Barriers
  if((BarrierPtr = m_BarrierParent) != NULL) {
    while(BarrierPtr != NULL) {

      // Remember which is next
      NextBarrier = BarrierPtr->Next;

      // Matched?
      if(BarrierPtr->ID == ID) {

        // Remove from list 
        if(BarrierPtr->Prev != NULL)
          BarrierPtr->Prev->Next = BarrierPtr->Next;
        else
          m_BarrierParent = BarrierPtr->Next;
        if(BarrierPtr->Next != NULL)
          BarrierPtr->Next->Prev = BarrierPtr->Prev;

        // Release memory
        BarrierPtr->Next = NULL;
        delete BarrierPtr;

        // Decrease number of Barriers and increase # removed
        m_NumBarriers--;
        Count++;
      }

      // Go to next Barrier
      BarrierPtr = NextBarrier;
    }
  }

  // Return TRUE if any found and removed
  return (Count) ? TRUE : FALSE;
}

BOOL cBarrier::Free()
{
  delete m_BarrierParent;
  m_BarrierParent = NULL;
  m_NumBarriers = 0;

  return TRUE;
}

long cBarrier::GetBarrier(float XPos, float YPos, float ZPos)
{
  float XDiff, YDiff, ZDiff, Dist;
  D3DXVECTOR2 vecNorm;
  sBarrier *Barrier;

  if((Barrier = m_BarrierParent) != NULL) {
    while(Barrier != NULL) {

      // Only bother if enabled
      if(Barrier->Enabled == TRUE) {

        // Check based on type
        switch(Barrier->Type) {
          case Barrier_Sphere:
            // Check distance from sphere (using radius)
            XDiff = (float)fabs(Barrier->x1 - XPos);
            YDiff = (float)fabs(Barrier->y1 - YPos);
            ZDiff = (float)fabs(Barrier->z1 - ZPos);
            Dist = XDiff*XDiff+YDiff*YDiff+ZDiff*ZDiff;
            if(Dist <= Barrier->Radius)
              return Barrier->ID;
            break;
    
          case Barrier_Box:
            // Check if inside box
            if(XPos >= Barrier->x1 && XPos <= Barrier->x2) {
              if(YPos >= Barrier->y1 && YPos <= Barrier->y2) {
                if(ZPos >= Barrier->z1 && ZPos <= Barrier->z2)
                  return Barrier->ID;
              }
            }
            break;

          case Barrier_Cylinder:
            // First make sure within height bounds
            if(YPos >= Barrier->y1 &&                         \
               YPos <= Barrier->y1 + Barrier->y2) {
              // Check distance from cylinder
              XDiff = (float)fabs(Barrier->x1 - XPos);
              YDiff = (float)fabs(Barrier->y1 - YPos);
              ZDiff = (float)fabs(Barrier->z1 - ZPos);
              Dist = XDiff*XDiff+YDiff*YDiff+ZDiff*ZDiff;
              if(Dist <= Barrier->Radius)
                return Barrier->ID;
            }
            break;

          case Barrier_Triangle:
            // First make sure within height bounds
            if(YPos >= Barrier->y1 &&                         \
               YPos <= Barrier->y1 + Barrier->y2) {
            
              // Check if point in front of all lines

              // x1,z1 to x2,z2
              D3DXVec2Normalize(&vecNorm,                     \
                     &D3DXVECTOR2(Barrier->z2 - Barrier->z1,  \
                                  Barrier->x1 - Barrier->x2));
              if(D3DXVec2Dot(&D3DXVECTOR2(XPos-Barrier->x1,   \
                                          ZPos-Barrier->z1),  \
                                          &vecNorm) < 0)
                break;

              // x2,z2 to x3,z3
              D3DXVec2Normalize(&vecNorm,                       \
                     &D3DXVECTOR2(Barrier->z3 - Barrier->z2,    \
                                  Barrier->x2 - Barrier->x3));
              if(D3DXVec2Dot(&D3DXVECTOR2(XPos-Barrier->x2,     \
                                          ZPos-Barrier->z2),    \
                                          &vecNorm) < 0)
                break;

              // x3,z3 to x1,z1
              D3DXVec2Normalize(&vecNorm,                       \
                     &D3DXVECTOR2(Barrier->z1 - Barrier->z3,    \
                                  Barrier->x3 - Barrier->x1));
              if(D3DXVec2Dot(&D3DXVECTOR2(XPos-Barrier->x3,     \
                                          ZPos-Barrier->z3),    \
                                          &vecNorm) < 0)
                break;

              return Barrier->ID;
            }
            break;
        }
      }

      // Go to next Barrier
      Barrier = Barrier->Next;
    }
  }

  return 0; // 0 means no Barrier found
}

BOOL cBarrier::GetEnableState(long ID)
{
  sBarrier *BarrierPtr;

  // Loop through all Barriers looking for ID
  if((BarrierPtr = m_BarrierParent) != NULL) {
    while(BarrierPtr != NULL) {

      // If matched ID then set return state
      if(BarrierPtr->ID == ID)
        return BarrierPtr->Enabled;

      // Go to next flag
      BarrierPtr = BarrierPtr->Next;
    }
  }

  // Return FALSE for none found
  return FALSE;
}

BOOL cBarrier::Enable(long ID, BOOL Enable)
{
  sBarrier *BarrierPtr;
  long Count = 0;

  // Loop through all Barriers looking for ID
  if((BarrierPtr = m_BarrierParent) != NULL) {
    while(BarrierPtr != NULL) {

      // If matched ID then set flag and increase count
      if(BarrierPtr->ID == ID) {
        BarrierPtr->Enabled = Enable;
        Count++;
      }

      // Go to next flag
      BarrierPtr = BarrierPtr->Next;
    }
  }

  // Return TRUE if any Barriers changed
  return (Count) ? TRUE : FALSE;
}

long cBarrier::GetNumBarriers()
{
  return m_NumBarriers;
}

sBarrier *cBarrier::GetParentBarrier()
{
  return m_BarrierParent;
}