game2002/server/gameserver/collider.cc

#include "precompile.h"

#include <a8/collision.h>

#include "entity.h"
#include "collider.h"

bool ColliderComponent::IntersectSegment(a8::Vec2& p0, a8::Vec2& p1)
{
    switch (type) {
    case CT_None:
        break;
    case CT_Aabb:
        {
            AabbCollider* a_aabb = (AabbCollider*)this;
            return a8::IntersectSegmentAabb(p0,
                                             p1,
                                             a_aabb->owner->pos + a_aabb->_min,
                                             a_aabb->owner->pos + a_aabb->_max);
        }
        break;
    case CT_Circle:
        {
            CircleCollider* a_circle = (CircleCollider*)this;
            return a8::IntersectSegmentCircle(p0,
                                               p1,
                                               a_circle->owner->pos + a_circle->pos,
                                               a_circle->rad);
        }
        break;
    default:
        break;
    }
    return false;
}

bool ColliderComponent::Intersect(ColliderComponent* b)
{
    switch (type) {
    case CT_None:
        break;
    case CT_Aabb:
        {
            AabbCollider* a_aabb = (AabbCollider*)this;
            switch (b->type) {
            case CT_None:
                break;
            case CT_Aabb:
                {
                    AabbCollider* b_aabb = (AabbCollider*)b;
                    return a8::IntersectAabbAabb(a_aabb->owner->pos + a_aabb->_min,
                                                  a_aabb->owner->pos + a_aabb->_max,
                                                  b_aabb->owner->pos + b_aabb->_min,
                                                  b_aabb->owner->pos + b_aabb->_max
                                                  );
                }
                break;
            case CT_Circle:
                {
                    CircleCollider* b_circle = (CircleCollider*)b;
                    return a8::IntersectAabbCircle(a_aabb->owner->pos + a_aabb->_min,
                                                    a_aabb->owner->pos + a_aabb->_max,
                                                    b_circle->owner->pos + b_circle->pos,
                                                    b_circle->rad);
                }
                break;
            default:
                break;
            }
        };
        break;
    case CT_Circle:
        {
            CircleCollider* a_circle = (CircleCollider*)this;
            switch (b->type) {
            case CT_None:
                break;
            case CT_Aabb:
                {
                    AabbCollider* b_aabb = (AabbCollider*)b;
                    return a8::IntersectAabbCircle(b_aabb->owner->pos + b_aabb->_min,
                                                    b_aabb->owner->pos + b_aabb->_max,
                                                    a_circle->owner->pos + a_circle->pos,
                                                    a_circle->rad);
                }
                break;
            case CT_Circle:
                {
                    CircleCollider* b_circle = (CircleCollider*)b;
                    return a8::IntersectCircleCircle(
                                                      a_circle->owner->pos + a_circle->pos,
                                                      a_circle->rad,
                                                      b_circle->owner->pos + b_circle->pos,
                                                      b_circle->rad);
                }
                break;
            case CT_Sector:
                {
                    SectorCollider* b_sector = (SectorCollider*)b;
                    return a8::IntersectSectorCircle(
                                                     b_sector->owner->pos + b_sector->pos,
                                                     b_sector->angle,
                                                     b_sector->rad,
                                                     a_circle->owner->pos + a_circle->pos,
                                                     a_circle->rad);
                }
                break;
            }
        }
        break;
    case CT_Sector:
        {
            SectorCollider* a_sector = (SectorCollider*)this;
            switch (b->type) {
            case CT_None:
                break;
            case CT_Circle:
                {
                    CircleCollider* b_circle = (CircleCollider*)b;
                    return a8::IntersectSectorCircle(
                                                     a_sector->owner->pos + a_sector->pos,
                                                     a_sector->angle,
                                                     a_sector->rad,
                                                     b_circle->owner->pos + b_circle->pos,
                                                     b_circle->rad);
                }
                break;
            default:
                break;
            }
        }
        break;
    default:
        break;
    }
    return false;
}

bool ColliderComponent::CalcSafePoint(ColliderComponent* b, a8::Vec2& new_pos)
{
    switch (type) {
    case CT_None:
        break;
    case CT_Aabb:
        {
            AabbCollider* a_aabb = (AabbCollider*)this;
            switch (b->type) {
            case CT_Aabb:
                {
                    AabbCollider* b_aabb = (AabbCollider*)b;
                    return a8::CalcAabbAabbSafePoint(a_aabb->owner->pos + a_aabb->_min,
                                                      a_aabb->owner->pos + a_aabb->_max,
                                                      b_aabb->owner->pos + b_aabb->_min,
                                                      b_aabb->owner->pos + b_aabb->_max,
                                                      new_pos);
                }
                break;
            case CT_Circle:
                {
                    CircleCollider* b_circle = (CircleCollider*)b;
                    return a8::CalcAabbAabbSafePoint(a_aabb->owner->pos + a_aabb->_min,
                                                      a_aabb->owner->pos + a_aabb->_max,
                                                      b_circle->owner->pos + b_circle->pos,
                                                      b_circle->rad,
                                                      new_pos);
                }
                break;
            default:
                break;
            }
        }
        break;
    case CT_Circle:
        {
            CircleCollider* a_circle = (CircleCollider*)this;
            switch (b->type) {
            case CT_Aabb:
                {
                    AabbCollider* b_aabb = (AabbCollider*)b;
                    return a8::CalcCircleAabbSafePoint(
                                                        a_circle->owner->pos + a_circle->pos,
                                                        a_circle->rad,
                                                        b_aabb->owner->pos + b_aabb->_min,
                                                        b_aabb->owner->pos + b_aabb->_max,
                                                        new_pos);
                }
                break;
            case CT_Circle:
                {
                    CircleCollider* b_circle = (CircleCollider*)b;
                    return a8::CalcCircleCircleSafePoint(
                                                          a_circle->owner->pos + a_circle->pos,
                                                          a_circle->rad,
                                                          b_circle->owner->pos + b_circle->pos,
                                                          b_circle->rad,
                                                          new_pos);
                }
                break;
            default:
                break;
            }
        }
        break;
    default:
        break;
    }
    return false;
}

void DestoryCollider(ColliderComponent* collider)
{
    switch (collider->type) {
    case CT_Aabb:
        {
            delete (AabbCollider*)collider;
        }
        break;
    case CT_Circle:
        {
            delete (CircleCollider*)collider;
        }
        break;
    case CT_Sector:
        {
            delete (SectorCollider*)collider;
        }
        break;
    default:
        {
            delete collider;
        }
        break;
    }
}