chars.cpp

这是一个服务端/客户端模式的小型网络游戏

				Msg.Header.Size     = sizeof(sStateChangeMessage);
				Msg.Header.PlayerID = CharPtr->dpnidPlayer;
				Msg.Action          = CHAR_DIE;
				Msg.AttackerDpnid	= CharPtr->Attacker->dpnidPlayer;
				
				// Send message to server
				m_Server->SendNetworkMessage(&Msg, DPNSEND_NOLOOPBACK);   
			}
			
			// Mark that processing can continue later on
			ToProcess = TRUE;
			
			// Mark character as still alive
			DeadChar = FALSE;
			
			// Process non-idle, non-walk actions
			if(CharPtr->Action != CHAR_IDLE &&                      \
				CharPtr->Action != CHAR_MOVE &&                      \
				!CharPtr->ActionTimer) {
				
				switch(CharPtr->Action) {
				case CHAR_ATTACK:
					// Process attack
					if(ToProcess == TRUE)
						Attack(CharPtr, CharPtr->Victim);
					break;
					
				case CHAR_SPELL:
					// Manually cast a spell
					if(m_SpellController != NULL && m_MSL != NULL &&  \
						ToProcess == TRUE) {
						m_SpellController->Add(CharPtr->SpellNum,       \
							CharPtr, CharPtr->SpellTarget,     \
							CharPtr->XPos,                     \
							CharPtr->YPos,                     \
							CharPtr->ZPos,                     \
							CharPtr->TargetX,                  \
							CharPtr->TargetY,                  \
							CharPtr->TargetZ);
					}
					break;
					
				case CHAR_ITEM:
					if(ToProcess == TRUE)
						Item(CharPtr, CharPtr,                          \
						CharPtr->ItemNum, CharPtr->CharItem);
					break;
					
				case CHAR_DIE:
					Death(CharPtr->Attacker, CharPtr);
					DeadChar = TRUE;   // Mark character as dead
					ToProcess = FALSE; // Don't allow updates
					break;
				}
			}
			
			// Clear movement
			XMove = YMove = ZMove = 0.0f;
			
			// Only continue if allowed (in case character died)
			if(ToProcess == TRUE) {
				
				// Only allow updates if lock/timer not in use 
				if(CharPtr->Enabled == TRUE &&                        \
					!CharPtr->ActionTimer &&                           \
					CharPtr->Locked == FALSE) {
				

					if( CharPtr->Action != CHAR_MOVE){
						// Reset action
						CharPtr->Action = CHAR_IDLE;
					}
					
					// Get movement
					if(CharPtr->Type == CHAR_PC)
						PCUpdate(CharPtr, CharPtr->Elapsed, &XMove, &YMove, &ZMove);
					else
						CharUpdate(CharPtr, CharPtr->Elapsed, &XMove,&YMove,&ZMove);

					// Check for validity of movement (clear if invalid)
					if(CheckMove(CharPtr,&XMove,&YMove,&ZMove)==FALSE) {
						XMove = YMove = ZMove = 0.0f;
						CharPtr->Action = CHAR_IDLE;
					}
				}

				// Process movement of character
				ProcessUpdate(CharPtr, XMove, YMove, ZMove);
				
				// Increase action charge of character
				CharPtr->Charge += ((float)CharPtr->Elapsed / 1000.0f *        \
					GetCharge(CharPtr));
				if(CharPtr->Charge > 100.0f)
					CharPtr->Charge = 100.0f;
			}

    }
	// Reset effect counter (after 4 seconds)
	if(CharPtr->Enabled ==FALSE){
		CharPtr->EffectCounter += CharPtr->Elapsed;
		if(CharPtr->EffectCounter > 10000) {
			CharPtr->Enabled = TRUE;
			CharPtr->EffectCounter = 0;
			if(CharPtr->Type == CHAR_PC) CharPtr->Def.Experience -= 30;
			sReliveChangeMessage rcm;
			rcm.Header.Type     = MSG_RELIVE_CHANGE;
			rcm.Header.Size     = sizeof(sReliveChangeMessage);
			rcm.Header.PlayerID = CharPtr->dpnidPlayer;
			rcm.Experience     = CharPtr->Def.Experience;
			if(CharPtr->Type == CHAR_PC || CharPtr->AI == CHAR_STAND) CharPtr->Action = CHAR_IDLE;
			else CharPtr->Action = CHAR_MOVE;
			CharPtr->HealthPoints = CharPtr->Def.HealthPoints;
			CharPtr->ManaPoints	 = CharPtr->Def.ManaPoints;

			// Send the message over network
			m_Server->SendNetworkMessage(&rcm, DPNSEND_NOLOOPBACK, -1);
			
		}
	}

    CharPtr->Time      = timeGetTime();
    // Go to next character
    CharPtr = NextChar;
  }
  
  
  
  return TRUE;
}



