객체 이동 경로 관리

여기에서 말하고자 하는 것은 앞으로 이동할 경로에 대한 예측이 아닌, 현재 객체가 이동한 경로를 관리하고
처리하는 방식에 대해 논의해 보고자 한다.

어떻게 보면 이미 지난 데이터라 의미없을지 모르지만 예측이 아닌 객체(A)의 이동 처리 방식에서는 타 객체(B)의 현재 위치는 예전 위치이기 때문에 만약, 타 객체(B)가  객체(A)를 공격할때 이에 대한 정확한 판단이
필요하게 된다. == 이를 위해 다음과 같은 객체의 처리가 필요하게 된다.

다음과 같이 객체의 이동이 발생 되었다고 가정하다.

객체(A)는 이동을 하지만, 객체(A)를 보고 있는 다른 객체(B)는 일정 시간 이후에 객체(A)의 이동을 보게 된다.

이러한 시점에서 객체(B)가 객체(A)를 공격한다면?

서버에서는 객체(A)가 객체(B)가 보고 있는 시점에 공격을 받는 위치에 있었는지 판단할 필요가 있다.

이를 위해 다음과 같은 처리 방식을 사용한다.

** FPS와 같이 이동에 대한 예측(객체(A)의 이동을 객체(B)는 바로 감지 한다)에서는 해당 방식을 사용할 필요가 없다.


객체 관리를 위해 필자는 다음과 같은 관리 구조를 가지고 있다.

#define MAX_BASELINE     8
  typedef int limit_t[MAX_BASELINE + 1];

#define RECORD_BEGINMSEC    500   /* 0.5 sec */
  struct info {
   sights_t actors;  // 시야 범위 객체의 간격
   struct urecord { // 이동 경로 저장 테이블
    int nstart;  // 저장 시작 위치
    unsigned __int64 begin_msec; // key 설정 마지막 시간

#define RECORD_MAXCOURSE   24
    struct course { // 객체의 이동정보를 recording 한 테이블
     unsigned __int64 msec; // 이동 발생 시간
     vector3d L;    // 위치
     uintptr_t udata;  // 부가 정보
#define RECORD_ISBEGIN    0x01
     unsigned int flags;  // 상태 정보
    } C[RECORD_MAXCOURSE];   // 저장 테이블
   } r; limit_t limit;  // relevant 설정 값
   
   RWLOCK_T rwlock;
  }; typedef struct info::urecord::course course_t;

해당 구조는 객체가 이동한 경로를 받아 일정 경로를 저장하고 있다가, 위치에 대한 판단이 필요할때 해당 정보를 참고하기 위해 사용되어 진다.

처리방식을 보면,
   1. 클라이언트는 일정 시간동안 자신(객체)의 이동 변화를 기록한다.
   2. 기록된 이동 변화 정보를 일정 시간 단위로 서버로 전송한다.
   3. 서버는 마지막 위치로 이동을 시키고 이동 경로를 저장한다.

여기에서 중요한 것은 이동이 발생된 시간인데 이 시간을 중심으로 객체의 위치를 판단하게 된다.

또한, 이렇게 저장된 정보를 시야범위에 따른 데이터 위치를 최소화 하는 용도로 사용할수 있다.

// 해당 시간과 근접한 위치의 이동데이터를 얻는다.
 actor::course_t actor::isbegin( unsigned __int64 begin_msec)
 {
  course_t r = { 0, { 0.0f, 0.0f, 0.0f }, false };

  ENTER_RDLOCK( &_M.rwlock); {
   int at = _M.r.nstart - 1,
    max = RECORD_MAXCOURSE;
   
   ((at < 0) ? (at += RECORD_MAXCOURSE): 0);
   while ((--max) >= 0)
   {
    course_t c = *(_M.r.C + at);

    if ((c.msec == 0) ||
      (c.msec < begin_msec))
     break;
    else {
     if (c.flags & RECORD_ISBEGIN)
     {
      r = c;
      break;
     }
    } if ((++at) >= RECORD_MAXCOURSE) at = 0;
   } LEAVE_RDLOCK( &_M.rwlock);
  } return r;
 }

 // 저장된 이동 경로로 부터 데이터를 얻는다.
 actor::course_t *actor::lookup( int at, actor::course_t *_r, int max)
 {
  if (at > 0)
   ;
  else {
   int nstart = max;

   ((max > RECORD_MAXCOURSE) ? (max = RECORD_MAXCOURSE): 0);
   ENTER_RDLOCK( &_M.rwlock); {
    if ((at = (_M.r.nstart - 1) + at) < 0) at += RECORD_MAXCOURSE;
    while ((--max) >= 0)
    {
     course_t r = *(_M.r.C + at);

     if (r.msec == 0)
      break;
     else {
      *(_r + (--nstart)) = r;
     } if ((++at) >= RECORD_MAXCOURSE) at = 0;
    } LEAVE_RDLOCK( &_M.rwlock);
   } return _r + nstart;
  } return NULL;
 }

 // 이동 경로를 저장한다.
 void actor::record( actor::course_t *t, int max, int begin_msec)
 {
  ENTER_RWLOCK( &_M.rwlock); {
   int n = 0;

   do {
    if ((t[n].msec - _M.r.begin_msec) >= ((unsigned __int64)begin_msec))
    {
     t[n].flags |= RECORD_ISBEGIN;
     _M.r.begin_msec= t[n].msec;
    } _M.r.C[_M.r.nstart] = t[n++];

    if ((++_M.r.nstart) >= RECORD_MAXCOURSE) _M.r.nstart = 0;
   } while ((--max) > 0);
  } LEAVE_RWLOCK( &_M.rwlock);
 }

여기에 추가적으로 해당 시간에 존재한 위치를 얻기 위해서는 일부 예측이 사용되어야 한다.
== 객체가 이동 중일수 있으므로, 위의 처리는 객체의 이동변화에 대한 값 만을 관리하고 있어, 이에 대한
   보정을 위해서는 일정 시간 이후(A -> B이동) 해당 객체의 위치를 예측해야 한다.