float cCharacterController::GetXZRadius(sCharacter *Character)
{
  float MinX, MaxX, MinZ, MaxZ;
  float x, z;

  // Error checking
  if(Character == NULL)
    return 0.0f;

  GetBounds(Character->ID, &MinX, NULL, &MinZ,             \
                              &MaxX, NULL, &MaxZ, NULL);
  x = (float)max(fabs(MinX), fabs(MaxX));
  z = (float)max(fabs(MinZ), fabs(MaxZ));

  return max(x, z);
}

///////////////////////////////////////////////////////////
// Set/Get Functions
///////////////////////////////////////////////////////////
sCharacter *cCharacterController::GetParentCharacter()
{
  return m_CharacterParent;
}

sCharacter *cCharacterController::GetCharacter(long IDNum)
{
  sCharacter *CharPtr;

  // Scan through all characters
  if((CharPtr = m_CharacterParent) != NULL) {
    while(CharPtr != NULL) {
    
      // Return character
      if(IDNum == CharPtr->ID)
        return CharPtr;
   
      // Go to next character
      CharPtr = CharPtr->Next;
    }
  }

  return NULL;
}

float cCharacterController::GetSpeed(sCharacter *Character)
{
  float Speed;
  
  // Error checking
  if(Character == NULL)
    return 0.0f;

  // Calculate adjusted speed
  Speed = Character->Def.Speed;

  // Bounds check value
  if(Speed < 1.0f)
    Speed = 1.0f;

  return Speed;
}

long cCharacterController::GetAttack(sCharacter *Character)
{
  long Attack;
  
  // Error checking
  if(Character == NULL)
    return 0;

  // Calculate adjusted attack
  Attack = Character->Def.Attack;

  // Adjust attack based on item value (in %(Value/100)+1)
  if(Character->Def.Weapon != -1 && m_MIL != NULL) {
    Attack = (long)((float)Attack *                           \
             (((float)m_MIL[Character->Def.Weapon].Value /    \
             100.0f) + 1.0f));
  }

  return Attack;
}

long cCharacterController::GetDefense(sCharacter *Character)
{
  long Defense;
  
  // Error checking
  if(Character == NULL)
    return 0;

  // Calculate adjusted defense
  Defense = Character->Def.Defense;
  
  if(Character->Def.Armor != -1 && m_MIL != NULL)
    Defense = (long)((float)Defense *                         \
             (((float)m_MIL[Character->Def.Armor].Value /     \
             100.0f) + 1.0f));

  if(Character->Def.Shield != -1 && m_MIL != NULL)
    Defense = (long)((float)Defense *                         \
             (((float)m_MIL[Character->Def.Shield].Value /    \
             100.0f) + 1.0f));

  // Bounds check value
  if(Defense < 0)
    Defense = 0;

  return Defense;
}

long cCharacterController::GetAgility(sCharacter *Character)
{
  long Agility;
  
  // Error checking
  if(Character == NULL)
    return 0;

  // Calculate adjusted agility
  Agility = Character->Def.Agility;

  return Agility;
}

long cCharacterController::GetResistance(sCharacter *Character)
{
  long Resistance;
  
  // Error checking
  if(Character == NULL)
    return 0;

  // Calculate adjusted resistance
  Resistance = Character->Def.Resistance;

  return Resistance;
}

long cCharacterController::GetMental(sCharacter *Character)
{
  long Mental;
  
  // Error checking
  if(Character == NULL)
    return 0;

  // Calculate adjusted mental
  Mental = Character->Def.Mental;
  
  return Mental;
}

long cCharacterController::GetToHit(sCharacter *Character)
{
  long ToHit;
  
  // Error checking
  if(Character == NULL)
    return 0;

  // Calculate adjusted to hit
  ToHit = Character->Def.ToHit;
  
  return ToHit;
}

float cCharacterController::GetCharge(sCharacter *Character)
{
  float Charge;
  
  // Error checking
  if(Character == NULL)
    return 0;

  // Calculate adjusted charge
  Charge = Character->Def.ChargeRate;
  
  return Charge;
}

cCharICS *cCharacterController::GetICS(long IDNum)
{
  sCharacter *CharPtr;

  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return NULL;
  return CharPtr->CharICS;
}

BOOL cCharacterController::SetLock(long IDNum, BOOL State)
{
  sCharacter *CharPtr;

  // Get pointer to character
  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;

  // Set new value
  CharPtr->Locked = State;
  return TRUE;
}

BOOL cCharacterController::SetActionTimer(long IDNum, long Timer)
{
  sCharacter *CharPtr;

  // Get pointer to character
  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;

  // Set new value
  CharPtr->ActionTimer = Timer;
  return TRUE;
}

BOOL cCharacterController::SetAction(sCharacter *Character,   \
                                     long Action,             \
                                     long AddTime)
{
  long MeshNum;

  // Error checking
  if(Character == NULL)
    return FALSE;

  // Make sure attack, spell, and item has supporting charge
  if(Action == CHAR_ATTACK || Action == CHAR_SPELL ||
     Action == CHAR_ITEM) {
    if(Character->Charge < 100.0f)
      return FALSE;
  }

  // Set action
  Character->Action = Action;

  // Play sound effect
  ActionSound(Character);

  // Get mesh number
  MeshNum = Character->Def.MeshNum;

  // Set action time (or set to 1 is addtime = -1)
  if(AddTime == -1)
    Character->ActionTimer = 1;
  else
    Character->ActionTimer = AddTime +  AnimationLength[Character->Definition][Action] * 30;

  return TRUE;
}

BOOL cCharacterController::SetDistance(                       \
               long IDNum, float Distance)
{
  sCharacter *CharPtr;

  // Get pointer to character
  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;

  // Set new value
  CharPtr->Distance = Distance;
  return TRUE;
}

float cCharacterController::GetDistance(long IDNum)
{
  sCharacter *CharPtr;

  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return 0.0f;
  return CharPtr->Distance;
}

BOOL cCharacterController::SetRoute(long IDNum,               \
                                    long NumPoints,           \
                                    sRoutePoint *Route)
{
  sCharacter *CharPtr;

  // Get pointer to character
  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;

  // Free old route
  delete [] CharPtr->Route;
  CharPtr->Route = NULL;

  // Set new route
  if((CharPtr->NumPoints = NumPoints) != NULL) {
    CharPtr->Route = new sRoutePoint[NumPoints];
    memcpy(CharPtr->Route,Route,NumPoints*sizeof(sRoutePoint));
    CharPtr->CurrentPoint = 0;
  }

  return TRUE;
}

BOOL cCharacterController::SetScript(long IDNum,              \
                                     char *ScriptFilename)
{
  sCharacter *CharPtr;

  // Get pointer to character
  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;

  // Set new script
  strcpy(CharPtr->ScriptFilename, ScriptFilename);
  return TRUE;
}

char *cCharacterController::GetScript(long IDNum)
{
  sCharacter *CharPtr;

  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return NULL;
  return CharPtr->ScriptFilename;
}

BOOL cCharacterController::SetEnable(long IDNum, BOOL Enabled)
{
  sCharacter *CharPtr;

  // Get pointer to character
  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;

  // Set new value
  CharPtr->Enabled = Enabled;
  return TRUE;
}

BOOL cCharacterController::GetEnable(long IDNum)
{
  sCharacter *CharPtr;

  if((CharPtr = GetCharacter(IDNum)) == NULL)
    return FALSE;
  return CharPtr->Enabled;
}